[PPAPI] Compositor API implementation

ppapi/examples/compositor/spinning_cube.cc

 // Copyright 2014 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 example program is based on Simple_VertexShader.c from:
 
 //
 // Book:      OpenGL(R) ES 2.0 Programming Guide
 // Authors:   Aaftab Munshi, Dan Ginsburg, Dave Shreiner
 // ISBN-10:   0321502795
 // ISBN-13:   9780321502797
 // Publisher: Addison-Wesley Professional
 // URLs:      http://safari.informit.com/9780321563835
 //            http://www.opengles-book.com
 //
 
-#include "ppapi/examples/gles2_spinning_cube/spinning_cube.h"
+#include "ppapi/examples/compositor/spinning_cube.h"
 
 #include <math.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
 
 #include "ppapi/lib/gl/include/GLES2/gl2.h"
 
 namespace {
 
 const float kPi = 3.14159265359f;
 
 int GenerateCube(GLuint *vbo_vertices,
                  GLuint *vbo_indices) {
   const int num_indices = 36;
 
   const GLfloat cube_vertices[] = {
     -0.5f, -0.5f, -0.5f,
+     0.5f, -0.5f, -0.5f,
+     0.5f, -0.5f,  0.5f,
     -0.5f, -0.5f,  0.5f,
-    0.5f, -0.5f,  0.5f,
-    0.5f, -0.5f, -0.5f,
     -0.5f,  0.5f, -0.5f,
+     0.5f,  0.5f, -0.5f,
+     0.5f,  0.5f,  0.5f,
     -0.5f,  0.5f,  0.5f,
-    0.5f,  0.5f,  0.5f,
-    0.5f,  0.5f, -0.5f,
-    -0.5f, -0.5f, -0.5f,
-    -0.5f,  0.5f, -0.5f,
-    0.5f,  0.5f, -0.5f,
-    0.5f, -0.5f, -0.5f,
-    -0.5f, -0.5f, 0.5f,
-    -0.5f,  0.5f, 0.5f,
-    0.5f,  0.5f, 0.5f,
-    0.5f, -0.5f, 0.5f,
-    -0.5f, -0.5f, -0.5f,
-    -0.5f, -0.5f,  0.5f,
-    -0.5f,  0.5f,  0.5f,
-    -0.5f,  0.5f, -0.5f,
-    0.5f, -0.5f, -0.5f,
-    0.5f, -0.5f,  0.5f,
-    0.5f,  0.5f,  0.5f,
-    0.5f,  0.5f, -0.5f,
   };
 
   const GLushort cube_indices[] = {
     0, 2, 1,
     0, 3, 2,
     4, 5, 6,
     4, 6, 7,
-    8, 9, 10,
-    8, 10, 11,
-    12, 15, 14,
-    12, 14, 13,
-    16, 17, 18,
-    16, 18, 19,
-    20, 23, 22,
-    20, 22, 21
+    3, 6, 2,
+    3, 7, 6,
+    0, 1, 5,
+    0, 5, 4,
+    0, 7, 3,
+    0, 4, 7,
+    1, 2, 6,
+    1, 6, 5,
   };
 
   if (vbo_vertices) {
     glGenBuffers(1, vbo_vertices);
     glBindBuffer(GL_ARRAY_BUFFER, *vbo_vertices);
     glBufferData(GL_ARRAY_BUFFER,
                  sizeof(cube_vertices),
                  cube_vertices,
                  GL_STATIC_DRAW);
     glBindBuffer(GL_ARRAY_BUFFER, 0);
@@ skipping 273 matching lines @@
 
 void SpinningCube::Init(uint32_t width, uint32_t height) {
   width_ = width;
   height_ = height;
 
   if (!initialized_) {
     initialized_ = true;
     const char vertext_shader_source[] =
         "uniform mat4 u_mvpMatrix;                   \n"
         "attribute vec4 a_position;                  \n"
+        "varying vec4 v_color;                       \n"
         "void main()                                 \n"
         "{                                           \n"
         "   gl_Position = u_mvpMatrix * a_position;  \n"
+        "   v_color = vec4(a_position.x + 0.5,       \n"
+        "                  a_position.y + 0.5,       \n"
+        "                  a_position.z + 0.5,       \n"
+        "                  0.8);                     \n"
         "}                                           \n";
 
     const char fragment_shader_source[] =
-        "precision mediump float;                            \n"
-        "void main()                                         \n"
-        "{                                                   \n"
-        "  gl_FragColor = vec4( 0.0, 0.0, 1.0, 1.0 );        \n"
-        "}                                                   \n";
+        "precision mediump float;                    \n"
+        "varying vec4 v_color;                       \n"
+        "void main()                                 \n"
+        "{                                           \n"
+        "  gl_FragColor = v_color;                   \n"
+        "}                                           \n";
 
     state_->program_object_ = LoadProgram(
         vertext_shader_source, fragment_shader_source);
     state_->position_location_ = glGetAttribLocation(
         state_->program_object_, "a_position");
     state_->mvp_location_ = glGetUniformLocation(
         state_->program_object_, "u_mvpMatrix");
-    state_->num_indices_ = GenerateCube(
-        &state_->vbo_vertices_, &state_->vbo_indices_);
+    state_->num_indices_ = GenerateCube(&state_->vbo_vertices_,
+                                        &state_->vbo_indices_);
 
     glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
   }
 }
 
 void SpinningCube::OnGLContextLost() {
   // TODO(yzshen): Is it correct that in this case we don't need to do cleanup
   // for program and buffers?
   initialized_ = false;
   height_ = 0;
@@ skipping 25 matching lines @@
 void SpinningCube::UpdateForDragDistance(float distance) {
   state_->angle_ += RotationForDragDistance(distance);
   if (state_->angle_ >= 360.0f )
     state_->angle_ -= 360.0f;
 
   Update();
 }
 
 void SpinningCube::Draw() {
   glViewport(0, 0, width_, height_);
-  glClear(GL_COLOR_BUFFER_BIT);
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glEnable(GL_DEPTH_TEST);
   glUseProgram(state_->program_object_);
+
   glBindBuffer(GL_ARRAY_BUFFER, state_->vbo_vertices_);
+  glVertexAttribPointer(state_->position_location_,
+                        3,
+                        GL_FLOAT,
+                        GL_FALSE, 3 * sizeof(GLfloat),
+                        0);
+  glEnableVertexAttribArray(state_->position_location_);
+
+  glUniformMatrix4fv(state_->mvp_location_,
+                     1,
+                     GL_FALSE,
+                     (GLfloat*) &state_->mvp_matrix_.m[0][0]);
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, state_->vbo_indices_);
-  glVertexAttribPointer(state_->position_location_,
-                           3,
-                           GL_FLOAT,
-                           GL_FALSE, 3 * sizeof(GLfloat),
-                           0);
-  glEnableVertexAttribArray(state_->position_location_);
-  glUniformMatrix4fv(state_->mvp_location_,
-                        1,
-                        GL_FALSE,
-                        (GLfloat*) &state_->mvp_matrix_.m[0][0]);
   glDrawElements(GL_TRIANGLES,
-                    state_->num_indices_,
-                    GL_UNSIGNED_SHORT,
-                    0);
+                 state_->num_indices_,
+                 GL_UNSIGNED_SHORT,
+                 0);
 }
 
 void SpinningCube::Update() {
   float aspect = static_cast<GLfloat>(width_) / static_cast<GLfloat>(height_);
 
   ESMatrix perspective;
   perspective.LoadIdentity();
   perspective.Perspective(60.0f, aspect, 1.0f, 20.0f );
 
   ESMatrix modelview;
   modelview.LoadIdentity();
   modelview.Translate(0.0, 0.0, -2.0);
   modelview.Rotate(state_->angle_ * direction_, 1.0, 0.0, 1.0);
 
   state_->mvp_matrix_.Multiply(&modelview, &perspective);
 }