Make appending default precision be controled by GLSL

bench/GLVec4ScalarBench.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkMatrix.h"
 #include "SkPoint.h"
 #include "SkString.h"
 
 #if SK_SUPPORT_GPU
 #include "GLBench.h"
 #include "gl/GrGLContext.h"
-#include "gl/GrGLGLSL.h"
 #include "gl/GrGLInterface.h"
 #include "gl/GrGLUtil.h"
+#include "glsl/GrGLSL.h"
 #include "glsl/GrGLSLCaps.h"
 #include "glsl/GrGLSLShaderVar.h"
 
 #include <stdio.h>
 
 /**
  * This is a GL benchmark for comparing the performance of using vec4 or float for coverage in GLSL.
  * The generated shader code from this bench will draw several overlapping circles, one in each
  * stage, to simulate coverage calculations.  The number of circles (i.e. the number of stages) can
  * be set as a parameter.
@@ skipping 58 matching lines @@
     CoverageSetup fCoverageSetup;
     uint32_t fNumStages;
     GrGLuint fVboId;
     GrGLuint fProgram;
     GrGLuint fFboTextureId;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLuint GLVec4ScalarBench::setupShader(const GrGLContext* ctx) {
-    const char* version = ctx->caps()->glslCaps()->versionDeclString();
+    const GrGLSLCaps* glslCaps = ctx->caps()->glslCaps();
+    const char* version = glslCaps->versionDeclString();
 
     // this shader draws fNumStages overlapping circles of increasing opacity (coverage) and
     // decreasing size, with the center of each subsequent circle closer to the bottom-right
     // corner of the screen than the previous circle.
 
     // set up vertex shader; this is a trivial vertex shader that passes through position and color
     GrGLSLShaderVar aPosition("a_position", kVec2f_GrSLType, GrShaderVar::kAttribute_TypeModifier);
     GrGLSLShaderVar oPosition("o_position", kVec2f_GrSLType, GrShaderVar::kVaryingOut_TypeModifier);
     GrGLSLShaderVar aColor("a_color", kVec3f_GrSLType, GrShaderVar::kAttribute_TypeModifier);
     GrGLSLShaderVar oColor("o_color", kVec3f_GrSLType, GrShaderVar::kVaryingOut_TypeModifier);
 
     SkString vshaderTxt(version);
-    aPosition.appendDecl(ctx->caps()->glslCaps(), &vshaderTxt);
+    aPosition.appendDecl(glslCaps, &vshaderTxt);
     vshaderTxt.append(";\n");
-    aColor.appendDecl(ctx->caps()->glslCaps(), &vshaderTxt);
+    aColor.appendDecl(glslCaps, &vshaderTxt);
     vshaderTxt.append(";\n");
-    oPosition.appendDecl(ctx->caps()->glslCaps(), &vshaderTxt);
+    oPosition.appendDecl(glslCaps, &vshaderTxt);
     vshaderTxt.append(";\n");
-    oColor.appendDecl(ctx->caps()->glslCaps(), &vshaderTxt);
+    oColor.appendDecl(glslCaps, &vshaderTxt);
     vshaderTxt.append(";\n");
 
     vshaderTxt.append(
             "void main()\n"
             "{\n"
             "    gl_Position = vec4(a_position, 0.0, 1.0);\n"
             "    o_position = a_position;\n"
             "    o_color = a_color;\n"
             "}\n");
 
     const GrGLInterface* gl = ctx->interface();
 
     // set up fragment shader; this fragment shader will have fNumStages coverage stages plus an
     // XP stage at the end.  Each coverage stage computes the pixel's distance from some hard-
     // coded center and compare that to some hard-coded circle radius to compute a coverage.
     // Then, this coverage is mixed with the coverage from the previous stage and passed to the
     // next stage.
     GrGLSLShaderVar oFragColor("o_FragColor", kVec4f_GrSLType, GrShaderVar::kOut_TypeModifier);
     SkString fshaderTxt(version);
-    GrGLAppendGLSLDefaultFloatPrecisionDeclaration(kDefault_GrSLPrecision, gl->fStandard,
-                                                   &fshaderTxt);
+    GrGLSLAppendDefaultFloatPrecisionDeclaration(kDefault_GrSLPrecision, *glslCaps, &fshaderTxt);
     oPosition.setTypeModifier(GrShaderVar::kVaryingIn_TypeModifier);
-    oPosition.appendDecl(ctx->caps()->glslCaps(), &fshaderTxt);
+    oPosition.appendDecl(glslCaps, &fshaderTxt);
     fshaderTxt.append(";\n");
     oColor.setTypeModifier(GrShaderVar::kVaryingIn_TypeModifier);
-    oColor.appendDecl(ctx->caps()->glslCaps(), &fshaderTxt);
+    oColor.appendDecl(glslCaps, &fshaderTxt);
     fshaderTxt.append(";\n");
 
     const char* fsOutName;
-    if (ctx->caps()->glslCaps()->mustDeclareFragmentShaderOutput()) {
-        oFragColor.appendDecl(ctx->caps()->glslCaps(), &fshaderTxt);
+    if (glslCaps->mustDeclareFragmentShaderOutput()) {
+        oFragColor.appendDecl(glslCaps, &fshaderTxt);
         fshaderTxt.append(";\n");
         fsOutName = oFragColor.c_str();
     } else {
         fsOutName = "gl_FragColor";
     }
 
 
     fshaderTxt.appendf(
             "void main()\n"
             "{\n"
@@ skipping 138 matching lines @@
 DEF_BENCH( return new GLVec4ScalarBench(GLVec4ScalarBench::kUseScalar_CoverageSetup, 2) )
 DEF_BENCH( return new GLVec4ScalarBench(GLVec4ScalarBench::kUseVec4_CoverageSetup, 2) )
 DEF_BENCH( return new GLVec4ScalarBench(GLVec4ScalarBench::kUseScalar_CoverageSetup, 4) )
 DEF_BENCH( return new GLVec4ScalarBench(GLVec4ScalarBench::kUseVec4_CoverageSetup, 4) )
 DEF_BENCH( return new GLVec4ScalarBench(GLVec4ScalarBench::kUseScalar_CoverageSetup, 6) )
 DEF_BENCH( return new GLVec4ScalarBench(GLVec4ScalarBench::kUseVec4_CoverageSetup, 6) )
 DEF_BENCH( return new GLVec4ScalarBench(GLVec4ScalarBench::kUseScalar_CoverageSetup, 8) )
 DEF_BENCH( return new GLVec4ScalarBench(GLVec4ScalarBench::kUseVec4_CoverageSetup, 8) )
 
 #endif