Repurpose GrGLCoordTransform as GrGLEffectArray

src/gpu/gl/GrGLShaderBuilder.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLShaderBuilder_DEFINED
 #define GrGLShaderBuilder_DEFINED
 
 #include "GrAllocator.h"
 #include "GrBackendEffectFactory.h"
 #include "GrColor.h"
 #include "GrEffect.h"
 #include "SkTypes.h"
-#include "gl/GrGLCoordTransform.h"
+#include "gl/GrGLEffectArray.h"
 #include "gl/GrGLSL.h"
 #include "gl/GrGLUniformManager.h"
 
 #include <stdarg.h>
 
 class GrGLContextInfo;
 class GrEffectStage;
 class GrGLProgramDesc;
 
 /**
   Contains all the incremental state of a shader as it is being built,as well as helpers to
   manipulate that state.
 */
 class GrGLShaderBuilder {
 public:
-    /**
-     * Passed to GrGLEffects to add texture reads to their shader code.
-     */
-    class TextureSampler {
-    public:
-        TextureSampler()
-            : fConfigComponentMask(0) {
-            // we will memcpy the first 4 bytes from passed in swizzle. This ensures the string is
-            // terminated.
-            fSwizzle[4] = '\0';
-        }
-
-        TextureSampler(const TextureSampler& other) { *this = other; }
-
-        TextureSampler& operator= (const TextureSampler& other) {
-            SkASSERT(0 == fConfigComponentMask);
-            SkASSERT(!fSamplerUniform.isValid());
-
-            fConfigComponentMask = other.fConfigComponentMask;
-            fSamplerUniform = other.fSamplerUniform;
-            return *this;
-        }
-
-        // bitfield of GrColorComponentFlags present in the texture's config.
-        uint32_t configComponentMask() const { return fConfigComponentMask; }
-
-        const char* swizzle() const { return fSwizzle; }
-
-        bool isInitialized() const { return 0 != fConfigComponentMask; }
-
-    private:
-        // The idx param is used to ensure multiple samplers within a single effect have unique
-        // uniform names. swizzle is a four char max string made up of chars 'r', 'g', 'b', and 'a'.
-        void init(GrGLShaderBuilder* builder,
-                  uint32_t configComponentMask,
-                  const char* swizzle,
-                  int idx) {
-            SkASSERT(!this->isInitialized());
-            SkASSERT(0 != configComponentMask);
-            SkASSERT(!fSamplerUniform.isValid());
-
-            SkASSERT(NULL != builder);
-            SkString name;
-            name.printf("Sampler%d", idx);
-            fSamplerUniform = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
-                                                  kSampler2D_GrSLType,
-                                                  name.c_str());
-            SkASSERT(fSamplerUniform.isValid());
-
-            fConfigComponentMask = configComponentMask;
-            memcpy(fSwizzle, swizzle, 4);
-        }
-
-        void init(GrGLShaderBuilder* builder, const GrTextureAccess* access, int idx) {
-            SkASSERT(NULL != access);
-            this->init(builder,
-                       GrPixelConfigComponentMask(access->getTexture()->config()),
-                       access->getSwizzle(),
-                       idx);
-        }
-
-        uint32_t                          fConfigComponentMask;
-        char                              fSwizzle[5];
-        GrGLUniformManager::UniformHandle fSamplerUniform;
-
-        friend class GrGLShaderBuilder; // to call init().
-    };
-
-    typedef SkTArray<GrGLCoordTransform::TransformedCoords> TransformedCoordsArray;
-    typedef SkTArray<TextureSampler> TextureSamplerArray;
     typedef GrTAllocator<GrGLShaderVar> VarArray;
     typedef GrBackendEffectFactory::EffectKey EffectKey;
+    typedef GrGLEffectArray::TextureSampler TextureSampler;
+    typedef GrGLEffectArray::TransformedCoordsArray TransformedCoordsArray;
 
     enum ShaderVisibility {
         kVertex_Visibility   = 0x1,
         kGeometry_Visibility = 0x2,
         kFragment_Visibility = 0x4,
     };
 
     GrGLShaderBuilder(GrGpuGL*,
                       GrGLUniformManager&,
                       const GrGLProgramDesc&,
@@ skipping 54 matching lines @@
     void fsEmitFunction(GrSLType returnType,
                         const char* name,
                         int argCnt,
                         const GrGLShaderVar* args,
                         const char* body,
                         SkString* outName);
 
     /** Add input/output variable declarations (i.e. 'varying') to the fragment shader. */
     GrGLShaderVar& fsInputAppend() { return fFSInputs.push_back(); }
 
-    /** Generates a EffectKey for the shader code based on the texture access parameters and the
-        capabilities of the GL context.  This is useful for keying the shader programs that may
-        have multiple representations, based on the type/format of textures used. */
-    static EffectKey KeyForTextureAccess(const GrTextureAccess&, const GrGLCaps&);
-
     typedef uint8_t DstReadKey;
     typedef uint8_t FragPosKey;
 
     /**  Returns a key for adding code to read the copy-of-dst color in service of effects that
          require reading the dst. It must not return 0 because 0 indicates that there is no dst
          copy read at all (in which case this function should not be called). */
     static DstReadKey KeyForDstRead(const GrTexture* dstCopy, const GrGLCaps&);
 
     /** Returns a key for reading the fragment location. This should only be called if there is an
         effect that will requires the fragment position. If the fragment position is not required,
@@ skipping 63 matching lines @@
      * Adds code for effects. effectStages contains the effects to add. effectKeys[i] is the key
      * generated from effectStages[i]. An entry in effectStages can be NULL, in which case it is
      * skipped. Moreover, if the corresponding key is GrGLEffect::NoEffectKey then it is skipped.
      * inOutFSColor specifies the input color to the first stage and is updated to be the
      * output color of the last stage. fsInOutColorKnownValue specifies whether the input color
      * has a known constant value and is updated to refer to the status of the output color.
      * The handles to texture samplers for effectStage[i] are added to effectSamplerHandles[i]. The
      * glEffects array is updated to contain the GrGLEffect generated for each entry in
      * effectStages.
      */
-    void emitEffects(const GrEffectStage* effectStages[],
-                     const EffectKey effectKeys[],
-                     int effectCnt,
-                     SkString*  inOutFSColor,
-                     GrSLConstantVec* fsInOutColorKnownValue,
-                     SkTArray<GrGLCoordTransform, false>* effectCoordTransformArrays[],
-                     SkTArray<GrGLUniformManager::UniformHandle, true>* effectSamplerHandles[],
-                     GrGLEffect* glEffects[]);
+    GrGLEffectArray* emitEffects(const GrEffectStage* effectStages[],

[bsalomon, 2013/10/02 20:17:06]

emitEffectsAndCreateFoo()?

Can we update the comment to make it clear that the caller gets a newly minted
object that it is responsible for deleting.

Also, while you're at it, all the stuff about NULL and kNoEffectKey is stale and
can be deleted.

And the language about glEffects and effectSamplerHandles can be removed.

[Chris Dalton, 2013/10/02 21:25:43]

Done.

+                                 const EffectKey effectKeys[],
+                                 int effectCnt,
+                                 SkString*  inOutFSColor,
+                                 GrSLConstantVec* fsInOutColorKnownValue);
 
     const char* getColorOutputName() const;
     const char* enableSecondaryOutput();
 
     GrGLUniformManager::UniformHandle getRTHeightUniform() const { return fRTHeightUniform; }
     GrGLUniformManager::UniformHandle getDstCopyTopLeftUniform() const {
         return fDstCopyTopLeftUniform;
     }
     GrGLUniformManager::UniformHandle getDstCopyScaleUniform() const {
         return fDstCopyScaleUniform;
     }
     GrGLUniformManager::UniformHandle getColorUniform() const { return fColorUniform; }
     GrGLUniformManager::UniformHandle getCoverageUniform() const { return fCoverageUniform; }
     GrGLUniformManager::UniformHandle getDstCopySamplerUniform() const {
-        return fDstCopySampler.fSamplerUniform;
+        return fDstCopySamplerUniform;
     }
 
     /** Helper class used to build the vertex and geometry shaders. This functionality
         is kept separate from the rest of GrGLShaderBuilder to allow for shaders programs
         that only use the fragment shader. */
     class VertexBuilder {
     public:
         VertexBuilder(GrGLShaderBuilder* parent, GrGpuGL* gpu, const GrGLProgramDesc&);
 
         /**
@@ skipping 178 matching lines @@
     GrGLUniformManager&                 fUniformManager;
     uint32_t                            fFSFeaturesAddedMask;
     SkString                            fFSFunctions;
     SkString                            fFSExtensions;
     VarArray                            fFSInputs;
     VarArray                            fFSOutputs;
 
     SkString                            fFSCode;
 
     bool                                fSetupFragPosition;
-    TextureSampler                      fDstCopySampler;
+    GrGLUniformManager::UniformHandle   fDstCopySamplerUniform;
 
     SkString                            fInputColor;
     GrSLConstantVec                     fKnownColorValue;
     SkString                            fInputCoverage;
     GrSLConstantVec                     fKnownCoverageValue;
 
     bool                                fHasCustomColorOutput;
     bool                                fHasSecondaryOutput;
 
     GrGLUniformManager::UniformHandle   fRTHeightUniform;
     GrGLUniformManager::UniformHandle   fDstCopyTopLeftUniform;
     GrGLUniformManager::UniformHandle   fDstCopyScaleUniform;
     GrGLUniformManager::UniformHandle   fColorUniform;
     GrGLUniformManager::UniformHandle   fCoverageUniform;
 
     bool                                fTopLeftFragPosRead;
 
     SkAutoTDelete<VertexBuilder>        fVertexBuilder;
 };
 
 #endif