More work in Command Buffers...

command_buffer/service/cross/gl/geometry_gl.cc

 /*
  * Copyright 2009, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 31 matching lines @@
 VertexBufferGL::~VertexBufferGL() {
   glDeleteBuffers(1, &gl_buffer_);
   CHECK_GL_ERROR();
 }
 
 // Creates the GL buffer object.
 void VertexBufferGL::Create() {
   glGenBuffers(1, &gl_buffer_);
   glBindBuffer(GL_ARRAY_BUFFER, gl_buffer_);
   GLenum usage =
-      (flags() & vertex_buffer::DYNAMIC) ?  GL_DYNAMIC_DRAW : GL_STATIC_DRAW;
+      (flags() & vertex_buffer::kDynamic) ?  GL_DYNAMIC_DRAW : GL_STATIC_DRAW;
   glBufferData(GL_ARRAY_BUFFER, size(), NULL, usage);
   CHECK_GL_ERROR();
 }
 
 // Sets the data into the GL buffer object.
 bool VertexBufferGL::SetData(unsigned int offset,
                              unsigned int size,
                              const void *data) {
   if (!gl_buffer_) {
     LOG(ERROR) << "Calling SetData on a non-initialized VertexBufferGL.";
@@ skipping 29 matching lines @@
 
 IndexBufferGL::~IndexBufferGL() {
   glDeleteBuffers(1, &gl_buffer_);
 }
 
 // Creates the GL buffer object.
 void IndexBufferGL::Create() {
   glGenBuffers(1, &gl_buffer_);
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, gl_buffer_);
   GLenum usage =
-      (flags() & vertex_buffer::DYNAMIC) ?  GL_DYNAMIC_DRAW : GL_STATIC_DRAW;
+      (flags() & vertex_buffer::kDynamic) ?  GL_DYNAMIC_DRAW : GL_STATIC_DRAW;
   glBufferData(GL_ELEMENT_ARRAY_BUFFER, size(), NULL, usage);
   CHECK_GL_ERROR();
 }
 
 // Sets the data into the GL buffer object.
 bool IndexBufferGL::SetData(unsigned int offset,
                             unsigned int size,
                             const void *data) {
   if (!gl_buffer_) {
     LOG(ERROR) << "Calling SetData on a non-initialized IndexBufferGL.";
@@ skipping 22 matching lines @@
     return false;
   }
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, gl_buffer_);
   glGetBufferSubData(GL_ELEMENT_ARRAY_BUFFER, offset, size, data);
   CHECK_GL_ERROR();
   return true;
 }
 
 // Sets the input element in the VertexStruct resource.
 void VertexStructGL::SetInput(unsigned int input_index,
-                              ResourceID vertex_buffer_id,
+                              ResourceId vertex_buffer_id,
                               unsigned int offset,
                               unsigned int stride,
                               vertex_struct::Type type,
                               vertex_struct::Semantic semantic,
                               unsigned int semantic_index) {
   Element &element = GetElement(input_index);
   element.vertex_buffer = vertex_buffer_id;
   element.offset = offset;
   element.stride = stride;
   element.type = type;
@@ skipping 72 matching lines @@
 //       14      texture coordinate set 6     MultiTexCoord(TEXTURE6, ...)
 //       15      texture coordinate set 7     MultiTexCoord(TEXTURE7, ...)
 //      8+n      texture coordinate set n     MultiTexCoord(TEXTURE0+n, ...)
 //
 // Note: we only accept at most 8 texture coordinates for maximum compatibility
 // with DirectX.
 
 inline unsigned int GetAttribIndex(vertex_struct::Semantic semantic,
                                    unsigned int semantic_index) {
   switch (semantic) {
-    case vertex_struct::POSITION:
+    case vertex_struct::kPosition:
       DCHECK_EQ(semantic_index, 0);
       return 0;
-    case vertex_struct::NORMAL:
+    case vertex_struct::kNormal:
       DCHECK_EQ(semantic_index, 0);
       return 2;
-    case vertex_struct::COLOR:
+    case vertex_struct::kColor:
       DCHECK_LT(semantic_index, 2);
       return 3 + semantic_index;
-    case vertex_struct::TEX_COORD:
+    case vertex_struct::kTexCoord:
       DCHECK_LT(semantic_index, 8);
       return 8 + semantic_index;
     default:
       DLOG(FATAL) << "Not reached.";
       return 0;
   }
 }
 
 inline void ExtractSizeTypeNormalized(vertex_struct::Type type,
                                       GLint *size,
                                       GLenum *gl_type,
                                       GLboolean *normalized) {
   switch (type) {
-    case vertex_struct::FLOAT1:
-    case vertex_struct::FLOAT2:
-    case vertex_struct::FLOAT3:
-    case vertex_struct::FLOAT4:
-      *size = type - vertex_struct::FLOAT1 + 1;
+    case vertex_struct::kFloat1:
+    case vertex_struct::kFloat2:
+    case vertex_struct::kFloat3:
+    case vertex_struct::kFloat4:
+      *size = type - vertex_struct::kFloat1 + 1;
       *gl_type = GL_FLOAT;
       *normalized = false;
       break;
-    case vertex_struct::UCHAR4N:
+    case vertex_struct::kUChar4N:
       *size = 4;
       *gl_type = GL_UNSIGNED_BYTE;
       *normalized = true;
       break;
     default:
       DLOG(FATAL) << "Not reached.";
       break;
   }
 }
 
@@ skipping 18 matching lines @@
     AttribDesc &attrib = attribs_[index];
     attrib.vertex_buffer_id = element.vertex_buffer;
     ExtractSizeTypeNormalized(element.type, &attrib.size, &attrib.type,
                               &attrib.normalized);
     attrib.stride = element.stride;
     attrib.offset = OffsetToPtrDiff(element.offset);
   }
   dirty_ = false;
 }
 
-BufferSyncInterface::ParseError GAPIGL::CreateVertexBuffer(ResourceID id,
+BufferSyncInterface::ParseError GAPIGL::CreateVertexBuffer(ResourceId id,
                                                            unsigned int size,
                                                            unsigned int flags) {
   VertexBufferGL *vertex_buffer = new VertexBufferGL(size, flags);
   vertex_buffer->Create();
   vertex_buffers_.Assign(id, vertex_buffer);
   return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIGL::DestroyVertexBuffer(ResourceID id) {
+BufferSyncInterface::ParseError GAPIGL::DestroyVertexBuffer(ResourceId id) {
   return vertex_buffers_.Destroy(id) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
-BufferSyncInterface::ParseError GAPIGL::SetVertexBufferData(ResourceID id,
+BufferSyncInterface::ParseError GAPIGL::SetVertexBufferData(ResourceId id,
                                                             unsigned int offset,
                                                             unsigned int size,
                                                             const void *data) {
   VertexBufferGL *vertex_buffer = vertex_buffers_.Get(id);
   if (!vertex_buffer) return BufferSyncInterface::kParseInvalidArguments;
   return vertex_buffer->SetData(offset, size, data) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
-BufferSyncInterface::ParseError GAPIGL::GetVertexBufferData(ResourceID id,
+BufferSyncInterface::ParseError GAPIGL::GetVertexBufferData(ResourceId id,
                                                             unsigned int offset,
                                                             unsigned int size,
                                                             void *data) {
   VertexBufferGL *vertex_buffer = vertex_buffers_.Get(id);
   if (!vertex_buffer) return BufferSyncInterface::kParseInvalidArguments;
   return vertex_buffer->GetData(offset, size, data) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
-BufferSyncInterface::ParseError GAPIGL::CreateIndexBuffer(ResourceID id,
+BufferSyncInterface::ParseError GAPIGL::CreateIndexBuffer(ResourceId id,
                                                           unsigned int size,
                                                           unsigned int flags) {
   IndexBufferGL *index_buffer = new IndexBufferGL(size, flags);
   index_buffer->Create();
   index_buffers_.Assign(id, index_buffer);
   return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIGL::DestroyIndexBuffer(ResourceID id) {
+BufferSyncInterface::ParseError GAPIGL::DestroyIndexBuffer(ResourceId id) {
   return index_buffers_.Destroy(id) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
-BufferSyncInterface::ParseError GAPIGL::SetIndexBufferData(ResourceID id,
+BufferSyncInterface::ParseError GAPIGL::SetIndexBufferData(ResourceId id,
                                                            unsigned int offset,
                                                            unsigned int size,
                                                            const void *data) {
   IndexBufferGL *index_buffer = index_buffers_.Get(id);
   if (!index_buffer) return BufferSyncInterface::kParseInvalidArguments;
   return index_buffer->SetData(offset, size, data) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
-BufferSyncInterface::ParseError GAPIGL::GetIndexBufferData(ResourceID id,
+BufferSyncInterface::ParseError GAPIGL::GetIndexBufferData(ResourceId id,
                                                            unsigned int offset,
                                                            unsigned int size,
                                                            void *data) {
   IndexBufferGL *index_buffer = index_buffers_.Get(id);
   if (!index_buffer) return BufferSyncInterface::kParseInvalidArguments;
   return index_buffer->GetData(offset, size, data) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
 BufferSyncInterface::ParseError GAPIGL::CreateVertexStruct(
-    ResourceID id,
+    ResourceId id,
     unsigned int input_count) {
   if (id == current_vertex_struct_) validate_streams_ = true;
   VertexStructGL *vertex_struct = new VertexStructGL(input_count);
   vertex_structs_.Assign(id, vertex_struct);
   return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIGL::DestroyVertexStruct(ResourceID id) {
+BufferSyncInterface::ParseError GAPIGL::DestroyVertexStruct(ResourceId id) {
   if (id == current_vertex_struct_) validate_streams_ = true;
   return vertex_structs_.Destroy(id) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
 BufferSyncInterface::ParseError GAPIGL::SetVertexInput(
-    ResourceID vertex_struct_id,
+    ResourceId vertex_struct_id,
     unsigned int input_index,
-    ResourceID vertex_buffer_id,
+    ResourceId vertex_buffer_id,
     unsigned int offset,
     unsigned int stride,
     vertex_struct::Type type,
     vertex_struct::Semantic semantic,
     unsigned int semantic_index) {
   switch (semantic) {
-    case vertex_struct::POSITION:
+    case vertex_struct::kPosition:
       if (semantic_index != 0) {
         return BufferSyncInterface::kParseInvalidArguments;
       }
       break;
-    case vertex_struct::NORMAL:
+    case vertex_struct::kNormal:
       if (semantic_index != 0) {
         return BufferSyncInterface::kParseInvalidArguments;
       }
       break;
-    case vertex_struct::COLOR:
+    case vertex_struct::kColor:
       if (semantic_index >= 2) {
         return BufferSyncInterface::kParseInvalidArguments;
       }
       break;
-    case vertex_struct::TEX_COORD:
+    case vertex_struct::kTexCoord:
       if (semantic_index >= 8) {
         return BufferSyncInterface::kParseInvalidArguments;
       }
       break;
     default:
       DLOG(FATAL) << "Not reached.";
       break;
   }
   if (vertex_buffer_id == current_vertex_struct_) validate_streams_ = true;
   VertexStructGL *vertex_struct = vertex_structs_.Get(vertex_struct_id);
   if (!vertex_struct || input_index >= vertex_struct->count())
     return BufferSyncInterface::kParseInvalidArguments;
   vertex_struct->SetInput(input_index, vertex_buffer_id, offset, stride, type,
                           semantic, semantic_index);
   return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIGL::SetVertexStruct(ResourceID id) {
+BufferSyncInterface::ParseError GAPIGL::SetVertexStruct(ResourceId id) {
   current_vertex_struct_ = id;
   validate_streams_ = true;
   return BufferSyncInterface::kParseNoError;
 }
 
 bool GAPIGL::ValidateStreams() {
   DCHECK(validate_streams_);
   VertexStructGL *vertex_struct = vertex_structs_.Get(current_vertex_struct_);
   if (!vertex_struct) {
     LOG(ERROR) << "Drawing with invalid streams.";
     return false;
   }
   max_vertices_ = vertex_struct->SetStreams(this);
   validate_streams_ = false;
   return max_vertices_ > 0;
 }
 
 namespace {
 
-void PrimitiveTypeToGL(GAPIInterface::PrimitiveType primitive_type,
+void PrimitiveTypeToGL(command_buffer::PrimitiveType primitive_type,
                        GLenum *gl_mode,
                        unsigned int *count) {
   switch (primitive_type) {
-    case GAPIInterface::POINTS:
+    case command_buffer::kPoints:
       *gl_mode = GL_POINTS;
       break;
-    case GAPIInterface::LINES:
+    case command_buffer::kLines:
       *gl_mode = GL_LINES;
       *count *= 2;
       break;
-    case GAPIInterface::LINE_STRIPS:
+    case command_buffer::kLineStrips:
       *gl_mode = GL_LINE_STRIP;
       ++*count;
       break;
-    case GAPIInterface::TRIANGLES:
+    case command_buffer::kTriangles:
       *gl_mode = GL_TRIANGLES;
       *count *= 3;
       break;
-    case GAPIInterface::TRIANGLE_STRIPS:
+    case command_buffer::kTriangleStrips:
       *gl_mode = GL_TRIANGLE_STRIP;
       *count += 2;
       break;
-    case GAPIInterface::TRIANGLE_FANS:
+    case command_buffer::kTriangleFans:
       *gl_mode = GL_TRIANGLE_FAN;
       *count += 2;
       break;
     default:
       LOG(FATAL) << "Invalid primitive type";
       break;
   }
 }
 
 }  // anonymous namespace
@@ skipping 13 matching lines @@
   if (first + count > max_vertices_) {
     return BufferSyncInterface::kParseInvalidArguments;
   }
   glDrawArrays(gl_mode, first, count);
   CHECK_GL_ERROR();
   return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPIGL::DrawIndexed(
     PrimitiveType primitive_type,
-    ResourceID index_buffer_id,
+    ResourceId index_buffer_id,
     unsigned int first,
     unsigned int count,
     unsigned int min_index,
     unsigned int max_index) {
   IndexBufferGL *index_buffer = index_buffers_.Get(index_buffer_id);
   if (!index_buffer) return BufferSyncInterface::kParseInvalidArguments;
   if (validate_effect_ && !ValidateEffect()) {
     return BufferSyncInterface::kParseInvalidArguments;
   }
   DCHECK(current_effect_);
   if (validate_streams_ && !ValidateStreams()) {
     return BufferSyncInterface::kParseInvalidArguments;
   }
   if ((min_index >= max_vertices_) || (max_index > max_vertices_)) {
     return BufferSyncInterface::kParseInvalidArguments;
   }
   GLenum gl_mode = GL_POINTS;
   PrimitiveTypeToGL(primitive_type, &gl_mode, &count);
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer->gl_buffer());
-  GLenum index_type = (index_buffer->flags() & index_buffer::INDEX_32BIT) ?
+  GLenum index_type = (index_buffer->flags() & index_buffer::kIndex32Bit) ?
                       GL_UNSIGNED_INT : GL_UNSIGNED_SHORT;
-  GLuint index_size = (index_buffer->flags() & index_buffer::INDEX_32BIT) ?
+  GLuint index_size = (index_buffer->flags() & index_buffer::kIndex32Bit) ?
                       sizeof(GLuint) : sizeof(GLushort);  // NOLINT
   GLuint offset = first * index_size;
   if (offset + count * index_size > index_buffer->size()) {
     return BufferSyncInterface::kParseInvalidArguments;
   }
   glDrawRangeElements(gl_mode, min_index, max_index, count, index_type,
                       OffsetToPtr(offset));
   CHECK_GL_ERROR();
   return BufferSyncInterface::kParseNoError;
 }
 
 }  // namespace command_buffer
 }  // namespace o3d