gl programs rewrite

src/gpu/gl/GrGLProgramDesc.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gl/builders/GrGLFragmentShaderBuilder.h"
 #include "GrGLProgramDesc.h"
 #include "GrBackendProcessorFactory.h"
@@ skipping 122 matching lines @@
     if ((textureKey | transformKey | classID) & kMetaKeyInvalidMask) {
         return NULL;
     }
 
     uint32_t* key = b->add32n(2);
     key[0] = (textureKey << 16 | transformKey);
     key[1] = (classID << 16);
     return key;
 }
 
-bool GrGLProgramDesc::GetProcessorKey(const GrProcessorStage& stage,
-                                      const GrGLCaps& caps,
-                                      bool useExplicitLocalCoords,
-                                      GrProcessorKeyBuilder* b,
-                                      uint16_t* processorKeySize) {
+static bool get_fp_key(const GrProcessorStage& stage,
+                       const GrGLCaps& caps,
+                       bool useExplicitLocalCoords,
+                       GrProcessorKeyBuilder* b,
+                       uint16_t* processorKeySize) {
     const GrProcessor& effect = *stage.getProcessor();
     const GrBackendProcessorFactory& factory = effect.getFactory();
     factory.getGLProcessorKey(effect, caps, b);
     size_t size = b->size();
     if (size > SK_MaxU16) {
         *processorKeySize = 0; // suppresses a warning.
         return false;
     }
     *processorKeySize = SkToU16(size);
     if (NULL == get_processor_meta_key(stage, useExplicitLocalCoords, caps, b)) {
         return false;
     }
     return true;
 }
 
-bool GrGLProgramDesc::GetGeometryProcessorKey(const GrGeometryStage& stage,
-                                              const GrGLCaps& caps,
-                                              bool useExplicitLocalCoords,
-                                              GrProcessorKeyBuilder* b,
-                                              uint16_t* processorKeySize) {
+static bool get_gp_key(const GrGeometryStage& stage,
+                       const GrGLCaps& caps,
+                       bool useExplicitLocalCoords,
+                       GrProcessorKeyBuilder* b,
+                       uint16_t* processorKeySize) {
     const GrProcessor& effect = *stage.getProcessor();
     const GrBackendProcessorFactory& factory = effect.getFactory();
     factory.getGLProcessorKey(effect, caps, b);
     size_t size = b->size();
     if (size > SK_MaxU16) {
         *processorKeySize = 0; // suppresses a warning.
         return false;
     }
     *processorKeySize = SkToU16(size);
     uint32_t* key = get_processor_meta_key(stage, useExplicitLocalCoords, caps, b);
     if (NULL == key) {
         return false;
     }
     uint32_t attribKey = gen_attrib_key(stage.getProcessor());
 
     // Currently we allow 16 bits for each of the above portions of the meta-key. Fail if they
     // don't fit.
     static const uint32_t kMetaKeyInvalidMask = ~((uint32_t) SK_MaxU16);
     if ((attribKey) & kMetaKeyInvalidMask) {
        return false;
     }
 
     key[1] |= attribKey;
     return true;
 }
 
+struct GeometryProcessorKeyBuilder {
+    typedef GrGeometryStage StagedProcessor;
+    static bool GetProcessorKey(const GrGeometryStage& gpStage,
+                                const GrGLCaps& caps,
+                                bool requiresLocalCoordAttrib,
+                                GrProcessorKeyBuilder* b,
+                                uint16_t* processorKeySize) {
+        return get_gp_key(gpStage, caps, requiresLocalCoordAttrib, b, processorKeySize);
+    }
+};
+
+struct FragmentProcessorKeyBuilder {
+    typedef GrFragmentStage StagedProcessor;
+    static bool GetProcessorKey(const GrFragmentStage& fpStage,
+                                const GrGLCaps& caps,
+                                bool requiresLocalCoordAttrib,
+                                GrProcessorKeyBuilder* b,
+                                uint16_t* processorKeySize) {
+        return get_fp_key(fpStage, caps, requiresLocalCoordAttrib, b, processorKeySize);
+    }
+};
+
+
+template <class ProcessorKeyBuilder>
+bool
+GrGLProgramDesc::BuildStagedProcessorKey(const typename ProcessorKeyBuilder::StagedProcessor& stage,
+                                         const GrGLCaps& caps,
+                                         bool requiresLocalCoordAttrib,
+                                         GrGLProgramDesc* desc,
+                                         int* offsetAndSizeIndex) {
+    GrProcessorKeyBuilder b(&desc->fKey);
+    uint16_t processorKeySize;
+    uint32_t processorOffset = desc->fKey.count();
+    if (processorOffset > SK_MaxU16 ||
+            !ProcessorKeyBuilder::GetProcessorKey(stage, caps, requiresLocalCoordAttrib, &b,
+                                                  &processorKeySize)){
+        desc->fKey.reset();
+        return false;
+    }
+
+    uint16_t* offsetAndSize =
+            reinterpret_cast<uint16_t*>(desc->fKey.begin() + kEffectKeyOffsetsAndLengthOffset +
+                                        *offsetAndSizeIndex * 2 * sizeof(uint16_t));
+    offsetAndSize[0] = SkToU16(processorOffset);
+    offsetAndSize[1] = processorKeySize;
+    ++(*offsetAndSizeIndex);
+    return true;
+}
 
 bool GrGLProgramDesc::Build(const GrOptDrawState& optState,
                             GrGpu::DrawType drawType,
                             GrBlendCoeff srcCoeff,
                             GrBlendCoeff dstCoeff,
                             GrGpuGL* gpu,
                             const GrDeviceCoordTexture* dstCopy,
                             const GrGeometryStage** geometryProcessor,
                             SkTArray<const GrFragmentStage*, true>* colorStages,
                             SkTArray<const GrFragmentStage*, true>* coverageStages,
@@ skipping 13 matching lines @@
 
     int numStages = optState.numTotalStages();
 
     GR_STATIC_ASSERT(0 == kEffectKeyOffsetsAndLengthOffset % sizeof(uint32_t));
     // Make room for everything up to and including the array of offsets to effect keys.
     desc->fKey.reset();
     desc->fKey.push_back_n(kEffectKeyOffsetsAndLengthOffset + 2 * sizeof(uint16_t) * numStages);
 
     int offsetAndSizeIndex = 0;
 
-    KeyHeader* header = desc->header();
-    // make sure any padding in the header is zeroed.
-    memset(desc->header(), 0, kHeaderSize);
-
     // We can only have one effect which touches the vertex shader
     if (optState.hasGeometryProcessor()) {
-        uint16_t* offsetAndSize =
-                reinterpret_cast<uint16_t*>(desc->fKey.begin() + kEffectKeyOffsetsAndLengthOffset +
-                                            offsetAndSizeIndex * 2 * sizeof(uint16_t));
-
-        GrProcessorKeyBuilder b(&desc->fKey);
-        uint16_t processorKeySize;
-        uint32_t processorOffset = desc->fKey.count();
         const GrGeometryStage& gpStage = *optState.getGeometryProcessor();
-        if (processorOffset > SK_MaxU16 ||
-                !GetGeometryProcessorKey(gpStage, gpu->glCaps(), requiresLocalCoordAttrib, &b,
-                                         &processorKeySize)) {
-            desc->fKey.reset();
+        if (!BuildStagedProcessorKey<GeometryProcessorKeyBuilder>(gpStage,
+                                                                  gpu->glCaps(),
+                                                                  requiresLocalCoordAttrib,
+                                                                  desc,
+                                                                  &offsetAndSizeIndex)) {
             return false;
         }
-
-        offsetAndSize[0] = SkToU16(processorOffset);
-        offsetAndSize[1] = processorKeySize;
-        ++offsetAndSizeIndex;
         *geometryProcessor = &gpStage;
-        header->fHasGeometryProcessor = true;
     }
 
     for (int s = 0; s < optState.numColorStages(); ++s) {
-        uint16_t* offsetAndSize =
-            reinterpret_cast<uint16_t*>(desc->fKey.begin() + kEffectKeyOffsetsAndLengthOffset +
-                                        offsetAndSizeIndex * 2 * sizeof(uint16_t));
-
-        GrProcessorKeyBuilder b(&desc->fKey);
-        uint16_t processorKeySize;
-        uint32_t processorOffset = desc->fKey.count();
-        if (processorOffset > SK_MaxU16 ||
-                !GetProcessorKey(optState.getColorStage(s), gpu->glCaps(),
-                                 requiresLocalCoordAttrib, &b, &processorKeySize)) {
-            desc->fKey.reset();
+        if (!BuildStagedProcessorKey<FragmentProcessorKeyBuilder>(optState.getColorStage(s),
+                                                                  gpu->glCaps(),
+                                                                  requiresLocalCoordAttrib,
+                                                                  desc,
+                                                                  &offsetAndSizeIndex)) {
             return false;
         }
-
-        offsetAndSize[0] = SkToU16(processorOffset);
-        offsetAndSize[1] = processorKeySize;
-        ++offsetAndSizeIndex;
     }
 
     for (int s = 0; s < optState.numCoverageStages(); ++s) {
-        uint16_t* offsetAndSize =
-            reinterpret_cast<uint16_t*>(desc->fKey.begin() + kEffectKeyOffsetsAndLengthOffset +
-                                        offsetAndSizeIndex * 2 * sizeof(uint16_t));
-
-        GrProcessorKeyBuilder b(&desc->fKey);
-        uint16_t processorKeySize;
-        uint32_t processorOffset = desc->fKey.count();
-        if (processorOffset > SK_MaxU16 ||
-                !GetProcessorKey(optState.getCoverageStage(s), gpu->glCaps(),
-                                 requiresLocalCoordAttrib, &b, &processorKeySize)) {
-            desc->fKey.reset();
+        if (!BuildStagedProcessorKey<FragmentProcessorKeyBuilder>(optState.getCoverageStage(s),
+                                                                  gpu->glCaps(),
+                                                                  requiresLocalCoordAttrib,
+                                                                  desc,
+                                                                  &offsetAndSizeIndex)) {
             return false;
         }
-
-        offsetAndSize[0] = SkToU16(processorOffset);
-        offsetAndSize[1] = processorKeySize;
-        ++offsetAndSizeIndex;
     }
 
+    // --------DO NOT MOVE HEADER ABOVE THIS LINE--------------------------------------------------
     // Because header is a pointer into the dynamic array, we can't push any new data into the key
     // below here.
+    KeyHeader* header = desc->header();
 
+    // make sure any padding in the header is zeroed.
+    memset(header, 0, kHeaderSize);
+
+    header->fHasGeometryProcessor = optState.hasGeometryProcessor();
 
     header->fEmitsPointSize = GrGpu::kDrawPoints_DrawType == drawType;
 
-    // Currently the experimental GS will only work with triangle prims (and it doesn't do anything
-    // other than pass through values from the VS to the FS anyway).
-#if GR_GL_EXPERIMENTAL_GS
-#if 0
-    header->fExperimentalGS = gpu->caps().geometryShaderSupport();
-#else
-    header->fExperimentalGS = false;
-#endif
-#endif
-
     if (gpu->caps()->pathRenderingSupport() &&
         GrGpu::IsPathRenderingDrawType(drawType) &&
         gpu->glPathRendering()->texturingMode() == GrGLPathRendering::FixedFunction_TexturingMode) {
         header->fUseFragShaderOnly = true;
         SkASSERT(!optState.hasGeometryProcessor());
     } else {
         header->fUseFragShaderOnly = false;
     }
 
     bool defaultToUniformInputs = GrGpu::IsPathRenderingDrawType(drawType) ||
@@ skipping 71 matching lines @@
 
     for (int s = 0; s < optState.numColorStages(); ++s) {
         colorStages->push_back(&optState.getColorStage(s));
     }
     for (int s = 0; s < optState.numCoverageStages(); ++s) {
         coverageStages->push_back(&optState.getCoverageStage(s));
     }
 
     header->fColorEffectCnt = colorStages->count();
     header->fCoverageEffectCnt = coverageStages->count();
-
     desc->finalize();
     return true;
 }
 
 void GrGLProgramDesc::finalize() {
     int keyLength = fKey.count();
     SkASSERT(0 == (keyLength % 4));
     *this->atOffset<uint32_t, kLengthOffset>() = SkToU32(keyLength);
 
     uint32_t* checksum = this->atOffset<uint32_t, kChecksumOffset>();
     *checksum = 0;
     *checksum = SkChecksum::Compute(reinterpret_cast<uint32_t*>(fKey.begin()), keyLength);
 }
 
 GrGLProgramDesc& GrGLProgramDesc::operator= (const GrGLProgramDesc& other) {
     size_t keyLength = other.keyLength();
     fKey.reset(keyLength);
     memcpy(fKey.begin(), other.fKey.begin(), keyLength);
     return *this;
 }