SlimDXc_Jun2010(VC++2008)/source/direct3d10/OutputMergerWrapper.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 \r
  24 #include <d3d10.h>\r
  25 #include <d3dx10.h>\r
  26 \r
  27 #include "../stack_array.h"\r
  28 \r
  29 #include "BlendState.h"\r
  30 #include "DepthStencilState.h"\r
  31 #include "DepthStencilView.h"\r
  32 #include "OutputMergerWrapper.h"\r
  33 #include "RenderTargetView.h"\r
  34 \r
  35 using namespace System;\r
  36 \r
  37 namespace SlimDX\r
  38 {\r
  39 namespace Direct3D10\r
  40 { \r
  41         OutputMergerWrapper::OutputMergerWrapper( ID3D10Device* device )\r
  42         {\r
  43                 if( device == 0 )\r
  44                         throw gcnew ArgumentNullException( "device" );\r
  45                 m_Device = device;\r
  46         }\r
  47         \r
  48         void OutputMergerWrapper::DepthStencilState::set( SlimDX::Direct3D10::DepthStencilState^ value )\r
  49         {\r
  50                 ID3D10DepthStencilState* oldState;\r
  51                 int oldReference;\r
  52                 m_Device->OMGetDepthStencilState( &oldState, reinterpret_cast<UINT*>( &oldReference ) );\r
  53                 if( oldState != NULL )\r
  54                         oldState->Release();\r
  55         \r
  56                 if( value == nullptr )\r
  57                         m_Device->OMSetDepthStencilState( 0, oldReference );\r
  58                 else\r
  59                         m_Device->OMSetDepthStencilState( value->InternalPointer, oldReference );\r
  60         }\r
  61         \r
  62         SlimDX::Direct3D10::DepthStencilState^ OutputMergerWrapper::DepthStencilState::get()\r
  63         {\r
  64                 ID3D10DepthStencilState* oldState = 0;\r
  65                 int oldReference = 0;\r
  66                 m_Device->OMGetDepthStencilState( &oldState, reinterpret_cast<UINT*>( &oldReference ) );\r
  67                 \r
  68                 return SlimDX::Direct3D10::DepthStencilState::FromPointer( oldState );\r
  69         }\r
  70         \r
  71         void OutputMergerWrapper::DepthStencilReference::set( int value )\r
  72         {\r
  73                 ID3D10DepthStencilState* oldState = 0;\r
  74                 int oldReference = 0;\r
  75                 m_Device->OMGetDepthStencilState( &oldState, reinterpret_cast<UINT*>( &oldReference ) );\r
  76         \r
  77                 m_Device->OMSetDepthStencilState( oldState, value );\r
  78                 if( oldState != NULL )\r
  79                         oldState->Release();\r
  80         }\r
  81         \r
  82         int OutputMergerWrapper::DepthStencilReference::get()\r
  83         {\r
  84                 ID3D10DepthStencilState* oldState = 0;\r
  85                 int oldReference = 0;\r
  86                 m_Device->OMGetDepthStencilState( &oldState, reinterpret_cast<UINT*>( &oldReference ) );\r
  87                 if( oldState != NULL )\r
  88                         oldState->Release();\r
  89                 \r
  90                 return oldReference;\r
  91         }\r
  92         \r
  93         void OutputMergerWrapper::BlendState::set( SlimDX::Direct3D10::BlendState^ value )\r
  94         {\r
  95                 ID3D10BlendState* oldState = 0;\r
  96                 float oldFactor[4];\r
  97                 int oldMask = 0;\r
  98                 m_Device->OMGetBlendState( &oldState, oldFactor, reinterpret_cast<UINT*>( &oldMask ) );\r
  99                 if( oldState != NULL )\r
 100                         oldState->Release();\r
 101                 \r
 102                 if( value == nullptr )\r
 103                         m_Device->OMSetBlendState( 0, oldFactor, oldMask );\r
 104                 else \r
 105                         m_Device->OMSetBlendState( value->InternalPointer, oldFactor, oldMask );\r
 106         }\r
 107         \r
 108         SlimDX::Direct3D10::BlendState^ OutputMergerWrapper::BlendState::get()\r
 109         {\r
 110                 ID3D10BlendState* oldState = 0;\r
 111                 float oldFactor[4];\r
 112                 int oldMask = 0;\r
 113                 m_Device->OMGetBlendState( &oldState, oldFactor, reinterpret_cast<UINT*>( &oldMask ) );\r
 114                 \r
 115                 return SlimDX::Direct3D10::BlendState::FromPointer( oldState );\r
 116         }\r
 117         \r
 118         void OutputMergerWrapper::BlendFactor::set( Color4 value )\r
 119         {\r
 120                 ID3D10BlendState* oldState = 0;\r
 121                 float oldFactor[4];\r
 122                 int oldMask = 0;\r
 123                 m_Device->OMGetBlendState( &oldState, oldFactor, reinterpret_cast<UINT*>( &oldMask ) );\r
 124                 \r
 125                 float newFactor[4] = { value.Red, value.Green, value.Blue, value.Alpha };\r
 126                 m_Device->OMSetBlendState( oldState, newFactor, oldMask );\r
 127                 if( oldState != NULL )\r
 128                         oldState->Release();\r
 129         }\r
 130         \r
 131         Color4 OutputMergerWrapper::BlendFactor::get()\r
 132         {\r
 133                 ID3D10BlendState* oldState = 0;\r
 134                 float oldFactor[4];\r
 135                 int oldMask = 0;\r
 136                 m_Device->OMGetBlendState( &oldState, oldFactor, reinterpret_cast<UINT*>( &oldMask ) );\r
 137                 if( oldState != NULL )\r
 138                         oldState->Release();\r
 139                 \r
 140                 return Color4( oldFactor[3], oldFactor[0], oldFactor[1], oldFactor[2] );\r
 141         }\r
 142         \r
 143         void OutputMergerWrapper::BlendSampleMask::set( int value )\r
 144         {\r
 145                 ID3D10BlendState* oldState = 0;\r
 146                 float oldFactor[4];\r
 147                 int oldMask = 0;\r
 148                 m_Device->OMGetBlendState( &oldState, oldFactor, reinterpret_cast<UINT*>( &oldMask ) );\r
 149         \r
 150                 m_Device->OMSetBlendState( oldState, oldFactor, value );\r
 151                 if( oldState != NULL )\r
 152                         oldState->Release();\r
 153         }\r
 154         \r
 155         int OutputMergerWrapper::BlendSampleMask::get()\r
 156         {\r
 157                 ID3D10BlendState* oldState = 0;\r
 158                 float oldFactor[4];\r
 159                 int oldMask = 0;\r
 160                 m_Device->OMGetBlendState( &oldState, oldFactor, reinterpret_cast<UINT*>( &oldMask ) );\r
 161                 if( oldState != NULL )\r
 162                         oldState->Release();\r
 163                 \r
 164                 return oldMask;\r
 165         }\r
 166         \r
 167         void OutputMergerWrapper::SetTargets( RenderTargetView^ renderTargetView )\r
 168         {\r
 169                 SetTargets( nullptr, renderTargetView );\r
 170         }\r
 171         \r
 172         void OutputMergerWrapper::SetTargets( DepthStencilView^ depthStencilView, RenderTargetView^ renderTargetView )\r
 173         {\r
 174                 ID3D10DepthStencilView *nativeDSV = depthStencilView == nullptr ? 0 : static_cast<ID3D10DepthStencilView*>( depthStencilView->InternalPointer );\r
 175                 ID3D10RenderTargetView *nativeRTV[] = { renderTargetView == nullptr ? 0 : static_cast<ID3D10RenderTargetView*>( renderTargetView->InternalPointer ) };\r
 176                 \r
 177                 m_Device->OMSetRenderTargets( 1, nativeRTV, nativeDSV );\r
 178         }\r
 179 \r
 180         void OutputMergerWrapper::SetTargets( ... array<RenderTargetView^>^ renderTargets )\r
 181         {\r
 182                 SetTargets( nullptr, renderTargets );\r
 183         }\r
 184 \r
 185         void OutputMergerWrapper::SetTargets( DepthStencilView^ depthStencilView, ... array<RenderTargetView^>^ renderTargets )\r
 186         {\r
 187                 ID3D10DepthStencilView *nativeDSV = depthStencilView == nullptr ? 0 : static_cast<ID3D10DepthStencilView*>( depthStencilView->InternalPointer );\r
 188                 ID3D10RenderTargetView* nativeRTVs[D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT];\r
 189                 \r
 190                 if( renderTargets == nullptr )\r
 191                 {\r
 192                         m_Device->OMSetRenderTargets( 0, 0, nativeDSV );\r
 193                 }\r
 194                 else \r
 195                 {\r
 196                         for( int i = 0; i < renderTargets->Length; ++i )\r
 197                                 nativeRTVs[ i ] = renderTargets[ i ] == nullptr ? 0 : static_cast<ID3D10RenderTargetView*>( renderTargets[ i ]->InternalPointer );\r
 198                         m_Device->OMSetRenderTargets( renderTargets->Length, nativeRTVs, nativeDSV );\r
 199                 }\r
 200         }\r
 201         \r
 202         DepthStencilView^ OutputMergerWrapper::GetDepthStencilView()\r
 203         {\r
 204                 ID3D10DepthStencilView *view;\r
 205 \r
 206                 m_Device->OMGetRenderTargets( 0, 0, &view );\r
 207                 return DepthStencilView::FromPointer( view );\r
 208         }\r
 209 \r
 210         array<RenderTargetView^>^ OutputMergerWrapper::GetRenderTargets( int count )\r
 211         {\r
 212                 stack_array<ID3D10RenderTargetView*> targets = stackalloc( ID3D10RenderTargetView*, count );\r
 213                 array<RenderTargetView^>^ results = gcnew array<RenderTargetView^>( count );\r
 214 \r
 215                 m_Device->OMGetRenderTargets( count, &targets[0], 0 );\r
 216 \r
 217                 for( int i = 0; i < count; i++ )\r
 218                         results[i] = RenderTargetView::FromPointer( targets[i] );\r
 219 \r
 220                 return results;\r
 221         }\r
 222 }\r
 223 }\r