expose bitmap in js.

core/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 213 matching lines @@
     : Texture2D(service_locator,
                 bitmap.width(),
                 bitmap.height(),
                 bitmap.format(),
                 bitmap.num_mipmaps(),
                 bitmap.CheckAlphaIsOne(),
                 resize_to_pot,
                 enable_render_surfaces),
       d3d_texture_(tex) {
   DCHECK(tex);
+  backing_bitmap_ = Bitmap::Ref(new Bitmap(service_locator));
 }
 
 // Attempts to create a IDirect3DTexture9 with the given specs.  If the creation
 // of the texture succeeds then it creates a Texture2DD3D9 object around it and
 // returns it.  This is the safe way to create a Texture2DD3D9 object that
 // contains a valid D3D9 texture.
 Texture2DD3D9* Texture2DD3D9::Create(ServiceLocator* service_locator,
                                      Bitmap* bitmap,
                                      RendererD3D9* renderer,
                                      bool enable_render_surfaces) {
@@ skipping 12 matching lines @@
     DLOG(ERROR) << "Failed to create Texture2D (D3D9) : ";
     return NULL;
   }
 
   Texture2DD3D9 *texture = new Texture2DD3D9(service_locator,
                                              d3d_texture,
                                              *bitmap,
                                              resize_to_pot,
                                              enable_render_surfaces);
 
-  texture->backing_bitmap_.SetFrom(bitmap);
-  if (texture->backing_bitmap_.image_data()) {
+  texture->backing_bitmap_->SetFrom(bitmap);
+  if (texture->backing_bitmap_->image_data()) {
     for (unsigned int i = 0; i < bitmap->num_mipmaps(); ++i) {
       if (!texture->UpdateBackedMipLevel(i)) {
         DLOG(ERROR) << "Failed to upload bitmap to texture.";
         delete texture;
         return NULL;
       }
       mip_width = std::max(1U, mip_width >> 1);
       mip_height = std::max(1U, mip_height >> 1);
     }
     if (!resize_to_pot)
-      texture->backing_bitmap_.FreeData();
+      texture->backing_bitmap_->FreeData();
   } else {
     if (resize_to_pot) {
-      texture->backing_bitmap_.AllocateData();
-      memset(texture->backing_bitmap_.image_data(), 0,
-             texture->backing_bitmap_.GetTotalSize());
+      texture->backing_bitmap_->AllocateData();
+      memset(texture->backing_bitmap_->image_data(), 0,
+             texture->backing_bitmap_->GetTotalSize());
     }
   }
 
   return texture;
 }
 
 // Destructor releases the D3D9 texture resource.
 Texture2DD3D9::~Texture2DD3D9() {
   d3d_texture_ = NULL;
 }
 
 bool Texture2DD3D9::UpdateBackedMipLevel(unsigned int level) {
   DCHECK_LT(level, static_cast<unsigned int>(levels()));
-  DCHECK(backing_bitmap_.image_data());
-  DCHECK_EQ(backing_bitmap_.width(), width());
-  DCHECK_EQ(backing_bitmap_.height(), height());
-  DCHECK_EQ(backing_bitmap_.format(), format());
-  DCHECK_EQ(backing_bitmap_.num_mipmaps(), levels());
+  DCHECK(backing_bitmap_->image_data());
+  DCHECK_EQ(backing_bitmap_->width(), width());
+  DCHECK_EQ(backing_bitmap_->height(), height());
+  DCHECK_EQ(backing_bitmap_->format(), format());
+  DCHECK_EQ(backing_bitmap_->num_mipmaps(), levels());
 
   unsigned int mip_width = std::max(1, width() >> level);
   unsigned int mip_height = std::max(1, height() >> level);
   unsigned int rect_width = mip_width;
   unsigned int rect_height = mip_height;
   if (resize_to_pot_) {
     rect_width = std::max(1U, Bitmap::GetPOTSize(width()) >> level);
     rect_height = std::max(1U, Bitmap::GetPOTSize(height()) >> level);
   }
 
   RECT rect = {0, 0, rect_width, rect_height};
   D3DLOCKED_RECT out_rect;
   out_rect.pBits = 0;
 
   if (!HR(d3d_texture_->LockRect(level, &out_rect, &rect, 0))) {
     DLOG(ERROR) << "Failed to lock texture level " << level << ".";
     return false;
   }
 
   DCHECK(out_rect.pBits);
   // TODO: check that the returned pitch is what we expect.
 
   const unsigned char *mip_data =
-      backing_bitmap_.GetMipData(level, TextureCUBE::FACE_POSITIVE_X);
+      backing_bitmap_->GetMipData(level, TextureCUBE::FACE_POSITIVE_X);
   if (resize_to_pot_) {
     Bitmap::Scale(mip_width, mip_height, format(), mip_data,
                   rect_width, rect_height,
                   static_cast<unsigned char *>(out_rect.pBits));
   } else {
     unsigned int mip_size =
         Bitmap::GetBufferSize(mip_width, mip_height, format());
     memcpy(out_rect.pBits, mip_data, mip_size);
   }
 
@@ skipping 50 matching lines @@
         << "Level " << level << " of texture \"" << name()
         << "\" is already locked.";
     return false;
   }
   if (render_surfaces_enabled()) {
     O3D_ERROR(service_locator())
         << "Attempting to lock a render-target texture: " << name();
     return false;
   }
   if (resize_to_pot_) {
-    DCHECK(backing_bitmap_.image_data());
-    *texture_data = backing_bitmap_.GetMipData(level,
+    DCHECK(backing_bitmap_->image_data());
+    *texture_data = backing_bitmap_->GetMipData(level,
                                                TextureCUBE::FACE_POSITIVE_X);
     locked_levels_ |= 1 << level;
     return true;
   } else {
     RECT rect = {0, 0, width(), height()};
     D3DLOCKED_RECT out_rect = {0};
 
     if (HR(d3d_texture_->LockRect(level, &out_rect, &rect, 0))) {
       *texture_data = out_rect.pBits;
       locked_levels_ |= 1 << level;
@@ skipping 44 matching lines @@
 }
 
 bool Texture2DD3D9::OnResetDevice() {
   if (render_surfaces_enabled()) {
     DCHECK(d3d_texture_ == NULL);
     Renderer* renderer = service_locator()->GetService<Renderer>();
     RendererD3D9 *renderer_d3d9 = down_cast<RendererD3D9*>(renderer);
     bool resize_to_pot;
     unsigned int mip_width, mip_height;
     return HR(CreateTexture2DD3D9(renderer_d3d9,
-                                  &backing_bitmap_,
+                                  backing_bitmap_,
                                   render_surfaces_enabled(),
                                   &resize_to_pot,
                                   &mip_width,
                                   &mip_height,
                                   &d3d_texture_));
   }
   return true;
 }
 
 const Texture::RGBASwizzleIndices& Texture2DD3D9::GetABGR32FSwizzleIndices() {
   return g_d3d_abgr32f_swizzle_indices;
 }
 
 // Constructs a cube texture object from the given (existing) D3D Cube texture.
 TextureCUBED3D9::TextureCUBED3D9(ServiceLocator* service_locator,
                                  IDirect3DCubeTexture9* tex,
                                  const Bitmap& bitmap,
                                  bool resize_to_pot,
                                  bool enable_render_surfaces)
     : TextureCUBE(service_locator,
                   bitmap.width(),
                   bitmap.format(),
                   bitmap.num_mipmaps(),
                   bitmap.CheckAlphaIsOne(),
                   resize_to_pot,
                   enable_render_surfaces),
       d3d_cube_texture_(tex) {
+  backing_bitmap_ = Bitmap::Ref(new Bitmap(service_locator));
 }
 
 // Attempts to create a D3D9 CubeTexture with the given specs.  If creation
 // fails the method returns NULL.  Otherwise, it wraps around the newly created
 // texture a TextureCUBED3D9 object and returns a pointer to it.
 TextureCUBED3D9* TextureCUBED3D9::Create(ServiceLocator* service_locator,
                                          Bitmap *bitmap,
                                          RendererD3D9 *renderer,
                                          bool enable_render_surfaces) {
   DCHECK_NE(bitmap->format(), Texture::UNKNOWN_FORMAT);
@@ skipping 12 matching lines @@
     DLOG(ERROR) << "Failed to create TextureCUBE (D3D9)";
     return NULL;
   }
 
   TextureCUBED3D9 *texture = new TextureCUBED3D9(service_locator,
                                                  d3d_texture,
                                                  *bitmap,
                                                  resize_to_pot,
                                                  enable_render_surfaces);
 
-  texture->backing_bitmap_.SetFrom(bitmap);
-  if (texture->backing_bitmap_.image_data()) {
+  texture->backing_bitmap_->SetFrom(bitmap);
+  if (texture->backing_bitmap_->image_data()) {
     for (int face = 0; face < 6; ++face) {
       unsigned int mip_edge = edge;
       for (unsigned int i = 0; i < bitmap->num_mipmaps(); ++i) {
         if (!texture->UpdateBackedMipLevel(i, static_cast<CubeFace>(face))) {
           DLOG(ERROR) << "Failed to upload bitmap to texture.";
           delete texture;
           return NULL;
         }
         mip_edge = std::max(1U, mip_edge >> 1);
       }
     }
     if (!resize_to_pot)
-      texture->backing_bitmap_.FreeData();
+      texture->backing_bitmap_->FreeData();
   } else {
     if (resize_to_pot) {
-      texture->backing_bitmap_.AllocateData();
-      memset(texture->backing_bitmap_.image_data(), 0,
-             texture->backing_bitmap_.GetTotalSize());
+      texture->backing_bitmap_->AllocateData();
+      memset(texture->backing_bitmap_->image_data(), 0,
+             texture->backing_bitmap_->GetTotalSize());
     }
   }
 
   return texture;
 }
 
 
 
 // Destructor releases the D3D9 texture resource.
 TextureCUBED3D9::~TextureCUBED3D9() {
   for (unsigned int i = 0; i < 6; ++i) {
     if (locked_levels_[i] != 0) {
       O3D_ERROR(service_locator())
           << "TextureCUBE \"" << name() << "\" was never unlocked before "
           << "being destroyed.";
       break;  // No need to report it more than once.
     }
   }
   d3d_cube_texture_ = NULL;
 }
 
 bool TextureCUBED3D9::UpdateBackedMipLevel(unsigned int level,
                                            TextureCUBE::CubeFace face) {
   DCHECK_LT(level, static_cast<unsigned int>(levels()));
-  DCHECK(backing_bitmap_.image_data());
-  DCHECK(backing_bitmap_.is_cubemap());
-  DCHECK_EQ(backing_bitmap_.width(), edge_length());
-  DCHECK_EQ(backing_bitmap_.height(), edge_length());
-  DCHECK_EQ(backing_bitmap_.format(), format());
-  DCHECK_EQ(backing_bitmap_.num_mipmaps(), levels());
+  DCHECK(backing_bitmap_->image_data());
+  DCHECK(backing_bitmap_->is_cubemap());
+  DCHECK_EQ(backing_bitmap_->width(), edge_length());
+  DCHECK_EQ(backing_bitmap_->height(), edge_length());
+  DCHECK_EQ(backing_bitmap_->format(), format());
+  DCHECK_EQ(backing_bitmap_->num_mipmaps(), levels());
 
   unsigned int mip_edge = std::max(1, edge_length() >> level);
   unsigned int rect_edge = mip_edge;
   if (resize_to_pot_) {
     rect_edge = std::max(1U, Bitmap::GetPOTSize(edge_length()) >> level);
   }
 
   RECT rect = {0, 0, rect_edge, rect_edge};
   D3DLOCKED_RECT out_rect;
   out_rect.pBits = 0;
 
   if (!HR(d3d_cube_texture_->LockRect(DX9CubeFace(face), level, &out_rect,
                                       &rect, 0))) {
     O3D_ERROR(service_locator())
         << "Failed to lock texture level " << level << " face " << face << ".";
     return false;
   }
 
   DCHECK(out_rect.pBits);
   // TODO: check that the returned pitch is what we expect.
 
-  const unsigned char *mip_data = backing_bitmap_.GetMipData(level, face);
+  const unsigned char *mip_data = backing_bitmap_->GetMipData(level, face);
   if (resize_to_pot_) {
     Bitmap::Scale(mip_edge, mip_edge, format(), mip_data,
                   rect_edge, rect_edge,
                   static_cast<unsigned char *>(out_rect.pBits));
   } else {
     unsigned int mip_size =
         Bitmap::GetBufferSize(mip_edge, mip_edge, format());
     memcpy(out_rect.pBits, mip_data, mip_size);
   }
 
@@ skipping 53 matching lines @@
         << "Level " << level << " Face " << face << " of texture \"" << name()
         << "\" is already locked.";
     return false;
   }
   if (render_surfaces_enabled()) {
     O3D_ERROR(service_locator())
         << "Attempting to lock a render-target texture: " << name();
     return false;
   }
   if (resize_to_pot_) {
-    DCHECK(backing_bitmap_.image_data());
-    *texture_data = backing_bitmap_.GetMipData(level, face);
+    DCHECK(backing_bitmap_->image_data());
+    *texture_data = backing_bitmap_->GetMipData(level, face);
     locked_levels_[face] |= 1 << level;
     return true;
   } else {
     RECT rect = {0, 0, edge_length(), edge_length()};
     D3DLOCKED_RECT out_rect = {0};
 
     if (HR(d3d_cube_texture_->LockRect(DX9CubeFace(face), level,
                                        &out_rect, &rect, 0))) {
       *texture_data = out_rect.pBits;
       locked_levels_[face] |= 1 << level;
@@ skipping 45 matching lines @@
 }
 
 bool TextureCUBED3D9::OnResetDevice() {
   if (render_surfaces_enabled()) {
     DCHECK(d3d_cube_texture_ == NULL);
     Renderer* renderer = service_locator()->GetService<Renderer>();
     RendererD3D9 *renderer_d3d9 = down_cast<RendererD3D9*>(renderer);
     bool resize_to_pot;
     unsigned int mip_edge;
     return HR(CreateTextureCUBED3D9(renderer_d3d9,
-                                    &backing_bitmap_,
+                                    backing_bitmap_,
                                     render_surfaces_enabled(),
                                     &resize_to_pot,
                                     &mip_edge,
                                     &d3d_cube_texture_));
   }
   return true;
 }
 
 const Texture::RGBASwizzleIndices& TextureCUBED3D9::GetABGR32FSwizzleIndices() {
   return g_d3d_abgr32f_swizzle_indices;
 }
 
 }  // namespace o3d