110401(DTXMania089)/SlimDXc_Jun2010(VC++2008)/source/direct3d11/DeviceContext11.cpp

   1 /*\r
   2 * Copyright (c) 2007-2010 SlimDX Group\r
   3 * \r
   4 * Permission is hereby granted, free of charge, to any person obtaining a copy\r
   5 * of this software and associated documentation files (the "Software"), to deal\r
   6 * in the Software without restriction, including without limitation the rights\r
   7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r
   8 * copies of the Software, and to permit persons to whom the Software is\r
   9 * furnished to do so, subject to the following conditions:\r
  10 * \r
  11 * The above copyright notice and this permission notice shall be included in\r
  12 * all copies or substantial portions of the Software.\r
  13 * \r
  14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
  15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
  16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r
  17 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r
  18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r
  19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\r
  20 * THE SOFTWARE.\r
  21 */\r
  22 #include "stdafx.h"\r
  23 \r
  24 #include "../DataStream.h"\r
  25 \r
  26 #include "Direct3D11Exception.h"\r
  27 \r
  28 #include "Buffer11.h"\r
  29 #include "CommandList11.h"\r
  30 #include "Asynchronous11.h"\r
  31 #include "DeviceContext11.h"\r
  32 #include "InputAssemblerWrapper11.h"\r
  33 #include "OutputMergerWrapper11.h"\r
  34 #include "StreamOutputWrapper11.h"\r
  35 #include "RasterizerWrapper11.h"\r
  36 #include "VertexShaderWrapper11.h"\r
  37 #include "PixelShaderWrapper11.h"\r
  38 #include "GeometryShaderWrapper11.h"\r
  39 #include "DomainShaderWrapper11.h"\r
  40 #include "HullShaderWrapper11.h"\r
  41 #include "ComputeShaderWrapper11.h"\r
  42 #include "DepthStencilView11.h"\r
  43 #include "RenderTargetView11.h"\r
  44 #include "UnorderedAccessView11.h"\r
  45 #include "ShaderResourceView11.h"\r
  46 #include "Resource11.h"\r
  47 #include "ResourceRegion11.h"\r
  48 #include "Predicate11.h"\r
  49 #include "Device11.h"\r
  50 \r
  51 using namespace System;\r
  52 using namespace System::Runtime::InteropServices;\r
  53 \r
  54 namespace SlimDX\r
  55 {\r
  56 namespace Direct3D11\r
  57 {\r
  58         void DeviceContext::InitializeSubclasses()\r
  59         {\r
  60                 inputAssembler = gcnew InputAssemblerWrapper( InternalPointer );\r
  61                 outputMerger = gcnew OutputMergerWrapper( InternalPointer );\r
  62                 streamOutput = gcnew StreamOutputWrapper( InternalPointer );\r
  63                 rasterizer = gcnew RasterizerWrapper( InternalPointer );\r
  64                 vertexShader = gcnew VertexShaderWrapper( InternalPointer );\r
  65                 pixelShader = gcnew PixelShaderWrapper( InternalPointer );\r
  66                 geometryShader = gcnew GeometryShaderWrapper( InternalPointer );\r
  67                 domainShader = gcnew DomainShaderWrapper( InternalPointer );\r
  68                 hullShader = gcnew HullShaderWrapper( InternalPointer );\r
  69                 computeShader = gcnew ComputeShaderWrapper( InternalPointer );\r
  70         }\r
  71 \r
  72         DeviceContext::DeviceContext( ID3D11DeviceContext* pointer, ComObject^ owner )\r
  73         {\r
  74                 Construct( pointer, owner );\r
  75                 InitializeSubclasses();\r
  76         }\r
  77         \r
  78         DeviceContext::DeviceContext( IntPtr pointer )\r
  79         {\r
  80                 Construct( pointer, NativeInterface );\r
  81                 InitializeSubclasses();\r
  82         }\r
  83         \r
  84         DeviceContext^ DeviceContext::FromPointer( ID3D11DeviceContext* pointer, ComObject^ owner, ComObjectFlags flags )\r
  85         {\r
  86                 return ConstructFromPointer<DeviceContext,ID3D11DeviceContext>( pointer, owner, flags );\r
  87         }\r
  88         \r
  89         DeviceContext^ DeviceContext::FromPointer( IntPtr pointer )\r
  90         {\r
  91                 return ConstructFromUserPointer<DeviceContext>( pointer );\r
  92         }\r
  93 \r
  94         DeviceContext::DeviceContext( SlimDX::Direct3D11::Device^ device )\r
  95         {\r
  96                 ID3D11DeviceContext* context;\r
  97 \r
  98                 HRESULT hr = device->InternalPointer->CreateDeferredContext( 0, &context );\r
  99                 if( RECORD_D3D11( hr ).IsFailure )\r
 100                         throw gcnew Direct3D11Exception( Result::Last );\r
 101 \r
 102                 Construct( context );\r
 103                 InitializeSubclasses();\r
 104         }\r
 105 \r
 106         void DeviceContext::Begin( Asynchronous^ data )\r
 107         {\r
 108                 InternalPointer->Begin( data->InternalPointer );\r
 109         }\r
 110 \r
 111         void DeviceContext::ClearDepthStencilView( DepthStencilView^ view, DepthStencilClearFlags flags, float depth, Byte stencil )\r
 112         {\r
 113                 InternalPointer->ClearDepthStencilView( view->InternalPointer, static_cast<UINT>( flags ), depth, stencil );\r
 114         }\r
 115         \r
 116         void DeviceContext::ClearRenderTargetView( RenderTargetView^ view, Color4 color )\r
 117         {\r
 118                 const float nativeColor[] = { color.Red, color.Green, color.Blue, color.Alpha };\r
 119                 InternalPointer->ClearRenderTargetView( view->InternalPointer, nativeColor );\r
 120         }\r
 121         \r
 122         void DeviceContext::ClearState()\r
 123         {\r
 124                 InternalPointer->ClearState();\r
 125         }\r
 126 \r
 127         void DeviceContext::ClearUnorderedAccessView( UnorderedAccessView^ unorderedAccessView, array<int>^ values )\r
 128         {\r
 129                 if( values->Length != 4 )\r
 130                         throw gcnew ArgumentException( "Must supply exactly four clear values", "values" );\r
 131 \r
 132                 const UINT nativeValues[] = { values[0], values[1], values[2], values[3] };\r
 133                 InternalPointer->ClearUnorderedAccessViewUint( unorderedAccessView->InternalPointer, nativeValues );\r
 134         }\r
 135 \r
 136         void DeviceContext::ClearUnorderedAccessView( UnorderedAccessView^ unorderedAccessView, array<float>^ values )\r
 137         {\r
 138                 if( values->Length != 4 )\r
 139                         throw gcnew ArgumentException( "Must supply exactly four clear values", "values" );\r
 140 \r
 141                 const FLOAT nativeValues[] = { values[0], values[1], values[2], values[3] };\r
 142                 InternalPointer->ClearUnorderedAccessViewFloat( unorderedAccessView->InternalPointer, nativeValues );\r
 143         }\r
 144         \r
 145         void DeviceContext::CopyResource( Resource^ source, Resource^ destination )\r
 146         {\r
 147                 InternalPointer->CopyResource( destination->InternalPointer, source->InternalPointer );\r
 148         }\r
 149 \r
 150         void DeviceContext::CopyStructureCount( UnorderedAccessView^ unorderedAccessView, Buffer^ destinationBuffer, int destinationOffset )\r
 151         {\r
 152                 InternalPointer->CopyStructureCount( destinationBuffer->InternalPointer, destinationOffset, unorderedAccessView->InternalPointer );\r
 153         }\r
 154         \r
 155         void DeviceContext::CopySubresourceRegion( Resource^ source, int sourceSubresource, ResourceRegion region, Resource^ destination, int destinationSubresource, int x, int y, int z )\r
 156         {\r
 157                 D3D11_BOX nativeRegion = region.CreateNativeVersion();\r
 158                 InternalPointer->CopySubresourceRegion( destination->InternalPointer, destinationSubresource, x, y, z, source->InternalPointer, sourceSubresource, &nativeRegion );\r
 159         }\r
 160         \r
 161         void DeviceContext::ResolveSubresource( Resource^ source, int sourceSubresource, Resource^ destination, int destinationSubresource, DXGI::Format format )\r
 162         {\r
 163                 InternalPointer->ResolveSubresource( destination->InternalPointer, destinationSubresource, source->InternalPointer, sourceSubresource, static_cast<DXGI_FORMAT>( format ) );\r
 164         }\r
 165         \r
 166         void DeviceContext::UpdateSubresource( DataBox^ source, Resource^ resource, int subresource ) \r
 167         {\r
 168                 InternalPointer->UpdateSubresource( resource->InternalPointer, static_cast<UINT>( subresource), 0, source->Data->PositionPointer, source->RowPitch,source->SlicePitch);\r
 169         }\r
 170 \r
 171         void DeviceContext::UpdateSubresource( DataBox^ source, Resource^ resource, int subresource, ResourceRegion region ) \r
 172         {\r
 173                 D3D11_BOX nativeRegion = region.CreateNativeVersion();\r
 174                 InternalPointer->UpdateSubresource( resource->InternalPointer, static_cast<UINT>( subresource), &nativeRegion, source->Data->PositionPointer, source->RowPitch,source->SlicePitch);\r
 175         }\r
 176 \r
 177         void DeviceContext::Dispatch( int threadGroupCountX, int threadGroupCountY, int threadGroupCountZ )\r
 178         {\r
 179                 InternalPointer->Dispatch( threadGroupCountX, threadGroupCountY, threadGroupCountZ );\r
 180         }\r
 181         \r
 182         void DeviceContext::DispatchIndirect( Buffer^ arguments, int alignedOffset )\r
 183         {\r
 184                 InternalPointer->DispatchIndirect( arguments->InternalPointer, alignedOffset );\r
 185         }\r
 186 \r
 187         void DeviceContext::Draw( int vertexCount, int startVertexLocation )\r
 188         {\r
 189                 InternalPointer->Draw( vertexCount, startVertexLocation );\r
 190         }\r
 191         \r
 192         void DeviceContext::DrawInstanced( int vertexCountPerInstance, int instanceCount, int startVertexLocation, int startInstanceLocation )\r
 193         {\r
 194                 InternalPointer->DrawInstanced( vertexCountPerInstance, instanceCount, startVertexLocation, startInstanceLocation );\r
 195         }\r
 196 \r
 197         void DeviceContext::DrawInstancedIndirect( Buffer^ arguments, int alignedOffset )\r
 198         {\r
 199                 InternalPointer->DrawInstancedIndirect( arguments->InternalPointer, alignedOffset );\r
 200         }\r
 201         \r
 202         void DeviceContext::DrawIndexed( int indexCount, int startIndexLocation, int baseVertexLocation )\r
 203         {\r
 204                 InternalPointer->DrawIndexed( indexCount, startIndexLocation, baseVertexLocation );\r
 205         }\r
 206         \r
 207         void DeviceContext::DrawIndexedInstanced( int indexCountPerInstance, int instanceCount, int startIndexLocation, int baseVertexLocation, int startInstanceLocation )\r
 208         {\r
 209                 InternalPointer->DrawIndexedInstanced( indexCountPerInstance, instanceCount, startIndexLocation, baseVertexLocation, startInstanceLocation );\r
 210         }\r
 211 \r
 212         void DeviceContext::DrawIndexedInstancedIndirect( Buffer^ arguments, int alignedOffset )\r
 213         {\r
 214                 InternalPointer->DrawIndexedInstancedIndirect( arguments->InternalPointer, alignedOffset );\r
 215         }\r
 216         \r
 217         void DeviceContext::DrawAuto()\r
 218         {\r
 219                 InternalPointer->DrawAuto();\r
 220         }\r
 221 \r
 222         void DeviceContext::End( Asynchronous^ data )\r
 223         {\r
 224                 InternalPointer->End( data->InternalPointer );\r
 225         }\r
 226 \r
 227         void DeviceContext::ExecuteCommandList( CommandList^ commands, bool restoreState )\r
 228         {\r
 229                 InternalPointer->ExecuteCommandList( commands->InternalPointer, restoreState );\r
 230         }\r
 231 \r
 232         CommandList^ DeviceContext::FinishCommandList( bool restoreState )\r
 233         {\r
 234                 ID3D11CommandList* commands;\r
 235 \r
 236                 HRESULT hr = InternalPointer->FinishCommandList( restoreState, &commands );\r
 237                 if( RECORD_D3D11( hr ).IsFailure )\r
 238                         return nullptr;\r
 239 \r
 240                 return CommandList::FromPointer( commands );\r
 241         }\r
 242         \r
 243         void DeviceContext::Flush()\r
 244         {\r
 245                 InternalPointer->Flush();\r
 246         }\r
 247         \r
 248         void DeviceContext::GenerateMips( ShaderResourceView^ view )\r
 249         {\r
 250                 InternalPointer->GenerateMips( view->InternalPointer );\r
 251         }\r
 252 \r
 253         float DeviceContext::GetMinimumLod( Resource^ resource )\r
 254         {\r
 255                 return InternalPointer->GetResourceMinLOD( resource->InternalPointer );\r
 256         }\r
 257 \r
 258         void DeviceContext::SetMinimumLod( Resource^ resource, float minimumLod )\r
 259         {\r
 260                 InternalPointer->SetResourceMinLOD( resource->InternalPointer, minimumLod );\r
 261         }\r
 262 \r
 263         DataStream^ DeviceContext::GetData( Asynchronous^ data )\r
 264         {\r
 265                 return GetData( data, AsynchronousFlags::None );\r
 266         }\r
 267         \r
 268         DataStream^ DeviceContext::GetData( Asynchronous^ data, AsynchronousFlags flags )\r
 269         {\r
 270                 int size = data->InternalPointer->GetDataSize();\r
 271                 DataStream^ result = gcnew DataStream( size, true, true );\r
 272 \r
 273                 if( RECORD_D3D11( InternalPointer->GetData( data->InternalPointer, result->PositionPointer, size, static_cast<UINT>( flags ) ) ).IsFailure )\r
 274                         return nullptr;\r
 275                 return result;\r
 276         }\r
 277 \r
 278 // disables bogus warning: \r
 279 // SlimDX::Direct3D11::DeviceContext::GetData<T>' : recursive on\r
 280 // all control paths, function will cause runtime stack overflow\r
 281 #pragma warning(disable:4717)\r
 282         generic<typename T> where T : value class\r
 283         T DeviceContext::GetData( Asynchronous^ data )\r
 284         {\r
 285                 return GetData<T>( data, AsynchronousFlags::None );\r
 286         }\r
 287 \r
 288         generic<typename T> where T : value class\r
 289         T DeviceContext::GetData( Asynchronous^ data, AsynchronousFlags flags )\r
 290         {\r
 291                 int size = Marshal::SizeOf(T::typeid);\r
 292                 T result;\r
 293 \r
 294                 if( RECORD_D3D11( InternalPointer->GetData( data->InternalPointer, &result, size, static_cast<UINT>( flags ) ) ).IsFailure )\r
 295                         return T();\r
 296 \r
 297                 return result;\r
 298         }\r
 299 #pragma warning(default:4717)\r
 300 \r
 301         void DeviceContext::GetPredication( [Out] Predicate^ %predicate, bool %predicateValue )\r
 302         {\r
 303                 ID3D11Predicate* pointer;\r
 304                 BOOL value;\r
 305 \r
 306                 InternalPointer->GetPredication( &pointer, &value );\r
 307 \r
 308                 predicate = Predicate::FromPointer( pointer );\r
 309                 predicateValue = value > 0;\r
 310         }\r
 311 \r
 312         void DeviceContext::SetPredication( Predicate^ predicate, bool predicateValue )\r
 313         {\r
 314                 InternalPointer->SetPredication( predicate->InternalPointer, predicateValue );\r
 315         }\r
 316 \r
 317         DataBox^ DeviceContext::MapSubresource( Resource^ resource, int subresource, int sizeInBytes, MapMode mode, MapFlags flags )\r
 318         {\r
 319                 D3D11_MAPPED_SUBRESOURCE mapped;\r
 320                 HRESULT hr = InternalPointer->Map( resource->InternalPointer, subresource, static_cast<D3D11_MAP>( mode ), static_cast<UINT>( flags ), &mapped );\r
 321                 if( RECORD_D3D11( hr ).IsFailure )\r
 322                         return nullptr;\r
 323 \r
 324                 DataBox^ box = gcnew DataBox( mapped.RowPitch, mapped.DepthPitch, gcnew DataStream( mapped.pData, sizeInBytes, true, true, false ) );\r
 325                 return box;\r
 326         }\r
 327 \r
 328         void DeviceContext::UnmapSubresource( Resource^ resource, int subresource )\r
 329         {\r
 330                 InternalPointer->Unmap( resource->InternalPointer, subresource );\r
 331         }\r
 332 \r
 333         DeviceContextType DeviceContext::Type::get()\r
 334         {\r
 335                 return static_cast<DeviceContextType>( InternalPointer->GetType() );\r
 336         }\r
 337 \r
 338         InputAssemblerWrapper^ DeviceContext::InputAssembler::get()\r
 339         {\r
 340                 return inputAssembler;\r
 341         }\r
 342         \r
 343         OutputMergerWrapper^ DeviceContext::OutputMerger::get()\r
 344         {\r
 345                 return outputMerger;\r
 346         }\r
 347         \r
 348         StreamOutputWrapper^ DeviceContext::StreamOutput::get()\r
 349         {\r
 350                 return streamOutput;\r
 351         }\r
 352         \r
 353         RasterizerWrapper^ DeviceContext::Rasterizer::get()\r
 354         {\r
 355                 return rasterizer;\r
 356         }\r
 357 \r
 358         VertexShaderWrapper^ DeviceContext::VertexShader::get()\r
 359         {\r
 360                 return vertexShader;\r
 361         }\r
 362 \r
 363         PixelShaderWrapper^ DeviceContext::PixelShader::get()\r
 364         {\r
 365                 return pixelShader;\r
 366         }\r
 367 \r
 368         GeometryShaderWrapper^ DeviceContext::GeometryShader::get()\r
 369         {\r
 370                 return geometryShader;\r
 371         }\r
 372 \r
 373         DomainShaderWrapper^ DeviceContext::DomainShader::get()\r
 374         {\r
 375                 return domainShader;\r
 376         }\r
 377 \r
 378         HullShaderWrapper^ DeviceContext::HullShader::get()\r
 379         {\r
 380                 return hullShader;\r
 381         }\r
 382 \r
 383         ComputeShaderWrapper^ DeviceContext::ComputeShader::get()\r
 384         {\r
 385                 return computeShader;\r
 386         }\r
 387 }\r
 388 }