Revert of Added a GLBench for testing performance of vec4 vs scalar for coverage in generated shader

bench/GLVec4ScalarBench.cpp

Index: bench/GLVec4ScalarBench.cpp
diff --git a/bench/GLVec4ScalarBench.cpp b/bench/GLVec4ScalarBench.cpp
deleted file mode 100644
index 1ba8855862c92a55d7ed8f6212f47a34bf126c17..0000000000000000000000000000000000000000
--- a/bench/GLVec4ScalarBench.cpp
+++ /dev/null
@@ -1,311 +0,0 @@
-/*
- * 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/GrGLGLSL.h"
-#include "gl/GrGLInterface.h"
-#include "gl/GrGLShaderVar.h"
-#include "gl/GrGLUtil.h"
-#include "glsl/GrGLSLCaps.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.
- */
-
-class GLVec4ScalarBench : public GLBench {
-public:
-    /*
-     * Use float or vec4 as GLSL data type for the output coverage
-     */
-    enum CoverageSetup {
-        kUseScalar_CoverageSetup,
-        kUseVec4_CoverageSetup,
-    };
-
-    /*
-     * numStages determines the number of shader stages before the XP,
-     * which consequently determines how many circles are drawn
-     */
-    GLVec4ScalarBench(CoverageSetup coverageSetup, uint32_t numStages)
-        : fCoverageSetup(coverageSetup)
-        , fNumStages(numStages)
-        , fVboId(0)
-        , fProgram(0)
-        , fVaoId(0) {
-        fName = NumStagesSetupToStr(coverageSetup, numStages);
-    }
-
-protected:
-    const char* onGetName() override {
-        return fName.c_str();
-    }
-
-    void setup(const GrGLContext*) override;
-    void glDraw(const int loops, const GrGLContext*) override;
-    void teardown(const GrGLInterface*) override;
-
-private:
-    void setupSingleVbo(const GrGLInterface*, const SkMatrix*);
-    GrGLuint setupShader(const GrGLContext*);
-
-
-    static SkString NumStagesSetupToStr(CoverageSetup coverageSetup, uint32_t numStages) {
-        SkString name("GLVec4ScalarBench");
-        switch (coverageSetup) {
-            default:
-            case kUseScalar_CoverageSetup:
-                name.appendf("_scalar_%u_stage", numStages);
-                break;
-            case kUseVec4_CoverageSetup:
-                name.appendf("_vec4_%u_stage", numStages);
-                break;
-        }
-        return name;
-    }
-
-    static const GrGLuint kScreenWidth = 800;
-    static const GrGLuint kScreenHeight = 600;
-    static const uint32_t kNumTriPerDraw = 512;
-    static const uint32_t kVerticesPerTri = 3;
-
-    SkString fName;
-    CoverageSetup fCoverageSetup;
-    uint32_t fNumStages;
-    GrGLuint fVboId;
-    GrGLuint fProgram;
-    GrGLuint fVaoId;
-    GrGLuint fFboTextureId;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-GrGLuint GLVec4ScalarBench::setupShader(const GrGLContext* ctx) {
-    const char* version = GrGLGetGLSLVersionDecl(*ctx);
-
-    // 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
-    GrGLShaderVar aPosition("a_position", kVec2f_GrSLType, GrShaderVar::kAttribute_TypeModifier);
-    GrGLShaderVar oPosition("o_position", kVec2f_GrSLType, GrShaderVar::kVaryingOut_TypeModifier);
-    GrGLShaderVar aColor("a_color", kVec3f_GrSLType, GrShaderVar::kAttribute_TypeModifier);
-    GrGLShaderVar oColor("o_color", kVec3f_GrSLType, GrShaderVar::kVaryingOut_TypeModifier);
-
-    SkString vshaderTxt(version);
-    aPosition.appendDecl(*ctx, &vshaderTxt);
-    vshaderTxt.append(";\n");
-    aColor.appendDecl(*ctx, &vshaderTxt);
-    vshaderTxt.append(";\n");
-    oPosition.appendDecl(*ctx, &vshaderTxt);
-    vshaderTxt.append(";\n");
-    oColor.appendDecl(*ctx, &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.
-    GrGLShaderVar oFragColor("o_FragColor", kVec4f_GrSLType, GrShaderVar::kOut_TypeModifier);
-    SkString fshaderTxt(version);
-    GrGLAppendGLSLDefaultFloatPrecisionDeclaration(kDefault_GrSLPrecision, gl->fStandard,
-                                                   &fshaderTxt);
-    oPosition.setTypeModifier(GrShaderVar::kVaryingIn_TypeModifier);
-    oPosition.appendDecl(*ctx, &fshaderTxt);
-    fshaderTxt.append(";\n");
-    oColor.setTypeModifier(GrShaderVar::kVaryingIn_TypeModifier);
-    oColor.appendDecl(*ctx, &fshaderTxt);
-    fshaderTxt.append(";\n");
-
-    const char* fsOutName;
-    if (ctx->caps()->glslCaps()->mustDeclareFragmentShaderOutput()) {
-        oFragColor.appendDecl(*ctx, &fshaderTxt);
-        fshaderTxt.append(";\n");
-        fsOutName = oFragColor.c_str();
-    } else {
-        fsOutName = "gl_FragColor";
-    }
-
-
-    fshaderTxt.appendf(
-            "void main()\n"
-            "{\n"
-            "    vec4 outputColor;\n"
-            "    %s outputCoverage;\n"
-            "    outputColor = vec4(%s, 1.0);\n"
-            "    outputCoverage = %s;\n",
-            fCoverageSetup == kUseVec4_CoverageSetup ? "vec4" : "float",
-            oColor.getName().c_str(),
-            fCoverageSetup == kUseVec4_CoverageSetup ? "vec4(1.0)" : "1.0"
-            );
-
-    float radius = 1.0f;
-    for (uint32_t i = 0; i < fNumStages; i++) {
-        float centerX = 1.0f - radius;
-        float centerY = 1.0f - radius;
-        fshaderTxt.appendf(
-            "    {\n"
-            "        float d = length(%s - vec2(%f, %f));\n"
-            "        float edgeAlpha = clamp(100.0 * (%f - d), 0.0, 1.0);\n"
-            "        outputCoverage = 0.5 * outputCoverage + 0.5 * %s;\n"
-            "    }\n",
-            oPosition.getName().c_str(), centerX, centerY,
-            radius,
-            fCoverageSetup == kUseVec4_CoverageSetup ? "vec4(edgeAlpha)" : "edgeAlpha"
-            );
-        radius *= 0.8f;
-    }
-    fshaderTxt.appendf(
-            "    {\n"
-            "        %s = outputColor * outputCoverage;\n"
-            "    }\n"
-            "}\n",
-            fsOutName);
-
-    return CreateProgram(gl, vshaderTxt.c_str(), fshaderTxt.c_str());
-}
-
-template<typename Func>
-static void setup_matrices(int numQuads, Func f) {
-    // We draw a really small triangle so we are not fill rate limited
-    for (int i = 0 ; i < numQuads; i++) {
-        SkMatrix m = SkMatrix::I();
-        m.setScale(0.01f, 0.01f);
-        f(m);
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-struct Vertex {
-    SkPoint fPositions;
-    GrGLfloat fColors[3];
-};
-
-void GLVec4ScalarBench::setupSingleVbo(const GrGLInterface* gl, const SkMatrix* viewMatrices) {
-    // triangles drawn will alternate between the top-right half of the screen and the bottom-left
-    // half of the screen
-    Vertex vertices[kVerticesPerTri * kNumTriPerDraw];
-    for (uint32_t i = 0; i < kNumTriPerDraw; i++) {
-        Vertex* v = &vertices[i * kVerticesPerTri];
-        if (i % 2 == 0) {
-            v[0].fPositions.set(-1.0f, -1.0f);
-            v[1].fPositions.set( 1.0f, -1.0f);
-            v[2].fPositions.set( 1.0f,  1.0f);
-        } else {
-            v[0].fPositions.set(-1.0f, -1.0f);
-            v[1].fPositions.set( 1.0f, 1.0f);
-            v[2].fPositions.set( -1.0f, 1.0f);
-        }
-        SkPoint* position = reinterpret_cast<SkPoint*>(v);
-        viewMatrices[i].mapPointsWithStride(position, sizeof(Vertex), kVerticesPerTri);
-
-        GrGLfloat color[3] = {1.0f, 0.0f, 1.0f};
-        for (uint32_t j = 0; j < kVerticesPerTri; j++) {
-            v->fColors[0] = color[0];
-            v->fColors[1] = color[1];
-            v->fColors[2] = color[2];
-            v++;
-        }
-    }
-
-    GR_GL_CALL(gl, GenBuffers(1, &fVboId));
-    GR_GL_CALL(gl, BindBuffer(GR_GL_ARRAY_BUFFER, fVboId));
-    GR_GL_CALL(gl, EnableVertexAttribArray(0));
-    GR_GL_CALL(gl, EnableVertexAttribArray(1));
-    GR_GL_CALL(gl, VertexAttribPointer(0, 2, GR_GL_FLOAT, GR_GL_FALSE, sizeof(Vertex),
-                                       (GrGLvoid*)0));
-    GR_GL_CALL(gl, VertexAttribPointer(1, 3, GR_GL_FLOAT, GR_GL_FALSE, sizeof(Vertex),
-                                       (GrGLvoid*)(sizeof(SkPoint))));
-    GR_GL_CALL(gl, BufferData(GR_GL_ARRAY_BUFFER, sizeof(vertices), vertices, GR_GL_STATIC_DRAW));
-}
-
-void GLVec4ScalarBench::setup(const GrGLContext* ctx) {
-    const GrGLInterface* gl = ctx->interface();
-    if (!gl) {
-        SkFAIL("GL interface is null in setup()\n");
-    }
-    fFboTextureId = SetupFramebuffer(gl, kScreenWidth, kScreenHeight);
-
-    fProgram = this->setupShader(ctx);
-
-    GR_GL_CALL(gl, GenVertexArrays(1, &fVaoId));
-    GR_GL_CALL(gl, BindVertexArray(fVaoId));
-
-    int index = 0;
-    SkMatrix viewMatrices[kNumTriPerDraw];
-    setup_matrices(kNumTriPerDraw, [&index, &viewMatrices](const SkMatrix& m) {
-        viewMatrices[index++] = m;
-    });
-    this->setupSingleVbo(gl, viewMatrices);
-
-    GR_GL_CALL(gl, UseProgram(fProgram));
-    GR_GL_CALL(gl, BindVertexArray(fVaoId));
-}
-
-void GLVec4ScalarBench::glDraw(const int loops, const GrGLContext* ctx) {
-    const GrGLInterface* gl = ctx->interface();
-
-    for (int i = 0; i < loops; i++) {
-        GR_GL_CALL(gl, DrawArrays(GR_GL_TRIANGLES, 0, kVerticesPerTri * kNumTriPerDraw));
-    }
-
-// using -w when running nanobench will not produce correct images;
-// changing this to #if 1 will write the correct images to the Skia folder.
-#if 0
-    SkString filename("out");
-    filename.appendf("_%s.png", this->getName());
-    DumpImage(gl, kScreenWidth, kScreenHeight, filename.c_str());
-#endif
-}
-
-void GLVec4ScalarBench::teardown(const GrGLInterface* gl) {
-    GR_GL_CALL(gl, BindBuffer(GR_GL_ARRAY_BUFFER, 0));
-    GR_GL_CALL(gl, BindVertexArray(0));
-    GR_GL_CALL(gl, BindTexture(GR_GL_TEXTURE_2D, 0));
-    GR_GL_CALL(gl, BindFramebuffer(GR_GL_FRAMEBUFFER, 0));
-    GR_GL_CALL(gl, DeleteTextures(1, &fFboTextureId));
-    GR_GL_CALL(gl, DeleteProgram(fProgram));
-    GR_GL_CALL(gl, DeleteBuffers(1, &fVboId));
-    GR_GL_CALL(gl, DeleteVertexArrays(1, &fVaoId));
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-DEF_BENCH( return new GLVec4ScalarBench(GLVec4ScalarBench::kUseScalar_CoverageSetup, 1) )
-DEF_BENCH( return new GLVec4ScalarBench(GLVec4ScalarBench::kUseVec4_CoverageSetup, 1) )
-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