Implement NVPR on GLES

src/gpu/gl/GrGLProgramEffects.cpp

Index: src/gpu/gl/GrGLProgramEffects.cpp
diff --git a/src/gpu/gl/GrGLProgramEffects.cpp b/src/gpu/gl/GrGLProgramEffects.cpp
index ee8bf60955515a5b0ae5b6441e95ee58b58231c8..7b597109efd4ef0ae582ce816a7b4fd88df24941 100644
--- a/src/gpu/gl/GrGLProgramEffects.cpp
+++ b/src/gpu/gl/GrGLProgramEffects.cpp
@@ -284,6 +284,13 @@ void GrGLVertexProgramEffects::emitTransforms(GrGLFullShaderBuilder* builder,
     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;
@@ -319,7 +326,13 @@ void GrGLVertexProgramEffects::emitTransforms(GrGLFullShaderBuilder* builder,
         }
         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() :
@@ -339,6 +352,7 @@ void GrGLVertexProgramEffects::emitTransforms(GrGLFullShaderBuilder* builder,
 }
 
 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();
@@ -347,12 +361,17 @@ void GrGLVertexProgramEffects::setData(GrGpuGL* gpu,
     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];
@@ -368,6 +387,35 @@ void GrGLVertexProgramEffects::setTransformData(const GrGLUniformManager& unifor
     }
 }
 
+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)
@@ -434,6 +482,7 @@ void GrGLPathTexGenProgramEffects::setupPathTexGen(GrGLFragmentOnlyShaderBuilder
 }
 
 void GrGLPathTexGenProgramEffects::setData(GrGpuGL* gpu,
+                                           GrGpu::DrawType,
                                        const GrGLUniformManager& uniformManager,
                                        const GrEffectStage* effectStages[]) {
     int numEffects = fGLEffects.count();