| /* |
| * Copyright 2015 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| |
| #ifndef GrVkProgram_DEFINED |
| #define GrVkProgram_DEFINED |
| |
| #include "GrVkImage.h" |
| #include "GrVkProgramDesc.h" |
| #include "GrVkProgramDataManager.h" |
| #include "glsl/GrGLSLProgramBuilder.h" |
| |
| #include "vulkan/vulkan.h" |
| |
| class GrPipeline; |
| class GrVkCommandBuffer; |
| class GrVkDescriptorPool; |
| class GrVkGpu; |
| class GrVkImageView; |
| class GrVkPipeline; |
| class GrVkSampler; |
| class GrVkUniformBuffer; |
| |
| class GrVkProgram : public SkRefCnt { |
| public:
|
| typedef GrGLSLProgramBuilder::BuiltinUniformHandles BuiltinUniformHandles;
|
| |
| ~GrVkProgram(); |
| |
| GrVkPipeline* vkPipeline() const { return fPipeline; } |
| |
| void setData(const GrVkGpu*, const GrPrimitiveProcessor&, const GrPipeline&); |
| |
| void bind(const GrVkGpu* gpu, GrVkCommandBuffer* commandBuffer);
|
|
|
| void addUniformResources(GrVkCommandBuffer&);
|
| |
| void freeGPUResources(const GrVkGpu* gpu); |
|
|
| // This releases resources the only a given instance of a GrVkProgram needs to hold onto and do
|
| // don't need to survive across new uses of the program.
|
| void freeTempResources(const GrVkGpu* gpu); |
| |
| void abandonGPUResources(); |
| |
| private: |
| typedef GrVkProgramDataManager::UniformInfoArray UniformInfoArray;
|
| typedef GrGLSLProgramDataManager::UniformHandle UniformHandle;
|
| |
| GrVkProgram(GrVkGpu* gpu, |
| GrVkPipeline* pipeline, |
| VkPipelineLayout layout, |
| VkDescriptorSetLayout dsLayout[2], |
| GrVkDescriptorPool* descriptorPool, |
| VkDescriptorSet descriptorSets[2], |
| const BuiltinUniformHandles& builtinUniformHandles, |
| const UniformInfoArray& uniforms, |
| uint32_t vertexUniformSize, |
| uint32_t fragmentUniformSize, |
| uint32_t numSamplers, |
| GrGLSLPrimitiveProcessor* geometryProcessor,
|
| GrGLSLXferProcessor* xferProcessor,
|
| const GrGLSLFragProcs& fragmentProcessors); |
|
|
| void writeUniformBuffers(const GrVkGpu* gpu);
|
| |
| void writeSamplers(const GrVkGpu* gpu, const SkTArray<const GrTextureAccess*>& textureBindings);
|
|
|
|
|
| /**
|
| * We use the RT's size and origin to adjust from Skia device space to OpenGL normalized device
|
| * space and to make device space positions have the correct origin for processors that require
|
| * them.
|
| */
|
| struct RenderTargetState {
|
| SkISize fRenderTargetSize;
|
| GrSurfaceOrigin fRenderTargetOrigin;
|
|
|
| RenderTargetState() { this->invalidate(); }
|
| void invalidate() {
|
| fRenderTargetSize.fWidth = -1;
|
| fRenderTargetSize.fHeight = -1;
|
| fRenderTargetOrigin = (GrSurfaceOrigin)-1;
|
| }
|
|
|
| /**
|
| * Gets a vec4 that adjusts the position from Skia device coords to GL's normalized device
|
| * coords. Assuming the transformed position, pos, is a homogeneous vec3, the vec, v, is
|
| * applied as such:
|
| * pos.x = dot(v.xy, pos.xz)
|
| * pos.y = dot(v.zw, pos.yz)
|
| */
|
| void getRTAdjustmentVec(float* destVec) {
|
| destVec[0] = 2.f / fRenderTargetSize.fWidth;
|
| destVec[1] = -1.f;
|
| if (kBottomLeft_GrSurfaceOrigin == fRenderTargetOrigin) {
|
| destVec[2] = -2.f / fRenderTargetSize.fHeight;
|
| destVec[3] = 1.f;
|
| } else {
|
| destVec[2] = 2.f / fRenderTargetSize.fHeight;
|
| destVec[3] = -1.f;
|
| }
|
| }
|
| };
|
| |
| // Helper for setData() that sets the view matrix and loads the render target height uniform
|
| void setRenderTargetState(const GrPipeline&); |
| |
| // GrVkGpu* fGpu; |
| |
| // GrVkResources |
| GrVkDescriptorPool* fDescriptorPool; |
| GrVkPipeline* fPipeline; |
| |
| // Used for binding DescriptorSets to the command buffer but does not need to survive during |
| // command buffer execution. Thus this is not need to be a GrVkResource. |
| VkPipelineLayout fPipelineLayout;
|
|
|
| // The first set (index 0) will be used for samplers and the second set (index 1) will be |
| // used for uniform buffers.
|
| // The DSLayouts only are needed for allocating the descriptor sets and must survive until after
|
| // descriptor sets have been updated. Thus the lifetime of the layouts will just be the life of
|
| //the GrVkProgram.
|
| VkDescriptorSetLayout fDSLayout[2];
|
| // The DescriptorSets need to survive until the gpu has finished all draws that use them.
|
| // However, they will only be freed by the descriptor pool. Thus by simply keeping the
|
| // descriptor pool alive through the draw, the descritor sets will also stay alive. Thus we do
|
| // not need a GrVkResource versions of VkDescriptorSet.
|
| VkDescriptorSet fDescriptorSets[2];
|
|
|
| SkAutoTDelete<GrVkUniformBuffer> fVertexUniformBuffer;
|
| SkAutoTDelete<GrVkUniformBuffer> fFragmentUniformBuffer;
|
|
|
| // GrVkResources used for sampling textures
|
| SkTDArray<GrVkSampler*> fSamplers;
|
| SkTDArray<const GrVkImageView*> fTextureViews; |
| SkTDArray<const GrVkImage::Resource*> fTextures;
|
|
|
| // Tracks the current render target uniforms stored in the vertex buffer.
|
| RenderTargetState fRenderTargetState;
|
| BuiltinUniformHandles fBuiltinUniformHandles;
|
|
|
| // Processors in the program
|
| SkAutoTDelete<GrGLSLPrimitiveProcessor> fGeometryProcessor;
|
| SkAutoTDelete<GrGLSLXferProcessor> fXferProcessor;
|
| GrGLSLFragProcs fFragmentProcessors;
|
|
|
| GrVkProgramDataManager fProgramDataManager; |
| |
| #ifdef SK_DEBUG |
| int fNumSamplers; |
| #endif |
| |
| friend class GrVkProgramBuilder; |
| }; |
| |
| #endif |