GrGLShaderBuilder.h revision a3d707b4ec17e925f71cc0c39d40252d2b788314 
1/*
2 * Copyright 2012 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 GrGLShaderBuilder_DEFINED
9#define GrGLShaderBuilder_DEFINED
10
11#include "GrAllocator.h"
12#include "GrCustomStage.h"
13#include "gl/GrGLShaderVar.h"
14#include "gl/GrGLSL.h"
15#include "gl/GrGLUniformManager.h"
16
17class GrGLContextInfo;
18
19/**
20  Contains all the incremental state of a shader as it is being built,as well as helpers to
21  manipulate that state.
22*/
23class GrGLShaderBuilder {
24
25public:
26    enum ShaderType {
27        kVertex_ShaderType   = 0x1,
28        kGeometry_ShaderType = 0x2,
29        kFragment_ShaderType = 0x4,
30    };
31
32    GrGLShaderBuilder(const GrGLContextInfo&, GrGLUniformManager&);
33
34    void computeSwizzle(uint32_t configFlags);
35    void computeModulate(const char* fsInColor);
36
37    /** Determines whether we should use texture2D() or texture2Dproj(), and if an explicit divide
38        is required for the sample coordinates, creates the new variable and emits the code to
39        initialize it. This should only be called by GrGLProgram.*/
40    void setupTextureAccess(const char* varyingFSName, GrSLType varyingType);
41
42    /** texture2D(samplerName, coordName), with projection if necessary; if coordName is not
43        specified, uses fSampleCoords. coordType must either be Vec2f or Vec3f. The latter is
44        interpreted as projective texture coords. */
45    void emitTextureLookup(const char* samplerName,
46                           const char* coordName = NULL,
47                           GrSLType coordType = kVec2f_GrSLType);
48
49    /** sets outColor to results of texture lookup, with swizzle, and/or modulate as necessary. If
50    coordName is NULL then it as if defaultTexCoordsName() was passed. coordType must be either
51    kVec2f or kVec3f. */
52    void emitTextureLookupAndModulate(const char* outColor,
53                                      const char* samplerName,
54                                      const char* coordName = NULL,
55                                      GrSLType coordType = kVec2f_GrSLType);
56
57    /** Gets the name of the default texture coords which are always kVec2f */
58    const char* defaultTexCoordsName() const { return fDefaultTexCoordsName.c_str(); }
59
60    /* Returns true if the texture matrix from which the default texture coords are computed has
61       perspective. */
62    bool defaultTextureMatrixIsPerspective() const {
63        return fTexCoordVaryingType == kVec3f_GrSLType;
64    }
65
66    /** Emits a texture lookup to the shader code with the form:
67          texture2D{Proj}(samplerName, coordName).swizzle
68        The routine selects the type of texturing based on samplerMode.
69        The generated swizzle state is built based on the format of the texture and the requested
70        swizzle access pattern.  coordType must either be Vec2f or Vec3f. The latter is interpreted
71        as projective texture coords.*/
72    void emitCustomTextureLookup(const GrTextureAccess& textureAccess,
73                                 const char* samplerName,
74                                 const char* coordName,
75                                 GrSLType coordType = kVec2f_GrSLType);
76
77    /** Emits a helper function outside of main(). Currently ShaderType must be
78        kFragment_ShaderType. */
79    void emitFunction(ShaderType shader,
80                      GrSLType returnType,
81                      const char* name,
82                      int argCnt,
83                      const GrGLShaderVar* args,
84                      const char* body,
85                      SkString* outName);
86
87    /** Generates a StageKey for the shader code based on the texture access parameters and the
88        capabilities of the GL context.  This is useful for keying the shader programs that may
89        have multiple representations, based on the type/format of textures used. */
90    static GrCustomStage::StageKey KeyForTextureAccess(const GrTextureAccess& access,
91                                                       const GrGLCaps& caps);
92
93    /** Add a uniform variable to the current program, that has visibilty in one or more shaders.
94        visibility is a bitfield of ShaderType values indicating from which shaders the uniform
95        should be accessible. At least one bit must be set. Geometry shader uniforms are not
96        supported at this time. The actual uniform name will be mangled. If outName is not NULL then
97        it will refer to the final uniform name after return. Use the addUniformArray variant to add
98        an array of uniforms.
99    */
100    GrGLUniformManager::UniformHandle addUniform(uint32_t visibility,
101                                                 GrSLType type,
102                                                 const char* name,
103                                                 const char** outName = NULL) {
104        return this->addUniformArray(visibility, type, name, GrGLShaderVar::kNonArray, outName);
105    }
106    GrGLUniformManager::UniformHandle addUniformArray(uint32_t visibility,
107                                                      GrSLType type,
108                                                      const char* name,
109                                                      int arrayCount,
110                                                      const char** outName = NULL);
111
112    const GrGLShaderVar& getUniformVariable(GrGLUniformManager::UniformHandle) const;
113
114    /**
115     * Shorcut for getUniformVariable(u).c_str()
116     */
117    const char* getUniformCStr(GrGLUniformManager::UniformHandle u) const {
118        return this->getUniformVariable(u).c_str();
119    }
120
121    /** Add a varying variable to the current program to pass values between vertex and fragment
122        shaders. If the last two parameters are non-NULL, they are filled in with the name
123        generated. */
124    void addVarying(GrSLType type,
125                    const char* name,
126                    const char** vsOutName = NULL,
127                    const char** fsInName = NULL);
128
129    /** Called after building is complete to get the final shader string. */
130    void getShader(ShaderType, SkString*) const;
131
132    /**
133     * TODO: Make this do all the compiling, linking, etc. Hide from the custom stages
134     */
135    void finished(GrGLuint programID);
136
137    /**
138     * Sets the current stage (used to make variable names unique).
139     * TODO: Hide from the custom stages
140     */
141    void setCurrentStage(int stage) { fCurrentStage = stage; }
142    void setNonStage() { fCurrentStage = kNonStageIdx; }
143
144private:
145
146    typedef GrTAllocator<GrGLShaderVar> VarArray;
147
148    void appendDecls(const VarArray&, SkString*) const;
149    void appendUniformDecls(ShaderType, SkString*) const;
150
151    typedef GrGLUniformManager::BuilderUniform BuilderUniform;
152    GrGLUniformManager::BuilderUniformArray fUniforms;
153
154    // TODO: Everything below here private.
155public:
156
157    SkString    fHeader; // VS+FS, GLSL version, etc
158    VarArray    fVSAttrs;
159    VarArray    fVSOutputs;
160    VarArray    fGSInputs;
161    VarArray    fGSOutputs;
162    VarArray    fFSInputs;
163    SkString    fGSHeader; // layout qualifiers specific to GS
164    VarArray    fFSOutputs;
165    SkString    fVSCode;
166    SkString    fGSCode;
167    SkString    fFSCode;
168    bool        fUsesGS;
169
170    /// Per-stage settings - only valid while we're inside GrGLProgram::genStageCode().
171    //@{
172
173    SkString         fSwizzle;
174    SkString         fModulate;
175
176    //@}
177
178private:
179    enum {
180        kNonStageIdx = -1,
181    };
182
183    const GrGLContextInfo&  fContext;
184    GrGLUniformManager&     fUniformManager;
185    int                     fCurrentStage;
186    SkString                fFSFunctions;
187
188    /// Per-stage settings - only valid while we're inside GrGLProgram::genStageCode().
189    //@{
190    GrSLType         fTexCoordVaryingType;  // the type, either Vec2f or Vec3f, of the coords passed
191                                            // as a varying from the VS to the FS.
192    SkString         fDefaultTexCoordsName; // the name of the default 2D coords value.
193    //@}
194
195};
196
197#endif
198