SlimDXc_Jun2010(VC++2008)/source/direct3d11/OutputMergerWrapper11.cpp

   1 #include "stdafx.h"
   2 /*
   3 * Copyright (c) 2007-2010 SlimDX Group
   4 *
   5 * Permission is hereby granted, free of charge, to any person obtaining a copy
   6 * of this software and associated documentation files (the "Software"), to deal
   7 * in the Software without restriction, including without limitation the rights
   8 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9 * copies of the Software, and to permit persons to whom the Software is
  10 * furnished to do so, subject to the following conditions:
  11 *
  12 * The above copyright notice and this permission notice shall be included in
  13 * all copies or substantial portions of the Software.
  14 *
  15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  21 * THE SOFTWARE.
  22 */
  23
  24 #include <d3d11.h>
  25 #include <d3dx11.h>
  26
  27 #include "../stack_array.h"
  28
  29 #include "BlendState11.h"
  30 #include "DepthStencilState11.h"
  31 #include "DepthStencilView11.h"
  32 #include "OutputMergerWrapper11.h"
  33 #include "RenderTargetView11.h"
  34 #include "UnorderedAccessView11.h"
  35
  36 using namespace System;
  37
  38 namespace SlimDX
  39 {
  40 namespace Direct3D11
  41 {
  42         OutputMergerWrapper::OutputMergerWrapper( ID3D11DeviceContext* device )
  43         {
  44                 if( device == 0 )
  45                         throw gcnew ArgumentNullException( "device" );
  46                 deviceContext = device;
  47         }
  48
  49         void OutputMergerWrapper::DepthStencilState::set( SlimDX::Direct3D11::DepthStencilState^ value )
  50         {
  51                 ID3D11DepthStencilState* oldState;
  52                 int oldReference;
  53                 deviceContext->OMGetDepthStencilState( &oldState, reinterpret_cast<UINT*>( &oldReference ) );
  54
  55                 if( oldState != NULL )
  56                         oldState->Release();
  57
  58                 if( value == nullptr )
  59                         deviceContext->OMSetDepthStencilState( 0, oldReference );
  60                 else
  61                         deviceContext->OMSetDepthStencilState( value->InternalPointer, oldReference );
  62         }
  63
  64         SlimDX::Direct3D11::DepthStencilState^ OutputMergerWrapper::DepthStencilState::get()
  65         {
  66                 ID3D11DepthStencilState* oldState = 0;
  67                 int oldReference = 0;
  68                 deviceContext->OMGetDepthStencilState( &oldState, reinterpret_cast<UINT*>( &oldReference ) );
  69
  70                 if( oldState == NULL )
  71                         return nullptr;
  72                 return SlimDX::Direct3D11::DepthStencilState::FromPointer( oldState );
  73         }
  74
  75         void OutputMergerWrapper::DepthStencilReference::set( int value )
  76         {
  77                 ID3D11DepthStencilState* oldState = 0;
  78                 int oldReference = 0;
  79                 deviceContext->OMGetDepthStencilState( &oldState, reinterpret_cast<UINT*>( &oldReference ) );
  80                 deviceContext->OMSetDepthStencilState( oldState, value );
  81
  82                 if( oldState != NULL )
  83                         oldState->Release();
  84         }
  85
  86         int OutputMergerWrapper::DepthStencilReference::get()
  87         {
  88                 ID3D11DepthStencilState* oldState = 0;
  89                 int oldReference = 0;
  90                 deviceContext->OMGetDepthStencilState( &oldState, reinterpret_cast<UINT*>( &oldReference ) );
  91
  92                 if( oldState != NULL )
  93                         oldState->Release();
  94
  95                 return oldReference;
  96         }
  97
  98         void OutputMergerWrapper::BlendState::set( SlimDX::Direct3D11::BlendState^ value )
  99         {
 100                 ID3D11BlendState* oldState = 0;
 101                 float oldFactor[4];
 102                 int oldMask = 0;
 103                 deviceContext->OMGetBlendState( &oldState, oldFactor, reinterpret_cast<UINT*>( &oldMask ) );
 104
 105                 if( oldState != NULL )
 106                         oldState->Release();
 107
 108                 if( value == nullptr )
 109                         deviceContext->OMSetBlendState( 0, oldFactor, oldMask );
 110                 else
 111                         deviceContext->OMSetBlendState( value->InternalPointer, oldFactor, oldMask );
 112         }
 113
 114         SlimDX::Direct3D11::BlendState^ OutputMergerWrapper::BlendState::get()
 115         {
 116                 ID3D11BlendState* oldState = 0;
 117                 float oldFactor[4];
 118                 int oldMask = 0;
 119                 deviceContext->OMGetBlendState( &oldState, oldFactor, reinterpret_cast<UINT*>( &oldMask ) );
 120
 121                 return SlimDX::Direct3D11::BlendState::FromPointer( oldState );
 122         }
 123
 124         void OutputMergerWrapper::BlendFactor::set( Color4 value )
 125         {
 126                 ID3D11BlendState* oldState = 0;
 127                 float oldFactor[4];
 128                 int oldMask = 0;
 129                 deviceContext->OMGetBlendState( &oldState, oldFactor, reinterpret_cast<UINT*>( &oldMask ) );
 130
 131                 float newFactor[4] = { value.Red, value.Green, value.Blue, value.Alpha };
 132                 deviceContext->OMSetBlendState( oldState, newFactor, oldMask );
 133
 134                 if( oldState != NULL )
 135                         oldState->Release();
 136         }
 137
 138         Color4 OutputMergerWrapper::BlendFactor::get()
 139         {
 140                 ID3D11BlendState* oldState = 0;
 141                 float oldFactor[4];
 142                 int oldMask = 0;
 143                 deviceContext->OMGetBlendState( &oldState, oldFactor, reinterpret_cast<UINT*>( &oldMask ) );
 144
 145                 if( oldState != NULL )
 146                         oldState->Release();
 147
 148                 return Color4( oldFactor[3], oldFactor[0], oldFactor[1], oldFactor[2] );
 149         }
 150
 151         void OutputMergerWrapper::BlendSampleMask::set( int value )
 152         {
 153                 ID3D11BlendState* oldState = 0;
 154                 float oldFactor[4];
 155                 int oldMask = 0;
 156                 deviceContext->OMGetBlendState( &oldState, oldFactor, reinterpret_cast<UINT*>( &oldMask ) );
 157                 deviceContext->OMSetBlendState( oldState, oldFactor, value );
 158
 159                 if( oldState != NULL )
 160                         oldState->Release();
 161         }
 162
 163         int OutputMergerWrapper::BlendSampleMask::get()
 164         {
 165                 ID3D11BlendState* oldState = 0;
 166                 float oldFactor[4];
 167                 int oldMask = 0;
 168                 deviceContext->OMGetBlendState( &oldState, oldFactor, reinterpret_cast<UINT*>( &oldMask ) );
 169
 170                 if( oldState != NULL )
 171                         oldState->Release();
 172
 173                 return oldMask;
 174         }
 175
 176         void OutputMergerWrapper::SetTargets( RenderTargetView^ renderTargetView )
 177         {
 178                 SetTargets( nullptr, renderTargetView );
 179         }
 180
 181         void OutputMergerWrapper::SetTargets( DepthStencilView^ depthStencilView, RenderTargetView^ renderTargetView )
 182         {
 183                 ID3D11DepthStencilView *nativeDSV = depthStencilView == nullptr ? 0 : static_cast<ID3D11DepthStencilView*>( depthStencilView->InternalPointer );
 184                 ID3D11RenderTargetView *nativeRTV[] = { renderTargetView == nullptr ? 0 : static_cast<ID3D11RenderTargetView*>( renderTargetView->InternalPointer ) };
 185
 186                 deviceContext->OMSetRenderTargets( 1, nativeRTV, nativeDSV );
 187         }
 188
 189         void OutputMergerWrapper::SetTargets( ... array<RenderTargetView^>^ renderTargets )
 190         {
 191                 SetTargets( nullptr, renderTargets );
 192         }
 193
 194         void OutputMergerWrapper::SetTargets( DepthStencilView^ depthStencilView, ... array<RenderTargetView^>^ renderTargets )
 195         {
 196                 ID3D11DepthStencilView *nativeDSV = depthStencilView == nullptr ? 0 : static_cast<ID3D11DepthStencilView*>( depthStencilView->InternalPointer );
 197                 ID3D11RenderTargetView* nativeRTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT];
 198
 199                 if( renderTargets == nullptr )
 200                 {
 201                         deviceContext->OMSetRenderTargets( 0, 0, nativeDSV );
 202                 }
 203                 else
 204                 {
 205                         for( int i = 0; i < renderTargets->Length; ++i )
 206                                 nativeRTVs[ i ] = renderTargets[ i ] == nullptr ? 0 : static_cast<ID3D11RenderTargetView*>( renderTargets[ i ]->InternalPointer );
 207                         deviceContext->OMSetRenderTargets( renderTargets->Length, nativeRTVs, nativeDSV );
 208                 }
 209         }
 210
 211         void OutputMergerWrapper::SetTargets( RenderTargetView^ renderTargetView, int startSlot, array<UnorderedAccessView^>^ unorderedAccessViews )
 212         {
 213                 array<int>^ lengths = gcnew array<int>( unorderedAccessViews->Length );
 214                 for( int i = 0; i < unorderedAccessViews->Length; i++ )
 215                         lengths[i] = -1;
 216
 217                 SetTargets( nullptr, renderTargetView, startSlot, unorderedAccessViews, lengths );
 218         }
 219
 220         void OutputMergerWrapper::SetTargets( DepthStencilView^ depthStencilView, RenderTargetView^ renderTargetView, int startSlot, array<UnorderedAccessView^>^ unorderedAccessViews )
 221         {
 222                 array<int>^ lengths = gcnew array<int>( unorderedAccessViews->Length );
 223                 for( int i = 0; i < unorderedAccessViews->Length; i++ )
 224                         lengths[i] = -1;
 225
 226                 SetTargets( depthStencilView, renderTargetView, startSlot, unorderedAccessViews, lengths );
 227         }
 228
 229         void OutputMergerWrapper::SetTargets( int startSlot, array<UnorderedAccessView^>^ unorderedAccessViews, ... array<RenderTargetView^>^ renderTargets )
 230         {
 231                 array<int>^ lengths = gcnew array<int>( unorderedAccessViews->Length );
 232                 for( int i = 0; i < unorderedAccessViews->Length; i++ )
 233                         lengths[i] = -1;
 234
 235                 SetTargets( nullptr, startSlot, unorderedAccessViews, lengths, renderTargets );
 236         }
 237
 238         void OutputMergerWrapper::SetTargets( DepthStencilView^ depthStencilView, int startSlot, array<UnorderedAccessView^>^ unorderedAccessViews, ... array<RenderTargetView^>^ renderTargets )
 239         {
 240                 array<int>^ lengths = gcnew array<int>( unorderedAccessViews->Length );
 241                 for( int i = 0; i < unorderedAccessViews->Length; i++ )
 242                         lengths[i] = -1;
 243
 244                 SetTargets( depthStencilView, startSlot, unorderedAccessViews, lengths, renderTargets );
 245         }
 246
 247         void OutputMergerWrapper::SetTargets( RenderTargetView^ renderTargetView, int startSlot, array<UnorderedAccessView^>^ unorderedAccessViews, array<int>^ lengths )
 248         {
 249                 SetTargets( nullptr, renderTargetView, startSlot, unorderedAccessViews, lengths );
 250         }
 251
 252         void OutputMergerWrapper::SetTargets( DepthStencilView^ depthStencilView, RenderTargetView^ renderTargetView, int startSlot, array<UnorderedAccessView^>^ unorderedAccessViews, array<int>^ initialLengths )
 253         {
 254                 ID3D11DepthStencilView *nativeDSV = depthStencilView == nullptr ? 0 : static_cast<ID3D11DepthStencilView*>( depthStencilView->InternalPointer );
 255                 ID3D11RenderTargetView *nativeRTV[] = { renderTargetView == nullptr ? 0 : static_cast<ID3D11RenderTargetView*>( renderTargetView->InternalPointer ) };
 256
 257                 stack_array<ID3D11UnorderedAccessView*> uavs = stackalloc( ID3D11UnorderedAccessView*, unorderedAccessViews->Length );
 258                 for( int i = 0; i < unorderedAccessViews->Length; i++ )
 259                         uavs[i] = unorderedAccessViews[i]->InternalPointer;
 260
 261                 pin_ptr<int> pinnedLengths = &initialLengths[0];
 262                 deviceContext->OMSetRenderTargetsAndUnorderedAccessViews( 1, nativeRTV, nativeDSV, startSlot, unorderedAccessViews->Length, &uavs[0], reinterpret_cast<UINT*>( pinnedLengths ) );
 263         }
 264
 265         void OutputMergerWrapper::SetTargets( int startSlot, array<UnorderedAccessView^>^ unorderedAccessViews, array<int>^ initialLengths, ... array<RenderTargetView^>^ renderTargets )
 266         {
 267                 SetTargets( nullptr, startSlot, unorderedAccessViews, initialLengths, renderTargets );
 268         }
 269
 270         void OutputMergerWrapper::SetTargets( DepthStencilView^ depthStencilView, int startSlot, array<UnorderedAccessView^>^ unorderedAccessViews, array<int>^ initialLengths, ... array<RenderTargetView^>^ renderTargets )
 271         {
 272                 ID3D11DepthStencilView *nativeDSV = depthStencilView == nullptr ? 0 : static_cast<ID3D11DepthStencilView*>( depthStencilView->InternalPointer );
 273                 ID3D11RenderTargetView* nativeRTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT];
 274
 275                 stack_array<ID3D11UnorderedAccessView*> uavs = stackalloc( ID3D11UnorderedAccessView*, unorderedAccessViews->Length );
 276                 for( int i = 0; i < unorderedAccessViews->Length; i++ )
 277                         uavs[i] = unorderedAccessViews[i]->InternalPointer;
 278
 279                 pin_ptr<int> pinnedLengths = &initialLengths[0];
 280                 if( renderTargets == nullptr )
 281                 {
 282                         deviceContext->OMSetRenderTargetsAndUnorderedAccessViews( 0, 0, nativeDSV, startSlot, unorderedAccessViews->Length, &uavs[0], reinterpret_cast<UINT*>( pinnedLengths ) );
 283                 }
 284                 else
 285                 {
 286                         for( int i = 0; i < renderTargets->Length; ++i )
 287                                 nativeRTVs[ i ] = renderTargets[ i ] == nullptr ? 0 : static_cast<ID3D11RenderTargetView*>( renderTargets[ i ]->InternalPointer );
 288                         deviceContext->OMSetRenderTargetsAndUnorderedAccessViews( renderTargets->Length, nativeRTVs, nativeDSV, startSlot, unorderedAccessViews->Length, &uavs[0], reinterpret_cast<UINT*>( pinnedLengths ) );
 289                 }
 290         }
 291
 292         DepthStencilView^ OutputMergerWrapper::GetDepthStencilView()
 293         {
 294                 ID3D11DepthStencilView *view;
 295
 296                 deviceContext->OMGetRenderTargets( 0, NULL, &view );
 297                 return DepthStencilView::FromPointer( view );
 298         }
 299
 300         array<RenderTargetView^>^ OutputMergerWrapper::GetRenderTargets( int count )
 301         {
 302                 stack_array<ID3D11RenderTargetView*> targets = stackalloc( ID3D11RenderTargetView*, count );
 303                 array<RenderTargetView^>^ results = gcnew array<RenderTargetView^>( count );
 304
 305                 deviceContext->OMGetRenderTargets( count, &targets[0], NULL );
 306
 307                 for( int i = 0; i < count; i++ )
 308                         results[i] = RenderTargetView::FromPointer( targets[i] );
 309
 310                 return results;
 311         }
 312
 313         array<UnorderedAccessView^>^ OutputMergerWrapper::GetUnorderedAccessViews( int startSlot, int count )
 314         {
 315                 stack_array<ID3D11UnorderedAccessView*> targets = stackalloc( ID3D11UnorderedAccessView*, count );
 316                 array<UnorderedAccessView^>^ results = gcnew array<UnorderedAccessView^>( count );
 317
 318                 deviceContext->OMGetRenderTargetsAndUnorderedAccessViews( 0, NULL, NULL, startSlot, count, &targets[0] );
 319
 320                 for( int i = 0; i < count; i++ )
 321                         results[i] = UnorderedAccessView::FromPointer( targets[i] );
 322
 323                 return results;
 324         }
 325 }
 326 }