Initial change to create GeometryProcessor

src/gpu/gl/GrGLProgramDesc.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLProgramDesc_DEFINED
 #define GrGLProgramDesc_DEFINED
 
@@ skipping 30 matching lines @@
     uint32_t keyLength() const { return *this->atOffset<uint32_t, kLengthOffset>(); }
 
     // Gets the a checksum of the key. Can be used as a hash value for a fast lookup in a cache.
     uint32_t getChecksum() const { return *this->atOffset<uint32_t, kChecksumOffset>(); }
 
     // For unit testing.
     bool setRandom(SkRandom*,
                    const GrGpuGL* gpu,
                    const GrRenderTarget* dummyDstRenderTarget,
                    const GrTexture* dummyDstCopyTexture,
+                   const GrEffectStage* geometryProcessor,
                    const GrEffectStage* stages[],
                    int numColorStages,
                    int numCoverageStages,
                    int currAttribIndex);
 
     /**
      * Builds a program descriptor from a GrDrawState. Whether the primitive type is points, the
      * output of GrDrawState::getBlendOpts, and the caps of the GrGpuGL are also inputs. It also
      * outputs the color and coverage stages referenced by the generated descriptor. This may
      * not contain all stages from the draw state and coverage stages from the drawState may
      * be treated as color stages in the output.
      */
     static bool Build(const GrDrawState&,
                       GrGpu::DrawType drawType,
                       GrDrawState::BlendOptFlags,
                       GrBlendCoeff srcCoeff,
                       GrBlendCoeff dstCoeff,
                       const GrGpuGL* gpu,
                       const GrDeviceCoordTexture* dstCopy,
+                      const GrEffectStage** outGeometryProcessor,
                       SkTArray<const GrEffectStage*, true>* outColorStages,
                       SkTArray<const GrEffectStage*, true>* outCoverageStages,
                       GrGLProgramDesc* outDesc);
 
+    bool hasGeometryProcessor() const { return this->getHeader().fHasGeometryProcessor; }
+
     int numColorEffects() const {
         return this->getHeader().fColorEffectCnt;
     }
 
     int numCoverageEffects() const {
         return this->getHeader().fCoverageEffectCnt;
     }
 
     int numTotalEffects() const { return this->numColorEffects() + this->numCoverageEffects(); }
 
@@ skipping 70 matching lines @@
         // production)
 #if GR_GL_EXPERIMENTAL_GS
         SkBool8                     fExperimentalGS;
 #endif
 
         int8_t                      fPositionAttributeIndex;
         int8_t                      fLocalCoordAttributeIndex;
         int8_t                      fColorAttributeIndex;
         int8_t                      fCoverageAttributeIndex;
 
+        SkBool8                     fHasGeometryProcessor;
         int8_t                      fColorEffectCnt;
         int8_t                      fCoverageEffectCnt;
     };
 
     // The key, stored in fKey, is composed of five parts:
     // 1. uint32_t for total key length.
     // 2. uint32_t for a checksum.
     // 3. Header struct defined above.
     // 4. An array of offsets to effect keys and their sizes (see 5). uint16_t for each
     //    offset and size.
@@ skipping 32 matching lines @@
                                            bool* setTrueIfRequiresVertexShader);
 
     void finalize();
 
     const KeyHeader& getHeader() const { return *this->atOffset<KeyHeader, kHeaderOffset>(); }
 
     /** Used to provide effects' keys to their emitCode() function. */
     class EffectKeyProvider {
     public:
         enum EffectType {
+            kGeometryProcessor_EffectType,
             kColor_EffectType,
             kCoverage_EffectType,
         };
 
         EffectKeyProvider(const GrGLProgramDesc* desc, EffectType type) : fDesc(desc) {
-            // Coverage effect key offsets begin immediately after those of the color effects.
-            fBaseIndex = kColor_EffectType == type ? 0 : desc->numColorEffects();
+            switch (type) {
+                case kGeometryProcessor_EffectType:
+                    // there can be only one
+                    fBaseIndex = 0;
+                    break;
+                case kColor_EffectType:
+                    fBaseIndex = desc->hasGeometryProcessor() ? 1 : 0;
+                    break;
+                case kCoverage_EffectType:
+                    fBaseIndex = desc->numColorEffects() + (desc->hasGeometryProcessor() ? 1 : 0);
+                    break;
+            }
         }
 
         GrEffectKey get(int index) const {
             const uint16_t* offsetsAndLengths = reinterpret_cast<const uint16_t*>(
                 fDesc->fKey.begin() + kEffectKeyOffsetsAndLengthOffset);
             // We store two uint16_ts per effect, one for the offset to the effect's key and one for
             // its length. Here we just need the offset.
             uint16_t offset = offsetsAndLengths[2 * (fBaseIndex + index) + 0];
             uint16_t length = offsetsAndLengths[2 * (fBaseIndex + index) + 1];
             // Currently effects must add to the key in units of uint32_t.
@@ skipping 21 matching lines @@
     friend class GrGLProgram;
     friend class GrGLProgramBuilder;
     friend class GrGLFullProgramBuilder;
     friend class GrGLFragmentOnlyProgramBuilder;
     friend class GrGLVertexShaderBuilder;
     friend class GrGLFragmentShaderBuilder;
     friend class GrGLGeometryShaderBuilder;
 };
 
 #endif