Implement NVPR on GLES

src/gpu/gl/GrGpuGL.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrGpuGL.h"
 #include "GrGLNameAllocator.h"
@@ skipping 1836 matching lines @@
     GrGLint writeMask = fHWPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
     GL_CALL(StencilFillPath(id, fillMode, writeMask));
 }
 
 void GrGpuGL::onGpuDrawPath(const GrPath* path, SkPath::FillType fill) {
     SkASSERT(this->caps()->pathRenderingSupport());
 
     GrGLuint id = static_cast<const GrGLPath*>(path)->pathID();
     SkASSERT(NULL != this->drawState()->getRenderTarget());
     SkASSERT(NULL != this->drawState()->getRenderTarget()->getStencilBuffer());
-    SkASSERT(!fCurrentProgram->hasVertexShader());
 
     flushPathStencilSettings(fill);
     const SkStrokeRec& stroke = path->getStroke();
 
     SkPath::FillType nonInvertedFill = SkPath::ConvertToNonInverseFillType(fill);
     SkASSERT(!fHWPathStencilSettings.isTwoSided());
     GrGLenum fillMode =
         gr_stencil_op_to_gl_path_rendering_fill_mode(fHWPathStencilSettings.passOp(GrStencilSettings::kFront_Face));
     GrGLint writeMask = fHWPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
 
@@ skipping 32 matching lines @@
     }
 }
 
 void GrGpuGL::onGpuDrawPaths(int pathCount, const GrPath** paths,
                              const SkMatrix* transforms,
                              SkPath::FillType fill,
                              SkStrokeRec::Style stroke) {
     SkASSERT(this->caps()->pathRenderingSupport());
     SkASSERT(NULL != this->drawState()->getRenderTarget());
     SkASSERT(NULL != this->drawState()->getRenderTarget()->getStencilBuffer());
-    SkASSERT(!fCurrentProgram->hasVertexShader());
     SkASSERT(stroke != SkStrokeRec::kHairline_Style);
 
     SkAutoMalloc pathData(pathCount * sizeof(GrGLuint));
     SkAutoMalloc transformData(pathCount * sizeof(GrGLfloat) * 6);
     GrGLfloat* transformValues =
         reinterpret_cast<GrGLfloat*>(transformData.get());
     GrGLuint* pathIDs = reinterpret_cast<GrGLuint*>(pathData.get());
 
     for (int i = 0; i < pathCount; ++i) {
         SkASSERT(transforms[i].asAffine(NULL));
@@ skipping 471 matching lines @@
         matrix.cheapEqualTo(fHWProjectionMatrixState.fViewMatrix)) {
         return;
     }
 
     fHWProjectionMatrixState.fViewMatrix = matrix;
     fHWProjectionMatrixState.fRenderTargetSize = renderTargetSize;
     fHWProjectionMatrixState.fRenderTargetOrigin = renderTargetOrigin;
 
     GrGLfloat glMatrix[4 * 4];
     fHWProjectionMatrixState.getRTAdjustedGLMatrix<4>(glMatrix);
-    GL_CALL(MatrixLoadf(GR_GL_PROJECTION, glMatrix));
+
+    GrGLenum matrixMode =
+        this->glStandard() == kGLES_GrGLStandard ? GR_GL_PATH_PROJECTION : GR_GL_PROJECTION;
+
+    GL_CALL(MatrixLoadf(matrixMode, glMatrix));
 }
 
 void GrGpuGL::enablePathTexGen(int unitIdx,
                                PathTexGenComponents components,
                                const GrGLfloat* coefficients) {
     SkASSERT(this->glCaps().pathRenderingSupport());
     SkASSERT(components >= kS_PathTexGenComponents &&
              components <= kSTR_PathTexGenComponents);
     SkASSERT(this->glCaps().maxFixedFunctionTextureCoords() >= unitIdx);
 
@@ skipping 59 matching lines @@
         SkASSERT(0 != fHWPathTexGenSettings[i].fNumComponents);
 
         this->setTextureUnit(i);
         GL_CALL(PathTexGen(GR_GL_TEXTURE0 + i, GR_GL_NONE, 0, NULL));
         fHWPathTexGenSettings[i].fNumComponents = 0;
     }
 
     fHWActivePathTexGenSets = numUsedTexCoordSets;
 }
 
+void GrGpuGL::setProgramPathFragmentInputGen(int fragmentInputLocation,
+                                             size_t components,
+                                             const GrGLfloat* coefficients) {
+    GL_CALL(ProgramPathFragmentInputGen(fHWProgramID,

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

If we consider the role of GrGpuGL to contain functions that draw and functions
that affect the global GL state, then this function is very much in a wrong
place.

However, to me it seems that getting robust access to the program id is not
possible without refactoring

+                                        fragmentInputLocation,
+                                        GR_GL_OBJECT_LINEAR,
+                                        components,
+                                        coefficients));
+}
+
 void GrGpuGL::flushMiscFixedFunctionState() {
 
     const GrDrawState& drawState = this->getDrawState();
 
     if (drawState.isDitherState()) {
         if (kYes_TriState != fHWDitherEnabled) {
             GL_CALL(Enable(GR_GL_DITHER));
             fHWDitherEnabled = kYes_TriState;
         }
     } else {
@@ skipping 523 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }