SlimDXc_Jun2010(VC++2008)/source/direct3d9/CubeTexture.cpp

   1 #include "stdafx.h"\r
   2 /*\r
   3 * Copyright (c) 2007-2010 SlimDX Group\r
   4 * \r
   5 * Permission is hereby granted, free of charge, to any person obtaining a copy\r
   6 * of this software and associated documentation files (the "Software"), to deal\r
   7 * in the Software without restriction, including without limitation the rights\r
   8 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r
   9 * copies of the Software, and to permit persons to whom the Software is\r
  10 * furnished to do so, subject to the following conditions:\r
  11 * \r
  12 * The above copyright notice and this permission notice shall be included in\r
  13 * all copies or substantial portions of the Software.\r
  14 * \r
  15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
  16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
  17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r
  18 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r
  19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r
  20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\r
  21 * THE SOFTWARE.\r
  22 */\r
  23 #include <d3d9.h>\r
  24 #include <d3dx9.h>\r
  25 #include <vcclr.h>\r
  26 \r
  27 #include "../DataStream.h"\r
  28 #include "../ComObject.h"\r
  29 #include "../Utilities.h"\r
  30 \r
  31 #include "../math/Vector2.h"\r
  32 \r
  33 #include "Device.h"\r
  34 #include "D3DX.h"\r
  35 #include "CubeTexture.h"\r
  36 \r
  37 #include "Direct3D9Exception.h"\r
  38 \r
  39 using namespace System;\r
  40 using namespace System::IO;\r
  41 using namespace System::Runtime::InteropServices;\r
  42 \r
  43 namespace SlimDX\r
  44 {\r
  45 namespace Direct3D9\r
  46 {\r
  47         void WINAPI NativeD3DXFill2D(D3DXVECTOR4 *out, CONST D3DXVECTOR2 *pTexCoord, CONST D3DXVECTOR2 *pTexelSize, LPVOID data);\r
  48         void WINAPI NativeD3DXFill3D(D3DXVECTOR4 *out, CONST D3DXVECTOR3 *pTexCoord, CONST D3DXVECTOR3 *pTexelSize, LPVOID data);\r
  49 \r
  50         CubeTexture::CubeTexture( SlimDX::Direct3D9::Device^ device, int edgeLength, int numLevels, Usage usage, Format format, Pool pool )\r
  51         {\r
  52                 IDirect3DCubeTexture9* texture = NULL;\r
  53                 HRESULT hr = device->InternalPointer->CreateCubeTexture( edgeLength, numLevels, static_cast<DWORD>( usage ),\r
  54                         static_cast<D3DFORMAT>( format ), static_cast<D3DPOOL>( pool ), &texture, NULL );\r
  55                 \r
  56                 if( RECORD_D3D9(hr).IsFailure )\r
  57                         throw gcnew Direct3D9Exception( Result::Last );\r
  58 \r
  59                 Construct(texture);\r
  60                 if( pool == Pool::Default )\r
  61                         this->IsDefaultPool = true;\r
  62         }\r
  63 \r
  64         CubeTexture::CubeTexture( SlimDX::Direct3D9::Device^ device, int edgeLength, int numLevels, Usage usage, Format format, Pool pool, [Out] IntPtr% sharedHandle )\r
  65         {\r
  66                 IDirect3DCubeTexture9* texture = NULL;\r
  67                 HANDLE sharedHandleNative = NULL;\r
  68                 HRESULT hr = device->InternalPointer->CreateCubeTexture( edgeLength, numLevels, static_cast<DWORD>( usage ),\r
  69                         static_cast<D3DFORMAT>( format ), static_cast<D3DPOOL>( pool ), &texture, &sharedHandleNative );\r
  70                 \r
  71                 if( RECORD_D3D9(hr).IsFailure )\r
  72                         throw gcnew Direct3D9Exception( Result::Last );\r
  73 \r
  74                 Construct(texture);\r
  75                 sharedHandle = IntPtr(sharedHandleNative);\r
  76                 if( pool == Pool::Default )\r
  77                         this->IsDefaultPool = true;\r
  78         }\r
  79 \r
  80         CubeTextureRequirements CubeTexture::CheckRequirements(SlimDX::Direct3D9::Device^ device, int size,\r
  81                 int numMipLevels, Usage usage, Format format, Pool pool)\r
  82         {\r
  83                 CubeTextureRequirements result;                                 // Result.\r
  84                 D3DFORMAT d3dFormat = static_cast<D3DFORMAT>( format ); // Format.\r
  85                 HRESULT hr;                                                                     // Error code.\r
  86 \r
  87                 // Get texture requirements.\r
  88                 hr = D3DXCheckCubeTextureRequirements(device->InternalPointer, reinterpret_cast<UINT*>( &size ), \r
  89                         reinterpret_cast<UINT*>( &numMipLevels ), static_cast<DWORD>( usage ),\r
  90                         reinterpret_cast<D3DFORMAT*>( &d3dFormat ), static_cast<D3DPOOL>( pool ) );\r
  91                 \r
  92                 if( RECORD_D3D9(hr).IsFailure )\r
  93                         return CubeTextureRequirements();\r
  94 \r
  95                 // Return proposed values.\r
  96                 result.Size = size;\r
  97                 result.Format = format;\r
  98                 result.MipLevelCount = numMipLevels;\r
  99 \r
 100                 return result;\r
 101         }\r
 102 \r
 103         CubeTexture^ CubeTexture::FromMemory_Internal( SlimDX::Direct3D9::Device^ device, const void* memory, UINT sizeBytes,\r
 104                 int size, int numLevels, Usage usage, Format format, Pool pool, Filter filter, Filter mipFilter, int colorKey,\r
 105                 ImageInformation* imageInformation, PaletteEntry* palette )\r
 106         {\r
 107                 IDirect3DCubeTexture9* texture = NULL;\r
 108 \r
 109                 HRESULT hr = D3DXCreateCubeTextureFromFileInMemoryEx( device->InternalPointer, memory, sizeBytes, size, numLevels,\r
 110                         static_cast<DWORD>( usage ), static_cast<D3DFORMAT>( format ), static_cast<D3DPOOL>( pool ), static_cast<DWORD>( filter ), static_cast<DWORD>( mipFilter ),\r
 111                         static_cast<D3DCOLOR>( colorKey ), reinterpret_cast<D3DXIMAGE_INFO*>( imageInformation ), \r
 112                         reinterpret_cast<PALETTEENTRY*>( palette ), &texture );\r
 113                 \r
 114                 if( RECORD_D3D9(hr).IsFailure )\r
 115                 {\r
 116                         palette = nullptr;\r
 117                         return nullptr;\r
 118                 }\r
 119 \r
 120                 CubeTexture^ result = gcnew CubeTexture( texture, nullptr );\r
 121                 if( pool == Pool::Default )\r
 122                         result->IsDefaultPool = true;\r
 123                 return result;\r
 124         }\r
 125 \r
 126         CubeTexture^ CubeTexture::FromMemory( SlimDX::Direct3D9::Device^ device, array<Byte>^ memory, int size, int numLevels,\r
 127                 Usage usage, Format format, Pool pool, Filter filter, Filter mipFilter, int colorKey,\r
 128                 [Out] ImageInformation% imageInformation, [Out] array<PaletteEntry>^% palette )\r
 129         {\r
 130                 pin_ptr<unsigned char> pinnedMemory = &memory[0];\r
 131                 imageInformation = ImageInformation();\r
 132                 pin_ptr<ImageInformation> pinnedImageInfo = &imageInformation;\r
 133                 palette = gcnew array<PaletteEntry>( 256 );\r
 134                 pin_ptr<PaletteEntry> pinnedPalette = &palette[0];\r
 135 \r
 136                 return FromMemory_Internal( device, pinnedMemory, static_cast<UINT>( memory->Length ), size, numLevels,\r
 137                         usage, format, pool, filter, mipFilter, colorKey, pinnedImageInfo, pinnedPalette );\r
 138         }\r
 139 \r
 140         CubeTexture^ CubeTexture::FromMemory( SlimDX::Direct3D9::Device^ device, array<Byte>^ memory, int size, int numLevels,\r
 141                 Usage usage, Format format, Pool pool, Filter filter, Filter mipFilter, int colorKey,\r
 142                 [Out] ImageInformation% imageInformation )\r
 143         {\r
 144                 pin_ptr<unsigned char> pinnedMemory = &memory[0];\r
 145                 pin_ptr<ImageInformation> pinnedImageInfo = &imageInformation;\r
 146 \r
 147                 return FromMemory_Internal( device, pinnedMemory, static_cast<UINT>( memory->Length ), size, numLevels,\r
 148                         usage, format, pool, filter, mipFilter, colorKey, pinnedImageInfo, NULL );\r
 149         }\r
 150 \r
 151         CubeTexture^ CubeTexture::FromMemory( SlimDX::Direct3D9::Device^ device, array<Byte>^ memory, int size, int numLevels,\r
 152                 Usage usage, Format format, Pool pool, Filter filter, Filter mipFilter, int colorKey )\r
 153         {\r
 154                 pin_ptr<unsigned char> pinnedMemory = &memory[0];\r
 155 \r
 156                 return FromMemory_Internal( device, pinnedMemory, static_cast<UINT>( memory->Length ), size, numLevels,\r
 157                         usage, format, pool, filter, mipFilter, colorKey, NULL, NULL );\r
 158         }\r
 159 \r
 160         CubeTexture^ CubeTexture::FromMemory( SlimDX::Direct3D9::Device^ device, array<Byte>^ memory, Usage usage, Pool pool )\r
 161         {\r
 162                 return CubeTexture::FromMemory( device, memory, D3DX::Default, D3DX::Default,\r
 163                         usage, Format::Unknown, pool, Filter::Default, Filter::Default, 0 );\r
 164         }\r
 165 \r
 166         CubeTexture^ CubeTexture::FromMemory( SlimDX::Direct3D9::Device^ device, array<Byte>^ memory )\r
 167         {\r
 168                 return CubeTexture::FromMemory( device, memory, Usage::None, Pool::Managed );\r
 169         }\r
 170 \r
 171         CubeTexture^ CubeTexture::FromStream( SlimDX::Direct3D9::Device^ device, Stream^ stream, int sizeBytes, int size, int numLevels,\r
 172                 Usage usage, Format format, Pool pool, Filter filter, Filter mipFilter, int colorKey,\r
 173                 [Out] ImageInformation% imageInformation, [Out] array<PaletteEntry>^% palette )\r
 174         {\r
 175                 DataStream^ ds;\r
 176                 array<Byte>^ data = Utilities::ReadStream( stream, sizeBytes, &ds );\r
 177                 \r
 178                 if( data == nullptr )\r
 179                 {\r
 180                         palette = gcnew array<PaletteEntry>( 256 );\r
 181                         pin_ptr<PaletteEntry> pinnedPalette = &palette[0];\r
 182                         imageInformation = ImageInformation();\r
 183                         pin_ptr<ImageInformation> pinnedImageInfo = &imageInformation;\r
 184 \r
 185                         CubeTexture^ texture = FromMemory_Internal( device, ds->PositionPointer, sizeBytes, size, numLevels,\r
 186                                 usage, format, pool, filter, mipFilter, colorKey, pinnedImageInfo, pinnedPalette );\r
 187 \r
 188                         ds->Seek( sizeBytes, SeekOrigin::Current );\r
 189                         return texture;\r
 190                 }\r
 191 \r
 192                 return CubeTexture::FromMemory( device, data, size, numLevels, usage, format, pool, filter, mipFilter, \r
 193                         colorKey, imageInformation, palette );\r
 194         }\r
 195 \r
 196         CubeTexture^ CubeTexture::FromStream( SlimDX::Direct3D9::Device^ device, Stream^ stream, int sizeBytes, int size, int numLevels,\r
 197                 Usage usage, Format format, Pool pool, Filter filter, Filter mipFilter, int colorKey,\r
 198                 [Out] ImageInformation% imageInformation )\r
 199         {\r
 200                 DataStream^ ds;\r
 201                 array<Byte>^ data = Utilities::ReadStream( stream, sizeBytes, &ds );\r
 202                 \r
 203                 if( data == nullptr )\r
 204                 {\r
 205                         imageInformation = ImageInformation();\r
 206                         pin_ptr<ImageInformation> pinnedImageInfo = &imageInformation;\r
 207 \r
 208                         CubeTexture^ texture = FromMemory_Internal( device, ds->PositionPointer, sizeBytes, size, numLevels,\r
 209                                 usage, format, pool, filter, mipFilter, colorKey, pinnedImageInfo, NULL );\r
 210 \r
 211                         ds->Seek( sizeBytes, SeekOrigin::Current );\r
 212                         return texture;\r
 213                 }\r
 214 \r
 215                 return CubeTexture::FromMemory( device, data, size, numLevels, usage, format, pool, filter, mipFilter, \r
 216                         colorKey, imageInformation );\r
 217         }\r
 218 \r
 219         CubeTexture^ CubeTexture::FromStream( SlimDX::Direct3D9::Device^ device, Stream^ stream, int sizeBytes, int size, int numLevels,\r
 220                 Usage usage, Format format, Pool pool, Filter filter, Filter mipFilter, int colorKey )\r
 221         {\r
 222                 DataStream^ ds;\r
 223                 array<Byte>^ data = Utilities::ReadStream( stream, sizeBytes, &ds );\r
 224                 \r
 225                 if( data == nullptr )\r
 226                 {\r
 227                         CubeTexture^ texture = FromMemory_Internal( device, ds->PositionPointer, sizeBytes, size, numLevels,\r
 228                                 usage, format, pool, filter, mipFilter, colorKey, NULL, NULL );\r
 229 \r
 230                         ds->Seek( sizeBytes, SeekOrigin::Current );\r
 231                         return texture;\r
 232                 }\r
 233 \r
 234                 return CubeTexture::FromMemory( device, data, size, numLevels, usage, format, pool, filter, mipFilter, colorKey );\r
 235         }\r
 236 \r
 237         CubeTexture^ CubeTexture::FromStream( SlimDX::Direct3D9::Device^ device, Stream^ stream, int size, int numLevels,\r
 238                 Usage usage, Format format, Pool pool, Filter filter, Filter mipFilter, int colorKey )\r
 239         {\r
 240                 return CubeTexture::FromStream( device, stream, 0, size, numLevels, usage, format, pool, filter, mipFilter, colorKey );\r
 241         }\r
 242 \r
 243         CubeTexture^ CubeTexture::FromStream( SlimDX::Direct3D9::Device^ device, Stream^ stream, Usage usage, Pool pool )\r
 244         {\r
 245                 return CubeTexture::FromStream( device, stream, D3DX::Default, D3DX::Default,\r
 246                         usage, Format::Unknown, pool, Filter::Default, Filter::Default, 0 );\r
 247         }\r
 248 \r
 249         CubeTexture^ CubeTexture::FromStream( SlimDX::Direct3D9::Device^ device, Stream^ stream )\r
 250         {\r
 251                 return CubeTexture::FromStream( device, stream, Usage::None, Pool::Managed );\r
 252         }\r
 253 \r
 254         CubeTexture^ CubeTexture::FromFile( SlimDX::Direct3D9::Device^ device, String^ fileName, int size, int numLevels,\r
 255                 Usage usage, Format format, Pool pool, Filter filter, Filter mipFilter, int colorKey,\r
 256                 [Out] ImageInformation% imageInformation, [Out] array<PaletteEntry>^% palette )\r
 257         {\r
 258                 IDirect3DCubeTexture9* texture = NULL;\r
 259                 pin_ptr<const wchar_t> pinnedName = PtrToStringChars( fileName );\r
 260                 imageInformation = ImageInformation();\r
 261                 pin_ptr<ImageInformation> pinnedImageInfo = &imageInformation;\r
 262                 palette = gcnew array<PaletteEntry>( 256 );\r
 263                 pin_ptr<PaletteEntry> pinnedPalette = &palette[0];\r
 264 \r
 265                 HRESULT hr = D3DXCreateCubeTextureFromFileEx( device->InternalPointer, pinnedName, size, \r
 266                         numLevels, static_cast<DWORD>( usage ), static_cast<D3DFORMAT>( format ), static_cast<D3DPOOL>( pool ), static_cast<DWORD>( filter ), static_cast<DWORD>( mipFilter ), \r
 267                         colorKey, reinterpret_cast<D3DXIMAGE_INFO*>( pinnedImageInfo ), reinterpret_cast<PALETTEENTRY*>( pinnedPalette ), &texture );\r
 268                 \r
 269                 if( RECORD_D3D9(hr).IsFailure )\r
 270                 {\r
 271                         palette = nullptr;\r
 272                         return nullptr;\r
 273                 }\r
 274 \r
 275                 CubeTexture^ result = gcnew CubeTexture( texture, nullptr );;\r
 276                 if( pool == Pool::Default )\r
 277                         result->IsDefaultPool = true;\r
 278                 return result;\r
 279         }\r
 280 \r
 281         CubeTexture^ CubeTexture::FromFile( SlimDX::Direct3D9::Device^ device, String^ fileName, int size, int numLevels,\r
 282                 Usage usage, Format format, Pool pool, Filter filter, Filter mipFilter, int colorKey,\r
 283                 [Out] ImageInformation% imageInformation )\r
 284         {\r
 285                 IDirect3DCubeTexture9* texture = NULL;\r
 286                 pin_ptr<const wchar_t> pinnedName = PtrToStringChars( fileName );\r
 287                 pin_ptr<ImageInformation> pinnedImageInfo = &imageInformation;\r
 288 \r
 289                 HRESULT hr = D3DXCreateCubeTextureFromFileEx( device->InternalPointer, pinnedName, size, \r
 290                         numLevels, static_cast<DWORD>( usage ), static_cast<D3DFORMAT>( format ), static_cast<D3DPOOL>( pool ), static_cast<DWORD>( filter ), static_cast<DWORD>( mipFilter ), \r
 291                         colorKey, reinterpret_cast<D3DXIMAGE_INFO*>( pinnedImageInfo ), NULL, &texture );\r
 292                 \r
 293                 if( RECORD_D3D9(hr).IsFailure )\r
 294                         return nullptr;\r
 295 \r
 296                 CubeTexture^ result = gcnew CubeTexture( texture, nullptr );;\r
 297                 if( pool == Pool::Default )\r
 298                         result->IsDefaultPool = true;\r
 299                 return result;\r
 300         }\r
 301 \r
 302         CubeTexture^ CubeTexture::FromFile( SlimDX::Direct3D9::Device^ device, String^ fileName, int size, int numLevels,\r
 303                 Usage usage, Format format, Pool pool, Filter filter, Filter mipFilter, int colorKey )\r
 304         {\r
 305                 IDirect3DCubeTexture9* texture = NULL;\r
 306                 pin_ptr<const wchar_t> pinnedName = PtrToStringChars( fileName );\r
 307 \r
 308                 HRESULT hr = D3DXCreateCubeTextureFromFileEx( device->InternalPointer, pinnedName, size, \r
 309                         numLevels, static_cast<DWORD>( usage ), static_cast<D3DFORMAT>( format ), static_cast<D3DPOOL>( pool ), static_cast<DWORD>( filter ), static_cast<DWORD>( mipFilter ), \r
 310                         colorKey, NULL, NULL, &texture );\r
 311                 \r
 312                 if( RECORD_D3D9(hr).IsFailure )\r
 313                         return nullptr;\r
 314 \r
 315                 CubeTexture^ result = gcnew CubeTexture( texture, nullptr );;\r
 316                 if( pool == Pool::Default )\r
 317                         result->IsDefaultPool = true;\r
 318                 return result;\r
 319         }\r
 320 \r
 321         CubeTexture^ CubeTexture::FromFile( SlimDX::Direct3D9::Device^ device, String^ fileName, Usage usage, Pool pool )\r
 322         {\r
 323                 return CubeTexture::FromFile( device, fileName, D3DX::Default, D3DX::Default,\r
 324                         usage, Format::Unknown, pool, Filter::Default, Filter::Default, 0 );\r
 325         }\r
 326 \r
 327         CubeTexture^ CubeTexture::FromFile( SlimDX::Direct3D9::Device^ device, String^ fileName )\r
 328         {\r
 329                 return CubeTexture::FromFile( device, fileName, Usage::None, Pool::Managed );\r
 330         }\r
 331 \r
 332         DataRectangle^ CubeTexture::LockRectangle( CubeMapFace face, int level, System::Drawing::Rectangle rect, LockFlags flags )\r
 333         {\r
 334                 D3DLOCKED_RECT lockedRect;\r
 335                 RECT nativeRect = { rect.Left, rect.Top, rect.Right, rect.Bottom };\r
 336                 HRESULT hr = InternalPointer->LockRect( static_cast<D3DCUBEMAP_FACES>( face ), level, &lockedRect, &nativeRect, static_cast<DWORD>( flags ) );\r
 337                 \r
 338                 if( RECORD_D3D9(hr).IsFailure )\r
 339                         return nullptr;\r
 340                 \r
 341                 int lockedSize = lockedRect.Pitch * GetLevelDescription( level ).Height;\r
 342                 \r
 343                 bool readOnly = (flags & LockFlags::ReadOnly) == LockFlags::ReadOnly;\r
 344                 DataRectangle^ outRect = gcnew DataRectangle( lockedRect.Pitch, gcnew DataStream( lockedRect.pBits, lockedSize, true, !readOnly, false ) );\r
 345                 return outRect;\r
 346         }\r
 347 \r
 348         DataRectangle^ CubeTexture::LockRectangle( CubeMapFace face, int level, LockFlags flags )\r
 349         {\r
 350                 D3DLOCKED_RECT lockedRect;\r
 351                 HRESULT hr = InternalPointer->LockRect( static_cast<D3DCUBEMAP_FACES>( face ), level, &lockedRect, NULL, static_cast<DWORD>( flags ) );\r
 352                 \r
 353                 if( RECORD_D3D9(hr).IsFailure )\r
 354                         return nullptr;\r
 355                 \r
 356                 int lockedSize = lockedRect.Pitch * GetLevelDescription( level ).Height;\r
 357 \r
 358                 bool readOnly = (flags & LockFlags::ReadOnly) == LockFlags::ReadOnly;\r
 359                 DataRectangle^ outRect = gcnew DataRectangle( lockedRect.Pitch, gcnew DataStream( lockedRect.pBits, lockedSize, true, !readOnly, false ) );\r
 360                 return outRect;\r
 361         }\r
 362 \r
 363         Result CubeTexture::UnlockRectangle( CubeMapFace face, int level )\r
 364         {\r
 365                 HRESULT hr = InternalPointer->UnlockRect( static_cast<D3DCUBEMAP_FACES>( face ), level );\r
 366                 return RECORD_D3D9( hr );\r
 367         }\r
 368 \r
 369         Result CubeTexture::AddDirtyRectangle( CubeMapFace face )\r
 370         {\r
 371                 HRESULT hr = InternalPointer->AddDirtyRect( static_cast<D3DCUBEMAP_FACES>( face ), NULL );\r
 372                 return RECORD_D3D9( hr );\r
 373         }\r
 374 \r
 375         Result CubeTexture::AddDirtyRectangle( CubeMapFace face, System::Drawing::Rectangle rect )\r
 376         {\r
 377                 RECT nativeRect = { rect.Left, rect.Top, rect.Right, rect.Bottom };\r
 378                 HRESULT hr = InternalPointer->AddDirtyRect( static_cast<D3DCUBEMAP_FACES>( face ), &nativeRect );\r
 379                 return RECORD_D3D9( hr );\r
 380         }\r
 381 \r
 382         SurfaceDescription CubeTexture::GetLevelDescription( int level )\r
 383         {\r
 384                 SurfaceDescription description;\r
 385                 HRESULT hr = InternalPointer->GetLevelDesc( level, reinterpret_cast<D3DSURFACE_DESC*>( &description ) );\r
 386                 RECORD_D3D9( hr );\r
 387                 return description;\r
 388         }\r
 389 \r
 390         Surface^ CubeTexture::GetCubeMapSurface( CubeMapFace face, int level )\r
 391         {\r
 392                 IDirect3DSurface9* surface;\r
 393                 HRESULT hr = InternalPointer->GetCubeMapSurface( static_cast<D3DCUBEMAP_FACES>( face ), level, &surface );\r
 394                 \r
 395                 if( RECORD_D3D9(hr).IsFailure )\r
 396                         return nullptr;\r
 397                 return Surface::FromPointer( surface );\r
 398         }\r
 399 \r
 400         Result CubeTexture::Fill(Fill3DCallback^ callback)\r
 401         {\r
 402                 HRESULT hr;             // Error code.\r
 403 \r
 404                 // Call the function.\r
 405                 hr = D3DXFillCubeTexture(InternalPointer, NativeD3DXFill3D, Marshal::GetFunctionPointerForDelegate(callback).ToPointer());\r
 406 \r
 407                 return RECORD_D3D9(hr);\r
 408         }\r
 409 \r
 410         Result CubeTexture::Fill( TextureShader^ shader )\r
 411         {\r
 412                 HRESULT hr = D3DXFillCubeTextureTX( InternalPointer, shader->InternalPointer );\r
 413                 return RECORD_D3D9( hr );\r
 414         }\r
 415 }\r
 416 }