Add back Vk files with LF endings

src/gpu/vk/GrVkProgram.h

+/*
+ * 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