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 "GrGLStencilBuffer.h"
@@ skipping 118 matching lines @@
 
 static bool gPrintStartupSpew;
 
 GrGpuGL::GrGpuGL(const GrGLContext& ctx, GrContext* context)
     : GrGpu(context)
     , fGLContext(ctx) {
 
     SkASSERT(ctx.isInitialized());
     fCaps.reset(SkRef(ctx.caps()));
 
+    if (this->glCaps().pathRenderingSupport()) {
+        fPathRendering.reset(GrGLPathRendering::Create(glInterface()));
+    }
+
     fHWBoundTextureUniqueIDs.reset(this->glCaps().maxFragmentTextureUnits());
-    fHWPathTexGenSettings.reset(this->glCaps().maxFixedFunctionTextureCoords());
+    if (this->glCaps().pathRenderingSupport() &&
+        !this->pathRendering()->caps().fragmentInputGenSupport) {

[bsalomon, 2014/08/07 21:02:52]

Maybe we should move the hw path tex gen settings stuff into GrGLPathRendering
and move the cap bits that specify particulars of the nvpr extension in play
there as well.. I'm not crazy about having this public fragmentinputGenSupport
on caps and it feels like GrGLPathRendering would better encapsulate path
rendering.

[Chris Dalton, 2014/08/07 23:02:55]

The original idea for GrGLPathRendering was to mirror the NVPR api exactly,
which does require a check for fragmentinputGenSupport (since it is impossible
to provide a backup implementation).

But we could alternatively invent our own non-nvpr method on GrGLPathRendering
that uses ProgramPathFragmentInputGen and falls back on PathTexGen. It would be
tricky though, since GrGLPathRendering would then have to somehow influence the
shader builders and coord transforms.

+        fHWPathTexGenSettings.reset(this->glCaps().maxFixedFunctionTextureCoords());
+    }
 
     GrGLClearErr(fGLContext.interface());
     if (gPrintStartupSpew) {
         const GrGLubyte* vendor;
         const GrGLubyte* renderer;
         const GrGLubyte* version;
         GL_CALL_RET(vendor, GetString(GR_GL_VENDOR));
         GL_CALL_RET(renderer, GetString(GR_GL_RENDERER));
         GL_CALL_RET(version, GetString(GR_GL_VERSION));
         GrPrintf("------------------------- create GrGpuGL %p --------------\n",
                  this);
         GrPrintf("------ VENDOR %s\n", vendor);
         GrPrintf("------ RENDERER %s\n", renderer);
         GrPrintf("------ VERSION %s\n",  version);
         GrPrintf("------ EXTENSIONS\n");
         ctx.extensions().print();
         GrPrintf("\n");
         GrPrintf(this->glCaps().dump().c_str());
     }
 
     fProgramCache = SkNEW_ARGS(ProgramCache, (this));
 
     SkASSERT(this->glCaps().maxVertexAttributes() >= GrDrawState::kMaxVertexAttribCnt);
 
     fLastSuccessfulStencilFmtIdx = 0;
     fHWProgramID = 0;
-
-    if (this->glCaps().pathRenderingSupport()) {
-        fPathRendering.reset(GrGLPathRendering::Create(glInterface()));
-    }
 }
 
 GrGpuGL::~GrGpuGL() {
     if (0 != fHWProgramID) {
         // detach the current program so there is no confusion on OpenGL's part
         // that we want it to be deleted
         SkASSERT(fHWProgramID == fCurrentProgram->programID());
         GL_CALL(UseProgram(0));
     }
 
@@ skipping 141 matching lines @@
         fHWGeometryState.invalidate();
     }
 
     if (resetBits & kRenderTarget_GrGLBackendState) {
         fHWBoundRenderTargetUniqueID = SK_InvalidUniqueID;
     }
 
     if (resetBits & kPathRendering_GrGLBackendState) {
         if (this->caps()->pathRenderingSupport()) {
             fHWProjectionMatrixState.invalidate();
             // we don't use the model view matrix.

[bsalomon, 2014/08/07 21:02:52]

Again, I think we should move this state tracking stuff to the PR class.

-            GL_CALL(MatrixLoadIdentity(GR_GL_MODELVIEW));
+            GrGLenum matrixMode =
+                this->glStandard() == kGLES_GrGLStandard ? GR_GL_PATH_MODELVIEW : GR_GL_MODELVIEW;
 
-            for (int i = 0; i < this->glCaps().maxFixedFunctionTextureCoords(); ++i) {
-                fPathRendering->pathTexGen(GR_GL_TEXTURE0 + i, GR_GL_NONE, 0, NULL);
-                fHWPathTexGenSettings[i].fMode = GR_GL_NONE;
-                fHWPathTexGenSettings[i].fNumComponents = 0;
+            GL_CALL(MatrixLoadIdentity(matrixMode));
+
+            if (!this->pathRendering()->caps().fragmentInputGenSupport) {
+                for (int i = 0; i < this->glCaps().maxFixedFunctionTextureCoords(); ++i) {
+                    fPathRendering->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();
     }
 
     // we assume these values
     if (resetBits & kPixelStore_GrGLBackendState) {
         if (this->glCaps().unpackRowLengthSupport()) {
             GL_CALL(PixelStorei(GR_GL_UNPACK_ROW_LENGTH, 0));
         }
         if (this->glCaps().packRowLengthSupport()) {
@@ skipping 1536 matching lines @@
     GrGLint writeMask = fHWPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
     fPathRendering->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 @@
         }
 
         this->drawSimpleRect(bounds);
     }
 }
 
 void GrGpuGL::onGpuDrawPaths(const GrPathRange* pathRange,
                              const uint32_t indices[], int count,
                              const float transforms[], PathTransformType transformsType,
                              SkPath::FillType fill) {
     SkASSERT(this->caps()->pathRenderingSupport());

[bsalomon, 2014/08/07 21:02:52]

Move whole impl to path rendering class?

     SkASSERT(NULL != this->drawState()->getRenderTarget());
     SkASSERT(NULL != this->drawState()->getRenderTarget()->getStencilBuffer());
-    SkASSERT(!fCurrentProgram->hasVertexShader());
 
     GrGLuint baseID = static_cast<const GrGLPathRange*>(pathRange)->basePathID();
 
     flushPathStencilSettings(fill);
     const SkStrokeRec& stroke = pathRange->getStroke();
 
     SkPath::FillType nonInvertedFill =
         SkPath::ConvertToNonInverseFillType(fill);
 
     SkASSERT(!fHWPathStencilSettings.isTwoSided());
@@ skipping 415 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 =

[bsalomon, 2014/08/07 21:02:52]

Move to PR class?

+        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 567 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }