SlimDXc_Jun2010(VC++2008)/source/direct3d9/EffectStateManager.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 "../ComObject.h"\r
  28 #include "../Math/Matrix.h"\r
  29 #include "../DataStream.h"\r
  30 #include "../Utilities.h"\r
  31 #include "../SlimDXException.h"\r
  32 \r
  33 #include "Enums.h"\r
  34 #include "Device.h"\r
  35 #include "PixelShader9.h"\r
  36 #include "VertexShader9.h"\r
  37 #include "Texture.h"\r
  38 #include "Effect9.h"\r
  39 #include "EffectStateManager.h"\r
  40 \r
  41 using namespace System;\r
  42 using namespace System::Runtime::InteropServices;\r
  43 \r
  44 namespace SlimDX\r
  45 {\r
  46 namespace Direct3D9\r
  47 {\r
  48         IEffectStateManagerShim::IEffectStateManagerShim( IEffectStateManager^ wrappedInterface, Effect^ effect )\r
  49         {\r
  50                 m_WrappedInterface = wrappedInterface;\r
  51                 m_Effect = effect;\r
  52 \r
  53                 refCount = 1;\r
  54         }\r
  55 \r
  56         HRESULT IEffectStateManagerShim::QueryInterface( const IID &iid, LPVOID *ppv )\r
  57         {\r
  58                 if( iid == IID_ID3DXEffectStateManager )\r
  59                 {\r
  60                         AddRef();\r
  61                         *reinterpret_cast<ID3DXEffectStateManager**>( ppv ) = this;\r
  62                         return S_OK;\r
  63                 }\r
  64 \r
  65                 return E_NOTIMPL;\r
  66         }\r
  67 \r
  68         ULONG IEffectStateManagerShim::AddRef()\r
  69         {\r
  70                 return ++refCount;\r
  71         }\r
  72 \r
  73         ULONG IEffectStateManagerShim::Release()\r
  74         {\r
  75                 if( --refCount == 0 )\r
  76                         delete this;\r
  77                 return refCount;\r
  78         }\r
  79 \r
  80         HRESULT IEffectStateManagerShim::LightEnable( DWORD Index, BOOL Enable )\r
  81         {\r
  82                 try\r
  83                 {\r
  84                         m_WrappedInterface->EnableLight( Index, Enable > 0 );\r
  85                 }\r
  86                 catch( SlimDXException^ ex)\r
  87                 {\r
  88                         return ex->ResultCode.Code;\r
  89                 }\r
  90                 catch( Exception^ )\r
  91                 {\r
  92                         return E_FAIL;\r
  93                 }\r
  94 \r
  95                 return S_OK;\r
  96         }\r
  97 \r
  98         HRESULT IEffectStateManagerShim::SetFVF( DWORD FVF )\r
  99         {\r
 100                 try\r
 101                 {\r
 102                         m_WrappedInterface->SetFVF( static_cast<VertexFormat>( FVF ) );\r
 103                 }\r
 104                 catch( SlimDXException^ ex)\r
 105                 {\r
 106                         return ex->ResultCode.Code;\r
 107                 }\r
 108                 catch( Exception^ )\r
 109                 {\r
 110                         return E_FAIL;\r
 111                 }\r
 112 \r
 113                 return S_OK;\r
 114         }\r
 115 \r
 116         HRESULT IEffectStateManagerShim::SetLight( DWORD index, const D3DLIGHT9* pLight )\r
 117         {\r
 118                 try\r
 119                 {\r
 120                         Light light;\r
 121                         light.Ambient = Color4::FromUnmanaged( pLight->Ambient );\r
 122                         light.Diffuse = Color4::FromUnmanaged( pLight->Diffuse );\r
 123                         light.Specular = Color4::FromUnmanaged( pLight->Specular );\r
 124                         light.Attenuation0 = pLight->Attenuation0;\r
 125                         light.Attenuation1 = pLight->Attenuation1;\r
 126                         light.Attenuation2 = pLight->Attenuation2;\r
 127                         light.Direction = Vector3( pLight->Direction.x, pLight->Direction.y, pLight->Direction.z );\r
 128                         light.Position = Vector3( pLight->Position.x, pLight->Position.y, pLight->Position.z );\r
 129                         light.Falloff = pLight->Falloff;\r
 130                         light.Phi = pLight->Phi;\r
 131                         light.Range = pLight->Range;\r
 132                         light.Theta = pLight->Theta;\r
 133                         light.Type = static_cast<LightType>( pLight->Type );\r
 134 \r
 135                         m_WrappedInterface->SetLight( index, light );\r
 136                 }\r
 137                 catch( SlimDXException^ ex)\r
 138                 {\r
 139                         return ex->ResultCode.Code;\r
 140                 }\r
 141                 catch( Exception^ )\r
 142                 {\r
 143                         return E_FAIL;\r
 144                 }\r
 145 \r
 146                 return S_OK;\r
 147         }\r
 148 \r
 149         HRESULT IEffectStateManagerShim::SetMaterial( const D3DMATERIAL9* pMaterial )\r
 150         {\r
 151                 try\r
 152                 {\r
 153                         Material material;\r
 154                         material.Ambient = Color4::FromUnmanaged( pMaterial->Ambient );\r
 155                         material.Specular = Color4::FromUnmanaged( pMaterial->Specular );\r
 156                         material.Diffuse = Color4::FromUnmanaged( pMaterial->Diffuse );\r
 157                         material.Emissive = Color4::FromUnmanaged( pMaterial->Emissive );\r
 158                         material.Power = pMaterial->Power;\r
 159 \r
 160                         m_WrappedInterface->SetMaterial( material );\r
 161                 }\r
 162                 catch( SlimDXException^ ex)\r
 163                 {\r
 164                         return ex->ResultCode.Code;\r
 165                 }\r
 166                 catch( Exception^ )\r
 167                 {\r
 168                         return E_FAIL;\r
 169                 }\r
 170 \r
 171                 return S_OK;\r
 172         }\r
 173 \r
 174         HRESULT IEffectStateManagerShim::SetNPatchMode( FLOAT nSegments )\r
 175         {\r
 176                 try\r
 177                 {\r
 178                         m_WrappedInterface->SetNPatchMode( nSegments );\r
 179                 }\r
 180                 catch( SlimDXException^ ex)\r
 181                 {\r
 182                         return ex->ResultCode.Code;\r
 183                 }\r
 184                 catch( Exception^ )\r
 185                 {\r
 186                         return E_FAIL;\r
 187                 }\r
 188 \r
 189                 return S_OK;\r
 190         }\r
 191 \r
 192         HRESULT IEffectStateManagerShim::SetTransform( D3DTRANSFORMSTATETYPE State, const D3DMATRIX* pMatrix )\r
 193         {\r
 194                 try\r
 195                 {\r
 196                         m_WrappedInterface->SetTransform( static_cast<TransformState>( State ), Matrix::FromD3DXMATRIX( *pMatrix ) );\r
 197                 }\r
 198                 catch( SlimDXException^ ex)\r
 199                 {\r
 200                         return ex->ResultCode.Code;\r
 201                 }\r
 202                 catch( Exception^ )\r
 203                 {\r
 204                         return E_FAIL;\r
 205                 }\r
 206 \r
 207                 return S_OK;\r
 208         }\r
 209 \r
 210         HRESULT IEffectStateManagerShim::SetPixelShader( LPDIRECT3DPIXELSHADER9 pShader )\r
 211         {\r
 212                 try\r
 213                 {\r
 214                         if( pShader == NULL )\r
 215                                 m_WrappedInterface->SetPixelShader( nullptr );\r
 216                         else\r
 217                         {\r
 218                                 pShader->AddRef();\r
 219                                 m_WrappedInterface->SetPixelShader( PixelShader::FromPointer( pShader, m_Effect ) );\r
 220                         }\r
 221                 }\r
 222                 catch( SlimDXException^ ex)\r
 223                 {\r
 224                         return ex->ResultCode.Code;\r
 225                 }\r
 226                 catch( Exception^ )\r
 227                 {\r
 228                         return E_FAIL;\r
 229                 }\r
 230 \r
 231                 return S_OK;\r
 232         }\r
 233 \r
 234         HRESULT IEffectStateManagerShim::SetPixelShaderConstantB( UINT StartRegister, const BOOL* pConstantData, UINT RegisterCount )\r
 235         {\r
 236                 try\r
 237                 {\r
 238                         array<bool>^ data = gcnew array<bool>( RegisterCount );\r
 239                         for( UINT i = 0; i < RegisterCount; i++ )\r
 240                                 data[i] = ( pConstantData[i] > 0 );\r
 241 \r
 242                         m_WrappedInterface->SetPixelShaderConstant( StartRegister, data );\r
 243                 }\r
 244                 catch( SlimDXException^ ex)\r
 245                 {\r
 246                         return ex->ResultCode.Code;\r
 247                 }\r
 248                 catch( Exception^ )\r
 249                 {\r
 250                         return E_FAIL;\r
 251                 }\r
 252 \r
 253                 return S_OK;\r
 254         }\r
 255 \r
 256         HRESULT IEffectStateManagerShim::SetPixelShaderConstantF( UINT StartRegister, const FLOAT* pConstantData, UINT RegisterCount )\r
 257         {\r
 258                 try\r
 259                 {\r
 260                         array<float>^ data = gcnew array<float>( RegisterCount * 4 );\r
 261                         Marshal::Copy( IntPtr( const_cast<FLOAT*>( pConstantData ) ), data, 0, RegisterCount * 4 );\r
 262 \r
 263                         m_WrappedInterface->SetPixelShaderConstant( StartRegister, data );\r
 264                 }\r
 265                 catch( SlimDXException^ ex)\r
 266                 {\r
 267                         return ex->ResultCode.Code;\r
 268                 }\r
 269                 catch( Exception^ )\r
 270                 {\r
 271                         return E_FAIL;\r
 272                 }\r
 273 \r
 274                 return S_OK;\r
 275         }\r
 276 \r
 277         HRESULT IEffectStateManagerShim::SetPixelShaderConstantI( UINT StartRegister, const INT* pConstantData, UINT RegisterCount )\r
 278         {\r
 279                 try\r
 280                 {\r
 281                         array<int>^ data = gcnew array<int>( RegisterCount * 4 );\r
 282                         Marshal::Copy( IntPtr( const_cast<INT*>( pConstantData ) ), data, 0, RegisterCount * 4 );\r
 283 \r
 284                         m_WrappedInterface->SetPixelShaderConstant( StartRegister, data );\r
 285                 }\r
 286                 catch( SlimDXException^ ex)\r
 287                 {\r
 288                         return ex->ResultCode.Code;\r
 289                 }\r
 290                 catch( Exception^ )\r
 291                 {\r
 292                         return E_FAIL;\r
 293                 }\r
 294 \r
 295                 return S_OK;\r
 296         }\r
 297 \r
 298         HRESULT IEffectStateManagerShim::SetVertexShader( LPDIRECT3DVERTEXSHADER9 pShader )\r
 299         {\r
 300                 try\r
 301                 {\r
 302                         if( pShader == NULL )\r
 303                                 m_WrappedInterface->SetVertexShader( nullptr );\r
 304                         else\r
 305                         {\r
 306                                 pShader->AddRef();\r
 307                                 m_WrappedInterface->SetVertexShader( VertexShader::FromPointer( pShader, m_Effect ) );\r
 308                         }\r
 309                 }\r
 310                 catch( SlimDXException^ ex)\r
 311                 {\r
 312                         return ex->ResultCode.Code;\r
 313                 }\r
 314                 catch( Exception^ )\r
 315                 {\r
 316                         return E_FAIL;\r
 317                 }\r
 318 \r
 319                 return S_OK;\r
 320         }\r
 321 \r
 322         HRESULT IEffectStateManagerShim::SetVertexShaderConstantB( UINT StartRegister, const BOOL* pConstantData, UINT RegisterCount )\r
 323         {\r
 324                 try\r
 325                 {\r
 326                         array<bool>^ data = gcnew array<bool>( RegisterCount );\r
 327                         for( UINT i = 0; i < RegisterCount; i++ )\r
 328                                 data[i] = ( pConstantData[i] > 0 );\r
 329 \r
 330                         m_WrappedInterface->SetVertexShaderConstant( StartRegister, data );\r
 331                 }\r
 332                 catch( SlimDXException^ ex)\r
 333                 {\r
 334                         return ex->ResultCode.Code;\r
 335                 }\r
 336                 catch( Exception^ )\r
 337                 {\r
 338                         return E_FAIL;\r
 339                 }\r
 340 \r
 341                 return S_OK;\r
 342         }\r
 343 \r
 344         HRESULT IEffectStateManagerShim::SetVertexShaderConstantF( UINT StartRegister, const FLOAT* pConstantData, UINT RegisterCount )\r
 345         {\r
 346                 try\r
 347                 {\r
 348                         array<float>^ data = gcnew array<float>( RegisterCount * 4 );\r
 349                         Marshal::Copy( IntPtr( const_cast<FLOAT*>( pConstantData ) ), data, 0, RegisterCount * 4 );\r
 350 \r
 351                         m_WrappedInterface->SetVertexShaderConstant( StartRegister, data );\r
 352                 }\r
 353                 catch( SlimDXException^ ex)\r
 354                 {\r
 355                         return ex->ResultCode.Code;\r
 356                 }\r
 357                 catch( Exception^ )\r
 358                 {\r
 359                         return E_FAIL;\r
 360                 }\r
 361 \r
 362                 return S_OK;\r
 363         }\r
 364 \r
 365         HRESULT IEffectStateManagerShim::SetVertexShaderConstantI( UINT StartRegister, const INT* pConstantData, UINT RegisterCount )\r
 366         {\r
 367                 try\r
 368                 {\r
 369                         array<int>^ data = gcnew array<int>( RegisterCount * 4 );\r
 370                         Marshal::Copy( IntPtr( const_cast<INT*>( pConstantData ) ), data, 0, RegisterCount * 4 );\r
 371 \r
 372                         m_WrappedInterface->SetVertexShaderConstant( StartRegister, data );\r
 373                 }\r
 374                 catch( SlimDXException^ ex)\r
 375                 {\r
 376                         return ex->ResultCode.Code;\r
 377                 }\r
 378                 catch( Exception^ )\r
 379                 {\r
 380                         return E_FAIL;\r
 381                 }\r
 382 \r
 383                 return S_OK;\r
 384         }\r
 385 \r
 386         HRESULT IEffectStateManagerShim::SetRenderState( D3DRENDERSTATETYPE State, DWORD Value )\r
 387         {\r
 388                 try\r
 389                 {\r
 390                         m_WrappedInterface->SetRenderState( static_cast<RenderState>( State ), Value );\r
 391                 }\r
 392                 catch( SlimDXException^ ex)\r
 393                 {\r
 394                         return ex->ResultCode.Code;\r
 395                 }\r
 396                 catch( Exception^ )\r
 397                 {\r
 398                         return E_FAIL;\r
 399                 }\r
 400 \r
 401                 return S_OK;\r
 402         }\r
 403 \r
 404         HRESULT IEffectStateManagerShim::SetSamplerState( DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value )\r
 405         {\r
 406                 try\r
 407                 {\r
 408                         m_WrappedInterface->SetSamplerState( Sampler, static_cast<SamplerState>( Type ), Value );\r
 409                 }\r
 410                 catch( SlimDXException^ ex)\r
 411                 {\r
 412                         return ex->ResultCode.Code;\r
 413                 }\r
 414                 catch( Exception^ )\r
 415                 {\r
 416                         return E_FAIL;\r
 417                 }\r
 418 \r
 419                 return S_OK;\r
 420         }\r
 421 \r
 422         HRESULT IEffectStateManagerShim::SetTexture( DWORD Stage, LPDIRECT3DBASETEXTURE9 pTexture )\r
 423         {\r
 424                 try\r
 425                 {\r
 426                         if( pTexture == NULL )\r
 427                                 m_WrappedInterface->SetTexture( Stage, nullptr );\r
 428                         else\r
 429                         {\r
 430                                 pTexture->AddRef();\r
 431                                 m_WrappedInterface->SetTexture( Stage, BaseTexture::FromUnmanaged( pTexture ) );\r
 432                         }\r
 433                 }\r
 434                 catch( SlimDXException^ ex)\r
 435                 {\r
 436                         return ex->ResultCode.Code;\r
 437                 }\r
 438                 catch( Exception^ )\r
 439                 {\r
 440                         return E_FAIL;\r
 441                 }\r
 442 \r
 443                 return S_OK;\r
 444         }\r
 445 \r
 446         HRESULT IEffectStateManagerShim::SetTextureStageState( DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD Value )\r
 447         {\r
 448                 try\r
 449                 {\r
 450                         m_WrappedInterface->SetTextureStageState( Stage, static_cast<TextureStage>( Type ), Value );\r
 451                 }\r
 452                 catch( SlimDXException^ ex)\r
 453                 {\r
 454                         return ex->ResultCode.Code;\r
 455                 }\r
 456                 catch( Exception^ )\r
 457                 {\r
 458                         return E_FAIL;\r
 459                 }\r
 460 \r
 461                 return S_OK;\r
 462         }\r
 463 }\r
 464 }