1/*
2* Copyright 2016 Google Inc.
3*
4* Use of this source code is governed by a BSD-style license that can be
5* found in the LICENSE file.
6*/
7
8#ifndef GrVkUniformHandler_DEFINED
9#define GrVkUniformHandler_DEFINED
10
11#include "GrAllocator.h"
12#include "GrShaderVar.h"
13#include "glsl/GrGLSLUniformHandler.h"
14
15class GrVkUniformHandler : public GrGLSLUniformHandler {
16public:
17    static const int kUniformsPerBlock = 8;
18
19    enum {
20        kUniformBufferDescSet = 0,
21        kSamplerDescSet = 1,
22        kTexelBufferDescSet = 2,
23    };
24    enum {
25        kGeometryBinding = 0,
26        kFragBinding = 1,
27    };
28
29    // fUBOffset is only valid if the GrSLType of the fVariable is not a sampler
30    struct UniformInfo {
31        GrShaderVar fVariable;
32        uint32_t        fVisibility;
33        uint32_t        fUBOffset;
34    };
35    typedef GrTAllocator<UniformInfo> UniformInfoArray;
36
37    const GrShaderVar& getUniformVariable(UniformHandle u) const override {
38        return fUniforms[u.toIndex()].fVariable;
39    }
40
41    const char* getUniformCStr(UniformHandle u) const override {
42        return this->getUniformVariable(u).c_str();
43    }
44
45private:
46    explicit GrVkUniformHandler(GrGLSLProgramBuilder* program)
47        : INHERITED(program)
48        , fUniforms(kUniformsPerBlock)
49        , fSamplers(kUniformsPerBlock)
50        , fTexelBuffers(kUniformsPerBlock)
51        , fCurrentGeometryUBOOffset(0)
52        , fCurrentFragmentUBOOffset(0) {
53    }
54
55    UniformHandle internalAddUniformArray(uint32_t visibility,
56                                          GrSLType type,
57                                          GrSLPrecision precision,
58                                          const char* name,
59                                          bool mangleName,
60                                          int arrayCount,
61                                          const char** outName) override;
62
63    SamplerHandle addSampler(uint32_t visibility,
64                             GrSwizzle swizzle,
65                             GrSLType type,
66                             GrSLPrecision precision,
67                             const char* name) override;
68
69    int numSamplers() const { return fSamplers.count(); }
70    const GrShaderVar& samplerVariable(SamplerHandle handle) const override {
71        return fSamplers[handle.toIndex()].fVariable;
72    }
73    GrSwizzle samplerSwizzle(SamplerHandle handle) const override {
74        return fSamplerSwizzles[handle.toIndex()];
75    }
76    uint32_t samplerVisibility(SamplerHandle handle) const {
77        return fSamplers[handle.toIndex()].fVisibility;
78    }
79
80    TexelBufferHandle addTexelBuffer(uint32_t visibility, GrSLPrecision,
81                                     const char* name) override;
82
83    int numTexelBuffers() const { return fTexelBuffers.count(); }
84    const GrShaderVar& texelBufferVariable(TexelBufferHandle handle) const override {
85        return fTexelBuffers[handle.toIndex()].fVariable;
86    }
87    uint32_t texelBufferVisibility(TexelBufferHandle handle) const {
88        return fTexelBuffers[handle.toIndex()].fVisibility;
89    }
90
91    ImageStorageHandle addImageStorage(uint32_t visibility, GrSLType,  GrImageStorageFormat,
92                                       GrSLMemoryModel, GrSLRestrict, GrIOType,
93                                       const char* name) override {
94        SkFAIL("Image storages not implemented for Vulkan.");
95        return 0;
96    }
97
98    const GrShaderVar& imageStorageVariable(ImageStorageHandle handle) const override {
99        SkFAIL("Image storages not implemented for Vulkan.");
100        static const GrShaderVar* gVar = nullptr;
101        return *gVar;
102    }
103
104    void appendUniformDecls(GrShaderFlags, SkString*) const override;
105
106    bool hasGeometryUniforms() const { return fCurrentGeometryUBOOffset > 0; }
107    bool hasFragmentUniforms() const { return fCurrentFragmentUBOOffset > 0; }
108
109
110    const UniformInfo& getUniformInfo(UniformHandle u) const {
111        return fUniforms[u.toIndex()];
112    }
113
114
115    UniformInfoArray    fUniforms;
116    UniformInfoArray    fSamplers;
117    SkTArray<GrSwizzle> fSamplerSwizzles;
118    UniformInfoArray    fTexelBuffers;
119
120    uint32_t            fCurrentGeometryUBOOffset;
121    uint32_t            fCurrentFragmentUBOOffset;
122
123    friend class GrVkPipelineStateBuilder;
124    friend class GrVkDescriptorSetManager;
125
126    typedef GrGLSLUniformHandler INHERITED;
127};
128
129#endif
130