Implement support for CHROMIUM_NV_path_rendering pseudo extension

src/gpu/gl/GrGLShaderBuilder.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gl/GrGLShaderBuilder.h"
 #include "gl/GrGLProgram.h"
 #include "gl/GrGLUniformHandle.h"
@@ skipping 168 matching lines @@
     switch (feature) {
         case kStandardDerivatives_GLSLFeature:
             if (!fGpu->glCaps().shaderDerivativeSupport()) {
                 return false;
             }
             if (kGLES_GrGLStandard == fGpu->glStandard()) {
                 this->addFSFeature(1 << kStandardDerivatives_GLSLFeature,
                                    "GL_OES_standard_derivatives");
             }
             return true;
+        case kTexCoordSupport_GLSLFeature:
+            if (!fGpu->glCaps().pathRenderingSupport()) {
+                return false;
+            }
+            if (kGLES_GrGLStandard == fGpu->glStandard()) {
+                this->addFSFeature(1 << kTexCoordSupport_GLSLFeature,
+                                   "GL_CHROMIUM_path_rendering");
+            }
+            return true;
         default:
             GrCrash("Unexpected GLSLFeature requested.");
             return false;
     }
 }
 
 bool GrGLShaderBuilder::enablePrivateFeature(GLSLPrivateFeature feature) {
     switch (feature) {
         case kFragCoordConventions_GLSLPrivateFeature:
             if (!fGpu->glCaps().fragCoordConventionsSupport()) {
@@ skipping 770 matching lines @@
     : INHERITED(gpu, uniformManager, desc)
     , fNumTexCoordSets(0) {
 
     SkASSERT(!desc.getHeader().fHasVertexCode);
     SkASSERT(gpu->glCaps().pathRenderingSupport());
     SkASSERT(GrGLProgramDesc::kAttribute_ColorInput != desc.getHeader().fColorInput);
     SkASSERT(GrGLProgramDesc::kAttribute_ColorInput != desc.getHeader().fCoverageInput);
 }
 
 int GrGLFragmentOnlyShaderBuilder::addTexCoordSets(int count) {
+    SkAssertResult(this->enableFeature(kTexCoordSupport_GLSLFeature));
     int firstFreeCoordSet = fNumTexCoordSets;
     fNumTexCoordSets += count;
     SkASSERT(gpu()->glCaps().maxFixedFunctionTextureCoords() >= fNumTexCoordSets);
     return firstFreeCoordSet;
 }
 
 GrGLProgramEffects* GrGLFragmentOnlyShaderBuilder::createAndEmitEffects(
         const GrEffectStage* effectStages[],
         const EffectKey effectKeys[],
         int effectCnt,
         GrGLSLExpr4* inOutFSColor) {
 
     GrGLPathTexGenProgramEffectsBuilder pathTexGenEffectsBuilder(this,
                                                                  effectCnt);
     this->INHERITED::createAndEmitEffects(&pathTexGenEffectsBuilder,
                                           effectStages,
                                           effectKeys,
                                           effectCnt,
                                           inOutFSColor);
     return pathTexGenEffectsBuilder.finish();
 }
+
+bool GrGLFragmentOnlyShaderBuilder::compileAndAttachShaders(GrGLuint programId, SkTDArray<GrGLuint>* shaderIds) const {
+    // Command buffer does not support vertexshader-less programs.
+    // Use a dummy shader.
+    const GrGLContext& glCtx = this->gpu()->glContext();
+    SkString vertShaderSrc(GrGetGLSLVersionDecl(this->ctxInfo()));
+    vertShaderSrc.append("void main() {\n");
+    vertShaderSrc.append("gl_Position = vec4(1);");
+    vertShaderSrc.append("}\n");
+    GrGLuint vertShaderId = attach_shader(glCtx, programId, GR_GL_VERTEX_SHADER, vertShaderSrc);
+    if (!vertShaderId) {
+        return false;
+    }
+    *shaderIds->append() = vertShaderId;
+
+    return this->INHERITED::compileAndAttachShaders(programId, shaderIds);
+}
+