gl programs rewrite

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
 
 #include "GrGLProcessor.h"
 #include "GrDrawState.h"
 #include "GrGpu.h"
 #include "GrOptDrawState.h"
 
 class GrGpuGL;
 
-#ifdef SK_DEBUG
-  // Optionally compile the experimental GS code. Set to SK_DEBUG so that debug build bots will
-  // execute the code.
-  #define GR_GL_EXPERIMENTAL_GS 1
-#else
-  #define GR_GL_EXPERIMENTAL_GS 0
-#endif
-
-
 /** This class describes a program to generate. It also serves as a program cache key. Very little
     of this is GL-specific. The GL-specific parts could be factored out into a subclass. */
 class GrGLProgramDesc {
 public:
     GrGLProgramDesc() {}
     GrGLProgramDesc(const GrGLProgramDesc& desc) { *this = desc; }
 
     // Returns this as a uint32_t array to be used as a key in the program cache.
     const uint32_t* asKey() const {
         return reinterpret_cast<const uint32_t*>(fKey.begin());
     }
 
     // Gets the number of bytes in asKey(). It will be a 4-byte aligned value. When comparing two
     // keys the size of either key can be used with memcmp() since the lengths themselves begin the
     // keys and thus the memcmp will exit early if the keys are of different lengths.
     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*,
-                   GrGpuGL*,
-                   const GrRenderTarget* dummyDstRenderTarget,
-                   const GrTexture* dummyDstCopyTexture,
-                   const GrGeometryStage* geometryProcessor,
-                   const GrFragmentStage* stages[],
-                   int numColorStages,
-                   int numCoverageStages,
-                   int currAttribIndex,
-                   GrGpu::DrawType);
-
     /**
      * Builds a program descriptor from a GrOptDrawState. Whether the primitive type is points, and
      * the caps of the GrGpuGL are also inputs. It also outputs the color and coverage stages
      * referenced by the generated descriptor. Coverage stages from the drawState may be treated as
      * color stages in the output.
      */
     static bool Build(const GrOptDrawState&,
                       GrGpu::DrawType,
                       GrBlendCoeff srcCoeff,
                       GrBlendCoeff dstCoeff,
@@ skipping 53 matching lines @@
 
         SkBool8                     fUseFragShaderOnly;
         SkBool8                     fEmitsPointSize;
 
         ColorInput                       fColorInput : 8;
         ColorInput                       fCoverageInput : 8;
 
         GrOptDrawState::PrimaryOutputType    fPrimaryOutputType : 8;
         GrOptDrawState::SecondaryOutputType  fSecondaryOutputType : 8;
 
-
-        // To enable experimental geometry shader code (not for use in
-        // 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;
     };
 
@@ skipping 20 matching lines @@
     template<typename T, size_t OFFSET> T* atOffset() {
         return reinterpret_cast<T*>(reinterpret_cast<intptr_t>(fKey.begin()) + OFFSET);
     }
 
     template<typename T, size_t OFFSET> const T* atOffset() const {
         return reinterpret_cast<const T*>(reinterpret_cast<intptr_t>(fKey.begin()) + OFFSET);
     }
 
     KeyHeader* header() { return this->atOffset<KeyHeader, kHeaderOffset>(); }
 
-    // Shared code between setRandom() and Build().
-    static bool GetProcessorKey(const GrProcessorStage& stage,
-                                const GrGLCaps& caps,
-                                bool useExplicitLocalCoords,
-                                GrProcessorKeyBuilder* b,
-                                uint16_t* effectKeySize);
-
-    static bool GetGeometryProcessorKey(const GrGeometryStage& stage,
+    // a helper class to handle getting an individual processor's key
+    template <class ProcessorKeyBuilder>
+    static bool BuildStagedProcessorKey(const typename ProcessorKeyBuilder::StagedProcessor& stage,
                                         const GrGLCaps& caps,
-                                        bool useExplicitLocalCoords,
-                                        GrProcessorKeyBuilder* b,
-                                        uint16_t* effectKeySize);
+                                        bool requiresLocalCoordAttrib,
+                                        GrGLProgramDesc* desc,
+                                        int* offsetAndSizeIndex);
     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,
@@ skipping 46 matching lines @@
     // visible to GrGLProcessors. Then make public accessors as necessary and remove friends.
     friend class GrGLProgram;
     friend class GrGLProgramBuilder;
     friend class GrGLLegacyNvprProgramBuilder;
     friend class GrGLVertexBuilder;
     friend class GrGLFragmentShaderBuilder;
     friend class GrGLGeometryBuilder;
 };
 
 #endif