Change command buffer client code to use structures....

core/cross/command_buffer/texture_cb.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 102 matching lines @@
     num_rows = (num_rows + 3) / 4;
   }
 
   for (unsigned yy = 0; yy < num_rows; ++yy) {
     memcpy(dst, src, bytes_per_row);
     src += src_pitch;
     dst += dst_pitch;
   }
 }
 
-// Sends the SET_TEXTURE_DATA command after formatting the args properly.
+// Sends the SetTextureData command after formatting the args properly.
 void SetTextureData(RendererCB *renderer,
                     ResourceID texture_id,
                     unsigned int x,
                     unsigned int y,
                     unsigned int mip_width,
                     unsigned int mip_height,
                     unsigned int z,
                     unsigned int depth,
                     unsigned int level,
                     TextureCUBE::CubeFace face,
                     int pitch,
                     size_t mip_size,
                     unsigned char* mip_data) {
   FencedAllocatorWrapper *allocator = renderer->allocator();
   CommandBufferHelper *helper = renderer->helper();
-
-  CommandBufferEntry args[10];
-  args[0].value_uint32 = texture_id;
-  args[1].value_uint32 =
-      set_texture_data_cmd::X::MakeValue(x) |
-      set_texture_data_cmd::Y::MakeValue(y);
-  args[2].value_uint32 =
-      set_texture_data_cmd::Width::MakeValue(mip_width) |
-      set_texture_data_cmd::Height::MakeValue(mip_height);
-  args[3].value_uint32 =
-      set_texture_data_cmd::Z::MakeValue(z) |
-      set_texture_data_cmd::Depth::MakeValue(depth);
-  args[4].value_uint32 =
-      set_texture_data_cmd::Level::MakeValue(level) |
-      set_texture_data_cmd::Face::MakeValue(face);
-  args[5].value_uint32 = pitch;
-  args[6].value_uint32 = 0;  // slice_pitch
-  args[7].value_uint32 = mip_size;
-  args[8].value_uint32 = renderer->transfer_shm_id();
-  args[9].value_uint32 = allocator->GetOffset(mip_data);
-  helper->AddCommand(command_buffer::SET_TEXTURE_DATA, 10, args);
+  helper->SetTextureData(
+      texture_id,
+      x, y, z,
+      mip_width, mip_height, depth,
+      level, face,
+      pitch,
+      0,  // slice_pitch
+      mip_size,
+      renderer->transfer_shm_id(),
+      allocator->GetOffset(mip_data));
   allocator->FreePendingToken(mip_data, helper->InsertToken());
 }
 // Updates a command buffer texture resource from a bitmap, rescaling if
 // necessary.
 void UpdateResourceFromBitmap(RendererCB *renderer,
                               ResourceID texture_id,
                               unsigned int level,
                               TextureCUBE::CubeFace face,
                               const Bitmap &bitmap) {
   DCHECK(bitmap.image_data());
@@ skipping 36 matching lines @@
   CommandBufferHelper *helper = renderer->helper();
   unsigned int mip_width = std::max(1U, bitmap.width() >> level);
   unsigned int mip_height = std::max(1U, bitmap.height() >> level);
   size_t mip_size =
       image::ComputeBufferSize(mip_width, mip_height, bitmap.format());
   unsigned char *buffer = allocator->AllocTyped<unsigned char>(mip_size);
   DCHECK(buffer);
 
   size_t pitch = image::ComputeBufferSize(mip_width, 1, bitmap.format());
 
-  CommandBufferEntry args[10];
-  args[0].value_uint32 = texture_id;
-  args[1].value_uint32 =
-      get_texture_data_cmd::X::MakeValue(0) |
-      get_texture_data_cmd::Y::MakeValue(0);
-  args[2].value_uint32 =
-      get_texture_data_cmd::Width::MakeValue(mip_width) |
-      get_texture_data_cmd::Height::MakeValue(mip_height);
-  args[3].value_uint32 =
-      get_texture_data_cmd::Z::MakeValue(0) |
-      get_texture_data_cmd::Depth::MakeValue(1);
-  args[4].value_uint32 =
-      get_texture_data_cmd::Level::MakeValue(level) |
-      get_texture_data_cmd::Face::MakeValue(face);
-  args[5].value_uint32 = pitch;
-  args[6].value_uint32 = 0;  // slice_pitch
-  args[7].value_uint32 = mip_size;
-  args[8].value_uint32 = renderer->transfer_shm_id();
-  args[9].value_uint32 = allocator->GetOffset(buffer);
-  helper->AddCommand(command_buffer::GET_TEXTURE_DATA, 10, args);
+  helper->GetTextureData(
+      texture_id,
+      0,
+      0,
+      0,
+      mip_width,
+      mip_height,
+      1,
+      level,
+      face,
+      pitch,
+      0,
+      mip_size,
+      renderer->transfer_shm_id(),
+      allocator->GetOffset(buffer));
   helper->Finish();
   memcpy(bitmap.GetMipData(level), buffer, mip_size);
   allocator->Free(buffer);
 }
 
 }  // anonymous namespace
 
 static const unsigned int kMaxTextureSize = 2048;
 
 // Texture2DCB -----------------------------------------------------------------
@@ skipping 19 matching lines @@
                     service_locator->GetService<Renderer>())),
       resource_id_(resource_id),
       backing_bitmap_(Bitmap::Ref(new Bitmap(service_locator))),
       has_levels_(0),
       locked_levels_(0) {
   DCHECK_NE(format, Texture::UNKNOWN_FORMAT);
 }
 
 Texture2DCB::~Texture2DCB() {
   if (resource_id_ != command_buffer::kInvalidResource) {
-    CommandBufferEntry args[1];
-    args[0].value_uint32 = resource_id_;
-    renderer_->helper()->AddCommand(command_buffer::DESTROY_TEXTURE, 1, args);
+    renderer_->helper()->DestroyTexture(resource_id_);
   }
 }
 
 // Creates a new texture object from scratch.
 Texture2DCB* Texture2DCB::Create(ServiceLocator* service_locator,
                                  Texture::Format format,
                                  int levels,
                                  int width,
                                  int height,
                                  bool enable_render_surfaces) {
   DCHECK_NE(format, Texture::UNKNOWN_FORMAT);
   RendererCB *renderer = static_cast<RendererCB *>(
       service_locator->GetService<Renderer>());
   texture::Format cb_format = CBFormatFromO3DFormat(format);
   if (cb_format == texture::NUM_FORMATS) {
     O3D_ERROR(service_locator)
         << "Unsupported format in Texture2DCB::Create.";
     return NULL;
   }
   if (width > kMaxTextureSize || height > kMaxTextureSize) {
     O3D_ERROR(service_locator) << "Texture dimensions (" << width
                                << ", " << height << ") too big.";
     return NULL;
   }
 
   ResourceID texture_id = renderer->texture_ids().AllocateID();
-  CommandBufferEntry args[3];
-  args[0].value_uint32 = texture_id;
-  args[1].value_uint32 =
-      create_texture_2d_cmd::Width::MakeValue(width) |
-      create_texture_2d_cmd::Height::MakeValue(height);
-  args[2].value_uint32 =
-      create_texture_2d_cmd::Levels::MakeValue(levels) |
-      create_texture_2d_cmd::Format::MakeValue(cb_format) |
-      create_texture_2d_cmd::Flags::MakeValue(enable_render_surfaces);
-  renderer->helper()->AddCommand(command_buffer::CREATE_TEXTURE_2D, 3, args);
+  renderer->helper()->CreateTexture2d(
+      texture_id,
+      width, height,
+      levels, cb_format, enable_render_surfaces);
 
   Texture2DCB *texture = new Texture2DCB(service_locator, texture_id,
                                          format, levels, width, height,
                                          enable_render_surfaces);
 
   return texture;
 }
 
 void Texture2DCB::SetRect(int level,
                           unsigned dst_left,
@@ skipping 165 matching lines @@
       resource_id_(resource_id) {
   for (int ii = 0; ii < static_cast<int>(NUMBER_OF_FACES); ++ii) {
     backing_bitmaps_[ii] = Bitmap::Ref(new Bitmap(service_locator));
     has_levels_[ii] = 0;
     locked_levels_[ii] = 0;
   }
 }
 
 TextureCUBECB::~TextureCUBECB() {
   if (resource_id_ != command_buffer::kInvalidResource) {
-    CommandBufferEntry args[1];
-    args[0].value_uint32 = resource_id_;
-    renderer_->helper()->AddCommand(command_buffer::DESTROY_TEXTURE, 1, args);
+    renderer_->helper()->DestroyTexture(resource_id_);
   }
 }
 
 // Create a new Cube texture from scratch.
 TextureCUBECB* TextureCUBECB::Create(ServiceLocator* service_locator,
                                      Texture::Format format,
                                      int levels,
                                      int edge_length,
                                      bool enable_render_surfaces) {
   DCHECK_NE(format, Texture::UNKNOWN_FORMAT);
   RendererCB *renderer = static_cast<RendererCB *>(
       service_locator->GetService<Renderer>());
   texture::Format cb_format = CBFormatFromO3DFormat(format);
   if (cb_format == texture::NUM_FORMATS) {
     O3D_ERROR(service_locator)
         << "Unsupported format in Texture2DCB::Create.";
     return NULL;
   }
   if (edge_length > kMaxTextureSize) {
     O3D_ERROR(service_locator) << "Texture dimensions (" << edge_length
                                << ", " << edge_length << ") too big.";
     return NULL;
   }
 
   ResourceID texture_id = renderer->texture_ids().AllocateID();
-  CommandBufferEntry args[3];
-  args[0].value_uint32 = texture_id;
-  args[1].value_uint32 = create_texture_cube_cmd::Side::MakeValue(edge_length);
-  args[2].value_uint32 =
-      create_texture_cube_cmd::Levels::MakeValue(levels) |
-      create_texture_cube_cmd::Format::MakeValue(cb_format) |
-      create_texture_cube_cmd::Flags::MakeValue(enable_render_surfaces);
-  renderer->helper()->AddCommand(command_buffer::CREATE_TEXTURE_CUBE, 3, args);
+  renderer->helper()->CreateTextureCube(
+      texture_id,
+      edge_length,
+      levels, cb_format, enable_render_surfaces);
 
   TextureCUBECB* texture =
       new TextureCUBECB(service_locator, texture_id, format, levels,
                         edge_length, enable_render_surfaces);
 
   return texture;
 }
 
 void TextureCUBECB::SetRect(TextureCUBE::CubeFace face,
                             int level,
@@ skipping 153 matching lines @@
                                                 face,
                                                 this,
                                                 renderer_));
 }
 
 const Texture::RGBASwizzleIndices& TextureCUBECB::GetABGR32FSwizzleIndices() {
   return g_cb_abgr32f_swizzle_indices;
 }
 
 }  // namespace o3d