110401(DTXMania089)/SlimDXc_Jun2010(VC++2008)/source/direct3d9/Device.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 <windows.h>\r
  24 #include <d3d9.h>\r
  25 #include <d3dx9.h>\r
  26 \r
  27 #include "../stack_array.h"\r
  28 #include "../DataStream.h"\r
  29 #include "../ComObject.h"\r
  30 #include "../Utilities.h"\r
  31 \r
  32 #include "Direct3D9Exception.h"\r
  33 \r
  34 #include "Device.h"\r
  35 #include "Direct3D.h"\r
  36 #include "PresentParameters.h"\r
  37 #include "VertexBuffer.h"\r
  38 #include "IndexBuffer.h"\r
  39 #include "Texture.h"\r
  40 #include "PixelShader9.h"\r
  41 #include "VertexShader9.h"\r
  42 #include "Query.h"\r
  43 #include "SwapChain.h"\r
  44 #include "StateBlock.h"\r
  45 #include "D3DX.h"\r
  46 \r
  47 using namespace System;\r
  48 using namespace System::Collections::Generic;\r
  49 using namespace System::Drawing;\r
  50 using namespace System::Runtime::InteropServices;\r
  51 using namespace System::Windows::Forms;\r
  52 \r
  53 namespace SlimDX\r
  54 {\r
  55 namespace Direct3D9\r
  56 {\r
  57         Device::Device()\r
  58         {\r
  59                 // this is called by DeviceEx\r
  60         }\r
  61 \r
  62         Device::Device( SlimDX::Direct3D9::Direct3D^ direct3D, int adapter, DeviceType deviceType, IntPtr controlHandle, CreateFlags createFlags, ... array<PresentParameters^>^ presentParameters )\r
  63         {\r
  64                 IDirect3DDevice9* device;\r
  65                 stack_array<D3DPRESENT_PARAMETERS> d3dpp = stackalloc( D3DPRESENT_PARAMETERS, presentParameters->Length );\r
  66 \r
  67                 for( int p = 0; p < presentParameters->Length; ++p )\r
  68                         d3dpp[p] = presentParameters[p]->ToUnmanaged();\r
  69 \r
  70                 HRESULT hr = direct3D->InternalPointer->CreateDevice( adapter,\r
  71                         static_cast<D3DDEVTYPE>( deviceType ),\r
  72                         static_cast<HWND>( controlHandle.ToPointer() ), \r
  73                         static_cast<DWORD>( createFlags ),\r
  74                         reinterpret_cast<D3DPRESENT_PARAMETERS*>( &d3dpp[0] ),\r
  75                         &device );\r
  76                 \r
  77                 if( RECORD_D3D9( hr ).IsFailure )\r
  78                         throw gcnew Direct3D9Exception( Result::Last );\r
  79 \r
  80                 for( int p = 0; p < presentParameters->Length; ++p )\r
  81                 {\r
  82                         presentParameters[p]->BackBufferCount = d3dpp[p].BackBufferCount;\r
  83                         presentParameters[p]->BackBufferFormat = static_cast<Format>( d3dpp[p].BackBufferFormat );\r
  84                         presentParameters[p]->BackBufferWidth = d3dpp[p].BackBufferWidth;\r
  85                         presentParameters[p]->BackBufferHeight = d3dpp[p].BackBufferHeight;\r
  86                 }\r
  87 \r
  88                 Construct(device);\r
  89         }\r
  90 \r
  91         void Device::VertexFormat::set( SlimDX::Direct3D9::VertexFormat value )\r
  92         {\r
  93                 HRESULT hr = InternalPointer->SetFVF( static_cast<DWORD>( value ) );\r
  94                 RECORD_D3D9( hr );\r
  95         }\r
  96 \r
  97         SlimDX::Direct3D9::VertexFormat Device::VertexFormat::get()\r
  98         {\r
  99                 DWORD fvf = 0;\r
 100                 HRESULT hr = InternalPointer->GetFVF( &fvf );\r
 101                 RECORD_D3D9( hr );\r
 102 \r
 103                 return static_cast<SlimDX::Direct3D9::VertexFormat>( fvf );\r
 104         }\r
 105         \r
 106         void Device::VertexDeclaration::set( SlimDX::Direct3D9::VertexDeclaration^ value )\r
 107         {\r
 108                 HRESULT hr;\r
 109                 if( value != nullptr )\r
 110                         hr = InternalPointer->SetVertexDeclaration( value->InternalPointer );\r
 111                 else\r
 112                         hr = InternalPointer->SetVertexDeclaration( NULL );\r
 113 \r
 114                 RECORD_D3D9( hr );\r
 115         }\r
 116 \r
 117         SlimDX::Direct3D9::VertexDeclaration^ Device::VertexDeclaration::get()\r
 118         {\r
 119                 IDirect3DVertexDeclaration9* decl;\r
 120                 HRESULT hr = InternalPointer->GetVertexDeclaration( &decl );\r
 121                 \r
 122                 if( RECORD_D3D9( hr ).IsFailure )\r
 123                         return nullptr;\r
 124 \r
 125                 return SlimDX::Direct3D9::VertexDeclaration::FromPointer( decl );\r
 126         }\r
 127 \r
 128         Result Device::DrawPrimitives( PrimitiveType primitiveType, int startIndex, int primitiveCount )\r
 129         {\r
 130                 HRESULT hr = InternalPointer->DrawPrimitive( static_cast<D3DPRIMITIVETYPE>( primitiveType ), startIndex, primitiveCount );\r
 131                 return RECORD_D3D9( hr );\r
 132         }\r
 133         \r
 134         generic<typename T>\r
 135         Result Device::DrawUserPrimitives( PrimitiveType primitiveType, int primitiveCount, array<T>^ data )\r
 136         {\r
 137                 return DrawUserPrimitives<T>( primitiveType, 0, primitiveCount, data );\r
 138         }\r
 139         \r
 140 // disables bogus warning: \r
 141 //SlimDX::Direct3D9::Device::DrawIndexedUserPrimitives<T>' : recursive on\r
 142 // all control paths, function will cause runtime stack overflow\r
 143 #pragma warning(disable:4717)\r
 144         generic<typename T>\r
 145         Result Device::DrawUserPrimitives( PrimitiveType primitiveType, int startIndex, int primitiveCount, array<T>^ data )\r
 146         {\r
 147                 pin_ptr<T> pinned_data = &data[startIndex];\r
 148 \r
 149                 HRESULT hr = InternalPointer->DrawPrimitiveUP( static_cast<D3DPRIMITIVETYPE>( primitiveType ), primitiveCount,\r
 150                         pinned_data, static_cast<DWORD>( sizeof(T) ) );\r
 151                 return RECORD_D3D9( hr );\r
 152         }\r
 153 #pragma warning(default:4717)\r
 154 \r
 155         Result Device::DrawIndexedPrimitives( PrimitiveType primitiveType, int baseVertexIndex, int minVertexIndex, \r
 156                 int numVertices, int startIndex, int primCount )\r
 157         {\r
 158                 HRESULT hr = InternalPointer->DrawIndexedPrimitive( static_cast<D3DPRIMITIVETYPE>( primitiveType ), baseVertexIndex,\r
 159                         minVertexIndex, numVertices, startIndex, primCount );\r
 160                 return RECORD_D3D9( hr );\r
 161         }\r
 162         \r
 163         generic<typename S, typename T>\r
 164         Result Device::DrawIndexedUserPrimitives( PrimitiveType primitiveType, int minVertexIndex, int numVertices, int primitiveCount,\r
 165                 array<S>^ indexData, Format indexDataFormat, array<T>^ vertexData, int vertexStride )\r
 166         {\r
 167                 return DrawIndexedUserPrimitives<S,T>( primitiveType, 0, 0, minVertexIndex, numVertices, primitiveCount, indexData, indexDataFormat, vertexData, vertexStride );\r
 168         }\r
 169 \r
 170         generic<typename S, typename T>\r
 171         Result Device::DrawIndexedUserPrimitives( PrimitiveType primitiveType, int startIndex, int minVertexIndex, int numVertices, int primitiveCount,\r
 172                 array<S>^ indexData, Format indexDataFormat, array<T>^ vertexData, int vertexStride )\r
 173         {\r
 174                 return DrawIndexedUserPrimitives<S,T>( primitiveType, startIndex, 0, minVertexIndex, numVertices, primitiveCount, indexData, indexDataFormat, vertexData, vertexStride );\r
 175         }\r
 176         \r
 177 // disables bogus warning: 'SlimDX::Direct3D9::Device::DrawIndexedUserPrimitives<S,T>' : recursive on all control paths,\r
 178 // function will cause runtime stack overflow\r
 179 #pragma warning(disable:4717)\r
 180         generic<typename S, typename T>\r
 181         Result Device::DrawIndexedUserPrimitives( PrimitiveType primitiveType, int startIndex, int startVertex, int minVertexIndex, int numVertices, int primitiveCount,\r
 182                 array<S>^ indexData, Format indexDataFormat, array<T>^ vertexData, int vertexStride )\r
 183         {\r
 184                 pin_ptr<S> pinnedIndices = &indexData[startIndex];\r
 185                 pin_ptr<T> pinnedVertices = &vertexData[startVertex];\r
 186 \r
 187                 HRESULT hr = InternalPointer->DrawIndexedPrimitiveUP( static_cast<D3DPRIMITIVETYPE>( primitiveType ), minVertexIndex, numVertices,\r
 188                         primitiveCount, pinnedIndices, static_cast<D3DFORMAT>( indexDataFormat ), pinnedVertices, vertexStride );\r
 189                 return RECORD_D3D9( hr );\r
 190         }\r
 191 #pragma warning(default:4717)\r
 192 \r
 193         Result Device::Clear( ClearFlags clearFlags, Color4 color, float zdepth, int stencil, array<System::Drawing::Rectangle>^ rectangles )\r
 194         {\r
 195                 return Clear( clearFlags, color.ToArgb(), zdepth, stencil, rectangles );\r
 196         }\r
 197 \r
 198         Result Device::Clear( ClearFlags clearFlags, int color, float zdepth, int stencil, array<System::Drawing::Rectangle>^ rectangles )\r
 199         {\r
 200                 if( rectangles == nullptr )\r
 201                 {\r
 202                         return Clear( clearFlags, color, zdepth, stencil );\r
 203                 }\r
 204 \r
 205                 stack_array<D3DRECT> rects = stackalloc( D3DRECT, rectangles->Length );\r
 206                 for( int i = 0; i < rectangles->Length; i++ )\r
 207                 {\r
 208                         D3DRECT rect;\r
 209                         rect.x1 = rectangles[i].Left;\r
 210                         rect.y1 = rectangles[i].Top;\r
 211                         rect.x2 = rectangles[i].Right;\r
 212                         rect.y2 = rectangles[i].Bottom;\r
 213 \r
 214                         rects[i] = rect;\r
 215                 }\r
 216 \r
 217                 HRESULT hr = InternalPointer->Clear( rectangles->Length, &rects[0], static_cast<DWORD>( clearFlags ), static_cast<D3DCOLOR>( color ), zdepth, stencil );\r
 218                 return RECORD_D3D9( hr );\r
 219         }\r
 220 \r
 221         Result Device::Clear( ClearFlags clearFlags, Color4 color, float zdepth, int stencil )\r
 222         {\r
 223                 return Clear( clearFlags, color.ToArgb(), zdepth, stencil );\r
 224         }\r
 225 \r
 226         Result Device::Clear( ClearFlags clearFlags, int color, float zdepth, int stencil )\r
 227         {\r
 228                 HRESULT hr = InternalPointer->Clear( 0, 0, static_cast<DWORD>( clearFlags ), static_cast<D3DCOLOR>( color ), zdepth, stencil );\r
 229                 return RECORD_D3D9( hr );\r
 230         }\r
 231 \r
 232         Result Device::BeginScene()\r
 233         {\r
 234                 HRESULT hr = InternalPointer->BeginScene();\r
 235                 return RECORD_D3D9( hr );\r
 236         }\r
 237 \r
 238         Result Device::EndScene()\r
 239         {\r
 240                 HRESULT hr = InternalPointer->EndScene();\r
 241                 return RECORD_D3D9( hr );\r
 242         }\r
 243 \r
 244         Result Device::Present()\r
 245         {\r
 246                 HRESULT hr = InternalPointer->Present( 0, 0, 0, 0 );\r
 247                 return RECORD_D3D9( hr );\r
 248         }\r
 249 \r
 250         Result Device::Present( SlimDX::Direct3D9::Present flags )\r
 251         {\r
 252                 IDirect3DSwapChain9* swapChain;\r
 253 \r
 254                 HRESULT hr = InternalPointer->GetSwapChain( 0, &swapChain );\r
 255                 \r
 256                 if( RECORD_D3D9( hr ).IsFailure )\r
 257                         return Result::Last;\r
 258 \r
 259                 hr = swapChain->Present( 0, 0, 0, 0, static_cast<DWORD>( flags ) );\r
 260                 RECORD_D3D9( hr );\r
 261 \r
 262                 hr = swapChain->Release();\r
 263                 RECORD_D3D9( hr );\r
 264 \r
 265                 return Result::Last;\r
 266         }\r
 267 \r
 268         Result Device::Present( System::Drawing::Rectangle sourceRectangle, System::Drawing::Rectangle destinationRectangle )\r
 269         {\r
 270                 RECT nativeSourceRect = { sourceRectangle.Left, sourceRectangle.Top, sourceRectangle.Right, sourceRectangle.Bottom };\r
 271                 RECT nativeDestRect = { destinationRectangle.Left, destinationRectangle.Top, destinationRectangle.Right, destinationRectangle.Bottom };\r
 272         \r
 273                 RECT *sourcePtr = NULL;\r
 274                 RECT *destPtr = NULL;\r
 275 \r
 276                 if( sourceRectangle != Rectangle::Empty )\r
 277                         sourcePtr = &nativeSourceRect;\r
 278                 if( destinationRectangle != Rectangle::Empty )\r
 279                         destPtr = &nativeDestRect;\r
 280 \r
 281                 HRESULT hr = InternalPointer->Present( sourcePtr, destPtr, NULL, NULL );\r
 282 \r
 283                 return RECORD_D3D9( hr );\r
 284         }\r
 285 \r
 286         Result Device::Present( System::Drawing::Rectangle sourceRectangle, System::Drawing::Rectangle destinationRectangle, System::IntPtr windowOverride )\r
 287         {\r
 288                 RECT nativeSourceRect = { sourceRectangle.Left, sourceRectangle.Top, sourceRectangle.Right, sourceRectangle.Bottom };\r
 289                 RECT nativeDestRect = { destinationRectangle.Left, destinationRectangle.Top, destinationRectangle.Right, destinationRectangle.Bottom };\r
 290         \r
 291                 RECT *sourcePtr = NULL;\r
 292                 RECT *destPtr = NULL;\r
 293 \r
 294                 if( sourceRectangle != Rectangle::Empty )\r
 295                         sourcePtr = &nativeSourceRect;\r
 296                 if( destinationRectangle != Rectangle::Empty )\r
 297                         destPtr = &nativeDestRect;\r
 298 \r
 299                 HRESULT hr = InternalPointer->Present( sourcePtr, destPtr, static_cast<HWND>( windowOverride.ToPointer() ), NULL );\r
 300 \r
 301                 return RECORD_D3D9( hr );\r
 302         }\r
 303 \r
 304         Result Device::Present( System::Drawing::Rectangle sourceRectangle, System::Drawing::Rectangle destinationRectangle, System::IntPtr windowOverride, System::Drawing::Region^ region )\r
 305         {\r
 306                 RECT nativeSourceRect = { sourceRectangle.Left, sourceRectangle.Top, sourceRectangle.Right, sourceRectangle.Bottom };\r
 307                 RECT nativeDestRect = { destinationRectangle.Left, destinationRectangle.Top, destinationRectangle.Right, destinationRectangle.Bottom };\r
 308 \r
 309                 RGNDATA nativeRegion;\r
 310                 Graphics^ graphics = Graphics::FromHwnd( windowOverride );\r
 311                 int count = GetRegionData( static_cast<HRGN>( region->GetHrgn(graphics).ToPointer() ), 0, NULL );\r
 312                 GetRegionData( static_cast<HRGN>( region->GetHrgn(graphics).ToPointer() ), count, &nativeRegion );\r
 313                 delete graphics;\r
 314 \r
 315                 RECT *sourcePtr = NULL;\r
 316                 RECT *destPtr = NULL;\r
 317 \r
 318                 if( sourceRectangle != Rectangle::Empty )\r
 319                         sourcePtr = &nativeSourceRect;\r
 320                 if( destinationRectangle != Rectangle::Empty )\r
 321                         destPtr = &nativeDestRect;\r
 322         \r
 323                 HRESULT hr = InternalPointer->Present( sourcePtr, destPtr, static_cast<HWND>( windowOverride.ToPointer() ), &nativeRegion );\r
 324 \r
 325                 return RECORD_D3D9( hr );\r
 326         }\r
 327 \r
 328         RasterStatus Device::GetRasterStatus( int swapChain )\r
 329         {\r
 330                 D3DRASTER_STATUS status;\r
 331                 HRESULT hr = InternalPointer->GetRasterStatus( swapChain, &status );\r
 332                 \r
 333                 if( RECORD_D3D9( hr ).IsFailure )\r
 334                         return SlimDX::Direct3D9::RasterStatus();\r
 335 \r
 336                 SlimDX::Direct3D9::RasterStatus result;\r
 337                 result.InVBlank = status.InVBlank > 0;\r
 338                 result.Scanline = status.ScanLine;\r
 339                 return result;\r
 340         }\r
 341 \r
 342         Result Device::SetRenderState( RenderState state, int value )\r
 343         {\r
 344                 HRESULT hr = InternalPointer->SetRenderState( static_cast<D3DRENDERSTATETYPE>( state ), value );\r
 345                 return RECORD_D3D9( hr );\r
 346         }\r
 347 \r
 348         Result Device::SetRenderState( RenderState state, bool value )\r
 349         {\r
 350                 BOOL boolValue = value ? TRUE : FALSE;\r
 351                 HRESULT hr = InternalPointer->SetRenderState( static_cast<D3DRENDERSTATETYPE>( state ), boolValue );\r
 352                 return RECORD_D3D9( hr );\r
 353         }\r
 354 \r
 355         Result Device::SetRenderState( RenderState state, float value )\r
 356         {\r
 357                 DWORD* dwValue = reinterpret_cast<DWORD*>( &value );\r
 358                 HRESULT hr = InternalPointer->SetRenderState( static_cast<D3DRENDERSTATETYPE>( state ), *dwValue );\r
 359                 return RECORD_D3D9( hr );\r
 360         }\r
 361 \r
 362         generic<typename T>\r
 363         Result Device::SetRenderState( RenderState state, T value )\r
 364         {\r
 365                 return SetRenderState( state, static_cast<int>( value ) );\r
 366         }\r
 367 \r
 368         Result Device::SetTextureStageState( int stage, TextureStage type, int value )\r
 369         {\r
 370                 HRESULT hr = InternalPointer->SetTextureStageState( stage, static_cast<D3DTEXTURESTAGESTATETYPE>( type ), value );\r
 371                 return RECORD_D3D9( hr );\r
 372         }\r
 373 \r
 374         Result Device::SetTextureStageState( int stage, TextureStage type, TextureOperation texOp )\r
 375         {\r
 376                 return SetTextureStageState( stage, type, static_cast<int>( texOp ) );\r
 377         }\r
 378 \r
 379         Result Device::SetTextureStageState( int stage, TextureStage type, TextureArgument texArg )\r
 380         {\r
 381                 return SetTextureStageState( stage, type, static_cast<int>( texArg ) );\r
 382         }\r
 383 \r
 384         Result Device::SetTextureStageState( int stage, TextureStage type, TextureTransform texTransform )\r
 385         {\r
 386                 return SetTextureStageState( stage, type, static_cast<int>( texTransform ) );\r
 387         }\r
 388 \r
 389         Result Device::SetTextureStageState( int stage, TextureStage type, float value )\r
 390         {\r
 391                 int* dwValue = reinterpret_cast<int*>( &value );\r
 392                 return SetTextureStageState( stage, type, *dwValue );\r
 393         }\r
 394 \r
 395         Result Device::SetSamplerState( int sampler, SamplerState type, int value )\r
 396         {\r
 397                 HRESULT hr = InternalPointer->SetSamplerState( sampler, static_cast<D3DSAMPLERSTATETYPE>( type ), value );\r
 398                 return RECORD_D3D9( hr );\r
 399         }\r
 400 \r
 401         Result Device::SetSamplerState( int sampler, SamplerState type, float value )\r
 402         {\r
 403                 DWORD* dwValue = reinterpret_cast<DWORD*>( &value );\r
 404                 HRESULT hr = InternalPointer->SetSamplerState( sampler, static_cast<D3DSAMPLERSTATETYPE>( type ), *dwValue );\r
 405                 return RECORD_D3D9( hr );\r
 406         }\r
 407 \r
 408         Result Device::SetSamplerState( int sampler, SamplerState type, TextureAddress textureAddress )\r
 409         {\r
 410                 return SetSamplerState( sampler, type, static_cast<int>( textureAddress ) );\r
 411         }\r
 412 \r
 413         Result Device::SetSamplerState( int sampler, SamplerState type, TextureFilter texFilter )\r
 414         {\r
 415                 return SetSamplerState( sampler, type, static_cast<int>( texFilter ) );\r
 416         }\r
 417 \r
 418         Result Device::SetTransform( TransformState state, Matrix* value )\r
 419         {\r
 420                 HRESULT hr = InternalPointer->SetTransform( static_cast<D3DTRANSFORMSTATETYPE>( state ), reinterpret_cast<const D3DMATRIX*>( value ) );\r
 421                 return RECORD_D3D9( hr );\r
 422         }\r
 423 \r
 424         Result Device::SetTransform( TransformState state, Matrix value )\r
 425         {\r
 426                 HRESULT hr = InternalPointer->SetTransform( static_cast<D3DTRANSFORMSTATETYPE>( state ), reinterpret_cast<const D3DMATRIX*>( &value ) );\r
 427                 return RECORD_D3D9( hr );\r
 428         }\r
 429         \r
 430         Matrix Device::GetTransform( TransformState state )\r
 431         {\r
 432                 Matrix result;\r
 433                 HRESULT hr = InternalPointer->GetTransform( static_cast<D3DTRANSFORMSTATETYPE>( state ), reinterpret_cast<D3DMATRIX*>( &result ) );\r
 434                 RECORD_D3D9( hr );\r
 435                 return result;\r
 436         }\r
 437 \r
 438         Result Device::SetTransform( int index, Matrix* value )\r
 439         {\r
 440                 return SetTransform( static_cast<TransformState>( index + 256 ), value );\r
 441         }\r
 442 \r
 443         Result Device::SetTransform( int index, Matrix value )\r
 444         {\r
 445                 return SetTransform( static_cast<TransformState>( index + 256 ), value );\r
 446         }\r
 447 \r
 448         Matrix Device::GetTransform( int index )\r
 449         {\r
 450                 return GetTransform( static_cast<TransformState>( index + 256 ) );\r
 451         }\r
 452 \r
 453         Result Device::MultiplyTransform( TransformState state, Matrix value )\r
 454         {\r
 455                 HRESULT hr = InternalPointer->MultiplyTransform( static_cast<D3DTRANSFORMSTATETYPE>( state ), reinterpret_cast<const D3DMATRIX*>( &value ) );\r
 456                 return RECORD_D3D9( hr );\r
 457         }\r
 458 \r
 459         Result Device::SetStreamSource( int stream, VertexBuffer^ streamData, int offsetInBytes, int stride )\r
 460         {\r
 461                 IDirect3DVertexBuffer9* vbPointer = streamData != nullptr ? streamData->InternalPointer : NULL;\r
 462                 HRESULT hr = InternalPointer->SetStreamSource( stream, vbPointer, offsetInBytes, stride );\r
 463                 return RECORD_D3D9( hr );\r
 464         }\r
 465 \r
 466         Result Device::SetStreamSourceFrequency( int stream, int frequency, StreamSource source )\r
 467         {\r
 468                 int value;\r
 469                 if( source == StreamSource::IndexedData )\r
 470                         value = D3DSTREAMSOURCE_INDEXEDDATA;\r
 471                 else\r
 472                         value = D3DSTREAMSOURCE_INSTANCEDATA;\r
 473 \r
 474                 HRESULT hr = InternalPointer->SetStreamSourceFreq( stream, value | frequency );\r
 475                 return RECORD_D3D9( hr );\r
 476         }\r
 477 \r
 478         Result Device::ResetStreamSourceFrequency( int stream )\r
 479         {\r
 480                 HRESULT hr = InternalPointer->SetStreamSourceFreq( stream, 1 );\r
 481                 return RECORD_D3D9( hr );\r
 482         }\r
 483 \r
 484         SlimDX::Direct3D9::Material Device::Material::get()\r
 485         {\r
 486                 SlimDX::Direct3D9::Material material;\r
 487 \r
 488                 HRESULT hr = InternalPointer->GetMaterial( reinterpret_cast<D3DMATERIAL9*>( &material ) );\r
 489                 RECORD_D3D9( hr );\r
 490 \r
 491                 return material;\r
 492         }\r
 493 \r
 494         void Device::Material::set( SlimDX::Direct3D9::Material material )\r
 495         {\r
 496                 HRESULT hr = InternalPointer->SetMaterial( reinterpret_cast<const D3DMATERIAL9*>( &material ) );\r
 497                 RECORD_D3D9( hr );\r
 498         }\r
 499 \r
 500         Result Device::TestCooperativeLevel()\r
 501         {\r
 502                 HRESULT hr = InternalPointer->TestCooperativeLevel();\r
 503                 return Result( hr );\r
 504         }\r
 505 \r
 506         Result Device::Reset( PresentParameters^ presentParameters )\r
 507         {\r
 508                 D3DPRESENT_PARAMETERS d3dpp;\r
 509 \r
 510                 d3dpp = presentParameters->ToUnmanaged();\r
 511                 HRESULT hr = InternalPointer->Reset( &d3dpp );\r
 512                 RECORD_D3D9( hr );\r
 513 \r
 514                 presentParameters->BackBufferCount = d3dpp.BackBufferCount;\r
 515                 presentParameters->BackBufferFormat = static_cast<Format>( d3dpp.BackBufferFormat );\r
 516                 presentParameters->BackBufferWidth = d3dpp.BackBufferWidth;\r
 517                 presentParameters->BackBufferHeight = d3dpp.BackBufferHeight;\r
 518 \r
 519                 return Result::Last;\r
 520         }\r
 521 \r
 522         Result Device::SetTexture( int sampler, BaseTexture^ texture )\r
 523         {\r
 524                 IDirect3DBaseTexture9* texturePointer = texture != nullptr ? texture->InternalPointer : NULL;\r
 525                 HRESULT hr = InternalPointer->SetTexture( sampler, texturePointer );\r
 526                 return RECORD_D3D9( hr );\r
 527         }\r
 528 \r
 529         BaseTexture^ Device::GetTexture( int stage )\r
 530         {\r
 531                 IDirect3DBaseTexture9 *texture;\r
 532                 HRESULT hr = InternalPointer->GetTexture( stage, &texture );\r
 533                 if( RECORD_D3D9( hr ).IsFailure )\r
 534                         return nullptr;\r
 535 \r
 536                 return BaseTexture::FromUnmanaged( texture );\r
 537         }\r
 538 \r
 539         Result Device::SetRenderTarget( int rtIndex, Surface^ target )\r
 540         {\r
 541                 IDirect3DSurface9* surfacePointer = target != nullptr ? target->InternalPointer : NULL;\r
 542                 HRESULT hr = InternalPointer->SetRenderTarget( rtIndex, surfacePointer );\r
 543                 return RECORD_D3D9( hr );\r
 544         }\r
 545         \r
 546         void Device::PixelShader::set( SlimDX::Direct3D9::PixelShader^ shader )\r
 547         {\r
 548                 IDirect3DPixelShader9 *ptr = shader != nullptr ? shader->InternalPointer : NULL; \r
 549                 HRESULT hr = InternalPointer->SetPixelShader( ptr );\r
 550                 RECORD_D3D9( hr );\r
 551         }\r
 552         \r
 553         void Device::VertexShader::set( SlimDX::Direct3D9::VertexShader^ shader )\r
 554         {\r
 555                 IDirect3DVertexShader9 *ptr = shader != nullptr ? shader->InternalPointer : NULL; \r
 556                 HRESULT hr = InternalPointer->SetVertexShader( ptr );\r
 557                 RECORD_D3D9( hr );\r
 558         }\r
 559         \r
 560         void Device::DepthStencilSurface::set( Surface^ target )\r
 561         {       \r
 562                 IDirect3DSurface9* surface = target != nullptr ? target->InternalPointer : NULL;\r
 563                 HRESULT hr = InternalPointer->SetDepthStencilSurface( surface );\r
 564                 RECORD_D3D9( hr );\r
 565         }\r
 566 \r
 567         Surface^ Device::GetBackBuffer( int swapChain, int backBuffer )\r
 568         {\r
 569                 IDirect3DSurface9* buffer;\r
 570 \r
 571                 HRESULT hr = InternalPointer->GetBackBuffer( swapChain, backBuffer, D3DBACKBUFFER_TYPE_MONO, &buffer );\r
 572                 \r
 573                 if( RECORD_D3D9( hr ).IsFailure )\r
 574                         return nullptr;\r
 575 \r
 576                 return Surface::FromPointer( buffer );\r
 577         }\r
 578 \r
 579         bool Device::IsQuerySupported( QueryType type )\r
 580         {\r
 581                 HRESULT hr = InternalPointer->CreateQuery( static_cast<D3DQUERYTYPE>( type ), NULL );\r
 582                 if( hr == D3DERR_NOTAVAILABLE )\r
 583                         return false;\r
 584                 \r
 585                 if( RECORD_D3D9( hr ).IsFailure )\r
 586                         return false;\r
 587 \r
 588                 return true;\r
 589         }\r
 590 \r
 591         Capabilities^ Device::Capabilities::get()\r
 592         {\r
 593                 D3DCAPS9 caps;\r
 594                 HRESULT hr = InternalPointer->GetDeviceCaps( &caps );\r
 595                 RECORD_D3D9( hr );\r
 596 \r
 597                 return gcnew SlimDX::Direct3D9::Capabilities( caps );\r
 598         }\r
 599 \r
 600         System::Int64 Device::AvailableTextureMemory::get()\r
 601         {\r
 602                 return InternalPointer->GetAvailableTextureMem();\r
 603         }\r
 604 \r
 605         int Device::ValidateDevice()\r
 606         {\r
 607                 DWORD passCount = 0;\r
 608 \r
 609                 HRESULT hr = InternalPointer->ValidateDevice( &passCount );\r
 610                 RECORD_D3D9( hr );\r
 611 \r
 612                 return passCount;\r
 613         }\r
 614 \r
 615         bool Device::ShowCursor::get()\r
 616         {\r
 617                 BOOL prev = InternalPointer->ShowCursor( true );\r
 618                 RECORD_D3D9( InternalPointer->ShowCursor( prev ) );\r
 619 \r
 620                 return prev > 0;\r
 621         }\r
 622 \r
 623         void Device::ShowCursor::set( bool value )\r
 624         {\r
 625                 RECORD_D3D9( InternalPointer->ShowCursor( value ) );\r
 626         }\r
 627 \r
 628         bool Device::SoftwareVertexProcessing::get()\r
 629         {\r
 630                 return InternalPointer->GetSoftwareVertexProcessing() > 0;\r
 631         }\r
 632 \r
 633         void Device::SoftwareVertexProcessing::set( bool value )\r
 634         {\r
 635                 HRESULT hr = InternalPointer->SetSoftwareVertexProcessing( value );\r
 636                 RECORD_D3D9( hr );\r
 637         }\r
 638 \r
 639         Surface^ Device::DepthStencilSurface::get()\r
 640         {\r
 641                 IDirect3DSurface9* surface;\r
 642 \r
 643                 HRESULT hr = InternalPointer->GetDepthStencilSurface( &surface );\r
 644                 \r
 645                 if( RECORD_D3D9( hr ).IsFailure )\r
 646                         return nullptr;\r
 647 \r
 648                 return Surface::FromPointer( surface );\r
 649         }\r
 650 \r
 651         SlimDX::Direct3D9::Viewport Device::Viewport::get()\r
 652         {\r
 653                 SlimDX::Direct3D9::Viewport viewport;\r
 654                 HRESULT hr = InternalPointer->GetViewport( reinterpret_cast<D3DVIEWPORT9*>( &viewport ) );\r
 655                 RECORD_D3D9( hr );\r
 656 \r
 657                 return viewport;\r
 658         }\r
 659 \r
 660         void Device::Viewport::set( SlimDX::Direct3D9::Viewport value )\r
 661         {\r
 662                 HRESULT hr = InternalPointer->SetViewport( reinterpret_cast<const D3DVIEWPORT9*>( &value ) );\r
 663                 RECORD_D3D9( hr );\r
 664         }\r
 665 \r
 666         void Device::ScissorRect::set(Drawing::Rectangle rect)\r
 667         {\r
 668                 RECT scissorRect = { rect.Left, rect.Top, rect.Right, rect.Bottom };\r
 669                 HRESULT hr = InternalPointer->SetScissorRect(&scissorRect);\r
 670                 RECORD_D3D9(hr);\r
 671         }\r
 672 \r
 673         Drawing::Rectangle Device::ScissorRect::get()\r
 674         {\r
 675                 RECT scissorRect;               // Scissor rectangle.\r
 676 \r
 677                 HRESULT hr = InternalPointer->GetScissorRect(&scissorRect);\r
 678                 RECORD_D3D9(hr);\r
 679 \r
 680                 return Utilities::ConvertRect(scissorRect);\r
 681         }\r
 682 \r
 683         Surface^ Device::GetRenderTarget( int index )\r
 684         {\r
 685                 IDirect3DSurface9* surface;\r
 686 \r
 687                 HRESULT hr = InternalPointer->GetRenderTarget( index, &surface );\r
 688                 \r
 689                 if( RECORD_D3D9( hr ).IsFailure )\r
 690                         return nullptr;\r
 691 \r
 692                 return Surface::FromPointer( surface );\r
 693         }\r
 694 \r
 695         generic<typename T>\r
 696         T Device::GetRenderState( RenderState state )\r
 697         {\r
 698                 DWORD value = 0;\r
 699                 HRESULT hr = InternalPointer->GetRenderState( static_cast<D3DRENDERSTATETYPE>( state ), &value );\r
 700                 RECORD_D3D9( hr );\r
 701 \r
 702                 return Utilities::FromIntToT<T>( value );\r
 703         }\r
 704         \r
 705         int Device::GetRenderState( RenderState state )\r
 706         {\r
 707                 DWORD value = 0;\r
 708                 HRESULT hr = InternalPointer->GetRenderState( static_cast<D3DRENDERSTATETYPE>( state ), &value );\r
 709                 RECORD_D3D9( hr );\r
 710 \r
 711                 return value;\r
 712         }\r
 713 \r
 714         generic<typename T>\r
 715         T Device::GetSamplerState( int sampler, SamplerState type )\r
 716         {\r
 717                 DWORD value = 0;\r
 718                 HRESULT hr = InternalPointer->GetSamplerState( sampler, static_cast<D3DSAMPLERSTATETYPE>( type ), &value );\r
 719                 RECORD_D3D9( hr );\r
 720 \r
 721                 return Utilities::FromIntToT<T>( value );\r
 722         }\r
 723 \r
 724         int Device::GetSamplerState( int sampler, SamplerState type )\r
 725         {\r
 726                 DWORD value = 0;\r
 727                 HRESULT hr = InternalPointer->GetSamplerState( sampler, static_cast<D3DSAMPLERSTATETYPE>( type ), &value );\r
 728                 RECORD_D3D9( hr );\r
 729 \r
 730                 return value;\r
 731         }\r
 732 \r
 733         generic<typename T>\r
 734         T Device::GetTextureStageState( int stage, TextureStage type )\r
 735         {\r
 736                 DWORD value = 0;\r
 737                 HRESULT hr = InternalPointer->GetTextureStageState( stage, static_cast<D3DTEXTURESTAGESTATETYPE>( type ), &value );\r
 738                 RECORD_D3D9( hr );\r
 739 \r
 740                 return Utilities::FromIntToT<T>( value );\r
 741         }\r
 742 \r
 743         int Device::GetTextureStageState( int stage, TextureStage type )\r
 744         {\r
 745                 DWORD value = 0;\r
 746                 HRESULT hr = InternalPointer->GetTextureStageState( stage, static_cast<D3DTEXTURESTAGESTATETYPE>( type ), &value );\r
 747                 RECORD_D3D9( hr );\r
 748 \r
 749                 return value;\r
 750         }\r
 751 \r
 752         array<PaletteEntry>^ Device::GetPaletteEntries( int paletteNumber )\r
 753         {\r
 754                 array<PaletteEntry>^ result = gcnew array<PaletteEntry>( 256 );\r
 755                 pin_ptr<PaletteEntry> pinnedResult = &result[0];\r
 756 \r
 757                 HRESULT hr = InternalPointer->GetPaletteEntries( paletteNumber, reinterpret_cast<PALETTEENTRY*>( pinnedResult ) );\r
 758                 \r
 759                 if( RECORD_D3D9( hr ).IsFailure )\r
 760                         return nullptr;\r
 761 \r
 762                 return result;\r
 763         }\r
 764 \r
 765         Result Device::SetPaletteEntries( int paletteNumber, array<PaletteEntry>^ entries )\r
 766         {\r
 767                 if( entries != nullptr && entries->Length != 256 )\r
 768                         throw gcnew ArgumentException( "Palettes must have exactly 256 entries.", "entries" );\r
 769 \r
 770                 pin_ptr<PaletteEntry> pinnedEntries = entries == nullptr ? nullptr : &entries[0];\r
 771 \r
 772                 HRESULT hr = InternalPointer->SetPaletteEntries( paletteNumber, reinterpret_cast<PALETTEENTRY*>( pinnedEntries ) );\r
 773                 return RECORD_D3D9( hr );\r
 774         }\r
 775 \r
 776         GammaRamp^ Device::GetGammaRamp( int swapChain )\r
 777         {\r
 778                 D3DGAMMARAMP ramp;\r
 779                 InternalPointer->GetGammaRamp( swapChain, &ramp );\r
 780 \r
 781                 return gcnew GammaRamp( ramp );\r
 782         }\r
 783 \r
 784         void Device::SetGammaRamp( int swapChain, GammaRamp^ ramp, bool calibrate )\r
 785         {\r
 786                 DWORD flags;\r
 787                 if( calibrate )\r
 788                         flags = D3DSGR_CALIBRATE;\r
 789                 else\r
 790                         flags = D3DSGR_NO_CALIBRATION;\r
 791 \r
 792                 D3DGAMMARAMP result = ramp->ToUnmanaged();\r
 793                 InternalPointer->SetGammaRamp( swapChain, flags, &result );\r
 794         }\r
 795 \r
 796         Result Device::GetStreamSource( int stream, [Out] VertexBuffer^% streamData, [Out] int% offsetBytes, [Out] int% stride )\r
 797         {\r
 798                 IDirect3DVertexBuffer9* localVb;\r
 799                 UINT localOffset, localStride;\r
 800 \r
 801                 HRESULT hr = InternalPointer->GetStreamSource( stream, &localVb, &localOffset, &localStride );\r
 802                 \r
 803                 if( RECORD_D3D9( hr ).IsFailure )\r
 804                 {\r
 805                         streamData = nullptr;\r
 806                         offsetBytes = 0;\r
 807                         stride = 0;\r
 808                         return Result::Last;\r
 809                 }\r
 810 \r
 811                 streamData = VertexBuffer::FromPointer( localVb );\r
 812                 offsetBytes = localOffset;\r
 813                 stride = localStride;\r
 814 \r
 815                 return Result::Last;\r
 816         }\r
 817 \r
 818         Result Device::GetStreamSourceFrequency( int stream, [Out] int% frequency, [Out] StreamSource% source )\r
 819         {\r
 820                 UINT localFreq = 0;\r
 821 \r
 822                 //set outputs to known defaults\r
 823                 frequency = 0;\r
 824                 source = StreamSource::IndexedData;\r
 825 \r
 826                 HRESULT hr = InternalPointer->GetStreamSourceFreq( stream, &localFreq );\r
 827                 RECORD_D3D9( hr );\r
 828 \r
 829                 //default setting was indexed data, so just check if it's actually instance data\r
 830                 if( localFreq & D3DSTREAMSOURCE_INSTANCEDATA )\r
 831                 {\r
 832                         source = StreamSource::InstanceData;\r
 833                 }\r
 834 \r
 835                 //mask out the flags that are in the upper bits\r
 836                 UINT mask = ~(D3DSTREAMSOURCE_INSTANCEDATA | D3DSTREAMSOURCE_INDEXEDDATA);\r
 837                 localFreq &= mask;\r
 838                 frequency = localFreq;\r
 839                 \r
 840                 return Result::Last;\r
 841         }\r
 842 \r
 843         SwapChain^ Device::GetSwapChain( int swapChainIndex )\r
 844         {\r
 845                 IDirect3DSwapChain9* swapChain;\r
 846 \r
 847                 HRESULT hr = InternalPointer->GetSwapChain( swapChainIndex, &swapChain );\r
 848                 \r
 849                 if( RECORD_D3D9( hr ).IsFailure )\r
 850                         return nullptr;\r
 851 \r
 852                 return SwapChain::FromPointer( swapChain );\r
 853         }\r
 854 \r
 855         IndexBuffer^ Device::Indices::get()\r
 856         {\r
 857                 IDirect3DIndexBuffer9* indices;\r
 858 \r
 859                 HRESULT hr = InternalPointer->GetIndices( &indices );\r
 860                 \r
 861                 if( RECORD_D3D9( hr ).IsFailure )\r
 862                         return nullptr;\r
 863 \r
 864                 return IndexBuffer::FromPointer( indices );\r
 865         }\r
 866 \r
 867         void Device::Indices::set( IndexBuffer^ indices )\r
 868         {\r
 869                 HRESULT hr;\r
 870                 if( indices != nullptr )\r
 871                         hr = InternalPointer->SetIndices( indices->InternalPointer );\r
 872                 else\r
 873                         hr = InternalPointer->SetIndices( NULL );\r
 874 \r
 875                 RECORD_D3D9( hr );\r
 876         }\r
 877 \r
 878         Result Device::ProcessVertices( int sourceStartIndex, int destinationIndex, int vertexCount, VertexBuffer^ destinationBuffer,\r
 879                 SlimDX::Direct3D9::VertexDeclaration^ vertexDeclaration, LockFlags flags )\r
 880         {\r
 881                 IDirect3DVertexBuffer9* vb = destinationBuffer->InternalPointer;\r
 882                 IDirect3DVertexDeclaration9* decl = vertexDeclaration != nullptr ? vertexDeclaration->InternalPointer : NULL;\r
 883 \r
 884                 HRESULT hr = InternalPointer->ProcessVertices( sourceStartIndex, destinationIndex, vertexCount, vb, decl, static_cast<DWORD>( flags ) );\r
 885                 return RECORD_D3D9( hr );\r
 886         }\r
 887 \r
 888         array<bool>^ Device::GetVertexShaderBooleanConstant( int startRegister, int count )\r
 889         {\r
 890                 stack_array<BOOL> booleans = stackalloc( BOOL, count );\r
 891 \r
 892                 HRESULT hr = InternalPointer->GetVertexShaderConstantB( startRegister, &booleans[0], count );\r
 893                 if( RECORD_D3D9( hr ).IsFailure )\r
 894                         return nullptr;\r
 895 \r
 896                 array<bool>^ results = gcnew array<bool>( count );\r
 897                 for( int i = 0; i < count; i++ )\r
 898                         results[i] = (booleans[i] != 0);\r
 899 \r
 900                 return results;\r
 901         }\r
 902 \r
 903         array<float>^ Device::GetVertexShaderFloatConstant( int startRegister, int count )\r
 904         {\r
 905                 stack_array<FLOAT> floats = stackalloc( FLOAT, count );\r
 906 \r
 907                 HRESULT hr = InternalPointer->GetVertexShaderConstantF( startRegister, &floats[0], count );\r
 908                 if( RECORD_D3D9( hr ).IsFailure )\r
 909                         return nullptr;\r
 910 \r
 911                 array<float>^ results = gcnew array<float>( count );\r
 912                 for( int i = 0; i < count; i++ )\r
 913                         results[i] = floats[i];\r
 914 \r
 915                 return results;\r
 916         }\r
 917 \r
 918         array<int>^ Device::GetVertexShaderIntegerConstant( int startRegister, int count )\r
 919         {\r
 920                 stack_array<INT> integers = stackalloc( INT, count );\r
 921 \r
 922                 HRESULT hr = InternalPointer->GetVertexShaderConstantI( startRegister, &integers[0], count );\r
 923                 if( RECORD_D3D9( hr ).IsFailure )\r
 924                         return nullptr;\r
 925 \r
 926                 array<int>^ results = gcnew array<int>( count );\r
 927                 for( int i = 0; i < count; i++ )\r
 928                         results[i] = integers[i];\r
 929 \r
 930                 return results;\r
 931         }\r
 932 \r
 933         array<bool>^ Device::GetPixelShaderBooleanConstant( int startRegister, int count )\r
 934         {\r
 935                 stack_array<BOOL> booleans = stackalloc( BOOL, count );\r
 936 \r
 937                 HRESULT hr = InternalPointer->GetPixelShaderConstantB( startRegister, &booleans[0], count );\r
 938                 if( RECORD_D3D9( hr ).IsFailure )\r
 939                         return nullptr;\r
 940 \r
 941                 array<bool>^ results = gcnew array<bool>( count );\r
 942                 for( int i = 0; i < count; i++ )\r
 943                         results[i] = (booleans[i] != 0);\r
 944 \r
 945                 return results;\r
 946         }\r
 947 \r
 948         array<float>^ Device::GetPixelShaderFloatConstant( int startRegister, int count )\r
 949         {\r
 950                 stack_array<FLOAT> floats = stackalloc( FLOAT, count );\r
 951 \r
 952                 HRESULT hr = InternalPointer->GetPixelShaderConstantF( startRegister, &floats[0], count );\r
 953                 if( RECORD_D3D9( hr ).IsFailure )\r
 954                         return nullptr;\r
 955 \r
 956                 array<float>^ results = gcnew array<float>( count );\r
 957                 for( int i = 0; i < count; i++ )\r
 958                         results[i] = floats[i];\r
 959 \r
 960                 return results;\r
 961         }\r
 962 \r
 963         array<int>^ Device::GetPixelShaderIntegerConstant( int startRegister, int count )\r
 964         {\r
 965                 stack_array<INT> integers = stackalloc( INT, count );\r
 966 \r
 967                 HRESULT hr = InternalPointer->GetPixelShaderConstantI( startRegister, &integers[0], count );\r
 968                 if( RECORD_D3D9( hr ).IsFailure )\r
 969                         return nullptr;\r
 970 \r
 971                 array<int>^ results = gcnew array<int>( count );\r
 972                 for( int i = 0; i < count; i++ )\r
 973                         results[i] = integers[i];\r
 974 \r
 975                 return results;\r
 976         }\r
 977 \r
 978         Result Device::SetVertexShaderConstant( int startRegister, array<bool>^ data, int offset, int count )\r
 979         {\r
 980                 Utilities::CheckArrayBounds( data, offset, count );\r
 981 \r
 982                 array<BOOL>^ boolData = Array::ConvertAll<bool, int>( data, gcnew Converter<bool, int>( Convert::ToInt32 ) );\r
 983                 pin_ptr<BOOL> pinnedData = &boolData[0];\r
 984 \r
 985                 Utilities::CheckArrayBounds( data, offset, count );\r
 986                 HRESULT hr = InternalPointer->SetVertexShaderConstantB( startRegister, pinnedData + offset, count );\r
 987                 return RECORD_D3D9( hr );\r
 988         }\r
 989 \r
 990         Result Device::SetVertexShaderConstant( int startRegister, array<float>^ data, int offset, int count )\r
 991         {\r
 992                 pin_ptr<float> pinnedData = &data[0];\r
 993 \r
 994                 Utilities::CheckArrayBounds( data, offset, count * 4 );\r
 995                 HRESULT hr = InternalPointer->SetVertexShaderConstantF( startRegister, pinnedData + offset, count );\r
 996                 return RECORD_D3D9( hr );\r
 997         }\r
 998 \r
 999         Result Device::SetVertexShaderConstant( int startRegister, array<Vector4>^ data, int offset, int count )\r
1000         {\r
1001                 pin_ptr<Vector4> pinnedData = &data[0];\r
1002                 float* pinnedDataPointer = reinterpret_cast<float*>( pinnedData + offset );\r
1003 \r
1004                 Utilities::CheckArrayBounds( data, offset, count );\r
1005                 HRESULT hr = InternalPointer->SetVertexShaderConstantF( startRegister, pinnedDataPointer, count );\r
1006                 return RECORD_D3D9( hr );\r
1007         }\r
1008 \r
1009         Result Device::SetVertexShaderConstant( int startRegister, array<int>^ data, int offset, int count )\r
1010         {\r
1011                 pin_ptr<int> pinnedData = &data[0];\r
1012 \r
1013                 Utilities::CheckArrayBounds( data, offset, count * 4 );\r
1014                 HRESULT hr = InternalPointer->SetVertexShaderConstantI( startRegister, pinnedData + offset, count );\r
1015                 return RECORD_D3D9( hr );\r
1016         }\r
1017 \r
1018         Result Device::SetVertexShaderConstant( int startRegister, Matrix data )\r
1019         {\r
1020                 HRESULT hr = InternalPointer->SetVertexShaderConstantF( startRegister, reinterpret_cast<float*>( &data ), 4 );\r
1021                 return RECORD_D3D9( hr );\r
1022         }\r
1023 \r
1024         Result Device::SetVertexShaderConstant( int startRegister, Matrix* data, int count )\r
1025         {\r
1026                 HRESULT hr = InternalPointer->SetVertexShaderConstantF( startRegister, reinterpret_cast<float*>( data ), count * 4 );\r
1027                 return RECORD_D3D9( hr );\r
1028         }\r
1029 \r
1030         Result Device::SetVertexShaderConstant( int startRegister, array<Matrix>^ data, int offset, int count )\r
1031         {\r
1032                 pin_ptr<Matrix> pinnedData = &data[0];\r
1033 \r
1034                 Utilities::CheckBounds( 0, data->Length, offset, count );\r
1035                 HRESULT hr = InternalPointer->SetVertexShaderConstantF( startRegister, reinterpret_cast<float*>( pinnedData + offset ), count * 4 );\r
1036                 return RECORD_D3D9( hr );\r
1037         }\r
1038 \r
1039         Result Device::SetPixelShaderConstant( int startRegister, array<bool>^ data, int offset, int count )\r
1040         {\r
1041                 array<BOOL>^ boolData = Array::ConvertAll<bool, int>( data, gcnew Converter<bool, int>( Convert::ToInt32 ) );\r
1042                 pin_ptr<BOOL> pinnedData = &boolData[0];\r
1043 \r
1044                 Utilities::CheckArrayBounds( data, offset, count );\r
1045                 HRESULT hr = InternalPointer->SetPixelShaderConstantB( startRegister, pinnedData + offset, count );\r
1046                 return RECORD_D3D9( hr );\r
1047         }\r
1048 \r
1049         Result Device::SetPixelShaderConstant( int startRegister, array<float>^ data, int offset, int count )\r
1050         {\r
1051                 pin_ptr<float> pinnedData = &data[0];\r
1052 \r
1053                 Utilities::CheckArrayBounds( data, offset, count * 4 );\r
1054                 HRESULT hr = InternalPointer->SetPixelShaderConstantF( startRegister, pinnedData + offset, count );\r
1055                 return RECORD_D3D9( hr );\r
1056         }\r
1057 \r
1058         Result Device::SetPixelShaderConstant( int startRegister, array<Vector4>^ data, int offset, int count )\r
1059         {\r
1060                 pin_ptr<Vector4> pinnedData = &data[0];\r
1061                 float* pinnedDataPointer = reinterpret_cast<float*>( pinnedData + offset );\r
1062 \r
1063                 Utilities::CheckArrayBounds( data, offset, count );\r
1064                 HRESULT hr = InternalPointer->SetPixelShaderConstantF( startRegister, pinnedDataPointer, count );\r
1065                 return RECORD_D3D9( hr );\r
1066         }\r
1067 \r
1068         Result Device::SetPixelShaderConstant( int startRegister, array<int>^ data, int offset, int count )\r
1069         {\r
1070                 pin_ptr<int> pinnedData = &data[0];\r
1071 \r
1072                 Utilities::CheckArrayBounds( data, offset, count * 4 );\r
1073                 HRESULT hr = InternalPointer->SetPixelShaderConstantI( startRegister, pinnedData + offset, count );\r
1074                 return RECORD_D3D9( hr );\r
1075         }\r
1076 \r
1077         Result Device::SetPixelShaderConstant( int startRegister, Matrix data )\r
1078         {\r
1079                 HRESULT hr = InternalPointer->SetPixelShaderConstantF( startRegister, reinterpret_cast<float*>( &data ), 4 );\r
1080                 return RECORD_D3D9( hr );\r
1081         }\r
1082 \r
1083         Result Device::SetPixelShaderConstant( int startRegister, Matrix* data, int count )\r
1084         {\r
1085                 HRESULT hr = InternalPointer->SetPixelShaderConstantF( startRegister, reinterpret_cast<float*>( data ), count * 4 );\r
1086                 return RECORD_D3D9( hr );\r
1087         }\r
1088 \r
1089         Result Device::SetPixelShaderConstant( int startRegister, array<Matrix>^ data, int offset, int count )\r
1090         {\r
1091                 pin_ptr<Matrix> pinnedData = &data[0];\r
1092 \r
1093                 Utilities::CheckBounds( 0, data->Length, offset, count );\r
1094                 HRESULT hr = InternalPointer->SetPixelShaderConstantF( startRegister, reinterpret_cast<float*>( pinnedData + offset ), count * 4 );\r
1095                 return RECORD_D3D9( hr );\r
1096         }\r
1097 \r
1098         Result Device::StretchRectangle( Surface^ source, System::Drawing::Rectangle sourceRect, Surface^ destination,\r
1099                 System::Drawing::Rectangle destRect, TextureFilter filter )\r
1100         {\r
1101                 RECT nativeSourceRect = { sourceRect.Left, sourceRect.Top, sourceRect.Right, sourceRect.Bottom };\r
1102                 RECT nativeDestRect = { destRect.Left, destRect.Top, destRect.Right, destRect.Bottom };\r
1103 \r
1104                 HRESULT hr = InternalPointer->StretchRect( source->InternalPointer, &nativeSourceRect, destination->InternalPointer,\r
1105                         &nativeDestRect, static_cast<D3DTEXTUREFILTERTYPE>( filter ) );\r
1106                 return RECORD_D3D9( hr );\r
1107         }\r
1108 \r
1109         Result Device::StretchRectangle( Surface^ source, Surface^ destination, TextureFilter filter )\r
1110         {\r
1111                 HRESULT hr = InternalPointer->StretchRect( source->InternalPointer, NULL, destination->InternalPointer,\r
1112                         NULL, static_cast<D3DTEXTUREFILTERTYPE>( filter ) );\r
1113                 return RECORD_D3D9( hr );\r
1114         }\r
1115 \r
1116         Result Device::UpdateSurface( Surface^ source, System::Drawing::Rectangle sourceRect,\r
1117                 Surface^ destination, System::Drawing::Point destinationPoint )\r
1118         {\r
1119                 RECT nativeSourceRect = { sourceRect.Left, sourceRect.Top, sourceRect.Right, sourceRect.Bottom };\r
1120                 POINT nativeDestPoint = { destinationPoint.X, destinationPoint.Y };\r
1121 \r
1122                 HRESULT hr = InternalPointer->UpdateSurface( source->InternalPointer, &nativeSourceRect,\r
1123                         destination->InternalPointer, &nativeDestPoint );\r
1124                 return RECORD_D3D9( hr );\r
1125         }\r
1126 \r
1127         Result Device::UpdateSurface( Surface^ source, Surface^ destination )\r
1128         {\r
1129                 HRESULT hr = InternalPointer->UpdateSurface( source->InternalPointer, NULL, destination->InternalPointer, NULL );\r
1130                 return RECORD_D3D9( hr );\r
1131         }\r
1132 \r
1133         Result Device::UpdateTexture( BaseTexture^ sourceTexture, BaseTexture^ destinationTexture )\r
1134         {\r
1135                 HRESULT hr = InternalPointer->UpdateTexture( sourceTexture->InternalPointer, destinationTexture->InternalPointer );\r
1136                 return RECORD_D3D9( hr );\r
1137         }\r
1138 \r
1139         Result Device::ColorFill( Surface^ destSurface, System::Drawing::Rectangle destRect, Color4 color )\r
1140         {\r
1141                 RECT nativeDestRect = { destRect.Left, destRect.Top, destRect.Right, destRect.Bottom };\r
1142 \r
1143                 HRESULT hr = InternalPointer->ColorFill( destSurface->InternalPointer, &nativeDestRect, static_cast<D3DCOLOR>( color.ToArgb() ) );\r
1144                 return RECORD_D3D9( hr );\r
1145         }\r
1146 \r
1147         Result Device::ColorFill( Surface^ destSurface, Color4 color )\r
1148         {\r
1149                 HRESULT hr = InternalPointer->ColorFill( destSurface->InternalPointer, NULL, static_cast<D3DCOLOR>( color.ToArgb() ) );\r
1150                 return RECORD_D3D9( hr );\r
1151         }\r
1152 \r
1153         Result Device::BeginStateBlock()\r
1154         {\r
1155                 HRESULT hr = InternalPointer->BeginStateBlock();\r
1156                 return RECORD_D3D9( hr );\r
1157         }\r
1158 \r
1159         StateBlock^ Device::EndStateBlock()\r
1160         {\r
1161                 IDirect3DStateBlock9* stateBlock;\r
1162                 HRESULT hr = InternalPointer->EndStateBlock( &stateBlock );\r
1163                 \r
1164                 if( RECORD_D3D9( hr ).IsFailure )\r
1165                         return nullptr;\r
1166 \r
1167                 return StateBlock::FromPointer( stateBlock );\r
1168         }\r
1169 \r
1170         SlimDX::Direct3D9::CreationParameters Device::CreationParameters::get()\r
1171         {\r
1172                 SlimDX::Direct3D9::CreationParameters parameters;\r
1173                 D3DDEVICE_CREATION_PARAMETERS dcp;\r
1174 \r
1175                 HRESULT hr = InternalPointer->GetCreationParameters( &dcp );\r
1176                 if( RECORD_D3D9( hr ).IsFailure )\r
1177                         return SlimDX::Direct3D9::CreationParameters();\r
1178 \r
1179                 parameters.AdapterOrdinal = dcp.AdapterOrdinal;\r
1180                 parameters.DeviceType = static_cast<DeviceType>( dcp.DeviceType );\r
1181                 parameters.Window = IntPtr( dcp.hFocusWindow );\r
1182                 parameters.BehaviorFlags = static_cast<CreateFlags>( dcp.BehaviorFlags );\r
1183 \r
1184                 return parameters;\r
1185         }\r
1186 \r
1187         SlimDX::Direct3D9::ClipStatus Device::ClipStatus::get()\r
1188         {\r
1189                 D3DCLIPSTATUS9 status;\r
1190 \r
1191                 HRESULT hr = InternalPointer->GetClipStatus( &status );\r
1192                 if( RECORD_D3D9( hr ).IsFailure )\r
1193                         return SlimDX::Direct3D9::ClipStatus();\r
1194 \r
1195                 SlimDX::Direct3D9::ClipStatus result;\r
1196                 result.ClipUnion = static_cast<ClipFlags>( status.ClipUnion );\r
1197                 result.ClipIntersection = static_cast<ClipFlags>( status.ClipIntersection );\r
1198 \r
1199                 return result;\r
1200         }\r
1201 \r
1202         void Device::ClipStatus::set( SlimDX::Direct3D9::ClipStatus value )\r
1203         {\r
1204                 HRESULT hr = InternalPointer->SetClipStatus( reinterpret_cast<const D3DCLIPSTATUS9*>( &value ) );\r
1205                 RECORD_D3D9( hr );\r
1206         }\r
1207 \r
1208         int Device::SwapChainCount::get()\r
1209         {\r
1210                 return InternalPointer->GetNumberOfSwapChains();\r
1211         }\r
1212 \r
1213         float Device::NPatchMode::get()\r
1214         {\r
1215                 return InternalPointer->GetNPatchMode();\r
1216         }\r
1217 \r
1218         void Device::NPatchMode::set( float value )\r
1219         {\r
1220                 HRESULT hr = InternalPointer->SetNPatchMode( value );\r
1221                 RECORD_D3D9( hr );\r
1222         }\r
1223 \r
1224         Result Device::DrawTrianglePatch( int handle, array<float>^ numSegments, TrianglePatchInfo info )\r
1225         {\r
1226                 pin_ptr<float> pinnedSegments = &numSegments[0];\r
1227 \r
1228                 HRESULT hr = InternalPointer->DrawTriPatch( handle, pinnedSegments, reinterpret_cast<D3DTRIPATCH_INFO*>( &info ) );\r
1229                 return RECORD_D3D9( hr );\r
1230         }\r
1231 \r
1232         Result Device::DrawTrianglePatch( int handle, array<float>^ numSegments )\r
1233         {\r
1234                 pin_ptr<float> pinnedSegments = &numSegments[0];\r
1235 \r
1236                 HRESULT hr = InternalPointer->DrawTriPatch( handle, pinnedSegments, NULL );\r
1237                 return RECORD_D3D9( hr );\r
1238         }\r
1239 \r
1240         Result Device::DrawRectanglePatch( int handle, array<float>^ numSegments, RectanglePatchInfo info )\r
1241         {\r
1242                 pin_ptr<float> pinnedSegments = &numSegments[0];\r
1243 \r
1244                 HRESULT hr = InternalPointer->DrawRectPatch( handle, pinnedSegments, reinterpret_cast<D3DRECTPATCH_INFO*>( &info ) );\r
1245                 return RECORD_D3D9( hr );\r
1246         }\r
1247 \r
1248         Result Device::DrawRectanglePatch( int handle, array<float>^ numSegments )\r
1249         {\r
1250                 pin_ptr<float> pinnedSegments = &numSegments[0];\r
1251 \r
1252                 HRESULT hr = InternalPointer->DrawRectPatch( handle, pinnedSegments, NULL );\r
1253                 return RECORD_D3D9( hr );\r
1254         }\r
1255 \r
1256         Result Device::DeletePatch( int handle )\r
1257         {\r
1258                 HRESULT hr = InternalPointer->DeletePatch( handle );\r
1259                 return RECORD_D3D9( hr );\r
1260         }\r
1261 \r
1262         DisplayMode Device::GetDisplayMode( int swapChain )\r
1263         {\r
1264                 DisplayMode displayMode;\r
1265 \r
1266                 HRESULT hr = InternalPointer->GetDisplayMode( swapChain, reinterpret_cast<D3DDISPLAYMODE*>( &displayMode ) );\r
1267                 RECORD_D3D9( hr );\r
1268                 \r
1269                 return displayMode;\r
1270         }\r
1271 \r
1272         Result Device::EvictManagedResources()\r
1273         {\r
1274                 HRESULT hr = InternalPointer->EvictManagedResources();\r
1275                 return RECORD_D3D9( hr );\r
1276         }\r
1277 \r
1278         Result Device::SetDialogBoxMode( bool enableDialogs )\r
1279         {\r
1280                 HRESULT hr = InternalPointer->SetDialogBoxMode( enableDialogs );\r
1281                 return RECORD_D3D9( hr );\r
1282         }\r
1283 \r
1284         Result Device::EnableLight( int lightIndex, bool enable )\r
1285         {\r
1286                 HRESULT hr = InternalPointer->LightEnable( lightIndex, enable );\r
1287                 return RECORD_D3D9( hr );\r
1288         }\r
1289 \r
1290         bool Device::IsLightEnabled( int lightIndex )\r
1291         {\r
1292                 BOOL enabled = FALSE;\r
1293                 HRESULT hr = InternalPointer->GetLightEnable( lightIndex, &enabled );\r
1294                 RECORD_D3D9( hr );\r
1295 \r
1296                 return enabled > 0;\r
1297         }\r
1298 \r
1299         Result Device::SetLight( int lightIndex, Light lightData )\r
1300         {\r
1301                 HRESULT hr = InternalPointer->SetLight( lightIndex, reinterpret_cast<const D3DLIGHT9*>( &lightData ) );\r
1302                 return RECORD_D3D9( hr );\r
1303         }\r
1304 \r
1305         Light Device::GetLight( int lightIndex )\r
1306         {\r
1307                 Light light;\r
1308                 HRESULT hr = InternalPointer->GetLight( lightIndex, reinterpret_cast<D3DLIGHT9*>( &light ) );\r
1309                 RECORD_D3D9( hr );\r
1310                 \r
1311                 return light;\r
1312         }\r
1313 \r
1314         Result Device::SetCursor( Cursor^ cursor, bool addWatermark )\r
1315         {\r
1316                 if( cursor == nullptr )\r
1317                         return RECORD_D3D9( S_OK );\r
1318 \r
1319                 IDirect3DSurface9 *cursorSurface = NULL;\r
1320                 ICONINFO iconInfo = {0};\r
1321                 HRESULT hr;\r
1322                 BITMAP bmp;\r
1323                 BITMAPINFO bmi = {0};\r
1324                 bool bwCursor;\r
1325                 int width = 0;\r
1326                 int heightSrc = 0;\r
1327                 int heightDest = 0;\r
1328                 COLORREF color;\r
1329                 COLORREF mask;\r
1330                 stack_array<COLORREF> arrayColor;\r
1331                 HDC hdcColor = NULL;\r
1332                 HDC hdcScreen = NULL;\r
1333                 HDC hdcMask = NULL;\r
1334                 HGDIOBJ oldObject;\r
1335                 DWORD *bitmap;\r
1336 \r
1337                 if( !GetIconInfo( static_cast<HICON>( cursor->Handle.ToPointer() ), &iconInfo ) )\r
1338                         return RECORD_D3D9( E_FAIL );\r
1339 \r
1340                 if( GetObject( static_cast<HGDIOBJ>( iconInfo.hbmMask ), sizeof( BITMAP ), static_cast<LPVOID>( &bmp ) ) == 0 )\r
1341                 {\r
1342                         if( iconInfo.hbmMask != NULL )\r
1343                                 DeleteObject( iconInfo.hbmMask );\r
1344                         if( iconInfo.hbmColor != NULL )\r
1345                                 DeleteObject( iconInfo.hbmColor );\r
1346                         return RECORD_D3D9( E_FAIL );\r
1347                 }\r
1348 \r
1349                 width = bmp.bmWidth;\r
1350                 heightSrc = bmp.bmHeight;\r
1351 \r
1352                 if( iconInfo.hbmColor == NULL )\r
1353                 {\r
1354                         bwCursor = true;\r
1355                         heightDest = heightSrc / 2;\r
1356                 }\r
1357                 else\r
1358                 {\r
1359                         bwCursor = false;\r
1360                         heightDest = heightSrc;\r
1361                 }\r
1362 \r
1363                 if( FAILED( hr = InternalPointer->CreateOffscreenPlainSurface( width, heightDest, D3DFMT_A8R8G8B8,\r
1364                         D3DPOOL_SCRATCH, &cursorSurface, NULL ) ) )\r
1365                 {\r
1366                         if( iconInfo.hbmMask != NULL )\r
1367                                 DeleteObject( iconInfo.hbmMask );\r
1368                         if( iconInfo.hbmColor != NULL )\r
1369                                 DeleteObject( iconInfo.hbmColor );\r
1370                         return RECORD_D3D9( hr );\r
1371                 }\r
1372 \r
1373                 stack_array<COLORREF> arrayMask = stackalloc( COLORREF, width * heightSrc );\r
1374 \r
1375                 bmi.bmiHeader.biSize = sizeof( bmi.bmiHeader );\r
1376                 bmi.bmiHeader.biWidth = width;\r
1377                 bmi.bmiHeader.biHeight = heightSrc;\r
1378                 bmi.bmiHeader.biPlanes = 1;\r
1379                 bmi.bmiHeader.biBitCount = 32;\r
1380                 bmi.bmiHeader.biCompression = BI_RGB;\r
1381 \r
1382                 hdcScreen = GetDC( NULL );\r
1383                 hdcMask = CreateCompatibleDC( hdcScreen );\r
1384                 if( hdcMask == NULL )\r
1385                 {\r
1386                         if( iconInfo.hbmMask != NULL )\r
1387                                 DeleteObject( iconInfo.hbmMask );\r
1388                         if( iconInfo.hbmColor != NULL )\r
1389                                 DeleteObject( iconInfo.hbmColor );\r
1390                         if( hdcScreen != NULL )\r
1391                                 ReleaseDC( NULL, hdcScreen );\r
1392                         if( cursorSurface != NULL )\r
1393                                 cursorSurface->Release();\r
1394                         return RECORD_D3D9( E_FAIL );\r
1395                 }\r
1396 \r
1397                 oldObject = SelectObject( hdcMask, iconInfo.hbmMask );\r
1398                 GetDIBits( hdcMask, iconInfo.hbmMask, 0, heightSrc, &arrayMask[0], &bmi, DIB_RGB_COLORS );\r
1399                 SelectObject( hdcMask, oldObject );\r
1400 \r
1401                 if( !bwCursor )\r
1402                 {\r
1403                         arrayColor = stack_array<COLORREF>( width * heightDest );\r
1404                         hdcColor = CreateCompatibleDC( hdcScreen );\r
1405                         if( hdcColor == NULL )\r
1406                         {\r
1407                                 if( iconInfo.hbmMask != NULL )\r
1408                                         DeleteObject( iconInfo.hbmMask );\r
1409                                 if( iconInfo.hbmColor != NULL )\r
1410                                         DeleteObject( iconInfo.hbmColor );\r
1411                                 if( hdcScreen != NULL )\r
1412                                         ReleaseDC( NULL, hdcScreen );\r
1413                                 if( hdcMask != NULL )\r
1414                                         DeleteDC( hdcMask );\r
1415                                 if( hdcColor != NULL )\r
1416                                         DeleteDC( hdcColor );\r
1417                                 if( cursorSurface != NULL )\r
1418                                         cursorSurface->Release();\r
1419                                 return RECORD_D3D9( E_FAIL );\r
1420                         }\r
1421 \r
1422                         SelectObject( hdcColor, iconInfo.hbmColor );\r
1423                         GetDIBits( hdcColor, iconInfo.hbmColor, 0, heightDest, &arrayColor[0], &bmi, DIB_RGB_COLORS );\r
1424                 }\r
1425 \r
1426                 D3DLOCKED_RECT lr;\r
1427                 cursorSurface->LockRect( &lr, NULL, 0 );\r
1428                 bitmap = static_cast<DWORD*>( lr.pBits );\r
1429 \r
1430                 for( int y = 0; y < heightDest; y++ )\r
1431                 {\r
1432                         for( int x = 0; x < width; x++ )\r
1433                         {\r
1434                                 if( bwCursor )\r
1435                                 {\r
1436                                         color = arrayMask[width * ( heightDest - 1 - y ) + x];\r
1437                                         mask = arrayMask[width * ( heightSrc - 1 - y ) + x];\r
1438                                 }\r
1439                                 else\r
1440                                 {\r
1441                                         color = arrayColor[width * ( heightDest - 1 - y ) + x];\r
1442                                         mask = arrayMask[width * ( heightDest - 1 - y ) + x];\r
1443                                 }\r
1444 \r
1445                                 if( mask == 0 )\r
1446                                         bitmap[width * y + x] = 0xff000000 | color;\r
1447                                 else\r
1448                                         bitmap[width * y + x] = 0x00000000;\r
1449 \r
1450                                 if( addWatermark && x < 12 && y < 5 )\r
1451                                 {\r
1452                                         const WORD wMask[5] = { 0xccc0, 0xa2a0, 0xa4a0, 0xa2a0, 0xccc0 };\r
1453                                         if( wMask[y] & ( 1 << ( 15 - x ) ) )\r
1454                                                 bitmap[width * y + x] |= 0xff808080;\r
1455                                 }\r
1456                         }\r
1457                 }\r
1458 \r
1459                 cursorSurface->UnlockRect();\r
1460 \r
1461                 hr = InternalPointer->SetCursorProperties( iconInfo.xHotspot, iconInfo.yHotspot, cursorSurface );\r
1462 \r
1463                 if( iconInfo.hbmMask != NULL )\r
1464                         DeleteObject( iconInfo.hbmMask );\r
1465                 if( iconInfo.hbmColor != NULL )\r
1466                         DeleteObject( iconInfo.hbmColor );\r
1467                 if( hdcScreen != NULL )\r
1468                         ReleaseDC( NULL, hdcScreen );\r
1469                 if( hdcMask != NULL )\r
1470                         DeleteDC( hdcMask );\r
1471                 if( hdcColor != NULL )\r
1472                         DeleteDC( hdcColor );\r
1473                 if( cursorSurface != NULL )\r
1474                         cursorSurface->Release();\r
1475                 return RECORD_D3D9( hr );\r
1476         }\r
1477 \r
1478         void Device::SetCursorPosition( int x, int y, bool immediateUpdate )\r
1479         {\r
1480                 DWORD flags = immediateUpdate ? D3DCURSOR_IMMEDIATE_UPDATE : 0;\r
1481                 InternalPointer->SetCursorPosition( x, y, flags );\r
1482         }\r
1483 \r
1484         Result Device::SetCursorProperties( int hotspotX, int hotspotY, Surface^ cursorBitmap )\r
1485         {\r
1486                 IDirect3DSurface9* surface = cursorBitmap != nullptr ? cursorBitmap->InternalPointer : NULL;\r
1487                 HRESULT hr = InternalPointer->SetCursorProperties( hotspotX, hotspotY, surface );\r
1488                 return RECORD_D3D9( hr );\r
1489         }\r
1490 \r
1491         void Device::CurrentTexturePalette::set( int value )\r
1492         {\r
1493                 HRESULT hr = InternalPointer->SetCurrentTexturePalette( value );\r
1494                 RECORD_D3D9( hr );\r
1495         }\r
1496 \r
1497         int Device::CurrentTexturePalette::get()\r
1498         {\r
1499                 unsigned int palette = 0;\r
1500                 HRESULT hr = InternalPointer->GetCurrentTexturePalette( &palette );\r
1501                 RECORD_D3D9( hr );\r
1502 \r
1503                 return static_cast<int>( palette );\r
1504         }\r
1505 \r
1506         VertexShader^ Device::VertexShader::get()\r
1507         {\r
1508                 IDirect3DVertexShader9* vs;\r
1509                 HRESULT hr = InternalPointer->GetVertexShader( &vs );\r
1510                 \r
1511                 if( RECORD_D3D9( hr ).IsFailure )\r
1512                         return nullptr;\r
1513 \r
1514                 return SlimDX::Direct3D9::VertexShader::FromPointer( vs );\r
1515         }\r
1516 \r
1517         PixelShader^ Device::PixelShader::get()\r
1518         {\r
1519                 IDirect3DPixelShader9* ps;\r
1520                 HRESULT hr = InternalPointer->GetPixelShader( &ps );\r
1521                 \r
1522                 if( RECORD_D3D9( hr ).IsFailure )\r
1523                         return nullptr;\r
1524 \r
1525                 return SlimDX::Direct3D9::PixelShader::FromPointer( ps );\r
1526         }\r
1527 \r
1528         DriverLevel Device::DriverLevel::get()\r
1529         {\r
1530                 return static_cast<SlimDX::Direct3D9::DriverLevel>( D3DXGetDriverLevel( InternalPointer ) );\r
1531         }\r
1532 \r
1533         String^ Device::VertexShaderProfile::get()\r
1534         {\r
1535                 LPCSTR profile = D3DXGetVertexShaderProfile( InternalPointer );\r
1536                 return gcnew String( profile );\r
1537         }\r
1538 \r
1539         String^ Device::PixelShaderProfile::get()\r
1540         {\r
1541                 LPCSTR profile = D3DXGetPixelShaderProfile( InternalPointer );\r
1542                 return gcnew String( profile );\r
1543         }\r
1544 \r
1545         Result Device::SetR2VBMode( bool enableR2VB )\r
1546         {\r
1547                 return SetRenderState( RenderState::PointSize, static_cast<int>( r2vbGlbEnable_Set( enableR2VB ) ) );\r
1548         }\r
1549 \r
1550         Result Device::BindRenderTargetToVertexStream( R2VBSampler sampler, Texture^ r2vbTarget, int stream, int stride, VertexBuffer^ dummyVb )\r
1551         {\r
1552                 if( SetTexture( D3DDMAPSAMPLER, r2vbTarget ).IsFailure )\r
1553                         return Result::Last;\r
1554 \r
1555                 if( SetRenderState( RenderState::PointSize, static_cast<int>( r2vbVStrm2SmpMap_Set( stream, static_cast<int>( sampler ) ) ) ).IsFailure )\r
1556                         return Result::Last;\r
1557 \r
1558                 if( SetStreamSource( stream, dummyVb, 0, stride ).IsFailure )\r
1559                         return Result::Last;\r
1560 \r
1561                 return RECORD_D3D9( D3D_OK );\r
1562         }\r
1563 \r
1564         Result Device::RestoreVertexStream( int stream )\r
1565         {\r
1566                 if( SetRenderState( RenderState::PointSize, static_cast<int>( r2vbVStrm2SmpMap_Set( stream, R2VB_VSMP_OVR_DIS ) ) ).IsFailure )\r
1567                         return Result::Last;\r
1568 \r
1569                 return SetTexture( D3DDMAPSAMPLER, nullptr );\r
1570         }\r
1571 \r
1572         Result Device::SetClipPlane( int index, Plane clipPlane )\r
1573         {\r
1574                 HRESULT hr = InternalPointer->SetClipPlane( index, reinterpret_cast<const float*>( &clipPlane ) );\r
1575                 return RECORD_D3D9( hr );\r
1576         }\r
1577 \r
1578         Plane Device::GetClipPlane( int index )\r
1579         {\r
1580                 Plane plane;\r
1581                 HRESULT hr = InternalPointer->GetClipPlane( index, reinterpret_cast<float*>( &plane ) );\r
1582                 RECORD_D3D9( hr );\r
1583 \r
1584                 return plane;\r
1585         }\r
1586 \r
1587         Result Device::GetFrontBufferData( int swapChain, Surface^ destinationSurface )\r
1588         {\r
1589                 IDirect3DSurface9* surface = destinationSurface != nullptr ? destinationSurface->InternalPointer : NULL;\r
1590                 HRESULT hr = InternalPointer->GetFrontBufferData( swapChain, surface );\r
1591                 return RECORD_D3D9( hr );\r
1592         }\r
1593 \r
1594         Result Device::GetRenderTargetData( Surface^ renderTarget, Surface^ destinationSurface )\r
1595         {\r
1596                 IDirect3DSurface9* target = renderTarget != nullptr     ? renderTarget->InternalPointer : NULL;\r
1597                 IDirect3DSurface9* destination = destinationSurface != nullptr ? destinationSurface->InternalPointer : NULL;\r
1598                 HRESULT hr = InternalPointer->GetRenderTargetData( target, destination );\r
1599                 return RECORD_D3D9( hr );\r
1600         }\r
1601 \r
1602         SlimDX::Direct3D9::Direct3D^ Device::Direct3D::get()\r
1603         {\r
1604                 IDirect3D9 *pointer;\r
1605 \r
1606                 HRESULT hr = InternalPointer->GetDirect3D( &pointer );\r
1607                 if( RECORD_D3D9( hr ).IsFailure )\r
1608                         return nullptr;\r
1609 \r
1610                 return SlimDX::Direct3D9::Direct3D::FromPointer( pointer );\r
1611         }\r
1612 }\r
1613 }\r