Solo gp

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 "GrGLEffect.h"
+#include "GrGLProcessor.h"
 #include "GrDrawState.h"
 #include "GrGpu.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
@@ skipping 19 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[],
+                   const GrGeometryStage* geometryProcessor,
+                   const GrFragmentStage* stages[],
                    int numColorStages,
                    int numCoverageStages,
                    int currAttribIndex);
 
     /**
      * 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&,
+    static bool Build(const GrOptDrawState& optState,

[bsalomon, 2014/09/22 15:35:24]

IMO param names that just repeat the type name aren't useful in decls (optState,
drawType, gpu, ...) I usually delete them when I'm editing code. We're not
consistent one way or the other, though.

                       GrGpu::DrawType drawType,
                       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);
+                      const GrGeometryStage** geometryProcessor,
+                      SkTArray<const GrFragmentStage*, true>* colorStages,
+                      SkTArray<const GrFragmentStage*, true>* coverageStages,
+                      GrGLProgramDesc* desc);
 
     bool hasGeometryProcessor() const {
         return SkToBool(this->getHeader().fHasGeometryProcessor);
     }
 
     int numColorEffects() const {
         return this->getHeader().fColorEffectCnt;
     }
 
     int numCoverageEffects() const {
@@ skipping 111 matching lines @@
         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 GetEffectKey(const GrEffectStage& stage, const GrGLCaps& caps,
-                             bool useExplicitLocalCoords, GrEffectKeyBuilder* b,
-                             uint16_t* effectKeySize);
+    static bool GetProcessorKey(const GrProcessorStage& stage,
+                                const GrGLCaps& caps,
+                                bool useExplicitLocalCoords,
+                                GrProcessorKeyBuilder* b,
+                                uint16_t* effectKeySize);
 
+    static bool GetGeometryProcessorKey(const GrGeometryStage& stage,
+                                        const GrGLCaps& caps,
+                                        bool useExplicitLocalCoords,
+                                        GrProcessorKeyBuilder* b,
+                                        uint16_t* effectKeySize);
     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) {
             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 {
+        GrProcessorKey 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.
             SkASSERT(0 == (length % sizeof(uint32_t)));
-            return GrEffectKey(reinterpret_cast<const uint32_t*>(fDesc->fKey.begin() + offset),
+            return GrProcessorKey(reinterpret_cast<const uint32_t*>(fDesc->fKey.begin() + offset),
                                length / sizeof(uint32_t));
         }
     private:
         const GrGLProgramDesc*  fDesc;
         int                     fBaseIndex;
     };
 
     enum {
         kMaxPreallocEffects = 8,
         kIntsPerEffect      = 4,    // This is an overestimate of the average effect key size.
         kPreAllocSize = kEffectKeyOffsetsAndLengthOffset +
                         kMaxPreallocEffects * sizeof(uint32_t) * kIntsPerEffect,
     };
 
     SkSTArray<kPreAllocSize, uint8_t, true> fKey;
 
     // GrGLProgram and GrGLShaderBuilder read the private fields to generate code. TODO: Split out
     // part of GrGLShaderBuilder that is used by effects so that this header doesn't need to be
-    // visible to GrGLEffects. Then make public accessors as necessary and remove friends.
+    // visible to GrGLProcessors. Then make public accessors as necessary and remove friends.
     friend class GrGLProgram;
     friend class GrGLProgramBuilder;
     friend class GrGLFullProgramBuilder;
     friend class GrGLFragmentOnlyProgramBuilder;
     friend class GrGLVertexShaderBuilder;
     friend class GrGLFragmentShaderBuilder;
     friend class GrGLGeometryShaderBuilder;
 };
 
 #endif