More work in Command Buffers...

command_buffer/service/win/d3d9/texture_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 24 matching lines @@
 
 #include "command_buffer/service/win/d3d9/gapi_d3d9.h"
 #include "command_buffer/service/win/d3d9/texture_d3d9.h"
 
 namespace o3d {
 namespace command_buffer {
 
 // Converts a texture format to a D3D texture format.
 D3DFORMAT TextureD3D9::D3DFormat(texture::Format format) {
   switch (format) {
-    case texture::XRGB8:  return D3DFMT_X8R8G8B8;
-    case texture::ARGB8:  return D3DFMT_A8R8G8B8;
-    case texture::ABGR16F:  return D3DFMT_A16B16G16R16F;
-    case texture::DXT1:  return D3DFMT_DXT1;
+    case texture::kXRGB8:  return D3DFMT_X8R8G8B8;
+    case texture::kARGB8:  return D3DFMT_A8R8G8B8;
+    case texture::kABGR16F:  return D3DFMT_A16B16G16R16F;
+    case texture::kDXT1:  return D3DFMT_DXT1;
     default:  return D3DFMT_UNKNOWN;
   };
 }
 
 // Converts a cube map face to a D3D face.
 D3DCUBEMAP_FACES TextureD3D9::D3DFace(texture::Face face) {
   switch (face) {
-    case texture::FACE_POSITIVE_X:
+    case texture::kFacePositiveX:
       return D3DCUBEMAP_FACE_POSITIVE_X;
-    case texture::FACE_NEGATIVE_X:
+    case texture::kFaceNegativeX:
       return D3DCUBEMAP_FACE_NEGATIVE_X;
-    case texture::FACE_POSITIVE_Y:
+    case texture::kFacePositiveY:
       return D3DCUBEMAP_FACE_POSITIVE_Y;
-    case texture::FACE_NEGATIVE_Y:
+    case texture::kFaceNegativeY:
       return D3DCUBEMAP_FACE_NEGATIVE_Y;
-    case texture::FACE_POSITIVE_Z:
+    case texture::kFacePositiveZ:
       return D3DCUBEMAP_FACE_POSITIVE_Z;
-    case texture::FACE_NEGATIVE_Z:
+    case texture::kFaceNegativeZ:
       return D3DCUBEMAP_FACE_NEGATIVE_Z;
   }
   LOG(FATAL) << "Not reached.";
   return D3DCUBEMAP_FACE_POSITIVE_X;
 }
 
 // Texture 2D functions
 
 // Destroys the 2D texture, releasing the D3D texture, and its shadow if any.
 Texture2DD3D9::~Texture2DD3D9() {
@@ skipping 26 matching lines @@
                                            D3DUSAGE_RENDERTARGET, d3d_format,
                                            D3DPOOL_DEFAULT, &d3d_texture,
                                            NULL);
     if (result != D3D_OK) {
       LOG(ERROR) << "DirectX error when calling CreateTexture: "
                  << DXGetErrorStringA(result);
       return NULL;
     }
     return new Texture2DD3D9(levels, format, flags, width, height, d3d_texture,
                              NULL, enable_render_surfaces);
-  } else if (flags & texture::DYNAMIC) {
+  } else if (flags & texture::kDynamic) {
     CComPtr<IDirect3DTexture9> d3d_texture = NULL;
     HRESULT result = device->CreateTexture(width, height, levels,
                                            D3DUSAGE_DYNAMIC, d3d_format,
                                            D3DPOOL_DEFAULT, &d3d_texture,
                                            NULL);
     if (result != D3D_OK) {
       LOG(ERROR) << "DirectX error when calling CreateTexture: "
                  << DXGetErrorStringA(result);
       return NULL;
     }
@@ skipping 43 matching lines @@
                    slice_pitch);
   if (!CheckVolume(mip_info, volume) || level >= levels() ||
       size < src_transfer_info.total_size)
     return false;
 
   bool full_rect = IsFullVolume(mip_info, volume);
   D3DLOCKED_RECT locked_rect;
   RECT rect = {volume.x, volume.y, volume.x+volume.width,
                volume.y+volume.height};
   DWORD lock_flags =
-      full_rect && (flags() & texture::DYNAMIC) ? D3DLOCK_DISCARD : 0;
+      full_rect && (flags() & texture::kDynamic) ? D3DLOCK_DISCARD : 0;
   HR(lock_texture->LockRect(level, &locked_rect, full_rect ? NULL : &rect,
                             lock_flags));
 
   TransferInfo dst_transfer_info;
   MakeTransferInfo(&dst_transfer_info, mip_info, volume, locked_rect.Pitch,
                    slice_pitch);
   TransferVolume(volume, mip_info, dst_transfer_info, locked_rect.pBits,
                  src_transfer_info, data);
 
   HR(lock_texture->UnlockRect(level));
@@ skipping 93 matching lines @@
                                                  D3DUSAGE_RENDERTARGET,
                                                  d3d_format, D3DPOOL_DEFAULT,
                                                  &d3d_texture, NULL);
     if (result != D3D_OK) {
       LOG(ERROR) << "DirectX error when calling CreateTexture: "
                  << DXGetErrorStringA(result);
       return NULL;
     }
     return new Texture3DD3D9(levels, format, flags, width, height, depth,
                              d3d_texture, NULL, enable_render_surfaces);
-  } else if (flags & texture::DYNAMIC) {
+  } else if (flags & texture::kDynamic) {
     CComPtr<IDirect3DVolumeTexture9> d3d_texture = NULL;
     HRESULT result = device->CreateVolumeTexture(width, height, depth, levels,
                                                  D3DUSAGE_DYNAMIC, d3d_format,
                                                  D3DPOOL_DEFAULT, &d3d_texture,
                                                  NULL);
     if (result != D3D_OK) {
       LOG(ERROR) << "DirectX error when calling CreateTexture: "
                  << DXGetErrorStringA(result);
       return NULL;
     }
@@ skipping 46 matching lines @@
                    slice_pitch);
   if (!CheckVolume(mip_info, volume) || level >= levels() ||
       size < src_transfer_info.total_size)
     return false;
 
   bool full_box = IsFullVolume(mip_info, volume);
   D3DLOCKED_BOX locked_box;
   D3DBOX box = {volume.x, volume.y, volume.z, volume.x+volume.width,
                 volume.y+volume.height, volume.z+volume.depth};
   DWORD lock_flags =
-      full_box && (flags() & texture::DYNAMIC) ? D3DLOCK_DISCARD : 0;
+      full_box && (flags() & texture::kDynamic) ? D3DLOCK_DISCARD : 0;
   HR(lock_texture->LockBox(level, &locked_box, full_box ? NULL : &box,
                            lock_flags));
 
   TransferInfo dst_transfer_info;
   MakeTransferInfo(&dst_transfer_info, mip_info, volume, locked_box.RowPitch,
                    locked_box.SlicePitch);
   TransferVolume(volume, mip_info, dst_transfer_info, locked_box.pBits,
                  src_transfer_info, data);
 
   HR(lock_texture->UnlockBox(level));
@@ skipping 85 matching lines @@
                                                D3DUSAGE_RENDERTARGET,
                                                d3d_format, D3DPOOL_DEFAULT,
                                                &d3d_texture, NULL);
     if (result != D3D_OK) {
       LOG(ERROR) << "DirectX error when calling CreateTexture: "
                  << DXGetErrorStringA(result);
       return NULL;
     }
     return new TextureCubeD3D9(levels, format, flags, side, d3d_texture, NULL,
                                enable_render_surfaces);
-  } else if (flags & texture::DYNAMIC) {
+  } else if (flags & texture::kDynamic) {
     CComPtr<IDirect3DCubeTexture9> d3d_texture = NULL;
     HRESULT result = device->CreateCubeTexture(side, levels, D3DUSAGE_DYNAMIC,
                                                d3d_format, D3DPOOL_DEFAULT,
                                                &d3d_texture, NULL);
     if (result != D3D_OK) {
       LOG(ERROR) << "DirectX error when calling CreateTexture: "
                  << DXGetErrorStringA(result);
       return NULL;
     }
     CComPtr<IDirect3DCubeTexture9> d3d_shadow = NULL;
@@ skipping 44 matching lines @@
   if (!CheckVolume(mip_info, volume) || level >= levels() ||
       size < src_transfer_info.total_size)
     return false;
 
   D3DCUBEMAP_FACES d3d_face = D3DFace(face);
   bool full_rect = IsFullVolume(mip_info, volume);
   D3DLOCKED_RECT locked_rect;
   RECT rect = {volume.x, volume.y, volume.x+volume.width,
                volume.y+volume.height};
   DWORD lock_flags =
-      full_rect && (flags() & texture::DYNAMIC) ? D3DLOCK_DISCARD : 0;
+      full_rect && (flags() & texture::kDynamic) ? D3DLOCK_DISCARD : 0;
   HR(lock_texture->LockRect(d3d_face, level, &locked_rect,
                             full_rect ? NULL : &rect, lock_flags));
 
   TransferInfo dst_transfer_info;
   MakeTransferInfo(&dst_transfer_info, mip_info, volume, locked_rect.Pitch,
                    slice_pitch);
   TransferVolume(volume, mip_info, dst_transfer_info, locked_rect.pBits,
                  src_transfer_info, data);
 
   HR(lock_texture->UnlockRect(d3d_face, level));
@@ skipping 61 matching lines @@
   HR(d3d_cube_texture->GetCubeMapSurface(
       D3DFace(static_cast<texture::Face>(side)),
       mip_level,
       direct3d_surface));
   return true;
 }
 
 // GAPID3D9 functions.
 
 // Destroys a texture resource.
-BufferSyncInterface::ParseError GAPID3D9::DestroyTexture(ResourceID id) {
+BufferSyncInterface::ParseError GAPID3D9::DestroyTexture(ResourceId id) {
   // Dirty effect, because this texture id may be used
   DirtyEffect();
   return textures_.Destroy(id) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
 // Creates a 2D texture resource.
 BufferSyncInterface::ParseError GAPID3D9::CreateTexture2D(
-    ResourceID id,
+    ResourceId id,
     unsigned int width,
     unsigned int height,
     unsigned int levels,
     texture::Format format,
     unsigned int flags,
     bool enable_render_surfaces) {
   Texture2DD3D9 *texture = Texture2DD3D9::Create(this, width, height, levels,
                                                  format, flags,
                                                  enable_render_surfaces);
   if (!texture) return BufferSyncInterface::kParseInvalidArguments;
   // Dirty effect, because this texture id may be used
   DirtyEffect();
   textures_.Assign(id, texture);
   return BufferSyncInterface::kParseNoError;
 }
 
 // Creates a 3D texture resource.
 BufferSyncInterface::ParseError GAPID3D9::CreateTexture3D(
-    ResourceID id,
+    ResourceId id,
     unsigned int width,
     unsigned int height,
     unsigned int depth,
     unsigned int levels,
     texture::Format format,
     unsigned int flags,
     bool enable_render_surfaces) {
   Texture3DD3D9 *texture = Texture3DD3D9::Create(this, width, height, depth,
                                                  levels, format, flags,
                                                  enable_render_surfaces);
   if (!texture) return BufferSyncInterface::kParseInvalidArguments;
   // Dirty effect, because this texture id may be used
   DirtyEffect();
   textures_.Assign(id, texture);
   return BufferSyncInterface::kParseNoError;
 }
 
 // Creates a cube map texture resource.
 BufferSyncInterface::ParseError GAPID3D9::CreateTextureCube(
-    ResourceID id,
+    ResourceId id,
     unsigned int side,
     unsigned int levels,
     texture::Format format,
     unsigned int flags,
     bool enable_render_surfaces) {
   TextureCubeD3D9 *texture = TextureCubeD3D9::Create(this, side, levels,
                                                      format, flags,
                                                      enable_render_surfaces);
   if (!texture) return BufferSyncInterface::kParseInvalidArguments;
   // Dirty effect, because this texture id may be used
   DirtyEffect();
   textures_.Assign(id, texture);
   return BufferSyncInterface::kParseNoError;
 }
 
 // Copies the data into a texture resource.
 BufferSyncInterface::ParseError GAPID3D9::SetTextureData(
-    ResourceID id,
+    ResourceId id,
     unsigned int x,
     unsigned int y,
     unsigned int z,
     unsigned int width,
     unsigned int height,
     unsigned int depth,
     unsigned int level,
     texture::Face face,
     unsigned int row_pitch,
     unsigned int slice_pitch,
     unsigned int size,
     const void *data) {
   TextureD3D9 *texture = textures_.Get(id);
   if (!texture)
     return BufferSyncInterface::kParseInvalidArguments;
   Volume volume = {x, y, z, width, height, depth};
   return texture->SetData(this, volume, level, face, row_pitch, slice_pitch,
                           size, data) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
 // Copies the data from a texture resource.
 BufferSyncInterface::ParseError GAPID3D9::GetTextureData(
-    ResourceID id,
+    ResourceId id,
     unsigned int x,
     unsigned int y,
     unsigned int z,
     unsigned int width,
     unsigned int height,
     unsigned int depth,
     unsigned int level,
     texture::Face face,
     unsigned int row_pitch,
     unsigned int slice_pitch,
     unsigned int size,
     void *data) {
   TextureD3D9 *texture = textures_.Get(id);
   if (!texture)
     return BufferSyncInterface::kParseInvalidArguments;
   Volume volume = {x, y, z, width, height, depth};
   return texture->GetData(this, volume, level, face, row_pitch, slice_pitch,
                           size, data) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
 }  // namespace command_buffer
 }  // namespace o3d