Default geometry processor

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 206 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;
 
-    // We can only have one effect which touches the vertex shader
-    if (optState.hasGeometryProcessor()) {
+    bool noGP = gpu->caps()->pathRenderingSupport() && GrGpu::IsPathRenderingDrawType(drawType);
+
+    // We can only have one effect which touches the vertex shader, optState will install a
+    // default GP if none are available
+    if (!noGP) {
         if (!BuildStagedProcessorKey<GeometryProcessorKeyBuilder>(*optState.getGeometryProcessor(),
                                                                   gpu->glCaps(),
                                                                   false,
                                                                   desc,
                                                                   &offsetAndSizeIndex)) {
             return false;
         }
     }
 
     for (int s = 0; s < optState.numFragmentStages(); ++s) {
         if (!BuildStagedProcessorKey<FragmentProcessorKeyBuilder>(optState.getFragmentStage(s),
                                                                   gpu->glCaps(),
                                                                   requiresLocalCoordAttrib,
                                                                   desc,
                                                                   &offsetAndSizeIndex)) {
             return false;
         }
     }
 
     // --------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;
 
-    if (gpu->caps()->pathRenderingSupport() &&
-        GrGpu::IsPathRenderingDrawType(drawType) &&
+    if (noGP &&
         gpu->glPathRendering()->texturingMode() == GrGLPathRendering::FixedFunction_TexturingMode) {
+        // We still have a default geometry processor installed on the opt draw state, but it is

[bsalomon, 2014/10/27 13:43:43]

I think we will have to figure out how to make the path draws work with no GP.
Maybe this comes about when we create this geometry bundle object.

+        // ignored for generating keys, and also ignored in the programbuilder
         header->fUseFragShaderOnly = true;
-        SkASSERT(!optState.hasGeometryProcessor());
     } else {
         header->fUseFragShaderOnly = false;
     }
 
     bool defaultToUniformInputs = GrGpu::IsPathRenderingDrawType(drawType) ||
                                   GR_GL_NO_CONSTANT_ATTRIBUTES;
 
     if (!inputColorIsUsed) {
         header->fColorInput = kAllOnes_ColorInput;
     } else if (defaultToUniformInputs && !optState.hasColorVertexAttribute()) {
@@ skipping 79 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;
 }