Implement NVPR on GLES

src/gpu/gl/GrGLProgramEffects.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 "GrGLProgramEffects.h"
 #include "GrDrawEffect.h"
 #include "gl/GrGLEffect.h"
@@ skipping 266 matching lines @@
 }
 
 void GrGLVertexProgramEffects::emitTransforms(GrGLFullShaderBuilder* builder,
                                               const GrEffectRef& effect,
                                               EffectKey effectKey,
                                               TransformedCoordsArray* outCoords) {
     SkTArray<Transform, true>& transforms = fTransforms.push_back();
     EffectKey totalKey = GrBackendEffectFactory::GetTransformKey(effectKey);
     int numTransforms = effect->numTransforms();
     transforms.push_back_n(numTransforms);
+
+    SkTArray<FragmentInputTransform, true>* fragmentInputTransforms = NULL;
+    if (builder->ctxInfo().caps()->pathRenderingSupport()) {
+        fragmentInputTransforms = &fFragmentInputTransforms.push_back();
+        fragmentInputTransforms->push_back_n(numTransforms);
+    }
+
     for (int t = 0; t < numTransforms; t++) {
         GrSLType varyingType = kVoid_GrSLType;
         const char* uniName;
         switch (get_matrix_type(totalKey, t)) {
             case kNoPersp_MatrixType:
                 uniName = "StageMatrix";
                 varyingType = kVec2f_GrSLType;
                 break;
             case kGeneral_MatrixType:
                 uniName = "StageMatrix";
@@ skipping 15 matching lines @@
 
         const char* varyingName = "MatrixCoord";
         SkString suffixedVaryingName;
         if (0 != t) {
             suffixedVaryingName.append(varyingName);
             suffixedVaryingName.appendf("_%i", t);
             varyingName = suffixedVaryingName.c_str();
         }
         const char* vsVaryingName;
         const char* fsVaryingName;
-        builder->addVarying(varyingType, varyingName, &vsVaryingName, &fsVaryingName);
+        GrGLUniformManager::FragmentInputHandle fragmentInputHandle = builder->addVarying(
+            varyingType, varyingName, &vsVaryingName, &fsVaryingName);
+
+        if (fragmentInputTransforms) {
+            (*fragmentInputTransforms)[t].fHandle = fragmentInputHandle;
+            (*fragmentInputTransforms)[t].fType = varyingType;
+        }
 
         const GrGLShaderVar& coords = kPosition_GrCoordSet == get_source_coords(totalKey, t) ?
                                           builder->positionAttribute() :
                                           builder->localCoordsAttribute();
         // varying = matrix * coords (logically)
         SkASSERT(kVec2f_GrSLType == varyingType || kVec3f_GrSLType == varyingType);
         if (kVec2f_GrSLType == varyingType) {
             builder->vsCodeAppendf("\t%s = (%s * vec3(%s, 1)).xy;\n",
                                    vsVaryingName, uniName, coords.c_str());
         } else {
             builder->vsCodeAppendf("\t%s = %s * vec3(%s, 1);\n",
                                    vsVaryingName, uniName, coords.c_str());
         }
         SkNEW_APPEND_TO_TARRAY(outCoords, TransformedCoords,
                                (SkString(fsVaryingName), varyingType));
     }
 }
 
 void GrGLVertexProgramEffects::setData(GrGpuGL* gpu,
+                                       GrGpu::DrawType drawType,
                                        const GrGLUniformManager& uniformManager,
                                        const GrEffectStage* effectStages[]) {

[Kimmo Kinnunen, 2014/07/01 13:01:21]

So here we would need a context which would point to "all things related to the
linked shader program that is currently in use".

Currently this context is the uniformManager, which is a subset or derivation of
"result of shader program link information".

What I'm trying to say is that, to my understanding, this sets the parameters of
a specific shader program. However, the function does not have explicit access
to the shader program, it only has access to the parameter instances. Maybe this
in turn happens to look ok because the global nature of the uniform set
functions. It turns uglier with the equivalent ProgramPathFragmentInputGen,
because this function takes in the explicit program parameter..

     int numEffects = fGLEffects.count();
     SkASSERT(numEffects == fTransforms.count());
     SkASSERT(numEffects == fSamplers.count());
     for (int e = 0; e < numEffects; ++e) {
         GrDrawEffect drawEffect(*effectStages[e], fHasExplicitLocalCoords);
         fGLEffects[e]->setData(uniformManager, drawEffect);
-        this->setTransformData(uniformManager, drawEffect, e);
+        if (GrGpu::IsPathRenderingDrawType(drawType)) {
+            this->setFragmentInputTransformData(gpu, uniformManager, drawEffect, e);
+        } else {
+            this->setTransformData(gpu, uniformManager, drawEffect, e);
+        }
         this->bindTextures(gpu, *drawEffect.effect(), e);
     }
 }
 
-void GrGLVertexProgramEffects::setTransformData(const GrGLUniformManager& uniformManager,
+void GrGLVertexProgramEffects::setTransformData(GrGpuGL* gpu,
+                                                const GrGLUniformManager& uniformManager,
                                                 const GrDrawEffect& drawEffect,
                                                 int effectIdx) {
     SkTArray<Transform, true>& transforms = fTransforms[effectIdx];
     int numTransforms = transforms.count();
     SkASSERT(numTransforms == (*drawEffect.effect())->numTransforms());
     for (int t = 0; t < numTransforms; ++t) {
         SkASSERT(transforms[t].fHandle.isValid());
         const SkMatrix& matrix = get_transform_matrix(drawEffect, t);
         if (!transforms[t].fCurrentValue.cheapEqualTo(matrix)) {
             uniformManager.setSkMatrix(transforms[t].fHandle, matrix);
             transforms[t].fCurrentValue = matrix;
         }
     }
 }
 
+void GrGLVertexProgramEffects::setFragmentInputTransformData(
+    GrGpuGL* gpu,
+    const GrGLUniformManager& uniformManager,
+    const GrDrawEffect& drawEffect,
+    int effectIdx) {
+    SkTArray<FragmentInputTransform, true>& transforms = fFragmentInputTransforms[effectIdx];
+    int numTransforms = transforms.count();
+    SkASSERT(numTransforms == (*drawEffect.effect())->numTransforms());
+    for (int t = 0; t < numTransforms; ++t) {
+        SkASSERT(transforms[t].fHandle.isValid());
+        const SkMatrix& transform = get_transform_matrix(drawEffect, t);
+        if (transforms[t].fCurrentValue.cheapEqualTo(transform))
+            continue;
+        transforms[t].fCurrentValue = transform;
+        switch (transforms[t].fType) {
+            case kVec2f_GrSLType: {
+                uniformManager.setFragmentInput(transforms[t].fHandle, 2, transform);
+                break;
+            }
+            case kVec3f_GrSLType: {
+                uniformManager.setFragmentInput(transforms[t].fHandle, 3, transform);
+                break;
+            }
+            default:
+                SkFAIL("Unexpected matrixs type.");
+        }
+    }
+}
+
 GrGLVertexProgramEffectsBuilder::GrGLVertexProgramEffectsBuilder(GrGLFullShaderBuilder* builder,
                                                                  int reserveCount)
     : fBuilder(builder)
     , fProgramEffects(SkNEW_ARGS(GrGLVertexProgramEffects,
                                  (reserveCount, fBuilder->hasExplicitLocalCoords()))) {
 }
 
 void GrGLVertexProgramEffectsBuilder::emitEffect(const GrEffectStage& stage,
                                                  GrGLProgramEffects::EffectKey key,
                                                  const char* outColor,
@@ skipping 46 matching lines @@
     for (int t = 0; t < numTransforms; ++t) {
         GrSLType type = kGeneral_MatrixType == get_matrix_type(totalKey, t) ?
                             kVec3f_GrSLType :
                             kVec2f_GrSLType;
         name.printf("%s(gl_TexCoord[%i])", GrGLSLTypeString(type), texCoordIndex++);
         SkNEW_APPEND_TO_TARRAY(outCoords, TransformedCoords, (name, type));
     }
 }
 
 void GrGLPathTexGenProgramEffects::setData(GrGpuGL* gpu,
+                                           GrGpu::DrawType,
                                        const GrGLUniformManager& uniformManager,
                                        const GrEffectStage* effectStages[]) {
     int numEffects = fGLEffects.count();
     SkASSERT(numEffects == fTransforms.count());
     SkASSERT(numEffects == fSamplers.count());
     for (int e = 0; e < numEffects; ++e) {
         GrDrawEffect drawEffect(*effectStages[e], false);
         fGLEffects[e]->setData(uniformManager, drawEffect);
         this->setPathTexGenState(gpu, drawEffect, e);
         this->bindTextures(gpu, *drawEffect.effect(), e);
@@ skipping 36 matching lines @@
 }
 
 void GrGLPathTexGenProgramEffectsBuilder::emitEffect(const GrEffectStage& stage,
                                                      GrGLProgramEffects::EffectKey key,
                                                      const char* outColor,
                                                      const char* inColor,
                                                      int stageIndex) {
     SkASSERT(NULL != fProgramEffects.get());
     fProgramEffects->emitEffect(fBuilder, stage, key, outColor, inColor, stageIndex);
 }