summaryrefslogtreecommitdiffstats
path: root/src/libs/dxvk-native-1.9.2a/src/d3d10/d3d10_device.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/libs/dxvk-native-1.9.2a/src/d3d10/d3d10_device.cpp')
-rw-r--r--src/libs/dxvk-native-1.9.2a/src/d3d10/d3d10_device.cpp1601
1 files changed, 1601 insertions, 0 deletions
diff --git a/src/libs/dxvk-native-1.9.2a/src/d3d10/d3d10_device.cpp b/src/libs/dxvk-native-1.9.2a/src/d3d10/d3d10_device.cpp
new file mode 100644
index 00000000..4b639fc6
--- /dev/null
+++ b/src/libs/dxvk-native-1.9.2a/src/d3d10/d3d10_device.cpp
@@ -0,0 +1,1601 @@
+#include "d3d10_device.h"
+
+#include "../d3d11/d3d11_device.h"
+#include "../d3d11/d3d11_context_imm.h"
+
+namespace dxvk {
+
+ D3D10Device::D3D10Device(
+ D3D11Device* pDevice,
+ D3D11ImmediateContext* pContext)
+ : m_device(pDevice), m_context(pContext) {
+ }
+
+
+ D3D10Device::~D3D10Device() {
+
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::QueryInterface(
+ REFIID riid,
+ void** ppvObject) {
+ return m_device->QueryInterface(riid, ppvObject);
+ }
+
+
+ ULONG STDMETHODCALLTYPE D3D10Device::AddRef() {
+ return m_device->AddRef();
+ }
+
+
+ ULONG STDMETHODCALLTYPE D3D10Device::Release() {
+ return m_device->Release();
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::GetPrivateData(
+ REFGUID guid,
+ UINT* pDataSize,
+ void* pData) {
+ return m_device->GetPrivateData(guid, pDataSize, pData);
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::SetPrivateData(
+ REFGUID guid,
+ UINT DataSize,
+ const void* pData) {
+ return m_device->SetPrivateData(guid, DataSize, pData);
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::SetPrivateDataInterface(
+ REFGUID guid,
+ const IUnknown* pData) {
+ return m_device->SetPrivateDataInterface(guid, pData);
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::GetDeviceRemovedReason() {
+ return m_device->GetDeviceRemovedReason();
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::SetExceptionMode(
+ UINT RaiseFlags) {
+ return m_device->SetExceptionMode(RaiseFlags);
+ }
+
+
+ UINT STDMETHODCALLTYPE D3D10Device::GetExceptionMode() {
+ return m_device->GetExceptionMode();
+ }
+
+
+ D3D10_FEATURE_LEVEL1 STDMETHODCALLTYPE D3D10Device::GetFeatureLevel() {
+ return D3D10_FEATURE_LEVEL1(m_device->GetFeatureLevel());
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::ClearState() {
+ m_context->ClearState();
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::Flush() {
+ m_context->Flush();
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::CreateBuffer(
+ const D3D10_BUFFER_DESC* pDesc,
+ const D3D10_SUBRESOURCE_DATA* pInitialData,
+ ID3D10Buffer** ppBuffer) {
+ InitReturnPtr(ppBuffer);
+
+ if (pDesc == nullptr)
+ return E_INVALIDARG;
+
+ D3D11_BUFFER_DESC d3d11Desc;
+ d3d11Desc.ByteWidth = pDesc->ByteWidth;
+ d3d11Desc.Usage = D3D11_USAGE(pDesc->Usage);
+ d3d11Desc.BindFlags = pDesc->BindFlags;
+ d3d11Desc.CPUAccessFlags = pDesc->CPUAccessFlags;
+ d3d11Desc.MiscFlags = ConvertD3D10ResourceFlags(pDesc->MiscFlags);
+ d3d11Desc.StructureByteStride = 0;
+
+ ID3D11Buffer* d3d11Buffer = nullptr;
+ HRESULT hr = m_device->CreateBuffer(&d3d11Desc,
+ reinterpret_cast<const D3D11_SUBRESOURCE_DATA*>(pInitialData),
+ ppBuffer != nullptr ? &d3d11Buffer : nullptr);
+
+ if (hr != S_OK)
+ return hr;
+
+ *ppBuffer = static_cast<D3D11Buffer*>(d3d11Buffer)->GetD3D10Iface();
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::CreateTexture1D(
+ const D3D10_TEXTURE1D_DESC* pDesc,
+ const D3D10_SUBRESOURCE_DATA* pInitialData,
+ ID3D10Texture1D** ppTexture1D) {
+ InitReturnPtr(ppTexture1D);
+
+ if (pDesc == nullptr)
+ return E_INVALIDARG;
+
+ D3D11_TEXTURE1D_DESC d3d11Desc;
+ d3d11Desc.Width = pDesc->Width;
+ d3d11Desc.MipLevels = pDesc->MipLevels;
+ d3d11Desc.ArraySize = pDesc->ArraySize;
+ d3d11Desc.Format = pDesc->Format;
+ d3d11Desc.Usage = D3D11_USAGE(pDesc->Usage);
+ d3d11Desc.BindFlags = pDesc->BindFlags;
+ d3d11Desc.CPUAccessFlags = pDesc->CPUAccessFlags;
+ d3d11Desc.MiscFlags = ConvertD3D10ResourceFlags(pDesc->MiscFlags);
+
+ ID3D11Texture1D* d3d11Texture1D = nullptr;
+ HRESULT hr = m_device->CreateTexture1D(&d3d11Desc,
+ reinterpret_cast<const D3D11_SUBRESOURCE_DATA*>(pInitialData),
+ ppTexture1D != nullptr ? &d3d11Texture1D : nullptr);
+
+ if (hr != S_OK)
+ return hr;
+
+ *ppTexture1D = static_cast<D3D11Texture1D*>(d3d11Texture1D)->GetD3D10Iface();
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::CreateTexture2D(
+ const D3D10_TEXTURE2D_DESC* pDesc,
+ const D3D10_SUBRESOURCE_DATA* pInitialData,
+ ID3D10Texture2D** ppTexture2D) {
+ InitReturnPtr(ppTexture2D);
+
+ if (pDesc == nullptr)
+ return E_INVALIDARG;
+
+ D3D11_TEXTURE2D_DESC d3d11Desc;
+ d3d11Desc.Width = pDesc->Width;
+ d3d11Desc.Height = pDesc->Height;
+ d3d11Desc.MipLevels = pDesc->MipLevels;
+ d3d11Desc.ArraySize = pDesc->ArraySize;
+ d3d11Desc.Format = pDesc->Format;
+ d3d11Desc.SampleDesc = pDesc->SampleDesc;
+ d3d11Desc.Usage = D3D11_USAGE(pDesc->Usage);
+ d3d11Desc.BindFlags = pDesc->BindFlags;
+ d3d11Desc.CPUAccessFlags = pDesc->CPUAccessFlags;
+ d3d11Desc.MiscFlags = ConvertD3D10ResourceFlags(pDesc->MiscFlags);
+
+ ID3D11Texture2D* d3d11Texture2D = nullptr;
+ HRESULT hr = m_device->CreateTexture2D(&d3d11Desc,
+ reinterpret_cast<const D3D11_SUBRESOURCE_DATA*>(pInitialData),
+ ppTexture2D != nullptr ? &d3d11Texture2D : nullptr);
+
+ if (hr != S_OK)
+ return hr;
+
+ *ppTexture2D = static_cast<D3D11Texture2D*>(d3d11Texture2D)->GetD3D10Iface();
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::CreateTexture3D(
+ const D3D10_TEXTURE3D_DESC* pDesc,
+ const D3D10_SUBRESOURCE_DATA* pInitialData,
+ ID3D10Texture3D** ppTexture3D) {
+ InitReturnPtr(ppTexture3D);
+
+ if (pDesc == nullptr)
+ return E_INVALIDARG;
+
+ D3D11_TEXTURE3D_DESC d3d11Desc;
+ d3d11Desc.Width = pDesc->Width;
+ d3d11Desc.Height = pDesc->Height;
+ d3d11Desc.Depth = pDesc->Depth;
+ d3d11Desc.MipLevels = pDesc->MipLevels;
+ d3d11Desc.Format = pDesc->Format;
+ d3d11Desc.Usage = D3D11_USAGE(pDesc->Usage);
+ d3d11Desc.BindFlags = pDesc->BindFlags;
+ d3d11Desc.CPUAccessFlags = pDesc->CPUAccessFlags;
+ d3d11Desc.MiscFlags = ConvertD3D10ResourceFlags(pDesc->MiscFlags);
+
+ ID3D11Texture3D* d3d11Texture3D = nullptr;
+ HRESULT hr = m_device->CreateTexture3D(&d3d11Desc,
+ reinterpret_cast<const D3D11_SUBRESOURCE_DATA*>(pInitialData),
+ ppTexture3D != nullptr ? &d3d11Texture3D : nullptr);
+
+ if (hr != S_OK)
+ return hr;
+
+ *ppTexture3D = static_cast<D3D11Texture3D*>(d3d11Texture3D)->GetD3D10Iface();
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::CreateShaderResourceView(
+ ID3D10Resource* pResource,
+ const D3D10_SHADER_RESOURCE_VIEW_DESC* pDesc,
+ ID3D10ShaderResourceView** ppSRView) {
+ InitReturnPtr(ppSRView);
+
+ if (!pResource)
+ return E_INVALIDARG;
+
+ Com<ID3D11Resource> d3d11Resource;
+ GetD3D11Resource(pResource, &d3d11Resource);
+
+ ID3D11ShaderResourceView* d3d11Srv = nullptr;
+ HRESULT hr = m_device->CreateShaderResourceView(d3d11Resource.ptr(),
+ reinterpret_cast<const D3D11_SHADER_RESOURCE_VIEW_DESC*>(pDesc),
+ ppSRView ? &d3d11Srv : nullptr);
+
+ if (hr != S_OK)
+ return hr;
+
+ *ppSRView = static_cast<D3D11ShaderResourceView*>(d3d11Srv)->GetD3D10Iface();
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::CreateShaderResourceView1(
+ ID3D10Resource* pResource,
+ const D3D10_SHADER_RESOURCE_VIEW_DESC1* pDesc,
+ ID3D10ShaderResourceView1** ppSRView) {
+ InitReturnPtr(ppSRView);
+
+ if (!pResource)
+ return E_INVALIDARG;
+
+ Com<ID3D11Resource> d3d11Resource;
+ GetD3D11Resource(pResource, &d3d11Resource);
+
+ ID3D11ShaderResourceView* d3d11View = nullptr;
+ HRESULT hr = m_device->CreateShaderResourceView(d3d11Resource.ptr(),
+ reinterpret_cast<const D3D11_SHADER_RESOURCE_VIEW_DESC*>(pDesc),
+ ppSRView ? &d3d11View : nullptr);
+
+ if (hr != S_OK)
+ return hr;
+
+ *ppSRView = static_cast<D3D11ShaderResourceView*>(d3d11View)->GetD3D10Iface();
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::CreateRenderTargetView(
+ ID3D10Resource* pResource,
+ const D3D10_RENDER_TARGET_VIEW_DESC* pDesc,
+ ID3D10RenderTargetView** ppRTView) {
+ InitReturnPtr(ppRTView);
+
+ if (!pResource)
+ return E_INVALIDARG;
+
+ Com<ID3D11Resource> d3d11Resource;
+ GetD3D11Resource(pResource, &d3d11Resource);
+
+ ID3D11RenderTargetView* d3d11View = nullptr;
+ HRESULT hr = m_device->CreateRenderTargetView(d3d11Resource.ptr(),
+ reinterpret_cast<const D3D11_RENDER_TARGET_VIEW_DESC*>(pDesc),
+ ppRTView ? &d3d11View : nullptr);
+
+ if (hr != S_OK)
+ return hr;
+
+ *ppRTView = static_cast<D3D11RenderTargetView*>(d3d11View)->GetD3D10Iface();
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::CreateDepthStencilView(
+ ID3D10Resource* pResource,
+ const D3D10_DEPTH_STENCIL_VIEW_DESC* pDesc,
+ ID3D10DepthStencilView** ppDepthStencilView) {
+ InitReturnPtr(ppDepthStencilView);
+
+ if (!pResource)
+ return E_INVALIDARG;
+
+ Com<ID3D11Resource> d3d11Resource;
+ GetD3D11Resource(pResource, &d3d11Resource);
+
+ // D3D10 doesn't have the Flags member, so we have
+ // to convert the structure. pDesc can be nullptr.
+ D3D11_DEPTH_STENCIL_VIEW_DESC d3d11Desc;
+
+ if (pDesc != nullptr) {
+ d3d11Desc.ViewDimension = D3D11_DSV_DIMENSION(pDesc->ViewDimension);
+ d3d11Desc.Format = pDesc->Format;
+ d3d11Desc.Flags = 0;
+
+ switch (pDesc->ViewDimension) {
+ case D3D10_DSV_DIMENSION_UNKNOWN:
+ break;
+
+ case D3D10_DSV_DIMENSION_TEXTURE1D:
+ d3d11Desc.Texture1D.MipSlice = pDesc->Texture1D.MipSlice;
+ break;
+
+ case D3D10_DSV_DIMENSION_TEXTURE1DARRAY:
+ d3d11Desc.Texture1DArray.MipSlice = pDesc->Texture1DArray.MipSlice;
+ d3d11Desc.Texture1DArray.FirstArraySlice = pDesc->Texture1DArray.FirstArraySlice;
+ d3d11Desc.Texture1DArray.ArraySize = pDesc->Texture1DArray.ArraySize;
+ break;
+
+ case D3D10_DSV_DIMENSION_TEXTURE2D:
+ d3d11Desc.Texture2D.MipSlice = pDesc->Texture2D.MipSlice;
+ break;
+
+ case D3D10_DSV_DIMENSION_TEXTURE2DARRAY:
+ d3d11Desc.Texture2DArray.MipSlice = pDesc->Texture2DArray.MipSlice;
+ d3d11Desc.Texture2DArray.FirstArraySlice = pDesc->Texture2DArray.FirstArraySlice;
+ d3d11Desc.Texture2DArray.ArraySize = pDesc->Texture2DArray.ArraySize;
+ break;
+
+ case D3D10_DSV_DIMENSION_TEXTURE2DMS:
+ break;
+
+ case D3D10_DSV_DIMENSION_TEXTURE2DMSARRAY:
+ d3d11Desc.Texture2DMSArray.FirstArraySlice = pDesc->Texture2DMSArray.FirstArraySlice;
+ d3d11Desc.Texture2DMSArray.ArraySize = pDesc->Texture2DMSArray.ArraySize;
+ break;
+ }
+ }
+
+ ID3D11DepthStencilView* d3d11View = nullptr;
+ HRESULT hr = m_device->CreateDepthStencilView(
+ d3d11Resource.ptr(), pDesc ? &d3d11Desc : nullptr,
+ ppDepthStencilView ? &d3d11View : nullptr);
+
+ if (hr != S_OK)
+ return hr;
+
+ *ppDepthStencilView = static_cast<D3D11DepthStencilView*>(d3d11View)->GetD3D10Iface();
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::CreateInputLayout(
+ const D3D10_INPUT_ELEMENT_DESC* pInputElementDescs,
+ UINT NumElements,
+ const void* pShaderBytecodeWithInputSignature,
+ SIZE_T BytecodeLength,
+ ID3D10InputLayout** ppInputLayout) {
+ InitReturnPtr(ppInputLayout);
+
+ static_assert(sizeof(D3D10_INPUT_ELEMENT_DESC) ==
+ sizeof(D3D11_INPUT_ELEMENT_DESC));
+
+ ID3D11InputLayout* d3d11InputLayout = nullptr;
+ HRESULT hr = m_device->CreateInputLayout(
+ reinterpret_cast<const D3D11_INPUT_ELEMENT_DESC*>(pInputElementDescs),
+ NumElements, pShaderBytecodeWithInputSignature, BytecodeLength,
+ ppInputLayout ? &d3d11InputLayout : nullptr);
+
+ if (hr != S_OK)
+ return hr;
+
+ *ppInputLayout = static_cast<D3D11InputLayout*>(d3d11InputLayout)->GetD3D10Iface();
+ return hr;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::CreateVertexShader(
+ const void* pShaderBytecode,
+ SIZE_T BytecodeLength,
+ ID3D10VertexShader** ppVertexShader) {
+ InitReturnPtr(ppVertexShader);
+
+ ID3D11VertexShader* d3d11Shader = nullptr;
+
+ HRESULT hr = m_device->CreateVertexShader(
+ pShaderBytecode, BytecodeLength, nullptr,
+ ppVertexShader ? &d3d11Shader : nullptr);
+
+ if (hr != S_OK)
+ return hr;
+
+ *ppVertexShader = static_cast<D3D11VertexShader*>(d3d11Shader)->GetD3D10Iface();
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::CreateGeometryShader(
+ const void* pShaderBytecode,
+ SIZE_T BytecodeLength,
+ ID3D10GeometryShader** ppGeometryShader) {
+ InitReturnPtr(ppGeometryShader);
+
+ ID3D11GeometryShader* d3d11Shader = nullptr;
+
+ HRESULT hr = m_device->CreateGeometryShader(
+ pShaderBytecode, BytecodeLength, nullptr,
+ ppGeometryShader ? &d3d11Shader : nullptr);
+
+ if (hr != S_OK)
+ return hr;
+
+ *ppGeometryShader = static_cast<D3D11GeometryShader*>(d3d11Shader)->GetD3D10Iface();
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::CreateGeometryShaderWithStreamOutput(
+ const void* pShaderBytecode,
+ SIZE_T BytecodeLength,
+ const D3D10_SO_DECLARATION_ENTRY* pSODeclaration,
+ UINT NumEntries,
+ UINT OutputStreamStride,
+ ID3D10GeometryShader** ppGeometryShader) {
+ InitReturnPtr(ppGeometryShader);
+
+ std::vector<D3D11_SO_DECLARATION_ENTRY> d3d11Entries(NumEntries);
+
+ for (uint32_t i = 0; i < NumEntries; i++) {
+ d3d11Entries[i].Stream = 0;
+ d3d11Entries[i].SemanticName = pSODeclaration[i].SemanticName;
+ d3d11Entries[i].SemanticIndex = pSODeclaration[i].SemanticIndex;
+ d3d11Entries[i].StartComponent = pSODeclaration[i].StartComponent;
+ d3d11Entries[i].ComponentCount = pSODeclaration[i].ComponentCount;
+ d3d11Entries[i].OutputSlot = pSODeclaration[i].OutputSlot;
+ }
+
+ ID3D11GeometryShader* d3d11Shader = nullptr;
+
+ HRESULT hr = m_device->CreateGeometryShaderWithStreamOutput(
+ pShaderBytecode, BytecodeLength,
+ d3d11Entries.data(),
+ d3d11Entries.size(),
+ &OutputStreamStride, 1,
+ D3D11_SO_NO_RASTERIZED_STREAM, nullptr,
+ ppGeometryShader ? &d3d11Shader : nullptr);
+
+ if (hr != S_OK)
+ return hr;
+
+ *ppGeometryShader = static_cast<D3D11GeometryShader*>(d3d11Shader)->GetD3D10Iface();
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::CreatePixelShader(
+ const void* pShaderBytecode,
+ SIZE_T BytecodeLength,
+ ID3D10PixelShader** ppPixelShader) {
+ InitReturnPtr(ppPixelShader);
+
+ ID3D11PixelShader* d3d11Shader = nullptr;
+
+ HRESULT hr = m_device->CreatePixelShader(
+ pShaderBytecode, BytecodeLength, nullptr,
+ ppPixelShader ? &d3d11Shader : nullptr);
+
+ if (hr != S_OK)
+ return hr;
+
+ *ppPixelShader = static_cast<D3D11PixelShader*>(d3d11Shader)->GetD3D10Iface();
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::CreateBlendState(
+ const D3D10_BLEND_DESC* pBlendStateDesc,
+ ID3D10BlendState** ppBlendState) {
+ InitReturnPtr(ppBlendState);
+
+ D3D11_BLEND_DESC d3d11Desc;
+
+ if (pBlendStateDesc != nullptr) {
+ d3d11Desc.AlphaToCoverageEnable = pBlendStateDesc->AlphaToCoverageEnable;
+ d3d11Desc.IndependentBlendEnable = TRUE;
+
+ for (uint32_t i = 0; i < 8; i++) {
+ d3d11Desc.RenderTarget[i].BlendEnable = pBlendStateDesc->BlendEnable[i];
+ d3d11Desc.RenderTarget[i].SrcBlend = D3D11_BLEND (pBlendStateDesc->SrcBlend);
+ d3d11Desc.RenderTarget[i].DestBlend = D3D11_BLEND (pBlendStateDesc->DestBlend);
+ d3d11Desc.RenderTarget[i].BlendOp = D3D11_BLEND_OP(pBlendStateDesc->BlendOp);
+ d3d11Desc.RenderTarget[i].SrcBlendAlpha = D3D11_BLEND (pBlendStateDesc->SrcBlendAlpha);
+ d3d11Desc.RenderTarget[i].DestBlendAlpha = D3D11_BLEND (pBlendStateDesc->DestBlendAlpha);
+ d3d11Desc.RenderTarget[i].BlendOpAlpha = D3D11_BLEND_OP(pBlendStateDesc->BlendOpAlpha);
+ d3d11Desc.RenderTarget[i].RenderTargetWriteMask = pBlendStateDesc->RenderTargetWriteMask[i];
+ }
+ }
+
+ ID3D11BlendState* d3d11BlendState = nullptr;
+ HRESULT hr = m_device->CreateBlendState(&d3d11Desc,
+ ppBlendState ? &d3d11BlendState : nullptr);
+
+ if (hr != S_OK)
+ return hr;
+
+ *ppBlendState = static_cast<D3D11BlendState*>(d3d11BlendState)->GetD3D10Iface();
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::CreateBlendState1(
+ const D3D10_BLEND_DESC1* pBlendStateDesc,
+ ID3D10BlendState1** ppBlendState) {
+ InitReturnPtr(ppBlendState);
+
+ ID3D11BlendState* d3d11BlendState = nullptr;
+ HRESULT hr = m_device->CreateBlendState(
+ reinterpret_cast<const D3D11_BLEND_DESC*>(pBlendStateDesc),
+ ppBlendState ? &d3d11BlendState : nullptr);
+
+ if (hr != S_OK)
+ return hr;
+
+ *ppBlendState = static_cast<D3D11BlendState*>(d3d11BlendState)->GetD3D10Iface();
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::CreateDepthStencilState(
+ const D3D10_DEPTH_STENCIL_DESC* pDepthStencilDesc,
+ ID3D10DepthStencilState** ppDepthStencilState) {
+ InitReturnPtr(ppDepthStencilState);
+
+ ID3D11DepthStencilState* d3d11DepthStencilState = nullptr;
+ HRESULT hr = m_device->CreateDepthStencilState(
+ reinterpret_cast<const D3D11_DEPTH_STENCIL_DESC*>(pDepthStencilDesc),
+ ppDepthStencilState ? &d3d11DepthStencilState : nullptr);
+
+ if (hr != S_OK)
+ return hr;
+
+ *ppDepthStencilState = static_cast<D3D11DepthStencilState*>(d3d11DepthStencilState)->GetD3D10Iface();
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::CreateRasterizerState(
+ const D3D10_RASTERIZER_DESC* pRasterizerDesc,
+ ID3D10RasterizerState** ppRasterizerState) {
+ InitReturnPtr(ppRasterizerState);
+
+ ID3D11RasterizerState* d3d11RasterizerState = nullptr;
+ HRESULT hr = m_device->CreateRasterizerState(
+ reinterpret_cast<const D3D11_RASTERIZER_DESC*>(pRasterizerDesc),
+ ppRasterizerState ? &d3d11RasterizerState : nullptr);
+
+ if (hr != S_OK)
+ return hr;
+
+ *ppRasterizerState = static_cast<D3D11RasterizerState*>(d3d11RasterizerState)->GetD3D10Iface();
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::CreateSamplerState(
+ const D3D10_SAMPLER_DESC* pSamplerDesc,
+ ID3D10SamplerState** ppSamplerState) {
+ InitReturnPtr(ppSamplerState);
+
+ if (pSamplerDesc == nullptr)
+ return E_INVALIDARG;
+
+ D3D11_SAMPLER_DESC d3d11Desc;
+ d3d11Desc.Filter = D3D11_FILTER(pSamplerDesc->Filter);
+ d3d11Desc.AddressU = D3D11_TEXTURE_ADDRESS_MODE(pSamplerDesc->AddressU);
+ d3d11Desc.AddressV = D3D11_TEXTURE_ADDRESS_MODE(pSamplerDesc->AddressV);
+ d3d11Desc.AddressW = D3D11_TEXTURE_ADDRESS_MODE(pSamplerDesc->AddressW);
+ d3d11Desc.MipLODBias = pSamplerDesc->MipLODBias;
+ d3d11Desc.MaxAnisotropy = pSamplerDesc->MaxAnisotropy;
+ d3d11Desc.ComparisonFunc = D3D11_COMPARISON_FUNC(pSamplerDesc->ComparisonFunc);
+ d3d11Desc.MinLOD = pSamplerDesc->MinLOD;
+ d3d11Desc.MaxLOD = pSamplerDesc->MaxLOD;
+
+ for (uint32_t i = 0; i < 4; i++)
+ d3d11Desc.BorderColor[i] = pSamplerDesc->BorderColor[i];
+
+ ID3D11SamplerState* d3d11SamplerState = nullptr;
+ HRESULT hr = m_device->CreateSamplerState(&d3d11Desc,
+ ppSamplerState ? &d3d11SamplerState : nullptr);
+
+ if (hr != S_OK)
+ return hr;
+
+ *ppSamplerState = static_cast<D3D11SamplerState*>(d3d11SamplerState)->GetD3D10Iface();
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::CreateQuery(
+ const D3D10_QUERY_DESC* pQueryDesc,
+ ID3D10Query** ppQuery) {
+ InitReturnPtr(ppQuery);
+
+ if (pQueryDesc == nullptr)
+ return E_INVALIDARG;
+
+ D3D11_QUERY_DESC d3d11Desc;
+ d3d11Desc.Query = D3D11_QUERY(pQueryDesc->Query);
+ d3d11Desc.MiscFlags = pQueryDesc->MiscFlags;
+
+ ID3D11Query* d3d11Query = nullptr;
+ HRESULT hr = m_device->CreateQuery(&d3d11Desc,
+ ppQuery ? &d3d11Query : nullptr);
+
+ if (hr != S_OK)
+ return hr;
+
+ *ppQuery = static_cast<D3D11Query*>(d3d11Query)->GetD3D10Iface();
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::CreatePredicate(
+ const D3D10_QUERY_DESC* pPredicateDesc,
+ ID3D10Predicate** ppPredicate) {
+ InitReturnPtr(ppPredicate);
+
+ D3D11_QUERY_DESC d3d11Desc;
+ d3d11Desc.Query = D3D11_QUERY(pPredicateDesc->Query);
+ d3d11Desc.MiscFlags = pPredicateDesc->MiscFlags;
+
+ ID3D11Predicate* d3d11Predicate = nullptr;
+ HRESULT hr = m_device->CreatePredicate(&d3d11Desc,
+ ppPredicate ? &d3d11Predicate : nullptr);
+
+ if (hr != S_OK)
+ return hr;
+
+ *ppPredicate = D3D11Query::FromPredicate(d3d11Predicate)->GetD3D10Iface();
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::CreateCounter(
+ const D3D10_COUNTER_DESC* pCounterDesc,
+ ID3D10Counter** ppCounter) {
+ Logger::err("D3D10Device::CreateCounter: Not implemented");
+ return E_NOTIMPL;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::CheckFormatSupport(
+ DXGI_FORMAT Format,
+ UINT* pFormatSupport) {
+ return m_device->CheckFormatSupport(Format, pFormatSupport);
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::CheckMultisampleQualityLevels(
+ DXGI_FORMAT Format,
+ UINT SampleCount,
+ UINT* pNumQualityLevels) {
+ return m_device->CheckMultisampleQualityLevels(
+ Format, SampleCount, pNumQualityLevels);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::CheckCounterInfo(
+ D3D10_COUNTER_INFO* pCounterInfo) {
+ Logger::err("D3D10Device::CheckCounterInfo: Not implemented");
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::CheckCounter(
+ const D3D10_COUNTER_DESC* pDesc,
+ D3D10_COUNTER_TYPE* pType,
+ UINT* pActiveCounters,
+ char* name,
+ UINT* pNameLength,
+ char* units,
+ UINT* pUnitsLength,
+ char* description,
+ UINT* pDescriptionLength) {
+ Logger::err("D3D10Device::CheckCounter: Not implemented");
+ return E_NOTIMPL;
+ }
+
+
+ UINT STDMETHODCALLTYPE D3D10Device::GetCreationFlags() {
+ return m_device->GetCreationFlags();
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10Device::OpenSharedResource(
+ HANDLE hResource,
+ REFIID ReturnedInterface,
+ void** ppResource) {
+ InitReturnPtr(ppResource);
+
+ Logger::err("D3D10Device::OpenSharedResource: Not implemented");
+ return E_NOTIMPL;
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::ClearRenderTargetView(
+ ID3D10RenderTargetView* pRenderTargetView,
+ const FLOAT ColorRGBA[4]) {
+ D3D10RenderTargetView* d3d10View = static_cast<D3D10RenderTargetView*>(pRenderTargetView);
+ D3D11RenderTargetView* d3d11View = d3d10View ? d3d10View->GetD3D11Iface() : nullptr;
+
+ m_context->ClearRenderTargetView(d3d11View, ColorRGBA);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::ClearDepthStencilView(
+ ID3D10DepthStencilView* pDepthStencilView,
+ UINT ClearFlags,
+ FLOAT Depth,
+ UINT8 Stencil) {
+ D3D10DepthStencilView* d3d10View = static_cast<D3D10DepthStencilView*>(pDepthStencilView);
+ D3D11DepthStencilView* d3d11View = d3d10View ? d3d10View->GetD3D11Iface() : nullptr;
+
+ m_context->ClearDepthStencilView(d3d11View, ClearFlags, Depth, Stencil);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::SetPredication(
+ ID3D10Predicate* pPredicate,
+ BOOL PredicateValue) {
+ D3D10Query* d3d10Predicate = static_cast<D3D10Query*>(pPredicate);
+ D3D11Query* d3d11Predicate = d3d10Predicate ? d3d10Predicate->GetD3D11Iface() : nullptr;
+
+ m_context->SetPredication(D3D11Query::AsPredicate(d3d11Predicate), PredicateValue);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::GetPredication(
+ ID3D10Predicate** ppPredicate,
+ BOOL* pPredicateValue) {
+ ID3D11Predicate* d3d11Predicate = nullptr;
+
+ m_context->GetPredication(
+ ppPredicate ? &d3d11Predicate : nullptr,
+ pPredicateValue);
+
+ if (ppPredicate)
+ *ppPredicate = d3d11Predicate ? D3D11Query::FromPredicate(d3d11Predicate)->GetD3D10Iface() : nullptr;
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::CopySubresourceRegion(
+ ID3D10Resource* pDstResource,
+ UINT DstSubresource,
+ UINT DstX,
+ UINT DstY,
+ UINT DstZ,
+ ID3D10Resource* pSrcResource,
+ UINT SrcSubresource,
+ const D3D10_BOX* pSrcBox) {
+ if (!pDstResource || !pSrcResource)
+ return;
+
+ Com<ID3D11Resource> d3d11DstResource;
+ Com<ID3D11Resource> d3d11SrcResource;
+
+ GetD3D11Resource(pDstResource, &d3d11DstResource);
+ GetD3D11Resource(pSrcResource, &d3d11SrcResource);
+
+ m_context->CopySubresourceRegion(
+ d3d11DstResource.ptr(), DstSubresource, DstX, DstY, DstZ,
+ d3d11SrcResource.ptr(), SrcSubresource,
+ reinterpret_cast<const D3D11_BOX*>(pSrcBox));
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::CopyResource(
+ ID3D10Resource* pDstResource,
+ ID3D10Resource* pSrcResource) {
+ if (!pDstResource || !pSrcResource)
+ return;
+
+ Com<ID3D11Resource> d3d11DstResource;
+ Com<ID3D11Resource> d3d11SrcResource;
+
+ GetD3D11Resource(pDstResource, &d3d11DstResource);
+ GetD3D11Resource(pSrcResource, &d3d11SrcResource);
+
+ m_context->CopyResource(
+ d3d11DstResource.ptr(),
+ d3d11SrcResource.ptr());
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::UpdateSubresource(
+ ID3D10Resource* pDstResource,
+ UINT DstSubresource,
+ const D3D10_BOX* pDstBox,
+ const void* pSrcData,
+ UINT SrcRowPitch,
+ UINT SrcDepthPitch) {
+ if (!pDstResource)
+ return;
+
+ Com<ID3D11Resource> d3d11DstResource;
+ GetD3D11Resource(pDstResource, &d3d11DstResource);
+
+ m_context->UpdateSubresource(
+ d3d11DstResource.ptr(), DstSubresource,
+ reinterpret_cast<const D3D11_BOX*>(pDstBox),
+ pSrcData, SrcRowPitch, SrcDepthPitch);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::GenerateMips(
+ ID3D10ShaderResourceView* pShaderResourceView) {
+ D3D10ShaderResourceView* d3d10View = static_cast<D3D10ShaderResourceView*>(pShaderResourceView);
+ D3D11ShaderResourceView* d3d11View = d3d10View ? d3d10View->GetD3D11Iface() : nullptr;
+
+ m_context->GenerateMips(d3d11View);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::ResolveSubresource(
+ ID3D10Resource* pDstResource,
+ UINT DstSubresource,
+ ID3D10Resource* pSrcResource,
+ UINT SrcSubresource,
+ DXGI_FORMAT Format) {
+ if (!pDstResource || !pSrcResource)
+ return;
+
+ Com<ID3D11Resource> d3d11DstResource;
+ Com<ID3D11Resource> d3d11SrcResource;
+
+ GetD3D11Resource(pDstResource, &d3d11DstResource);
+ GetD3D11Resource(pSrcResource, &d3d11SrcResource);
+
+ m_context->ResolveSubresource(
+ d3d11DstResource.ptr(), DstSubresource,
+ d3d11SrcResource.ptr(), SrcSubresource,
+ Format);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::Draw(
+ UINT VertexCount,
+ UINT StartVertexLocation) {
+ m_context->Draw(VertexCount,
+ StartVertexLocation);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::DrawIndexed(
+ UINT IndexCount,
+ UINT StartIndexLocation,
+ INT BaseVertexLocation) {
+ m_context->DrawIndexed(IndexCount,
+ StartIndexLocation,
+ BaseVertexLocation);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::DrawInstanced(
+ UINT VertexCountPerInstance,
+ UINT InstanceCount,
+ UINT StartVertexLocation,
+ UINT StartInstanceLocation) {
+ m_context->DrawInstanced(
+ VertexCountPerInstance,
+ InstanceCount,
+ StartVertexLocation,
+ StartInstanceLocation);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::DrawIndexedInstanced(
+ UINT IndexCountPerInstance,
+ UINT InstanceCount,
+ UINT StartIndexLocation,
+ INT BaseVertexLocation,
+ UINT StartInstanceLocation) {
+ m_context->DrawIndexedInstanced(
+ IndexCountPerInstance,
+ InstanceCount,
+ StartIndexLocation,
+ BaseVertexLocation,
+ StartInstanceLocation);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::DrawAuto() {
+ m_context->DrawAuto();
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::IASetInputLayout(
+ ID3D10InputLayout* pInputLayout) {
+ D3D10InputLayout* d3d10InputLayout = static_cast<D3D10InputLayout*>(pInputLayout);
+ D3D11InputLayout* d3d11InputLayout = d3d10InputLayout ? d3d10InputLayout->GetD3D11Iface() : nullptr;
+
+ m_context->IASetInputLayout(d3d11InputLayout);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::IASetPrimitiveTopology(
+ D3D10_PRIMITIVE_TOPOLOGY Topology) {
+ m_context->IASetPrimitiveTopology(
+ D3D11_PRIMITIVE_TOPOLOGY(Topology));
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::IASetVertexBuffers(
+ UINT StartSlot,
+ UINT NumBuffers,
+ ID3D10Buffer* const* ppVertexBuffers,
+ const UINT* pStrides,
+ const UINT* pOffsets) {
+ ID3D11Buffer* d3d11Buffers[D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT];
+
+ if (NumBuffers > D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT)
+ return;
+
+ for (uint32_t i = 0; i < NumBuffers; i++) {
+ d3d11Buffers[i] = ppVertexBuffers[i]
+ ? static_cast<D3D10Buffer*>(ppVertexBuffers[i])->GetD3D11Iface()
+ : nullptr;
+ }
+
+ m_context->IASetVertexBuffers(
+ StartSlot, NumBuffers, d3d11Buffers,
+ pStrides, pOffsets);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::IASetIndexBuffer(
+ ID3D10Buffer* pIndexBuffer,
+ DXGI_FORMAT Format,
+ UINT Offset) {
+ D3D10Buffer* d3d10Buffer = static_cast<D3D10Buffer*>(pIndexBuffer);
+ D3D11Buffer* d3d11Buffer = d3d10Buffer ? d3d10Buffer->GetD3D11Iface() : nullptr;
+
+ m_context->IASetIndexBuffer(d3d11Buffer, Format, Offset);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::IAGetInputLayout(
+ ID3D10InputLayout** ppInputLayout) {
+ ID3D11InputLayout* d3d11InputLayout = nullptr;
+ m_context->IAGetInputLayout(&d3d11InputLayout);
+
+ *ppInputLayout = d3d11InputLayout
+ ? static_cast<D3D11InputLayout*>(d3d11InputLayout)->GetD3D10Iface()
+ : nullptr;
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::IAGetPrimitiveTopology(
+ D3D10_PRIMITIVE_TOPOLOGY* pTopology) {
+ D3D11_PRIMITIVE_TOPOLOGY d3d11Topology;
+ m_context->IAGetPrimitiveTopology(&d3d11Topology);
+
+ *pTopology = d3d11Topology <= 32 /* begin patch list */
+ ? D3D10_PRIMITIVE_TOPOLOGY(d3d11Topology)
+ : D3D10_PRIMITIVE_TOPOLOGY_UNDEFINED;
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::IAGetVertexBuffers(
+ UINT StartSlot,
+ UINT NumBuffers,
+ ID3D10Buffer** ppVertexBuffers,
+ UINT* pStrides,
+ UINT* pOffsets) {
+ ID3D11Buffer* d3d11Buffers[D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT];
+
+ m_context->IAGetVertexBuffers(
+ StartSlot, NumBuffers,
+ ppVertexBuffers ? d3d11Buffers : nullptr,
+ pStrides, pOffsets);
+
+ if (ppVertexBuffers) {
+ for (uint32_t i = 0; i < NumBuffers; i++) {
+ ppVertexBuffers[i] = d3d11Buffers[i]
+ ? static_cast<D3D11Buffer*>(d3d11Buffers[i])->GetD3D10Iface()
+ : nullptr;
+ }
+ }
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::IAGetIndexBuffer(
+ ID3D10Buffer** pIndexBuffer,
+ DXGI_FORMAT* Format,
+ UINT* Offset) {
+ ID3D11Buffer* d3d11Buffer = nullptr;
+
+ m_context->IAGetIndexBuffer(
+ pIndexBuffer ? &d3d11Buffer : nullptr,
+ Format, Offset);
+
+ if (pIndexBuffer)
+ *pIndexBuffer = d3d11Buffer ? static_cast<D3D11Buffer*>(d3d11Buffer)->GetD3D10Iface() : nullptr;
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::VSSetShader(
+ ID3D10VertexShader* pVertexShader) {
+ D3D10VertexShader* d3d10Shader = static_cast<D3D10VertexShader*>(pVertexShader);
+ D3D11VertexShader* d3d11Shader = d3d10Shader ? d3d10Shader->GetD3D11Iface() : nullptr;
+
+ m_context->VSSetShader(d3d11Shader, nullptr, 0);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::VSSetConstantBuffers(
+ UINT StartSlot,
+ UINT NumBuffers,
+ ID3D10Buffer* const* ppConstantBuffers) {
+ ID3D11Buffer* d3d11Buffers[D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT];
+
+ if (NumBuffers > D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT)
+ return;
+
+ for (uint32_t i = 0; i < NumBuffers; i++) {
+ d3d11Buffers[i] = ppConstantBuffers && ppConstantBuffers[i]
+ ? static_cast<D3D10Buffer*>(ppConstantBuffers[i])->GetD3D11Iface()
+ : nullptr;
+ }
+
+ m_context->VSSetConstantBuffers(StartSlot, NumBuffers, d3d11Buffers);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::VSSetShaderResources(
+ UINT StartSlot,
+ UINT NumViews,
+ ID3D10ShaderResourceView* const* ppShaderResourceViews) {
+ ID3D11ShaderResourceView* d3d11Views[D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT];
+
+ if (NumViews > D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT)
+ return;
+
+ for (uint32_t i = 0; i < NumViews; i++) {
+ d3d11Views[i] = ppShaderResourceViews && ppShaderResourceViews[i]
+ ? static_cast<D3D10ShaderResourceView*>(ppShaderResourceViews[i])->GetD3D11Iface()
+ : nullptr;
+ }
+
+ m_context->VSSetShaderResources(StartSlot, NumViews, d3d11Views);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::VSSetSamplers(
+ UINT StartSlot,
+ UINT NumSamplers,
+ ID3D10SamplerState* const* ppSamplers) {
+ ID3D11SamplerState* d3d11Samplers[D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT];
+
+ if (NumSamplers > D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT)
+ return;
+
+ for (uint32_t i = 0; i < NumSamplers; i++) {
+ d3d11Samplers[i] = ppSamplers && ppSamplers[i]
+ ? static_cast<D3D10SamplerState*>(ppSamplers[i])->GetD3D11Iface()
+ : nullptr;
+ }
+
+ m_context->VSSetSamplers(StartSlot, NumSamplers, d3d11Samplers);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::VSGetShader(
+ ID3D10VertexShader** ppVertexShader) {
+ ID3D11VertexShader* d3d11Shader = nullptr;
+ m_context->VSGetShader(&d3d11Shader, nullptr, nullptr);
+
+ *ppVertexShader = d3d11Shader ? static_cast<D3D11VertexShader*>(d3d11Shader)->GetD3D10Iface() : nullptr;
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::VSGetConstantBuffers(
+ UINT StartSlot,
+ UINT NumBuffers,
+ ID3D10Buffer** ppConstantBuffers) {
+ ID3D11Buffer* d3d11Buffers[D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT];
+ m_context->VSGetConstantBuffers(StartSlot, NumBuffers, d3d11Buffers);
+
+ for (uint32_t i = 0; i < NumBuffers; i++) {
+ ppConstantBuffers[i] = d3d11Buffers[i]
+ ? static_cast<D3D11Buffer*>(d3d11Buffers[i])->GetD3D10Iface()
+ : nullptr;
+ }
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::VSGetShaderResources(
+ UINT StartSlot,
+ UINT NumViews,
+ ID3D10ShaderResourceView** ppShaderResourceViews) {
+ ID3D11ShaderResourceView* d3d11Views[D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT];
+ m_context->VSGetShaderResources(StartSlot, NumViews, d3d11Views);
+
+ for (uint32_t i = 0; i < NumViews; i++) {
+ ppShaderResourceViews[i] = d3d11Views[i]
+ ? static_cast<D3D11ShaderResourceView*>(d3d11Views[i])->GetD3D10Iface()
+ : nullptr;
+ }
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::VSGetSamplers(
+ UINT StartSlot,
+ UINT NumSamplers,
+ ID3D10SamplerState** ppSamplers) {
+ ID3D11SamplerState* d3d11Samplers[D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT];
+ m_context->VSGetSamplers(StartSlot, NumSamplers, d3d11Samplers);
+
+ for (uint32_t i = 0; i < NumSamplers; i++) {
+ ppSamplers[i] = d3d11Samplers[i]
+ ? static_cast<D3D11SamplerState*>(d3d11Samplers[i])->GetD3D10Iface()
+ : nullptr;
+ }
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::GSSetShader(
+ ID3D10GeometryShader* pShader) {
+ D3D10GeometryShader* d3d10Shader = static_cast<D3D10GeometryShader*>(pShader);
+ D3D11GeometryShader* d3d11Shader = d3d10Shader ? d3d10Shader->GetD3D11Iface() : nullptr;
+
+ m_context->GSSetShader(d3d11Shader, nullptr, 0);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::GSSetConstantBuffers(
+ UINT StartSlot,
+ UINT NumBuffers,
+ ID3D10Buffer* const* ppConstantBuffers) {
+ ID3D11Buffer* d3d11Buffers[D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT];
+
+ if (NumBuffers > D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT)
+ return;
+
+ for (uint32_t i = 0; i < NumBuffers; i++) {
+ d3d11Buffers[i] = ppConstantBuffers && ppConstantBuffers[i]
+ ? static_cast<D3D10Buffer*>(ppConstantBuffers[i])->GetD3D11Iface()
+ : nullptr;
+ }
+
+ m_context->GSSetConstantBuffers(StartSlot, NumBuffers, d3d11Buffers);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::GSSetShaderResources(
+ UINT StartSlot,
+ UINT NumViews,
+ ID3D10ShaderResourceView* const* ppShaderResourceViews) {
+ ID3D11ShaderResourceView* d3d11Views[D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT];
+
+ if (NumViews > D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT)
+ return;
+
+ for (uint32_t i = 0; i < NumViews; i++) {
+ d3d11Views[i] = ppShaderResourceViews && ppShaderResourceViews[i]
+ ? static_cast<D3D10ShaderResourceView*>(ppShaderResourceViews[i])->GetD3D11Iface()
+ : nullptr;
+ }
+
+ m_context->GSSetShaderResources(StartSlot, NumViews, d3d11Views);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::GSSetSamplers(
+ UINT StartSlot,
+ UINT NumSamplers,
+ ID3D10SamplerState* const* ppSamplers) {
+ ID3D11SamplerState* d3d11Samplers[D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT];
+
+ if (NumSamplers > D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT)
+ return;
+
+ for (uint32_t i = 0; i < NumSamplers; i++) {
+ d3d11Samplers[i] = ppSamplers && ppSamplers[i]
+ ? static_cast<D3D10SamplerState*>(ppSamplers[i])->GetD3D11Iface()
+ : nullptr;
+ }
+
+ m_context->GSSetSamplers(StartSlot, NumSamplers, d3d11Samplers);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::GSGetShader(
+ ID3D10GeometryShader** ppGeometryShader) {
+ ID3D11GeometryShader* d3d11Shader = nullptr;
+ m_context->GSGetShader(&d3d11Shader, nullptr, nullptr);
+
+ *ppGeometryShader = d3d11Shader ? static_cast<D3D11GeometryShader*>(d3d11Shader)->GetD3D10Iface() : nullptr;
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::GSGetConstantBuffers(
+ UINT StartSlot,
+ UINT NumBuffers,
+ ID3D10Buffer** ppConstantBuffers) {
+ ID3D11Buffer* d3d11Buffers[D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT];
+ m_context->GSGetConstantBuffers(StartSlot, NumBuffers, d3d11Buffers);
+
+ for (uint32_t i = 0; i < NumBuffers; i++) {
+ ppConstantBuffers[i] = d3d11Buffers[i]
+ ? static_cast<D3D11Buffer*>(d3d11Buffers[i])->GetD3D10Iface()
+ : nullptr;
+ }
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::GSGetShaderResources(
+ UINT StartSlot,
+ UINT NumViews,
+ ID3D10ShaderResourceView** ppShaderResourceViews) {
+ ID3D11ShaderResourceView* d3d11Views[D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT];
+ m_context->GSGetShaderResources(StartSlot, NumViews, d3d11Views);
+
+ for (uint32_t i = 0; i < NumViews; i++) {
+ ppShaderResourceViews[i] = d3d11Views[i]
+ ? static_cast<D3D11ShaderResourceView*>(d3d11Views[i])->GetD3D10Iface()
+ : nullptr;
+ }
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::GSGetSamplers(
+ UINT StartSlot,
+ UINT NumSamplers,
+ ID3D10SamplerState** ppSamplers) {
+ ID3D11SamplerState* d3d11Samplers[D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT];
+ m_context->GSGetSamplers(StartSlot, NumSamplers, d3d11Samplers);
+
+ for (uint32_t i = 0; i < NumSamplers; i++) {
+ ppSamplers[i] = d3d11Samplers[i]
+ ? static_cast<D3D11SamplerState*>(d3d11Samplers[i])->GetD3D10Iface()
+ : nullptr;
+ }
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::PSSetShader(
+ ID3D10PixelShader* pPixelShader) {
+ D3D10PixelShader* d3d10Shader = static_cast<D3D10PixelShader*>(pPixelShader);
+ D3D11PixelShader* d3d11Shader = d3d10Shader ? d3d10Shader->GetD3D11Iface() : nullptr;
+
+ m_context->PSSetShader(d3d11Shader, nullptr, 0);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::PSSetConstantBuffers(
+ UINT StartSlot,
+ UINT NumBuffers,
+ ID3D10Buffer* const* ppConstantBuffers) {
+ ID3D11Buffer* d3d11Buffers[D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT];
+
+ if (NumBuffers > D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT)
+ return;
+
+ for (uint32_t i = 0; i < NumBuffers; i++) {
+ d3d11Buffers[i] = ppConstantBuffers && ppConstantBuffers[i]
+ ? static_cast<D3D10Buffer*>(ppConstantBuffers[i])->GetD3D11Iface()
+ : nullptr;
+ }
+
+ m_context->PSSetConstantBuffers(StartSlot, NumBuffers, d3d11Buffers);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::PSSetShaderResources(
+ UINT StartSlot,
+ UINT NumViews,
+ ID3D10ShaderResourceView* const* ppShaderResourceViews) {
+ ID3D11ShaderResourceView* d3d11Views[D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT];
+
+ if (NumViews > D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT)
+ return;
+
+ for (uint32_t i = 0; i < NumViews; i++) {
+ d3d11Views[i] = ppShaderResourceViews && ppShaderResourceViews[i]
+ ? static_cast<D3D10ShaderResourceView*>(ppShaderResourceViews[i])->GetD3D11Iface()
+ : nullptr;
+ }
+
+ m_context->PSSetShaderResources(StartSlot, NumViews, d3d11Views);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::PSSetSamplers(
+ UINT StartSlot,
+ UINT NumSamplers,
+ ID3D10SamplerState* const* ppSamplers) {
+ ID3D11SamplerState* d3d11Samplers[D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT];
+
+ if (NumSamplers > D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT)
+ return;
+
+ for (uint32_t i = 0; i < NumSamplers; i++) {
+ d3d11Samplers[i] = ppSamplers && ppSamplers[i]
+ ? static_cast<D3D10SamplerState*>(ppSamplers[i])->GetD3D11Iface()
+ : nullptr;
+ }
+
+ m_context->PSSetSamplers(StartSlot, NumSamplers, d3d11Samplers);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::PSGetShader(
+ ID3D10PixelShader** ppPixelShader) {
+ ID3D11PixelShader* d3d11Shader = nullptr;
+ m_context->PSGetShader(&d3d11Shader, nullptr, nullptr);
+
+ *ppPixelShader = d3d11Shader ? static_cast<D3D11PixelShader*>(d3d11Shader)->GetD3D10Iface() : nullptr;
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::PSGetConstantBuffers(
+ UINT StartSlot,
+ UINT NumBuffers,
+ ID3D10Buffer** ppConstantBuffers) {
+ ID3D11Buffer* d3d11Buffers[D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT];
+ m_context->PSGetConstantBuffers(StartSlot, NumBuffers, d3d11Buffers);
+
+ for (uint32_t i = 0; i < NumBuffers; i++) {
+ ppConstantBuffers[i] = d3d11Buffers[i]
+ ? static_cast<D3D11Buffer*>(d3d11Buffers[i])->GetD3D10Iface()
+ : nullptr;
+ }
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::PSGetShaderResources(
+ UINT StartSlot,
+ UINT NumViews,
+ ID3D10ShaderResourceView** ppShaderResourceViews) {
+ ID3D11ShaderResourceView* d3d11Views[D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT];
+ m_context->PSGetShaderResources(StartSlot, NumViews, d3d11Views);
+
+ for (uint32_t i = 0; i < NumViews; i++) {
+ ppShaderResourceViews[i] = d3d11Views[i]
+ ? static_cast<D3D11ShaderResourceView*>(d3d11Views[i])->GetD3D10Iface()
+ : nullptr;
+ }
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::PSGetSamplers(
+ UINT StartSlot,
+ UINT NumSamplers,
+ ID3D10SamplerState** ppSamplers) {
+ ID3D11SamplerState* d3d11Samplers[D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT];
+ m_context->PSGetSamplers(StartSlot, NumSamplers, d3d11Samplers);
+
+ for (uint32_t i = 0; i < NumSamplers; i++) {
+ ppSamplers[i] = d3d11Samplers[i]
+ ? static_cast<D3D11SamplerState*>(d3d11Samplers[i])->GetD3D10Iface()
+ : nullptr;
+ }
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::OMSetRenderTargets(
+ UINT NumViews,
+ ID3D10RenderTargetView* const* ppRenderTargetViews,
+ ID3D10DepthStencilView* pDepthStencilView) {
+ ID3D11RenderTargetView* d3d11Rtv[D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT];
+
+ if (NumViews > D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT)
+ return;
+
+ for (uint32_t i = 0; i < NumViews; i++) {
+ d3d11Rtv[i] = ppRenderTargetViews && ppRenderTargetViews[i]
+ ? static_cast<D3D10RenderTargetView*>(ppRenderTargetViews[i])->GetD3D11Iface()
+ : nullptr;
+ }
+
+ D3D10DepthStencilView* d3d10Dsv = static_cast<D3D10DepthStencilView*>(pDepthStencilView);
+ D3D11DepthStencilView* d3d11Dsv = d3d10Dsv ? d3d10Dsv->GetD3D11Iface() : nullptr;
+
+ m_context->OMSetRenderTargets(NumViews, d3d11Rtv, d3d11Dsv);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::OMSetBlendState(
+ ID3D10BlendState* pBlendState,
+ const FLOAT BlendFactor[4],
+ UINT SampleMask) {
+ D3D10BlendState* d3d10BlendState = static_cast<D3D10BlendState*>(pBlendState);
+ D3D11BlendState* d3d11BlendState = d3d10BlendState ? d3d10BlendState->GetD3D11Iface() : nullptr;
+
+ m_context->OMSetBlendState(d3d11BlendState, BlendFactor, SampleMask);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::OMSetDepthStencilState(
+ ID3D10DepthStencilState* pDepthStencilState,
+ UINT StencilRef) {
+ D3D10DepthStencilState* d3d10DepthStencilState = static_cast<D3D10DepthStencilState*>(pDepthStencilState);
+ D3D11DepthStencilState* d3d11DepthStencilState = d3d10DepthStencilState ? d3d10DepthStencilState->GetD3D11Iface() : nullptr;
+
+ m_context->OMSetDepthStencilState(d3d11DepthStencilState, StencilRef);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::OMGetRenderTargets(
+ UINT NumViews,
+ ID3D10RenderTargetView** ppRenderTargetViews,
+ ID3D10DepthStencilView** ppDepthStencilView) {
+ ID3D11RenderTargetView* d3d11Rtv[D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT];
+ ID3D11DepthStencilView* d3d11Dsv = nullptr;
+
+ m_context->OMGetRenderTargets(NumViews,
+ ppRenderTargetViews ? d3d11Rtv : nullptr,
+ ppDepthStencilView ? &d3d11Dsv : nullptr);
+
+ if (ppRenderTargetViews != nullptr) {
+ for (uint32_t i = 0; i < NumViews; i++) {
+ ppRenderTargetViews[i] = d3d11Rtv[i]
+ ? static_cast<D3D11RenderTargetView*>(d3d11Rtv[i])->GetD3D10Iface()
+ : nullptr;
+ }
+ }
+
+ if (ppDepthStencilView)
+ *ppDepthStencilView = d3d11Dsv ? static_cast<D3D11DepthStencilView*>(d3d11Dsv)->GetD3D10Iface() : nullptr;
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::OMGetBlendState(
+ ID3D10BlendState** ppBlendState,
+ FLOAT BlendFactor[4],
+ UINT* pSampleMask) {
+ ID3D11BlendState* d3d11BlendState = nullptr;
+
+ m_context->OMGetBlendState(
+ ppBlendState ? &d3d11BlendState : nullptr,
+ BlendFactor, pSampleMask);
+
+ if (ppBlendState != nullptr)
+ *ppBlendState = d3d11BlendState ? static_cast<D3D11BlendState*>(d3d11BlendState)->GetD3D10Iface() : nullptr;
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::OMGetDepthStencilState(
+ ID3D10DepthStencilState** ppDepthStencilState,
+ UINT* pStencilRef) {
+ ID3D11DepthStencilState* d3d11DepthStencilState = nullptr;
+
+ m_context->OMGetDepthStencilState(
+ ppDepthStencilState ? &d3d11DepthStencilState : nullptr,
+ pStencilRef);
+
+ if (ppDepthStencilState != nullptr)
+ *ppDepthStencilState = d3d11DepthStencilState ? static_cast<D3D11DepthStencilState*>(d3d11DepthStencilState)->GetD3D10Iface() : nullptr;
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::RSSetState(
+ ID3D10RasterizerState* pRasterizerState) {
+ D3D10RasterizerState* d3d10RasterizerState = static_cast<D3D10RasterizerState*>(pRasterizerState);
+ D3D11RasterizerState* d3d11RasterizerState = d3d10RasterizerState ? d3d10RasterizerState->GetD3D11Iface() : nullptr;
+
+ m_context->RSSetState(d3d11RasterizerState);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::RSSetViewports(
+ UINT NumViewports,
+ const D3D10_VIEWPORT* pViewports) {
+ D3D11_VIEWPORT vp[D3D10_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE];
+
+ if (NumViewports > D3D10_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE)
+ return;
+
+ for (uint32_t i = 0; i < NumViewports; i++) {
+ vp[i].TopLeftX = float(pViewports[i].TopLeftX);
+ vp[i].TopLeftY = float(pViewports[i].TopLeftY);
+ vp[i].Width = float(pViewports[i].Width);
+ vp[i].Height = float(pViewports[i].Height);
+ vp[i].MinDepth = pViewports[i].MinDepth;
+ vp[i].MaxDepth = pViewports[i].MaxDepth;
+ }
+
+ m_context->RSSetViewports(NumViewports, vp);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::RSSetScissorRects(
+ UINT NumRects,
+ const D3D10_RECT* pRects) {
+ m_context->RSSetScissorRects(NumRects, pRects);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::RSGetState(
+ ID3D10RasterizerState** ppRasterizerState) {
+ ID3D11RasterizerState* d3d11RasterizerState = nullptr;
+ m_context->RSGetState(&d3d11RasterizerState);
+
+ *ppRasterizerState = d3d11RasterizerState ? static_cast<D3D11RasterizerState*>(d3d11RasterizerState)->GetD3D10Iface() : nullptr;
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::RSGetViewports(
+ UINT* NumViewports,
+ D3D10_VIEWPORT* pViewports) {
+ D3D11_VIEWPORT vp[D3D10_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE];
+ m_context->RSGetViewports(NumViewports, pViewports != nullptr ? vp : nullptr);
+
+ if (pViewports != nullptr) {
+ for (uint32_t i = 0; i < *NumViewports; i++) {
+ pViewports[i].TopLeftX = int32_t(vp[i].TopLeftX);
+ pViewports[i].TopLeftY = int32_t(vp[i].TopLeftY);
+ pViewports[i].Width = uint32_t(vp[i].Width);
+ pViewports[i].Height = uint32_t(vp[i].Height);
+ pViewports[i].MinDepth = vp[i].MinDepth;
+ pViewports[i].MaxDepth = vp[i].MaxDepth;
+ }
+ }
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::RSGetScissorRects(
+ UINT* NumRects,
+ D3D10_RECT* pRects) {
+ m_context->RSGetScissorRects(NumRects, pRects);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::SOSetTargets(
+ UINT NumBuffers,
+ ID3D10Buffer* const* ppSOTargets,
+ const UINT* pOffsets) {
+ ID3D11Buffer* d3d11Buffers[D3D10_SO_BUFFER_SLOT_COUNT];
+
+ if (NumBuffers > D3D10_SO_BUFFER_SLOT_COUNT)
+ return;
+
+ for (uint32_t i = 0; i < NumBuffers; i++) {
+ d3d11Buffers[i] = ppSOTargets && ppSOTargets[i]
+ ? static_cast<D3D10Buffer*>(ppSOTargets[i])->GetD3D11Iface()
+ : nullptr;
+ }
+
+ m_context->SOSetTargets(NumBuffers, d3d11Buffers, pOffsets);
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::SOGetTargets(
+ UINT NumBuffers,
+ ID3D10Buffer** ppSOTargets,
+ UINT* pOffsets) {
+ ID3D11Buffer* d3d11Buffers[D3D10_SO_BUFFER_SLOT_COUNT];
+
+ m_context->SOGetTargetsWithOffsets(NumBuffers,
+ ppSOTargets ? d3d11Buffers : nullptr,
+ pOffsets);
+
+ if (ppSOTargets != nullptr) {
+ for (uint32_t i = 0; i < NumBuffers; i++) {
+ ppSOTargets[i] = d3d11Buffers[i]
+ ? static_cast<D3D11Buffer*>(d3d11Buffers[i])->GetD3D10Iface()
+ : nullptr;
+ }
+ }
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::SetTextFilterSize(
+ UINT Width,
+ UINT Height) {
+ // D3D10 doesn't seem to actually store or do anything with these values,
+ // as when calling GetTextFilterSize, it just makes the values 0.
+ }
+
+
+ void STDMETHODCALLTYPE D3D10Device::GetTextFilterSize(
+ UINT* pWidth,
+ UINT* pHeight) {
+ if (pWidth)
+ *pWidth = 0;
+
+ if (pHeight)
+ *pHeight = 0;
+ }
+
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-11 19:04:43 +0000