Fine tune vertex attrib commands handling.

gpu/command_buffer/client/vertex_array_object_manager.cc

 // Copyright (c) 2012 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.
 
 #include "gpu/command_buffer/client/vertex_array_object_manager.h"
 
 #include "base/logging.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
@@ skipping 29 matching lines @@
   class VertexAttrib {
    public:
     VertexAttrib()
         : enabled_(false),
           buffer_id_(0),
           size_(4),
           type_(GL_FLOAT),
           normalized_(GL_FALSE),
           pointer_(NULL),
           gl_stride_(0),
-          divisor_(0) {
+          divisor_(0),
+          integer_(GL_FALSE) {
     }
 
     bool enabled() const {
       return enabled_;
     }
 
     void set_enabled(bool enabled) {
       enabled_ = enabled;
     }
 
@@ skipping 26 matching lines @@
     }
 
     bool IsClientSide() const {
       return buffer_id_ == 0;
     }
 
     GLuint divisor() const {
       return divisor_;
     }
 
+    GLboolean integer() const {
+      return integer_;
+    }
+
     void SetInfo(
         GLuint buffer_id,
         GLint size,
         GLenum type,
         GLboolean normalized,
         GLsizei gl_stride,
-        const GLvoid* pointer) {
+        const GLvoid* pointer,
+        GLboolean integer) {
       buffer_id_ = buffer_id;
       size_ = size;
       type_ = type;
       normalized_ = normalized;
       gl_stride_ = gl_stride;
       pointer_ = pointer;
+      integer_ = integer;
     }
 
     void SetDivisor(GLuint divisor) {
       divisor_ = divisor;
     }
 
    private:
     // Whether or not this attribute is enabled.
     bool enabled_;
 
@@ skipping 11 matching lines @@
 
     // The pointer/offset into the buffer.
     const GLvoid* pointer_;
 
     // The stride that will be used to access the buffer. This is the bogus GL
     // stride where 0 = compute the stride based on size and type.
     GLsizei gl_stride_;
 
     // Divisor, for geometry instancing.
     GLuint divisor_;
+
+    GLboolean integer_;
   };
 
   typedef std::vector<VertexAttrib> VertexAttribs;
 
   explicit VertexArrayObject(GLuint max_vertex_attribs);
 
   void UnbindBuffer(GLuint id);
 
   bool BindElementArray(GLuint id);
 
   bool HaveEnabledClientSideBuffers() const;
 
   void SetAttribEnable(GLuint index, bool enabled);
 
   void SetAttribPointer(
     GLuint buffer_id,
     GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride,
-    const void* ptr);
+    const void* ptr, GLboolean integer);
 
   bool GetVertexAttrib(
       GLuint index, GLenum pname, uint32* param) const;
 
   void SetAttribDivisor(GLuint index, GLuint divisor);
 
   bool GetAttribPointer(GLuint index, GLenum pname, void** ptr) const;
 
   const VertexAttribs& vertex_attribs() const {
     return vertex_attribs_;
@@ skipping 64 matching lines @@
   }
 }
 
 void VertexArrayObject::SetAttribPointer(
     GLuint buffer_id,
     GLuint index,
     GLint size,
     GLenum type,
     GLboolean normalized,
     GLsizei stride,
-    const void* ptr) {
+    const void* ptr,
+    GLboolean integer) {
   if (index < vertex_attribs_.size()) {
     VertexAttrib& attrib = vertex_attribs_[index];
     if (attrib.IsClientSide() && attrib.enabled()) {
       --num_client_side_pointers_enabled_;
       DCHECK_GE(num_client_side_pointers_enabled_, 0);
     }
 
-    attrib.SetInfo(buffer_id, size, type, normalized, stride, ptr);
+    attrib.SetInfo(buffer_id, size, type, normalized, stride, ptr, integer);
 
     if (attrib.IsClientSide() && attrib.enabled()) {
       ++num_client_side_pointers_enabled_;
     }
   }
 }
 
 bool VertexArrayObject::GetVertexAttrib(
     GLuint index, GLenum pname, uint32* param) const {
   const VertexAttrib* attrib = GetAttrib(index);
@@ skipping 14 matching lines @@
     case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
       *param = attrib->stride();
       break;
     case GL_VERTEX_ATTRIB_ARRAY_TYPE:
       *param = attrib->type();
       break;
     case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
       *param = attrib->normalized();
       break;
     case GL_VERTEX_ATTRIB_ARRAY_INTEGER:
-      // TODO(zmo): cache this on the client side.
-      return false;
+      *param = attrib->integer();
+      break;
     default:
       return false;  // pass through to service side.
   }
   return true;
 }
 
 void VertexArrayObject::SetAttribDivisor(GLuint index, GLuint divisor) {
   if (index < vertex_attribs_.size()) {
     VertexAttrib& attrib = vertex_attribs_[index];
     attrib.SetDivisor(divisor);
@@ skipping 126 matching lines @@
   return bound_vertex_array_object_->GetAttribPointer(index, pname, ptr);
 }
 
 bool VertexArrayObjectManager::SetAttribPointer(
     GLuint buffer_id,
     GLuint index,
     GLint size,
     GLenum type,
     GLboolean normalized,
     GLsizei stride,
-    const void* ptr) {
+    const void* ptr,
+    GLboolean integer) {
   // Client side arrays are not allowed in vaos.
   if (buffer_id == 0 && !IsDefaultVAOBound()) {
     return false;
   }
   bound_vertex_array_object_->SetAttribPointer(
-      buffer_id, index, size, type, normalized, stride, ptr);
+      buffer_id, index, size, type, normalized, stride, ptr, integer);
   return true;
 }
 
 void VertexArrayObjectManager::SetAttribDivisor(GLuint index, GLuint divisor) {
   bound_vertex_array_object_->SetAttribDivisor(index, divisor);
 }
 
 // Collects the data into the collection buffer and returns the number of
 // bytes collected.
 GLsizei VertexArrayObjectManager::CollectData(
@@ skipping 176 matching lines @@
       function_name, gl, gl_helper, num_elements, primcount,
       &simulated_client_side_buffers);
   *simulated = *simulated || simulated_client_side_buffers;
   return true;
 }
 
 }  // namespace gles2
 }  // namespace gpu