Calculate stage stats in GrOptDrawState

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/GrGLProgramBuilder.h"
 #include "GrGLProgramDesc.h"
 #include "GrBackendEffectFactory.h"
 #include "GrDrawEffect.h"
 #include "GrEffect.h"
 #include "GrGpuGL.h"
 #include "GrOptDrawState.h"
 
 #include "SkChecksum.h"
 
-bool GrGLProgramDesc::GetEffectKeyAndUpdateStats(const GrEffectStage& stage,
-                                                 const GrGLCaps& caps,
-                                                 bool useExplicitLocalCoords,
-                                                 GrEffectKeyBuilder* b,
-                                                 uint16_t* effectKeySize,
-                                                 bool* setTrueIfReadsDst,
-                                                 bool* setTrueIfReadsPos,
-                                                 bool* setTrueIfRequiresVertexShader) {
+bool GrGLProgramDesc::GetEffectKey(const GrEffectStage& stage, const GrGLCaps& caps,
+                                   bool useExplicitLocalCoords, GrEffectKeyBuilder* b,
+                                   uint16_t* effectKeySize) {
     const GrBackendEffectFactory& factory = stage.getEffect()->getFactory();
     GrDrawEffect drawEffect(stage, useExplicitLocalCoords);
-    if (stage.getEffect()->willReadDstColor()) {
-        *setTrueIfReadsDst = true;
-    }
-    if (stage.getEffect()->willReadFragmentPosition()) {
-        *setTrueIfReadsPos = true;
-    }
-    if (stage.getEffect()->requiresVertexShader()) {
-        *setTrueIfRequiresVertexShader = true;
-    }
     factory.getGLEffectKey(drawEffect, caps, b);
     size_t size = b->size();
     if (size > SK_MaxU16) {
         *effectKeySize = 0; // suppresses a warning.
         return false;
     }
     *effectKeySize = SkToU16(size);
     if (!GrGLProgramEffects::GenEffectMetaKey(drawEffect, caps, b)) {
         return false;
     }
@@ skipping 19 matching lines @@
     // descriptor will not affect program generation (because of the attribute
     // bindings in use or other descriptor field settings) it should be set
     // to a canonical value to avoid duplicate programs with different keys.
 
     bool requiresColorAttrib = optState.hasColorVertexAttribute();
     bool requiresCoverageAttrib = optState.hasCoverageVertexAttribute();
     // we only need the local coords if we're actually going to generate effect code
     bool requiresLocalCoordAttrib = optState.numTotalStages() > 0 &&
                                     optState.hasLocalCoordAttribute();
 
-    bool readsDst = false;
-    bool readFragPosition = false;
+    bool readsDst = optState.readsDst();

[bsalomon, 2014/09/05 15:27:55]

remove the vars?

[egdaniel, 2014/09/08 19:19:49]

removed

+    bool readFragPosition = optState.readsFragPosition();
 
     // Provide option for shader programs without vertex shader only when drawing paths.
-    bool requiresVertexShader = !GrGpu::IsPathRenderingDrawType(drawType);
+    bool requiresVertexShader =

[bsalomon, 2014/09/05 15:27:55]

I wonder whether this should just be an assert... We better not be doing nvpr
and have a GP.

[egdaniel, 2014/09/08 19:19:49]

Added assert below

On 2014/09/05 15:27:55, bsalomon wrote:

+        !GrGpu::IsPathRenderingDrawType(drawType) ? true : optState.requiresVertexShader();
 
     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;
     bool effectKeySuccess = 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));
 
         GrEffectKeyBuilder b(&desc->fKey);
         uint16_t effectKeySize;
         uint32_t effectOffset = desc->fKey.count();
-        effectKeySuccess |= GetEffectKeyAndUpdateStats(
+        effectKeySuccess |= GetEffectKey(
             optState.getColorStage(s), gpu->glCaps(),
             requiresLocalCoordAttrib, &b,
-            &effectKeySize, &readsDst,
-            &readFragPosition, &requiresVertexShader);
+            &effectKeySize);
         effectKeySuccess |= (effectOffset <= SK_MaxU16);
 
         offsetAndSize[0] = SkToU16(effectOffset);
         offsetAndSize[1] = effectKeySize;
         ++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));
 
         GrEffectKeyBuilder b(&desc->fKey);
         uint16_t effectKeySize;
         uint32_t effectOffset = desc->fKey.count();
-        effectKeySuccess |= GetEffectKeyAndUpdateStats(
+        effectKeySuccess |= GetEffectKey(
             optState.getCoverageStage(s), gpu->glCaps(),
             requiresLocalCoordAttrib, &b,
-            &effectKeySize, &readsDst,
-            &readFragPosition, &requiresVertexShader);
+            &effectKeySize);
         effectKeySuccess |= (effectOffset <= SK_MaxU16);
 
         offsetAndSize[0] = SkToU16(effectOffset);
         offsetAndSize[1] = effectKeySize;
         ++offsetAndSizeIndex;
     }
 
     if (!effectKeySuccess) {
         desc->fKey.reset();
         return false;
@@ skipping 146 matching lines @@
     *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;
 }