Change the color of the spinning cube on click.

mojo/examples/sample_app/spinning_cube.cc

 // Copyright 2013 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
@@ skipping 296 matching lines @@
  public:
   GLState();
 
   void OnGLContextLost();
 
   GLfloat angle_;  // Survives losing the GL context.
 
   GLuint program_object_;
   GLint position_location_;
   GLint mvp_location_;
+  GLint color_location_;
   GLuint vbo_vertices_;
   GLuint vbo_indices_;
   int num_indices_;
   ESMatrix mvp_matrix_;
 };
 
 SpinningCube::GLState::GLState()
     : angle_(0) {
   OnGLContextLost();
 }
 
 void SpinningCube::GLState::OnGLContextLost() {
   program_object_ = 0;
   position_location_ = 0;
   mvp_location_ = 0;
+  color_location_ = 0;
   vbo_vertices_ = 0;
   vbo_indices_ = 0;
   num_indices_ = 0;
 }
 
 SpinningCube::SpinningCube()
     : initialized_(false),
       width_(0),
       height_(0),
       state_(new GLState()),
       fling_multiplier_(1.0f),
-      direction_(1) {
+      direction_(1),
+      color_() {
   state_->angle_ = 45.0f;
+  set_color(0.0, 1.0, 0.0);
 }
 
 SpinningCube::~SpinningCube() {
   if (!initialized_)
     return;
   if (state_->vbo_vertices_)
     glDeleteBuffers(1, &state_->vbo_vertices_);
   if (state_->vbo_indices_)
     glDeleteBuffers(1, &state_->vbo_indices_);
   if (state_->program_object_)
     glDeleteProgram(state_->program_object_);
 }
 
 void SpinningCube::Init(uint32_t width, uint32_t height) {
   width_ = width;
   height_ = height;
 
   const char vertext_shader_source[] =
       "uniform mat4 u_mvpMatrix;                   \n"
       "attribute vec4 a_position;                  \n"
       "void main()                                 \n"
       "{                                           \n"
       "   gl_Position = u_mvpMatrix * a_position;  \n"
       "}                                           \n";
 
   const char fragment_shader_source[] =
       "precision mediump float;                            \n"
+      "uniform vec4 u_color;                               \n"
       "void main()                                         \n"
       "{                                                   \n"
-      "  gl_FragColor = vec4( 0.0, 1.0, 0.0, 1.0 );        \n"
+      "  gl_FragColor = u_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_->color_location_ = glGetUniformLocation(
+      state_->program_object_, "u_color");
   state_->num_indices_ = GenerateCube(
       &state_->vbo_vertices_, &state_->vbo_indices_);
 
   glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
   initialized_ = true;
 }
 
 void SpinningCube::OnGLContextLost() {
   initialized_ = false;
   height_ = 0;
@@ skipping 39 matching lines @@
   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]);
+  glUniform4f(state_->color_location_, color_[0], color_[1], color_[2], 1.0);
   glDrawElements(GL_TRIANGLES,
                     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);
 }
 
 }  // namespace examples
 }  // namespace mojo