Implement NVPR on GLES

src/gpu/gl/GrGLPathRendering.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gl/GrGLPathRendering.h"
 #include "gl/GrGLInterface.h"
 #include "gl/GrGLNameAllocator.h"
@@ skipping 37 matching lines @@
 
 GrGLPathRendering::GrGLPathRendering(GrGpuGL* gpu, const GrGLInterface* glInterface)
     : fGpu(gpu),
       fGLInterface(SkRef(glInterface)) {
     fCaps.thenFunctionsSupport =
         NULL != glInterface->fFunctions.fStencilThenCoverFillPath &&
         NULL != glInterface->fFunctions.fStencilThenCoverStrokePath &&
         NULL != glInterface->fFunctions.fStencilThenCoverFillPathInstanced &&
         NULL != glInterface->fFunctions.fStencilThenCoverStrokePathInstanced;
     fCaps.fragmentInputGenSupport =
+        kGLES_GrGLStandard == glInterface->fStandard &&
         NULL != glInterface->fFunctions.fProgramPathFragmentInputGen;
-    fHWPathTexGenSettings.reset(fGpu->glCaps().maxFixedFunctionTextureCoords());
+
+    if (!fCaps.fragmentInputGenSupport) {
+        fHWPathTexGenSettings.reset(fGpu->glCaps().maxFixedFunctionTextureCoords());
+    }
 }
 
 GrGLPathRendering::~GrGLPathRendering() {
 }
 
 void GrGLPathRendering::abandonGpuResources() {
     fPathNameAllocator.reset(NULL);
 }
 
 void GrGLPathRendering::onResetContext() {
     fHWProjectionMatrixState.invalidate();
     // we don't use the model view matrix.
-    GL_CALL(MatrixLoadIdentity(GR_GL_MODELVIEW));
+    GrGLenum matrixMode =
+        fGpu->glStandard() == kGLES_GrGLStandard ? GR_GL_PATH_MODELVIEW : GR_GL_MODELVIEW;
+    GL_CALL(MatrixLoadIdentity(matrixMode));
 
-    for (int i = 0; i < fGpu->glCaps().maxFixedFunctionTextureCoords(); ++i) {
-        GL_CALL(PathTexGen(GR_GL_TEXTURE0 + i, GR_GL_NONE, 0, NULL));
-        fHWPathTexGenSettings[i].fMode = GR_GL_NONE;
-        fHWPathTexGenSettings[i].fNumComponents = 0;
+    if (!caps().fragmentInputGenSupport) {
+        for (int i = 0; i < fGpu->glCaps().maxFixedFunctionTextureCoords(); ++i) {
+            GL_CALL(PathTexGen(GR_GL_TEXTURE0 + i, GR_GL_NONE, 0, NULL));
+            fHWPathTexGenSettings[i].fMode = GR_GL_NONE;
+            fHWPathTexGenSettings[i].fNumComponents = 0;
+        }
+        fHWActivePathTexGenSets = 0;
     }
-    fHWActivePathTexGenSets = 0;
     fHWPathStencilSettings.invalidate();
 }
 
 GrPath* GrGLPathRendering::createPath(const SkPath& inPath, const SkStrokeRec& stroke) {
     return SkNEW_ARGS(GrGLPath, (fGpu, inPath, stroke));
 }
 
 GrPathRange* GrGLPathRendering::createPathRange(size_t size, const SkStrokeRec& stroke) {
     return SkNEW_ARGS(GrGLPathRange, (fGpu, size, stroke));
 }
 
 void GrGLPathRendering::stencilPath(const GrPath* path, SkPath::FillType fill) {
     GrGLuint id = static_cast<const GrGLPath*>(path)->pathID();
     SkASSERT(NULL != fGpu->drawState()->getRenderTarget());
     SkASSERT(NULL != fGpu->drawState()->getRenderTarget()->getStencilBuffer());
 
     this->flushPathStencilSettings(fill);
 
     GrGLenum fillMode =
         gr_stencil_op_to_gl_path_rendering_fill_mode(fHWPathStencilSettings.passOp(GrStencilSettings::kFront_Face));
     GrGLint writeMask = fHWPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
     GL_CALL(StencilFillPath(id, fillMode, writeMask));
 }
 
 void GrGLPathRendering::drawPath(const GrPath* path, SkPath::FillType fill) {
     GrGLuint id = static_cast<const GrGLPath*>(path)->pathID();
     SkASSERT(NULL != fGpu->drawState()->getRenderTarget());
     SkASSERT(NULL != fGpu->drawState()->getRenderTarget()->getStencilBuffer());
-    SkASSERT(!fGpu->fCurrentProgram->hasVertexShader());
 
     this->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 34 matching lines @@
         fGpu->drawSimpleRect(bounds);
     }
 }
 
 void GrGLPathRendering::drawPaths(const GrPathRange* pathRange, const uint32_t indices[], int count,
                                   const float transforms[], PathTransformType transformsType,
                                   SkPath::FillType fill) {
     SkASSERT(fGpu->caps()->pathRenderingSupport());
     SkASSERT(NULL != fGpu->drawState()->getRenderTarget());
     SkASSERT(NULL != fGpu->drawState()->getRenderTarget()->getStencilBuffer());
-    SkASSERT(!fGpu->fCurrentProgram->hasVertexShader());
 
     GrGLuint baseID = static_cast<const GrGLPathRange*>(pathRange)->basePathID();
 
     this->flushPathStencilSettings(fill);
     const SkStrokeRec& stroke = pathRange->getStroke();
 
     SkPath::FillType nonInvertedFill =
         SkPath::ConvertToNonInverseFillType(fill);
 
     SkASSERT(!fHWPathStencilSettings.isTwoSided());
@@ skipping 163 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 =
+         fGpu->glStandard() == kGLES_GrGLStandard ? GR_GL_PATH_PROJECTION : GR_GL_PROJECTION;
+     GL_CALL(MatrixLoadf(matrixMode, glMatrix));
 }
 
 GrGLuint GrGLPathRendering::genPaths(GrGLsizei range) {
     if (range > 1) {
         GrGLuint name;
         GL_CALL_RET(name, GenPaths(range));
         return name;
     }
 
     if (NULL == fPathNameAllocator.get()) {
@@ skipping 99 matching lines @@
                                                     reference, mask, coverMode, transformType,
                                                     transformValues));
         return;
     }
 
     GL_CALL(StencilStrokePathInstanced(numPaths, pathNameType, paths, pathBase,
                                        reference, mask, transformType, transformValues));
     GL_CALL(CoverStrokePathInstanced(numPaths, pathNameType, paths, pathBase,
                                      coverMode, transformType, transformValues));
 }