Use noperspective interpolation for 2D draws

src/gpu/gl/GrGLGpu.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 "GrGLGpu.h"
 #include "GrGLGLSL.h"
 #include "GrGLStencilAttachment.h"
@@ skipping 267 matching lines @@
     }
 
     if (0 != fPLSSetupProgram.fProgram) {
         GL_CALL(DeleteProgram(fPLSSetupProgram.fProgram));
     }
 
     delete fProgramCache;
 }
 
 void GrGLGpu::createPLSSetupProgram() {
-    const char* version = this->glCaps().glslCaps()->versionDeclString();
+    const GrGLSLCaps* glslCaps = this->glCaps().glslCaps();
+    const char* version = glslCaps->versionDeclString();
 
     GrGLSLShaderVar aVertex("a_vertex", kVec2f_GrSLType, GrShaderVar::kAttribute_TypeModifier);
     GrGLSLShaderVar uTexCoordXform("u_texCoordXform", kVec4f_GrSLType,
                                    GrShaderVar::kUniform_TypeModifier);
     GrGLSLShaderVar uPosXform("u_posXform", kVec4f_GrSLType, GrShaderVar::kUniform_TypeModifier);
     GrGLSLShaderVar uTexture("u_texture", kSampler2D_GrSLType, GrShaderVar::kUniform_TypeModifier);
     GrGLSLShaderVar vTexCoord("v_texCoord", kVec2f_GrSLType, GrShaderVar::kVaryingOut_TypeModifier);
     
     SkString vshaderTxt(version);
-    aVertex.appendDecl(this->glCaps().glslCaps(), &vshaderTxt);
+    if (glslCaps->noperspectiveInterpolationSupport()) {
+        if (const char* extension = glslCaps->noperspectiveInterpolationExtensionString()) {
+            vshaderTxt.appendf("#extension %s : require\n", extension);
+        }
+        vTexCoord.addModifier("noperspective");
+    }
+    aVertex.appendDecl(glslCaps, &vshaderTxt);
     vshaderTxt.append(";");
-    uTexCoordXform.appendDecl(this->glCaps().glslCaps(), &vshaderTxt);
+    uTexCoordXform.appendDecl(glslCaps, &vshaderTxt);
     vshaderTxt.append(";");
-    uPosXform.appendDecl(this->glCaps().glslCaps(), &vshaderTxt);
+    uPosXform.appendDecl(glslCaps, &vshaderTxt);
     vshaderTxt.append(";");
-    vTexCoord.appendDecl(this->glCaps().glslCaps(), &vshaderTxt);
+    vTexCoord.appendDecl(glslCaps, &vshaderTxt);
     vshaderTxt.append(";");
     
     vshaderTxt.append(
         "// PLS Setup Program VS\n"
         "void main() {"
         "  gl_Position.xy = a_vertex * u_posXform.xy + u_posXform.zw;"
         "  gl_Position.zw = vec2(0, 1);"
         "}"
     );
 
     SkString fshaderTxt(version);
+    if (glslCaps->noperspectiveInterpolationSupport()) {
+        if (const char* extension = glslCaps->noperspectiveInterpolationExtensionString()) {
+            fshaderTxt.appendf("#extension %s : require\n", extension);
+        }
+    }
     fshaderTxt.append("#extension ");
-    fshaderTxt.append(this->glCaps().glslCaps()->fbFetchExtensionString());
+    fshaderTxt.append(glslCaps->fbFetchExtensionString());
     fshaderTxt.append(" : require\n");
     fshaderTxt.append("#extension GL_EXT_shader_pixel_local_storage : require\n");
-    GrGLSLAppendDefaultFloatPrecisionDeclaration(kDefault_GrSLPrecision,
-                                                 *this->glCaps().glslCaps(),
-                                                 &fshaderTxt);
+    GrGLSLAppendDefaultFloatPrecisionDeclaration(kDefault_GrSLPrecision, *glslCaps, &fshaderTxt);
     vTexCoord.setTypeModifier(GrShaderVar::kVaryingIn_TypeModifier);
-    vTexCoord.appendDecl(this->glCaps().glslCaps(), &fshaderTxt);
+    vTexCoord.appendDecl(glslCaps, &fshaderTxt);
     fshaderTxt.append(";");
-    uTexture.appendDecl(this->glCaps().glslCaps(), &fshaderTxt);
+    uTexture.appendDecl(glslCaps, &fshaderTxt);
     fshaderTxt.append(";");
 
     fshaderTxt.appendf(
         "// PLS Setup Program FS\n"
         GR_GL_PLS_PATH_DATA_DECL
         "void main() {\n"
         "    " GR_GL_PLS_DSTCOLOR_NAME " = gl_LastFragColorARM;\n"
         "    pls.windings = ivec4(0, 0, 0, 0);\n"
         "}"
     );
@@ skipping 2879 matching lines @@
         return this->copySurfaceAsBlitFramebuffer(dst, src, srcRect, dstPoint);
     }
 
     return false;
 }
 
 void GrGLGpu::createCopyPrograms() {
     for (size_t i = 0; i < SK_ARRAY_COUNT(fCopyPrograms); ++i) {
         fCopyPrograms[i].fProgram = 0;
     }
-    const char* version = this->glCaps().glslCaps()->versionDeclString();
+    const GrGLSLCaps* glslCaps = this->glCaps().glslCaps();
+    const char* version = glslCaps->versionDeclString();
     static const GrSLType kSamplerTypes[3] = { kSampler2D_GrSLType, kSamplerExternal_GrSLType,
                                                kSampler2DRect_GrSLType };
     SkASSERT(3 == SK_ARRAY_COUNT(fCopyPrograms));
     for (int i = 0; i < 3; ++i) {
         if (kSamplerExternal_GrSLType == kSamplerTypes[i] &&
             !this->glCaps().externalTextureSupport()) {
             continue;
         }
         if (kSampler2DRect_GrSLType == kSamplerTypes[i] &&
             !this->glCaps().rectangleTextureSupport()) {
             continue;
         }
         GrGLSLShaderVar aVertex("a_vertex", kVec2f_GrSLType, GrShaderVar::kAttribute_TypeModifier);
         GrGLSLShaderVar uTexCoordXform("u_texCoordXform", kVec4f_GrSLType,
                                      GrShaderVar::kUniform_TypeModifier);
         GrGLSLShaderVar uPosXform("u_posXform", kVec4f_GrSLType,
                                   GrShaderVar::kUniform_TypeModifier);
         GrGLSLShaderVar uTexture("u_texture", kSamplerTypes[i],
                                  GrShaderVar::kUniform_TypeModifier);
         GrGLSLShaderVar vTexCoord("v_texCoord", kVec2f_GrSLType,
                                   GrShaderVar::kVaryingOut_TypeModifier);
         GrGLSLShaderVar oFragColor("o_FragColor", kVec4f_GrSLType,
                                    GrShaderVar::kOut_TypeModifier);
 
         SkString vshaderTxt(version);
-        aVertex.appendDecl(this->glCaps().glslCaps(), &vshaderTxt);
+        if (glslCaps->noperspectiveInterpolationSupport()) {
+            if (const char* extension = glslCaps->noperspectiveInterpolationExtensionString()) {
+                vshaderTxt.appendf("#extension %s : require\n", extension);
+            }
+            vTexCoord.addModifier("noperspective");
+        }
+
+        aVertex.appendDecl(glslCaps, &vshaderTxt);
         vshaderTxt.append(";");
-        uTexCoordXform.appendDecl(this->glCaps().glslCaps(), &vshaderTxt);
+        uTexCoordXform.appendDecl(glslCaps, &vshaderTxt);
         vshaderTxt.append(";");
-        uPosXform.appendDecl(this->glCaps().glslCaps(), &vshaderTxt);
+        uPosXform.appendDecl(glslCaps, &vshaderTxt);
         vshaderTxt.append(";");
-        vTexCoord.appendDecl(this->glCaps().glslCaps(), &vshaderTxt);
+        vTexCoord.appendDecl(glslCaps, &vshaderTxt);
         vshaderTxt.append(";");
 
         vshaderTxt.append(
             "// Copy Program VS\n"
             "void main() {"
             "  v_texCoord = a_vertex.xy * u_texCoordXform.xy + u_texCoordXform.zw;"
             "  gl_Position.xy = a_vertex * u_posXform.xy + u_posXform.zw;"
             "  gl_Position.zw = vec2(0, 1);"
             "}"
         );
 
         SkString fshaderTxt(version);
+        if (glslCaps->noperspectiveInterpolationSupport()) {
+            if (const char* extension = glslCaps->noperspectiveInterpolationExtensionString()) {
+                fshaderTxt.appendf("#extension %s : require\n", extension);
+            }
+        }
         if (kSamplerTypes[i] == kSamplerExternal_GrSLType) {
             fshaderTxt.appendf("#extension %s : require\n",
-                               this->glCaps().glslCaps()->externalTextureExtensionString());
+                               glslCaps->externalTextureExtensionString());
         }
-        GrGLSLAppendDefaultFloatPrecisionDeclaration(kDefault_GrSLPrecision,
-                                                     *this->glCaps().glslCaps(),
+        GrGLSLAppendDefaultFloatPrecisionDeclaration(kDefault_GrSLPrecision, *glslCaps,
                                                      &fshaderTxt);
         vTexCoord.setTypeModifier(GrShaderVar::kVaryingIn_TypeModifier);
-        vTexCoord.appendDecl(this->glCaps().glslCaps(), &fshaderTxt);
+        vTexCoord.appendDecl(glslCaps, &fshaderTxt);
         fshaderTxt.append(";");
-        uTexture.appendDecl(this->glCaps().glslCaps(), &fshaderTxt);
+        uTexture.appendDecl(glslCaps, &fshaderTxt);
         fshaderTxt.append(";");
         const char* fsOutName;
-        if (this->glCaps().glslCaps()->mustDeclareFragmentShaderOutput()) {
-            oFragColor.appendDecl(this->glCaps().glslCaps(), &fshaderTxt);
+        if (glslCaps->mustDeclareFragmentShaderOutput()) {
+            oFragColor.appendDecl(glslCaps, &fshaderTxt);
             fshaderTxt.append(";");
             fsOutName = oFragColor.c_str();
         } else {
             fsOutName = "gl_FragColor";
         }
         fshaderTxt.appendf(
             "// Copy Program FS\n"
             "void main() {"
             "  %s = %s(u_texture, v_texCoord);"
             "}",
@@ skipping 547 matching lines @@
         if (GR_GL_TEXTURE_EXTERNAL == glTexture->target() ||
             GR_GL_TEXTURE_RECTANGLE == glTexture->target()) {
             copyParams->fFilter = GrTextureParams::kNone_FilterMode;
             copyParams->fWidth = texture->width();
             copyParams->fHeight = texture->height();
             return true;
         }
     }
     return false;
 }