110401(DTXMania089)/SlimDXc_Jun2010(VC++2008)/source/direct3d11/OutputMergerWrapper11.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 <d3d11.h>\r
  25 #include <d3dx11.h>\r
  26 \r
  27 #include "../stack_array.h"\r
  28 \r
  29 #include "BlendState11.h"\r
  30 #include "DepthStencilState11.h"\r
  31 #include "DepthStencilView11.h"\r
  32 #include "OutputMergerWrapper11.h"\r
  33 #include "RenderTargetView11.h"\r
  34 #include "UnorderedAccessView11.h"\r
  35 \r
  36 using namespace System;\r
  37 \r
  38 namespace SlimDX\r
  39 {\r
  40 namespace Direct3D11\r
  41 { \r
  42         OutputMergerWrapper::OutputMergerWrapper( ID3D11DeviceContext* device )\r
  43         {\r
  44                 if( device == 0 )\r
  45                         throw gcnew ArgumentNullException( "device" );\r
  46                 deviceContext = device;\r
  47         }\r
  48         \r
  49         void OutputMergerWrapper::DepthStencilState::set( SlimDX::Direct3D11::DepthStencilState^ value )\r
  50         {\r
  51                 ID3D11DepthStencilState* oldState;\r
  52                 int oldReference;\r
  53                 deviceContext->OMGetDepthStencilState( &oldState, reinterpret_cast<UINT*>( &oldReference ) );\r
  54 \r
  55                 if( oldState != NULL )\r
  56                         oldState->Release();\r
  57         \r
  58                 if( value == nullptr )\r
  59                         deviceContext->OMSetDepthStencilState( 0, oldReference );\r
  60                 else\r
  61                         deviceContext->OMSetDepthStencilState( value->InternalPointer, oldReference );\r
  62         }\r
  63         \r
  64         SlimDX::Direct3D11::DepthStencilState^ OutputMergerWrapper::DepthStencilState::get()\r
  65         {\r
  66                 ID3D11DepthStencilState* oldState = 0;\r
  67                 int oldReference = 0;\r
  68                 deviceContext->OMGetDepthStencilState( &oldState, reinterpret_cast<UINT*>( &oldReference ) );\r
  69                 \r
  70                 if( oldState == NULL )\r
  71                         return nullptr;\r
  72                 return SlimDX::Direct3D11::DepthStencilState::FromPointer( oldState );\r
  73         }\r
  74         \r
  75         void OutputMergerWrapper::DepthStencilReference::set( int value )\r
  76         {\r
  77                 ID3D11DepthStencilState* oldState = 0;\r
  78                 int oldReference = 0;\r
  79                 deviceContext->OMGetDepthStencilState( &oldState, reinterpret_cast<UINT*>( &oldReference ) );\r
  80                 deviceContext->OMSetDepthStencilState( oldState, value );\r
  81 \r
  82                 if( oldState != NULL )\r
  83                         oldState->Release();\r
  84         }\r
  85         \r
  86         int OutputMergerWrapper::DepthStencilReference::get()\r
  87         {\r
  88                 ID3D11DepthStencilState* oldState = 0;\r
  89                 int oldReference = 0;\r
  90                 deviceContext->OMGetDepthStencilState( &oldState, reinterpret_cast<UINT*>( &oldReference ) );\r
  91 \r
  92                 if( oldState != NULL )\r
  93                         oldState->Release();\r
  94                 \r
  95                 return oldReference;\r
  96         }\r
  97         \r
  98         void OutputMergerWrapper::BlendState::set( SlimDX::Direct3D11::BlendState^ value )\r
  99         {\r
 100                 ID3D11BlendState* oldState = 0;\r
 101                 float oldFactor[4];\r
 102                 int oldMask = 0;\r
 103                 deviceContext->OMGetBlendState( &oldState, oldFactor, reinterpret_cast<UINT*>( &oldMask ) );\r
 104 \r
 105                 if( oldState != NULL )\r
 106                         oldState->Release();\r
 107                 \r
 108                 if( value == nullptr )\r
 109                         deviceContext->OMSetBlendState( 0, oldFactor, oldMask );\r
 110                 else\r
 111                         deviceContext->OMSetBlendState( value->InternalPointer, oldFactor, oldMask );\r
 112         }\r
 113         \r
 114         SlimDX::Direct3D11::BlendState^ OutputMergerWrapper::BlendState::get()\r
 115         {\r
 116                 ID3D11BlendState* oldState = 0;\r
 117                 float oldFactor[4];\r
 118                 int oldMask = 0;\r
 119                 deviceContext->OMGetBlendState( &oldState, oldFactor, reinterpret_cast<UINT*>( &oldMask ) );\r
 120                 \r
 121                 return SlimDX::Direct3D11::BlendState::FromPointer( oldState );\r
 122         }\r
 123         \r
 124         void OutputMergerWrapper::BlendFactor::set( Color4 value )\r
 125         {\r
 126                 ID3D11BlendState* oldState = 0;\r
 127                 float oldFactor[4];\r
 128                 int oldMask = 0;\r
 129                 deviceContext->OMGetBlendState( &oldState, oldFactor, reinterpret_cast<UINT*>( &oldMask ) );\r
 130                 \r
 131                 float newFactor[4] = { value.Red, value.Green, value.Blue, value.Alpha };\r
 132                 deviceContext->OMSetBlendState( oldState, newFactor, oldMask );\r
 133 \r
 134                 if( oldState != NULL )\r
 135                         oldState->Release();\r
 136         }\r
 137         \r
 138         Color4 OutputMergerWrapper::BlendFactor::get()\r
 139         {\r
 140                 ID3D11BlendState* oldState = 0;\r
 141                 float oldFactor[4];\r
 142                 int oldMask = 0;\r
 143                 deviceContext->OMGetBlendState( &oldState, oldFactor, reinterpret_cast<UINT*>( &oldMask ) );\r
 144 \r
 145                 if( oldState != NULL )\r
 146                         oldState->Release();\r
 147                 \r
 148                 return Color4( oldFactor[3], oldFactor[0], oldFactor[1], oldFactor[2] );\r
 149         }\r
 150         \r
 151         void OutputMergerWrapper::BlendSampleMask::set( int value )\r
 152         {\r
 153                 ID3D11BlendState* oldState = 0;\r
 154                 float oldFactor[4];\r
 155                 int oldMask = 0;\r
 156                 deviceContext->OMGetBlendState( &oldState, oldFactor, reinterpret_cast<UINT*>( &oldMask ) );\r
 157                 deviceContext->OMSetBlendState( oldState, oldFactor, value );\r
 158 \r
 159                 if( oldState != NULL )\r
 160                         oldState->Release();\r
 161         }\r
 162         \r
 163         int OutputMergerWrapper::BlendSampleMask::get()\r
 164         {\r
 165                 ID3D11BlendState* oldState = 0;\r
 166                 float oldFactor[4];\r
 167                 int oldMask = 0;\r
 168                 deviceContext->OMGetBlendState( &oldState, oldFactor, reinterpret_cast<UINT*>( &oldMask ) );\r
 169 \r
 170                 if( oldState != NULL )\r
 171                         oldState->Release();\r
 172                 \r
 173                 return oldMask;\r
 174         }\r
 175         \r
 176         void OutputMergerWrapper::SetTargets( RenderTargetView^ renderTargetView )\r
 177         {\r
 178                 SetTargets( nullptr, renderTargetView );\r
 179         }\r
 180         \r
 181         void OutputMergerWrapper::SetTargets( DepthStencilView^ depthStencilView, RenderTargetView^ renderTargetView )\r
 182         {\r
 183                 ID3D11DepthStencilView *nativeDSV = depthStencilView == nullptr ? 0 : static_cast<ID3D11DepthStencilView*>( depthStencilView->InternalPointer );\r
 184                 ID3D11RenderTargetView *nativeRTV[] = { renderTargetView == nullptr ? 0 : static_cast<ID3D11RenderTargetView*>( renderTargetView->InternalPointer ) };\r
 185                 \r
 186                 deviceContext->OMSetRenderTargets( 1, nativeRTV, nativeDSV );\r
 187         }\r
 188 \r
 189         void OutputMergerWrapper::SetTargets( ... array<RenderTargetView^>^ renderTargets )\r
 190         {\r
 191                 SetTargets( nullptr, renderTargets );\r
 192         }\r
 193 \r
 194         void OutputMergerWrapper::SetTargets( DepthStencilView^ depthStencilView, ... array<RenderTargetView^>^ renderTargets )\r
 195         {\r
 196                 ID3D11DepthStencilView *nativeDSV = depthStencilView == nullptr ? 0 : static_cast<ID3D11DepthStencilView*>( depthStencilView->InternalPointer );\r
 197                 ID3D11RenderTargetView* nativeRTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT];\r
 198                 \r
 199                 if( renderTargets == nullptr )\r
 200                 {\r
 201                         deviceContext->OMSetRenderTargets( 0, 0, nativeDSV );\r
 202                 }\r
 203                 else \r
 204                 {\r
 205                         for( int i = 0; i < renderTargets->Length; ++i )\r
 206                                 nativeRTVs[ i ] = renderTargets[ i ] == nullptr ? 0 : static_cast<ID3D11RenderTargetView*>( renderTargets[ i ]->InternalPointer );\r
 207                         deviceContext->OMSetRenderTargets( renderTargets->Length, nativeRTVs, nativeDSV );\r
 208                 }\r
 209         }\r
 210 \r
 211         void OutputMergerWrapper::SetTargets( RenderTargetView^ renderTargetView, int startSlot, array<UnorderedAccessView^>^ unorderedAccessViews )\r
 212         {\r
 213                 array<int>^ lengths = gcnew array<int>( unorderedAccessViews->Length );\r
 214                 for( int i = 0; i < unorderedAccessViews->Length; i++ )\r
 215                         lengths[i] = -1;\r
 216 \r
 217                 SetTargets( nullptr, renderTargetView, startSlot, unorderedAccessViews, lengths );\r
 218         }\r
 219         \r
 220         void OutputMergerWrapper::SetTargets( DepthStencilView^ depthStencilView, RenderTargetView^ renderTargetView, int startSlot, array<UnorderedAccessView^>^ unorderedAccessViews )\r
 221         {\r
 222                 array<int>^ lengths = gcnew array<int>( unorderedAccessViews->Length );\r
 223                 for( int i = 0; i < unorderedAccessViews->Length; i++ )\r
 224                         lengths[i] = -1;\r
 225 \r
 226                 SetTargets( depthStencilView, renderTargetView, startSlot, unorderedAccessViews, lengths );\r
 227         }\r
 228 \r
 229         void OutputMergerWrapper::SetTargets( int startSlot, array<UnorderedAccessView^>^ unorderedAccessViews, ... array<RenderTargetView^>^ renderTargets )\r
 230         {\r
 231                 array<int>^ lengths = gcnew array<int>( unorderedAccessViews->Length );\r
 232                 for( int i = 0; i < unorderedAccessViews->Length; i++ )\r
 233                         lengths[i] = -1;\r
 234 \r
 235                 SetTargets( nullptr, startSlot, unorderedAccessViews, lengths, renderTargets );\r
 236         }\r
 237 \r
 238         void OutputMergerWrapper::SetTargets( DepthStencilView^ depthStencilView, int startSlot, array<UnorderedAccessView^>^ unorderedAccessViews, ... array<RenderTargetView^>^ renderTargets )\r
 239         {\r
 240                 array<int>^ lengths = gcnew array<int>( unorderedAccessViews->Length );\r
 241                 for( int i = 0; i < unorderedAccessViews->Length; i++ )\r
 242                         lengths[i] = -1;\r
 243 \r
 244                 SetTargets( depthStencilView, startSlot, unorderedAccessViews, lengths, renderTargets );\r
 245         }\r
 246 \r
 247         void OutputMergerWrapper::SetTargets( RenderTargetView^ renderTargetView, int startSlot, array<UnorderedAccessView^>^ unorderedAccessViews, array<int>^ lengths )\r
 248         {\r
 249                 SetTargets( nullptr, renderTargetView, startSlot, unorderedAccessViews, lengths );\r
 250         }\r
 251         \r
 252         void OutputMergerWrapper::SetTargets( DepthStencilView^ depthStencilView, RenderTargetView^ renderTargetView, int startSlot, array<UnorderedAccessView^>^ unorderedAccessViews, array<int>^ initialLengths )\r
 253         {\r
 254                 ID3D11DepthStencilView *nativeDSV = depthStencilView == nullptr ? 0 : static_cast<ID3D11DepthStencilView*>( depthStencilView->InternalPointer );\r
 255                 ID3D11RenderTargetView *nativeRTV[] = { renderTargetView == nullptr ? 0 : static_cast<ID3D11RenderTargetView*>( renderTargetView->InternalPointer ) };\r
 256 \r
 257                 stack_array<ID3D11UnorderedAccessView*> uavs = stackalloc( ID3D11UnorderedAccessView*, unorderedAccessViews->Length );\r
 258                 for( int i = 0; i < unorderedAccessViews->Length; i++ )\r
 259                         uavs[i] = unorderedAccessViews[i]->InternalPointer;\r
 260 \r
 261                 pin_ptr<int> pinnedLengths = &initialLengths[0];\r
 262                 deviceContext->OMSetRenderTargetsAndUnorderedAccessViews( 1, nativeRTV, nativeDSV, startSlot, unorderedAccessViews->Length, &uavs[0], reinterpret_cast<UINT*>( pinnedLengths ) );\r
 263         }\r
 264 \r
 265         void OutputMergerWrapper::SetTargets( int startSlot, array<UnorderedAccessView^>^ unorderedAccessViews, array<int>^ initialLengths, ... array<RenderTargetView^>^ renderTargets )\r
 266         {\r
 267                 SetTargets( nullptr, startSlot, unorderedAccessViews, initialLengths, renderTargets );\r
 268         }\r
 269 \r
 270         void OutputMergerWrapper::SetTargets( DepthStencilView^ depthStencilView, int startSlot, array<UnorderedAccessView^>^ unorderedAccessViews, array<int>^ initialLengths, ... array<RenderTargetView^>^ renderTargets )\r
 271         {\r
 272                 ID3D11DepthStencilView *nativeDSV = depthStencilView == nullptr ? 0 : static_cast<ID3D11DepthStencilView*>( depthStencilView->InternalPointer );\r
 273                 ID3D11RenderTargetView* nativeRTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT];\r
 274 \r
 275                 stack_array<ID3D11UnorderedAccessView*> uavs = stackalloc( ID3D11UnorderedAccessView*, unorderedAccessViews->Length );\r
 276                 for( int i = 0; i < unorderedAccessViews->Length; i++ )\r
 277                         uavs[i] = unorderedAccessViews[i]->InternalPointer;\r
 278 \r
 279                 pin_ptr<int> pinnedLengths = &initialLengths[0];\r
 280                 if( renderTargets == nullptr )\r
 281                 {\r
 282                         deviceContext->OMSetRenderTargetsAndUnorderedAccessViews( 0, 0, nativeDSV, startSlot, unorderedAccessViews->Length, &uavs[0], reinterpret_cast<UINT*>( pinnedLengths ) );\r
 283                 }\r
 284                 else \r
 285                 {\r
 286                         for( int i = 0; i < renderTargets->Length; ++i )\r
 287                                 nativeRTVs[ i ] = renderTargets[ i ] == nullptr ? 0 : static_cast<ID3D11RenderTargetView*>( renderTargets[ i ]->InternalPointer );\r
 288                         deviceContext->OMSetRenderTargetsAndUnorderedAccessViews( renderTargets->Length, nativeRTVs, nativeDSV, startSlot, unorderedAccessViews->Length, &uavs[0], reinterpret_cast<UINT*>( pinnedLengths ) );\r
 289                 }\r
 290         }\r
 291 \r
 292         DepthStencilView^ OutputMergerWrapper::GetDepthStencilView()\r
 293         {\r
 294                 ID3D11DepthStencilView *view;\r
 295 \r
 296                 deviceContext->OMGetRenderTargets( 0, NULL, &view );\r
 297                 return DepthStencilView::FromPointer( view );\r
 298         }\r
 299 \r
 300         array<RenderTargetView^>^ OutputMergerWrapper::GetRenderTargets( int count )\r
 301         {\r
 302                 stack_array<ID3D11RenderTargetView*> targets = stackalloc( ID3D11RenderTargetView*, count );\r
 303                 array<RenderTargetView^>^ results = gcnew array<RenderTargetView^>( count );\r
 304 \r
 305                 deviceContext->OMGetRenderTargets( count, &targets[0], NULL );\r
 306 \r
 307                 for( int i = 0; i < count; i++ )\r
 308                         results[i] = RenderTargetView::FromPointer( targets[i] );\r
 309 \r
 310                 return results;\r
 311         }\r
 312 \r
 313         array<UnorderedAccessView^>^ OutputMergerWrapper::GetUnorderedAccessViews( int startSlot, int count )\r
 314         {\r
 315                 stack_array<ID3D11UnorderedAccessView*> targets = stackalloc( ID3D11UnorderedAccessView*, count );\r
 316                 array<UnorderedAccessView^>^ results = gcnew array<UnorderedAccessView^>( count );\r
 317 \r
 318                 deviceContext->OMGetRenderTargetsAndUnorderedAccessViews( 0, NULL, NULL, startSlot, count, &targets[0] );\r
 319 \r
 320                 for( int i = 0; i < count; i++ )\r
 321                         results[i] = UnorderedAccessView::FromPointer( targets[i] );\r
 322 \r
 323                 return results;\r
 324         }\r
 325 }\r
 326 }\r