More work in Command Buffers...

command_buffer/service/win/d3d9/geometry_d3d9.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 37 matching lines @@
   if (d3d_vertex_buffer_) {
     d3d_vertex_buffer_->Release();
     d3d_vertex_buffer_ = NULL;
   }
 }
 
 // Creates a D3D9 vertex buffer.
 void VertexBufferD3D9::Create(GAPID3D9 *gapi) {
   DCHECK(d3d_vertex_buffer_ == NULL);
 
-  DWORD d3d_usage = (flags() & vertex_buffer::DYNAMIC) ? D3DUSAGE_DYNAMIC : 0;
+  DWORD d3d_usage = (flags() & vertex_buffer::kDynamic) ? D3DUSAGE_DYNAMIC : 0;
   D3DPOOL d3d_pool = D3DPOOL_MANAGED;
   HR(gapi->d3d_device()->CreateVertexBuffer(size(), d3d_usage, 0, d3d_pool,
                                             &d3d_vertex_buffer_, NULL));
 }
 
 // Sets the data into the D3D9 vertex buffer, using Lock() and memcpy.
 bool VertexBufferD3D9::SetData(unsigned int offset,
                                unsigned int size,
                                const void *data) {
   if (!d3d_vertex_buffer_) {
     LOG(ERROR) << "Calling SetData on a non-initialized VertexBufferD3D9.";
     return false;
   }
   if ((offset >= this->size()) || (offset + size > this->size())) {
     LOG(ERROR) << "Invalid size or offset on VertexBufferD3D9::SetData.";
     return false;
   }
   void *ptr = NULL;
   DWORD lock_flags = 0;
   // If we are setting the full buffer, discard the old data. That's only
   // possible to do for a dynamic d3d vertex buffer.
   if ((offset == 0) && (size == this->size()) &&
-      (flags() & vertex_buffer::DYNAMIC))
+      (flags() & vertex_buffer::kDynamic))
     lock_flags = D3DLOCK_DISCARD;
   HR(d3d_vertex_buffer_->Lock(offset, size, &ptr, lock_flags));
   memcpy(ptr, data, size);
   HR(d3d_vertex_buffer_->Unlock());
   return true;
 }
 
 // Gets the data from the D3D9 vertex buffer, using Lock() and memcpy.
 bool VertexBufferD3D9::GetData(unsigned int offset,
                                unsigned int size,
@@ skipping 20 matching lines @@
   if (d3d_index_buffer_) {
     d3d_index_buffer_->Release();
     d3d_index_buffer_ = NULL;
   }
 }
 
 // Creates a D3D9 index buffer.
 void IndexBufferD3D9::Create(GAPID3D9 *gapi) {
   DCHECK(d3d_index_buffer_ == NULL);
 
-  DWORD d3d_usage = (flags() & index_buffer::DYNAMIC) ? D3DUSAGE_DYNAMIC : 0;
+  DWORD d3d_usage = (flags() & index_buffer::kDynamic) ? D3DUSAGE_DYNAMIC : 0;
   D3DFORMAT d3d_format =
-      (flags() & index_buffer::INDEX_32BIT) ? D3DFMT_INDEX32 : D3DFMT_INDEX16;
+      (flags() & index_buffer::kIndex32Bit) ? D3DFMT_INDEX32 : D3DFMT_INDEX16;
   D3DPOOL d3d_pool = D3DPOOL_MANAGED;
   HR(gapi->d3d_device()->CreateIndexBuffer(size(), d3d_usage, d3d_format,
                                            d3d_pool, &d3d_index_buffer_,
                                            NULL));
 }
 
 // Sets the data into the D3D9 index buffer, using Lock() and memcpy.
 bool IndexBufferD3D9::SetData(unsigned int offset,
                               unsigned int size,
                               const void *data) {
   if (!d3d_index_buffer_) {
     LOG(ERROR) << "Calling SetData on a non-initialized IndexBufferD3D9.";
     return false;
   }
   if ((offset >= this->size()) || (offset + size > this->size())) {
     LOG(ERROR) << "Invalid size or offset on IndexBufferD3D9::SetData.";
     return false;
   }
   void *ptr = NULL;
   DWORD lock_flags = 0;
   // If we are setting the full buffer, discard the old data. That's only
   // possible to do for a dynamic d3d index buffer.
   if ((offset == 0) && (size == this->size()) &&
-      (flags() & index_buffer::DYNAMIC))
+      (flags() & index_buffer::kDynamic))
     lock_flags = D3DLOCK_DISCARD;
   HR(d3d_index_buffer_->Lock(offset, size, &ptr, lock_flags));
   memcpy(ptr, data, size);
   HR(d3d_index_buffer_->Unlock());
   return true;
 }
 
 // Gets the data from the D3D9 index buffer, using Lock() and memcpy.
 bool IndexBufferD3D9::GetData(unsigned int offset,
                               unsigned int size,
                               void *data) {
   if (!d3d_index_buffer_) {
     LOG(ERROR) << "Calling SetData on a non-initialized IndexBufferD3D9.";
     return false;
   }
   if ((offset >= this->size()) || (offset + size > this->size())) {
     LOG(ERROR) << "Invalid size or offset on IndexBufferD3D9::SetData.";
     return false;
   }
   void *ptr = NULL;
   DWORD lock_flags = D3DLOCK_READONLY;
   HR(d3d_index_buffer_->Lock(offset, size, &ptr, lock_flags));
   memcpy(data, ptr, size);
   HR(d3d_index_buffer_->Unlock());
   return true;
 }
 
 // Sets the input element in the VertexStruct resource.
 void VertexStructD3D9::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 26 matching lines @@
       max_vertices = std::min(max_vertices,
                               vertex_buffer->size() / pair.second);
     }
   }
   return max_vertices;
 }
 
 // Converts a vertex_struct::Type to a D3DDECLTYPE.
 static D3DDECLTYPE D3DType(vertex_struct::Type type) {
   switch (type) {
-    case vertex_struct::FLOAT1:
+    case vertex_struct::kFloat1:
       return D3DDECLTYPE_FLOAT1;
-    case vertex_struct::FLOAT2:
+    case vertex_struct::kFloat2:
       return D3DDECLTYPE_FLOAT2;
-    case vertex_struct::FLOAT3:
+    case vertex_struct::kFloat3:
       return D3DDECLTYPE_FLOAT3;
-    case vertex_struct::FLOAT4:
+    case vertex_struct::kFloat4:
       return D3DDECLTYPE_FLOAT4;
-    case vertex_struct::UCHAR4N:
+    case vertex_struct::kUChar4N:
       return D3DDECLTYPE_UBYTE4N;
-    case vertex_struct::NUM_TYPES:
+    case vertex_struct::kNumTypes:
       break;
   }
   LOG(FATAL) << "Invalid type";
   return D3DDECLTYPE_FLOAT1;
 }
 
 // Converts a vertex_struct::Semantic to a D3DDECLUSAGE.
 static D3DDECLUSAGE D3DUsage(vertex_struct::Semantic semantic) {
   switch (semantic) {
-    case vertex_struct::POSITION:
+    case vertex_struct::kPosition:
       return D3DDECLUSAGE_POSITION;
-    case vertex_struct::NORMAL:
+    case vertex_struct::kNormal:
       return D3DDECLUSAGE_NORMAL;
-    case vertex_struct::COLOR:
+    case vertex_struct::kColor:
       return D3DDECLUSAGE_COLOR;
-    case vertex_struct::TEX_COORD:
+    case vertex_struct::kTexCoord:
       return D3DDECLUSAGE_TEXCOORD;
-    case vertex_struct::NUM_SEMANTICS:
+    case vertex_struct::kNumSemantics:
       break;
   }
   LOG(FATAL) << "Invalid type";
   return D3DDECLUSAGE_POSITION;
 }
 
 // Destroys the d3d vertex declaration.
 VertexStructD3D9::~VertexStructD3D9() {
   Destroy();
 }
@@ skipping 39 matching lines @@
   D3DVERTEXELEMENT9 &end = d3d_elements[count_];
   end.Stream = 0xFF;
   end.Type = D3DDECLTYPE_UNUSED;
   HR(d3d_device->CreateVertexDeclaration(d3d_elements.get(),
                                          &d3d_vertex_decl_));
   dirty_ = false;
 }
 
 // Creates and assigns a VertexBufferD3D9 resource.
 BufferSyncInterface::ParseError GAPID3D9::CreateVertexBuffer(
-    ResourceID id,
+    ResourceId id,
     unsigned int size,
     unsigned int flags) {
   VertexBufferD3D9 *vertex_buffer = new VertexBufferD3D9(size, flags);
   vertex_buffer->Create(this);
   vertex_buffers_.Assign(id, vertex_buffer);
   return BufferSyncInterface::kParseNoError;
 }
 
 // Destroys a VertexBufferD3D9 resource.
-BufferSyncInterface::ParseError GAPID3D9::DestroyVertexBuffer(ResourceID id) {
+BufferSyncInterface::ParseError GAPID3D9::DestroyVertexBuffer(ResourceId id) {
   return vertex_buffers_.Destroy(id) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
 // Copies the data into the VertexBufferD3D9 resource.
 BufferSyncInterface::ParseError GAPID3D9::SetVertexBufferData(
-    ResourceID id,
+    ResourceId id,
     unsigned int offset,
     unsigned int size,
     const void *data) {
   VertexBufferD3D9 *vertex_buffer = vertex_buffers_.Get(id);
   if (!vertex_buffer) return BufferSyncInterface::kParseInvalidArguments;
   return vertex_buffer->SetData(offset, size, data) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
 // Copies the data from the VertexBufferD3D9 resource.
 BufferSyncInterface::ParseError GAPID3D9::GetVertexBufferData(
-    ResourceID id,
+    ResourceId id,
     unsigned int offset,
     unsigned int size,
     void *data) {
   VertexBufferD3D9 *vertex_buffer = vertex_buffers_.Get(id);
   if (!vertex_buffer) return BufferSyncInterface::kParseInvalidArguments;
   return vertex_buffer->GetData(offset, size, data) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
 // Creates and assigns an IndexBufferD3D9 resource.
 BufferSyncInterface::ParseError GAPID3D9::CreateIndexBuffer(
-    ResourceID id,
+    ResourceId id,
     unsigned int size,
     unsigned int flags) {
   IndexBufferD3D9 *index_buffer = new IndexBufferD3D9(size, flags);
   index_buffer->Create(this);
   index_buffers_.Assign(id, index_buffer);
   return BufferSyncInterface::kParseNoError;
 }
 
 // Destroys an IndexBufferD3D9 resource.
-BufferSyncInterface::ParseError GAPID3D9::DestroyIndexBuffer(ResourceID id) {
+BufferSyncInterface::ParseError GAPID3D9::DestroyIndexBuffer(ResourceId id) {
   return index_buffers_.Destroy(id) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
 // Copies the data into the IndexBufferD3D9 resource.
 BufferSyncInterface::ParseError GAPID3D9::SetIndexBufferData(
-    ResourceID id,
+    ResourceId id,
     unsigned int offset,
     unsigned int size,
     const void *data) {
   IndexBufferD3D9 *index_buffer = index_buffers_.Get(id);
   if (!index_buffer) return BufferSyncInterface::kParseInvalidArguments;
   return index_buffer->SetData(offset, size, data) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
 // Copies the data from the IndexBufferD3D9 resource.
 BufferSyncInterface::ParseError GAPID3D9::GetIndexBufferData(
-    ResourceID id,
+    ResourceId id,
     unsigned int offset,
     unsigned int size,
     void *data) {
   IndexBufferD3D9 *index_buffer = index_buffers_.Get(id);
   if (!index_buffer) return BufferSyncInterface::kParseInvalidArguments;
   return index_buffer->GetData(offset, size, data) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
 // Creates and assigns a VertexStructD3D9 resource.
 BufferSyncInterface::ParseError GAPID3D9::CreateVertexStruct(
-    ResourceID id, unsigned int input_count) {
+    ResourceId id, unsigned int input_count) {
   if (id == current_vertex_struct_) validate_streams_ = true;
   VertexStructD3D9 *vertex_struct = new VertexStructD3D9(input_count);
   vertex_structs_.Assign(id, vertex_struct);
   return BufferSyncInterface::kParseNoError;
 }
 
 // Destroys a VertexStructD3D9 resource.
-BufferSyncInterface::ParseError GAPID3D9::DestroyVertexStruct(ResourceID id) {
+BufferSyncInterface::ParseError GAPID3D9::DestroyVertexStruct(ResourceId id) {
   if (id == current_vertex_struct_) validate_streams_ = true;
   return vertex_structs_.Destroy(id) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
 // Sets an input into a VertexStructD3D9 resource.
 BufferSyncInterface::ParseError GAPID3D9::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) {
   if (vertex_buffer_id == current_vertex_struct_) validate_streams_ = true;
   VertexStructD3D9 *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;
 }
 
 }  // namespace command_buffer
 }  // namespace o3d