More work in Command Buffers...

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 30 matching lines @@
 #include "command_buffer/common/cross/cmd_buffer_format.h"
 #include "command_buffer/common/cross/resource.h"
 #include "command_buffer/client/cross/cmd_buffer_helper.h"
 #include "command_buffer/client/cross/fenced_allocator.h"
 
 namespace o3d {
 
 using command_buffer::CommandBufferEntry;
 using command_buffer::CommandBufferHelper;
 using command_buffer::FencedAllocatorWrapper;
-using command_buffer::ResourceID;
+using command_buffer::ResourceId;
 namespace texture = command_buffer::texture;
-namespace set_texture_data_cmd = command_buffer::set_texture_data_cmd;
-namespace get_texture_data_cmd = command_buffer::get_texture_data_cmd;
-namespace create_texture_2d_cmd = command_buffer::create_texture_2d_cmd;
-namespace create_texture_cube_cmd = command_buffer::create_texture_cube_cmd;
 
 namespace {
 
 const Texture::RGBASwizzleIndices g_cb_abgr32f_swizzle_indices =
     {0, 1, 2, 3};
 
 // Converts an O3D texture format to a command buffer texture format.
 texture::Format CBFormatFromO3DFormat(Texture::Format format) {
   switch (format) {
     case Texture::XRGB8:
-      return texture::XRGB8;
+      return texture::kXRGB8;
     case Texture::ARGB8:
-      return texture::ARGB8;
+      return texture::kARGB8;
     case Texture::ABGR16F:
-      return texture::ABGR16F;
+      return texture::kABGR16F;
     case Texture::DXT1:
-      return texture::DXT1;
+      return texture::kDXT1;
       // TODO: DXT3/5. It's not yet supported by the command buffer
       // renderer, though it would be a simple addition.
     default:
       break;
   }
   // failed to find a matching format
   LOG(ERROR) << "Unrecognized Texture format type.";
-  return texture::NUM_FORMATS;
+  return texture::kNumFormats;
 }
 
 // Checks that enums match in value, so that they can be directly used in
-// set_texture_data_cmd::Face bitfields.
-COMPILE_ASSERT(TextureCUBE::FACE_POSITIVE_X == texture::FACE_POSITIVE_X,
+// SetTextureData::Face bitfields.
+COMPILE_ASSERT(TextureCUBE::FACE_POSITIVE_X == texture::kFacePositiveX,
                FACE_POSITIVE_X_enums_don_t_match);
-COMPILE_ASSERT(TextureCUBE::FACE_NEGATIVE_X == texture::FACE_NEGATIVE_X,
+COMPILE_ASSERT(TextureCUBE::FACE_NEGATIVE_X == texture::kFaceNegativeX,
                FACE_NEGATIVE_X_enums_don_t_match);
-COMPILE_ASSERT(TextureCUBE::FACE_POSITIVE_Y == texture::FACE_POSITIVE_Y,
+COMPILE_ASSERT(TextureCUBE::FACE_POSITIVE_Y == texture::kFacePositiveY,
                FACE_POSITIVE_Y_enums_don_t_match);
-COMPILE_ASSERT(TextureCUBE::FACE_NEGATIVE_Y == texture::FACE_NEGATIVE_Y,
+COMPILE_ASSERT(TextureCUBE::FACE_NEGATIVE_Y == texture::kFaceNegativeY,
                FACE_NEGATIVE_Y_enums_don_t_match);
-COMPILE_ASSERT(TextureCUBE::FACE_POSITIVE_Z == texture::FACE_POSITIVE_Z,
+COMPILE_ASSERT(TextureCUBE::FACE_POSITIVE_Z == texture::kFacePositiveZ,
                FACE_POSITIVE_Z_enums_don_t_match);
-COMPILE_ASSERT(TextureCUBE::FACE_NEGATIVE_Z == texture::FACE_NEGATIVE_Z,
+COMPILE_ASSERT(TextureCUBE::FACE_NEGATIVE_Z == texture::kFaceNegativeZ,
                FACE_NEGATIVE_Z_enums_don_t_match);
 
 // Writes the data information into a buffer to be sent to the server side.
 void SetTextureDataBuffer(Texture::Format format,
                           const void* src_data,
                           int src_pitch,
                           unsigned src_width,
                           unsigned src_height,
                           void* dst_buffer,
                           unsigned int dst_pitch) {
   const uint8* src = static_cast<const uint8*>(src_data);
   uint8* dst = static_cast<uint8*>(dst_buffer);
 
   size_t bytes_per_row = image::ComputePitch(format, src_width);
   unsigned num_rows = src_height;
   if (Texture::IsCompressedFormat(format)) {
     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 SetTextureData command after formatting the args properly.
 void SetTextureData(RendererCB *renderer,
-                    ResourceID texture_id,
+                    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();
   helper->SetTextureData(
       texture_id,
       x, y, z,
       mip_width, mip_height, depth,
-      level, face,
+      level, static_cast<texture::Face>(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,
+                              ResourceId texture_id,
                               unsigned int level,
                               TextureCUBE::CubeFace face,
                               const Bitmap &bitmap) {
   DCHECK(bitmap.image_data());
   FencedAllocatorWrapper *allocator = renderer->allocator();
   CommandBufferHelper *helper = renderer->helper();
   unsigned int mip_width = std::max(1U, bitmap.width() >> level);
   unsigned int mip_height = std::max(1U, bitmap.height() >> level);
   unsigned char *mip_data = bitmap.GetMipData(level);
   size_t mip_size =
@@ skipping 14 matching lines @@
                  1,
                  level,
                  face,
                  pitch,
                  mip_size,
                  mip_data);
 }
 
 // Copies back texture resource data into a bitmap.
 void CopyBackResourceToBitmap(RendererCB *renderer,
-                              ResourceID texture_id,
+                              ResourceId texture_id,
                               unsigned int level,
                               TextureCUBE::CubeFace face,
                               const Bitmap &bitmap) {
   DCHECK(bitmap.image_data());
   FencedAllocatorWrapper *allocator = renderer->allocator();
   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());
 
   helper->GetTextureData(
       texture_id,
       0,
       0,
       0,
       mip_width,
       mip_height,
       1,
       level,
-      face,
+      static_cast<texture::Face>(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 -----------------------------------------------------------------
 
 // Constructs a 2D texture object from an existing command-buffer 2D texture
 // resource.
 // NOTE: the Texture2DCB now owns the texture resource and will destroy it on
 // exit.
 Texture2DCB::Texture2DCB(ServiceLocator* service_locator,
-                         ResourceID resource_id,
+                         ResourceId resource_id,
                          Texture::Format format,
                          int levels,
                          int width,
                          int height,
                          bool enable_render_surfaces)
     : Texture2D(service_locator,
                 width,
                 height,
                 format,
                 levels,
@@ skipping 17 matching lines @@
 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) {
+  if (cb_format == texture::kNumFormats) {
     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();
+  ResourceId texture_id = renderer->texture_ids().AllocateID();
   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;
@@ skipping 147 matching lines @@
                                                 renderer_));
 }
 
 const Texture::RGBASwizzleIndices& Texture2DCB::GetABGR32FSwizzleIndices() {
   return g_cb_abgr32f_swizzle_indices;
 }
 // TextureCUBECB ---------------------------------------------------------------
 
 // Creates a texture from a pre-existing texture resource.
 TextureCUBECB::TextureCUBECB(ServiceLocator* service_locator,
-                             ResourceID resource_id,
+                             ResourceId resource_id,
                              Texture::Format format,
                              int levels,
                              int edge_length,
                              bool enable_render_surfaces)
     : TextureCUBE(service_locator,
                   edge_length,
                   format,
                   levels,
                   enable_render_surfaces),
       renderer_(static_cast<RendererCB*>(
@@ skipping 15 matching lines @@
 // 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) {
+  if (cb_format == texture::kNumFormats) {
     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();
+  ResourceId texture_id = renderer->texture_ids().AllocateID();
   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;
@@ skipping 157 matching lines @@
                                                 face,
                                                 this,
                                                 renderer_));
 }
 
 const Texture::RGBASwizzleIndices& TextureCUBECB::GetABGR32FSwizzleIndices() {
   return g_cb_abgr32f_swizzle_indices;
 }
 
 }  // namespace o3d