[GPU] Get GPU process running on the mac...

gpu/command_buffer/client/gles2_demo_cc.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file is here so other GLES2 related files can have a common set of
 // includes where appropriate.
 
+#include <math.h>
 #include <GLES2/gl2.h>
 #include "gpu/command_buffer/client/gles2_demo_cc.h"
 
 namespace {
 
 GLuint g_texture = 0;
 int g_textureLoc = -1;
 GLuint g_programObject = 0;
+GLuint g_worldMatrixLoc = 0;
 GLuint g_vbo = 0;
 GLsizei g_texCoordOffset = 0;
+int g_angle = 0;
 
 void CheckGLError() {
   GLenum error = glGetError();
   if (error != GL_NO_ERROR) {
     DLOG(ERROR) << "GL Error: " << error;
   }
 }
 
 GLuint LoadShader(GLenum type, const char* shaderSrc) {
   GLuint shader = glCreateShader(type);
@@ skipping 14 matching lines @@
     std::string log(buffer, length);
     DLOG(ERROR) << "Error compiling shader:" << log;
     glDeleteShader(shader);
     return 0;
   }
   return shader;
 }
 
 void InitShaders() {
   static const char* vShaderStr =
+    "uniform mat4 worldMatrix;\n"
     "attribute vec3 g_Position;\n"
     "attribute vec2 g_TexCoord0;\n"
     "varying vec2 texCoord;\n"
     "void main()\n"
     "{\n"
-    "   gl_Position = vec4(g_Position.x, g_Position.y, g_Position.z, 1.0);\n"
+    "   gl_Position = worldMatrix *\n"
+    "                 vec4(g_Position.x, g_Position.y, g_Position.z, 1.0);\n"
     "   texCoord = g_TexCoord0;\n"
     "}\n";
   static const char* fShaderStr =
     "uniform sampler2D tex;\n"
     "varying vec2 texCoord;\n"
     "void main()\n"
     "{\n"
     "  gl_FragColor = texture2D(tex, texCoord);\n"
     "}\n";
 
@@ skipping 19 matching lines @@
   if (linked == 0) {
     char buffer[1024];
     GLsizei length;
     glGetProgramInfoLog(programObject, sizeof(buffer), &length, buffer);
     std::string log(buffer, length);
     DLOG(ERROR) << "Error linking program:" << log;
     glDeleteProgram(programObject);
     return;
   }
   g_programObject = programObject;
+  g_worldMatrixLoc = glGetUniformLocation(g_programObject, "worldMatrix");
   g_textureLoc = glGetUniformLocation(g_programObject, "tex");
   glGenBuffers(1, &g_vbo);
   glBindBuffer(GL_ARRAY_BUFFER, g_vbo);
   static float vertices[] = {
       0.25,  0.75, 0.0,
      -0.75,  0.75, 0.0,
      -0.75, -0.25, 0.0,
       0.25,  0.75, 0.0,
      -0.75, -0.25, 0.0,
       0.25, -0.25, 0.0,
@@ skipping 10 matching lines @@
   glBufferData(GL_ARRAY_BUFFER,
                sizeof(vertices) + sizeof(texCoords),
                NULL,
                GL_STATIC_DRAW);
   glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices);
   glBufferSubData(GL_ARRAY_BUFFER, g_texCoordOffset,
                   sizeof(texCoords), texCoords);
   CheckGLError();
 }
 
+#define PI 3.1415926535897932384626433832795f
+
 void Draw() {
+  // TODO(kbr): base the angle on time rather than on ticks
+  g_angle = (g_angle + 1) % 360;
+  // Rotate about the Z axis
+  GLfloat rot_matrix[16];
+  GLfloat cos_angle = cosf(static_cast<GLfloat>(g_angle) * PI / 180.0f);
+  GLfloat sin_angle = sinf(static_cast<GLfloat>(g_angle) * PI / 180.0f);
+  // OpenGL matrices are column-major
+  rot_matrix[0] = cos_angle;
+  rot_matrix[1] = sin_angle;
+  rot_matrix[2] = 0.0f;
+  rot_matrix[3] = 0.0f;
+
+  rot_matrix[4] = -sin_angle;
+  rot_matrix[5] = cos_angle;
+  rot_matrix[6] = 0.0f;
+  rot_matrix[7] = 0.0f;
+
+  rot_matrix[8] = 0.0f;
+  rot_matrix[9] = 0.0f;
+  rot_matrix[10] = 1.0f;
+  rot_matrix[11] = 0.0f;
+
+  rot_matrix[12] = 0.0f;
+  rot_matrix[13] = 0.0f;
+  rot_matrix[14] = 0.0f;
+  rot_matrix[15] = 1.0f;
+
   // Note: the viewport is automatically set up to cover the entire Canvas.
   // Clear the color buffer
   glClear(GL_COLOR_BUFFER_BIT);
   CheckGLError();
   // Use the program object
   glUseProgram(g_programObject);
   CheckGLError();
+  // Set up the model matrix
+  glUniformMatrix4fv(g_worldMatrixLoc, 1, GL_FALSE, rot_matrix);
+
   // Load the vertex data
   glBindBuffer(GL_ARRAY_BUFFER, g_vbo);
   glEnableVertexAttribArray(0);
   glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
   glEnableVertexAttribArray(1);
   glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0,
                         reinterpret_cast<const void*>(g_texCoordOffset));
   CheckGLError();
   // Bind the texture to texture unit 0
   glBindTexture(GL_TEXTURE_2D, g_texture);
@@ skipping 35 matching lines @@
 }  // anonymous namespace.
 
 void GLFromCPPTestFunction() {
   static bool initialized = false;
   if (!initialized) {
     initialized = true;
     Init();
   }
   Draw();
 }