fix for angle

bench/GLVertexAttributesBench.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 "Benchmark.h"
 #include "SkCanvas.h"
 #include "SkImageEncoder.h"
 #if SK_SUPPORT_GPU
 #include "GrTest.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 native GL benchmark for determining the cost of uploading vertex attributes
  */
 class GLVertexAttributesBench : public Benchmark {
 public:
     GLVertexAttributesBench(uint32_t attribs)
         : fTexture(0)
         , fBuffers(0)
         , fProgram(0)
-        , fVAO(0)
         , fVBO(0)
         , fAttribs(attribs)
         , fStride(2 * sizeof(SkPoint) + fAttribs * sizeof(GrGLfloat) * 4) {
         fName.appendf("GLVertexAttributesBench_%d", fAttribs);
     }
 
 protected:
     const char* onGetName() override { return fName.c_str(); }
     void onPerCanvasPreDraw(SkCanvas* canvas) override;
     void setup(const GrGLContext*);
     void onDraw(const int loops, SkCanvas*) override;
     void onPerCanvasPostDraw(SkCanvas* canvas) override;
 
     static const GrGLuint kScreenWidth = 800;
     static const GrGLuint kScreenHeight = 600;
     static const uint32_t kNumTri = 10000;
     static const uint32_t kVerticesPerTri = 3;
     static const uint32_t kDrawMultiplier = 512;
     static const uint32_t kMaxAttribs = 7;
 
 private:
     GrGLuint fTexture;
     SkTArray<GrGLuint> fBuffers;
     GrGLuint fProgram;
-    GrGLuint fVAO;
     GrGLuint fVBO;
     SkTArray<unsigned char> fVertices;
     uint32_t fAttribs;
     size_t fStride;
     SkString fName;
     typedef Benchmark INHERITED;
 };
 
 static const GrGLContext* get_gl_context(SkCanvas* canvas) {
     // This bench exclusively tests GL calls directly
@@ skipping 31 matching lines @@
     // This bench exclusively tests GL calls directly
     const GrGLContext* ctx = get_gl_context(canvas);
     if (!ctx) {
         return;
     }
 
     const GrGLInterface* gl = ctx->interface();
 
     // teardown
     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, &fTexture));
     GR_GL_CALL(gl, DeleteProgram(fProgram));
     GR_GL_CALL(gl, DeleteBuffers(fBuffers.count(), fBuffers.begin()));
-    GR_GL_CALL(gl, DeleteVertexArrays(1, &fVAO));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 static GrGLuint load_shader(const GrGLInterface* gl, const char* shaderSrc, GrGLenum type) {
     GrGLuint shader;
     // Create the shader object
     GR_GL_CALL_RET(gl, shader, CreateShader(type));
 
     // Load the shader source
@@ skipping 51 matching lines @@
             "void main()\n"
             "{\n"
                 "gl_Position = a_position;\n");
 
     for (uint32_t i = 0; i < attribs; i++) {
         vshaderTxt.appendf("%s = %s;\n", oVars[i].c_str(), aVars[i].c_str());
     }
 
     // Passthrough position as a dummy
     for (uint32_t i = attribs; i < maxAttribs; i++) {
-        vshaderTxt.appendf("%s = vec4(0.f, 0.f, 0.f, 1.f);\n", oVars[i].c_str());
+        vshaderTxt.appendf("%s = vec4(0, 0, 0, 1);\n", oVars[i].c_str());
     }
 
     vshaderTxt.append("}\n");
 
     const GrGLInterface* gl = ctx->interface();
     GrGLuint vertexShader = load_shader(gl, vshaderTxt.c_str(), GR_GL_VERTEX_SHADER);
 
     // setup fragment shader
     GrGLShaderVar oFragColor("o_FragColor", kVec4f_GrSLType, GrShaderVar::kOut_TypeModifier);
     SkString fshaderTxt(version);
@@ skipping 77 matching lines @@
         SkDebugf("------ failed to encode %s\n", filename);
         remove(filename);   // remove any partial file
         return;
     }
 }
 #endif
 
 static void setup_framebuffer(const GrGLInterface* gl, int screenWidth, int screenHeight) {
     //Setup framebuffer
     GrGLuint texture;
-    GR_GL_CALL(gl, PixelStorei(GR_GL_UNPACK_ROW_LENGTH, 0));
-    GR_GL_CALL(gl, PixelStorei(GR_GL_PACK_ROW_LENGTH, 0));
     GR_GL_CALL(gl, GenTextures(1, &texture));
     GR_GL_CALL(gl, ActiveTexture(GR_GL_TEXTURE15));
     GR_GL_CALL(gl, BindTexture(GR_GL_TEXTURE_2D, texture));
     GR_GL_CALL(gl, TexParameteri(GR_GL_TEXTURE_2D, GR_GL_TEXTURE_MAG_FILTER, GR_GL_NEAREST));
     GR_GL_CALL(gl, TexParameteri(GR_GL_TEXTURE_2D, GR_GL_TEXTURE_MIN_FILTER, GR_GL_NEAREST));
     GR_GL_CALL(gl, TexParameteri(GR_GL_TEXTURE_2D, GR_GL_TEXTURE_WRAP_S, GR_GL_CLAMP_TO_EDGE));
     GR_GL_CALL(gl, TexParameteri(GR_GL_TEXTURE_2D, GR_GL_TEXTURE_WRAP_T, GR_GL_CLAMP_TO_EDGE));
     GR_GL_CALL(gl, TexImage2D(GR_GL_TEXTURE_2D,
                               0, //level
-                              GR_GL_RGBA8, //internal format
+                              GR_GL_RGBA, //internal format
                               screenWidth, // width
                               screenHeight, // height
                               0, //border
                               GR_GL_RGBA, //format
                               GR_GL_UNSIGNED_BYTE, // type
                               NULL));
 
     // bind framebuffer
     GrGLuint framebuffer;
     GR_GL_CALL(gl, BindTexture(GR_GL_TEXTURE_2D, 0));
@@ skipping 16 matching lines @@
     fProgram = compile_shader(ctx, fAttribs, kMaxAttribs);
 
     // setup matrices
     SkMatrix viewMatrices[kNumTri];
     for (uint32_t i = 0 ; i < kNumTri; i++) {
         SkMatrix m = SkMatrix::I();
         m.setScale(0.0001f, 0.0001f);
         viewMatrices[i] = m;
     }
 
-    // setup VAO
-    GR_GL_CALL(gl, GenVertexArrays(1, &fVAO));
-    GR_GL_CALL(gl, BindVertexArray(fVAO));
-
     // presetup vertex attributes, color is set to be a light gray no matter how many vertex
     // attributes are used
     float targetColor = 0.9f;
     float colorContribution = targetColor / fAttribs;
     fVertices.reset(static_cast<int>(kVerticesPerTri * kNumTri * fStride));
     for (uint32_t i = 0; i < kNumTri; i++) {
         unsigned char* ptr = &fVertices[static_cast<int>(i * kVerticesPerTri * fStride)];
         SkPoint* p = reinterpret_cast<SkPoint*>(ptr);
         p->set(-1.0f, -1.0f); p++; p->set( 0.0f, 1.0f);
         p = reinterpret_cast<SkPoint*>(ptr + fStride);
@@ skipping 18 matching lines @@
 
     GR_GL_CALL(gl, GenBuffers(1, &fVBO));
     fBuffers.push_back(fVBO);
 
     // clear screen
     GR_GL_CALL(gl, ClearColor(0.03f, 0.03f, 0.03f, 1.0f));
     GR_GL_CALL(gl, Clear(GR_GL_COLOR_BUFFER_BIT));
 
     // set us up to draw
     GR_GL_CALL(gl, UseProgram(fProgram));
-    GR_GL_CALL(gl, BindVertexArray(fVAO));
 }
 
 void GLVertexAttributesBench::onDraw(const int loops, SkCanvas* canvas) {
     const GrGLContext* ctx = get_gl_context(canvas);
     if (!ctx) {
         return;
     }
 
     const GrGLInterface* gl = ctx->interface();
 
@@ skipping 37 matching lines @@
 
 DEF_BENCH( return new GLVertexAttributesBench(0) )
 DEF_BENCH( return new GLVertexAttributesBench(1) )
 DEF_BENCH( return new GLVertexAttributesBench(2) )
 DEF_BENCH( return new GLVertexAttributesBench(3) )
 DEF_BENCH( return new GLVertexAttributesBench(4) )
 DEF_BENCH( return new GLVertexAttributesBench(5) )
 DEF_BENCH( return new GLVertexAttributesBench(6) )
 DEF_BENCH( return new GLVertexAttributesBench(7) )
 #endif