summaryrefslogtreecommitdiffstats
path: root/src/libs/dxvk-native-1.9.2a/src/d3d10/d3d10_reflection.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/libs/dxvk-native-1.9.2a/src/d3d10/d3d10_reflection.cpp')
-rw-r--r--src/libs/dxvk-native-1.9.2a/src/d3d10/d3d10_reflection.cpp326
1 files changed, 326 insertions, 0 deletions
diff --git a/src/libs/dxvk-native-1.9.2a/src/d3d10/d3d10_reflection.cpp b/src/libs/dxvk-native-1.9.2a/src/d3d10/d3d10_reflection.cpp
new file mode 100644
index 00000000..d49dea90
--- /dev/null
+++ b/src/libs/dxvk-native-1.9.2a/src/d3d10/d3d10_reflection.cpp
@@ -0,0 +1,326 @@
+#include "d3d10_reflection.h"
+
+namespace dxvk {
+
+ D3D10ShaderReflectionType::D3D10ShaderReflectionType(
+ ID3D11ShaderReflectionType* d3d11)
+ : m_d3d11(d3d11) {
+
+ }
+
+
+ D3D10ShaderReflectionType::~D3D10ShaderReflectionType() {
+
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10ShaderReflectionType::GetDesc(
+ D3D10_SHADER_TYPE_DESC* pDesc) {
+ D3D11_SHADER_TYPE_DESC d3d11Desc;
+ HRESULT hr = m_d3d11->GetDesc(&d3d11Desc);
+
+ if (FAILED(hr))
+ return hr;
+
+ pDesc->Class = D3D10_SHADER_VARIABLE_CLASS(d3d11Desc.Class);
+ pDesc->Type = D3D10_SHADER_VARIABLE_TYPE (d3d11Desc.Type);
+ pDesc->Rows = d3d11Desc.Rows;
+ pDesc->Columns = d3d11Desc.Columns;
+ pDesc->Elements = d3d11Desc.Elements;
+ pDesc->Members = d3d11Desc.Members;
+ pDesc->Offset = d3d11Desc.Offset;
+ return S_OK;
+ }
+
+
+ ID3D10ShaderReflectionType* STDMETHODCALLTYPE D3D10ShaderReflectionType::GetMemberTypeByIndex(
+ UINT Index) {
+ return FindMemberType(m_d3d11->GetMemberTypeByIndex(Index));
+ }
+
+
+ ID3D10ShaderReflectionType* STDMETHODCALLTYPE D3D10ShaderReflectionType::GetMemberTypeByName(
+ const char* Name) {
+ return FindMemberType(m_d3d11->GetMemberTypeByName(Name));
+ }
+
+
+ const char* STDMETHODCALLTYPE D3D10ShaderReflectionType::GetMemberTypeName(
+ UINT Index) {
+ return m_d3d11->GetMemberTypeName(Index);
+ }
+
+
+ ID3D10ShaderReflectionType* D3D10ShaderReflectionType::FindMemberType(
+ ID3D11ShaderReflectionType* pMemberType) {
+ if (!pMemberType)
+ return nullptr;
+
+ auto entry = m_members.find(pMemberType);
+
+ if (entry == m_members.end()) {
+ entry = m_members.insert({ pMemberType,
+ std::make_unique<D3D10ShaderReflectionType>(pMemberType) }).first;
+ }
+
+ return entry->second.get();
+ }
+
+
+ D3D10ShaderReflectionVariable::D3D10ShaderReflectionVariable(ID3D11ShaderReflectionVariable* d3d11)
+ : m_d3d11(d3d11), m_type(m_d3d11->GetType()) {
+
+ }
+
+
+ D3D10ShaderReflectionVariable::~D3D10ShaderReflectionVariable() {
+
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10ShaderReflectionVariable::GetDesc(
+ D3D10_SHADER_VARIABLE_DESC* pDesc) {
+ D3D11_SHADER_VARIABLE_DESC d3d11Desc;
+ HRESULT hr = m_d3d11->GetDesc(&d3d11Desc);
+
+ if (FAILED(hr))
+ return hr;
+
+ pDesc->Name = d3d11Desc.Name;
+ pDesc->StartOffset = d3d11Desc.StartOffset;
+ pDesc->Size = d3d11Desc.Size;
+ pDesc->uFlags = d3d11Desc.uFlags;
+ pDesc->DefaultValue = d3d11Desc.DefaultValue;
+ return S_OK;
+ }
+
+
+ ID3D10ShaderReflectionType* STDMETHODCALLTYPE D3D10ShaderReflectionVariable::GetType() {
+ return &m_type;
+ }
+
+
+ D3D10ShaderReflectionConstantBuffer::D3D10ShaderReflectionConstantBuffer(
+ ID3D11ShaderReflectionConstantBuffer* d3d11)
+ : m_d3d11(d3d11) {
+
+ }
+
+
+ D3D10ShaderReflectionConstantBuffer::~D3D10ShaderReflectionConstantBuffer() {
+
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10ShaderReflectionConstantBuffer::GetDesc(
+ D3D10_SHADER_BUFFER_DESC* pDesc) {
+ D3D11_SHADER_BUFFER_DESC d3d11Desc;
+ HRESULT hr = m_d3d11->GetDesc(&d3d11Desc);
+
+ if (FAILED(hr))
+ return hr;
+
+ pDesc->Name = d3d11Desc.Name;
+ pDesc->Type = D3D10_CBUFFER_TYPE(d3d11Desc.Type);
+ pDesc->Variables = d3d11Desc.Variables;
+ pDesc->Size = d3d11Desc.Size;
+ pDesc->uFlags = d3d11Desc.uFlags;
+ return S_OK;
+ }
+
+
+ ID3D10ShaderReflectionVariable* STDMETHODCALLTYPE D3D10ShaderReflectionConstantBuffer::GetVariableByIndex(
+ UINT Index) {
+ return FindVariable(m_d3d11->GetVariableByIndex(Index));
+ }
+
+
+ ID3D10ShaderReflectionVariable* STDMETHODCALLTYPE D3D10ShaderReflectionConstantBuffer::GetVariableByName(
+ LPCSTR Name) {
+ return FindVariable(m_d3d11->GetVariableByName(Name));
+ }
+
+
+ ID3D10ShaderReflectionVariable* D3D10ShaderReflectionConstantBuffer::FindVariable(
+ ID3D11ShaderReflectionVariable* pVariable) {
+ if (!pVariable)
+ return nullptr;
+
+ auto entry = m_variables.find(pVariable);
+
+ if (entry == m_variables.end()) {
+ entry = m_variables.emplace(
+ std::piecewise_construct,
+ std::forward_as_tuple(pVariable),
+ std::forward_as_tuple(pVariable)).first;
+ }
+
+ return &entry->second;
+ }
+
+
+ D3D10ShaderReflection::D3D10ShaderReflection(ID3D11ShaderReflection* d3d11)
+ : m_d3d11(d3d11) {
+
+ }
+
+
+ D3D10ShaderReflection::~D3D10ShaderReflection() {
+
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10ShaderReflection::QueryInterface(
+ REFIID riid,
+ void** ppvObject) {
+ if (ppvObject == nullptr)
+ return E_POINTER;
+
+ static const GUID IID_ID3D10ShaderReflection
+ = {0xd40e20b6,0xf8f7,0x42ad,{0xab,0x20,0x4b,0xaf,0x8f,0x15,0xdf,0xaa}};
+
+ if (riid == __uuidof(IUnknown)
+ || riid == IID_ID3D10ShaderReflection) {
+ *ppvObject = ref(this);
+ return S_OK;
+ }
+
+ return E_NOINTERFACE;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10ShaderReflection::GetDesc(
+ D3D10_SHADER_DESC* pDesc) {
+ D3D11_SHADER_DESC d3d11Desc;
+ HRESULT hr = m_d3d11->GetDesc(&d3d11Desc);
+
+ if (FAILED(hr))
+ return hr;
+
+ pDesc->Version = d3d11Desc.Version;
+ pDesc->Creator = d3d11Desc.Creator;
+ pDesc->Flags = d3d11Desc.Flags;
+ pDesc->ConstantBuffers = d3d11Desc.ConstantBuffers;
+ pDesc->BoundResources = d3d11Desc.BoundResources;
+ pDesc->InputParameters = d3d11Desc.InputParameters;
+ pDesc->OutputParameters = d3d11Desc.OutputParameters;
+ pDesc->InstructionCount = d3d11Desc.InstructionCount;
+ pDesc->TempRegisterCount = d3d11Desc.TempRegisterCount;
+ pDesc->TempArrayCount = d3d11Desc.TempArrayCount;
+ pDesc->DefCount = d3d11Desc.DefCount;
+ pDesc->DclCount = d3d11Desc.DclCount;
+ pDesc->TextureNormalInstructions = d3d11Desc.TextureNormalInstructions;
+ pDesc->TextureLoadInstructions = d3d11Desc.TextureLoadInstructions;
+ pDesc->TextureCompInstructions = d3d11Desc.TextureCompInstructions;
+ pDesc->TextureBiasInstructions = d3d11Desc.TextureBiasInstructions;
+ pDesc->TextureGradientInstructions = d3d11Desc.TextureGradientInstructions;
+ pDesc->FloatInstructionCount = d3d11Desc.FloatInstructionCount;
+ pDesc->IntInstructionCount = d3d11Desc.IntInstructionCount;
+ pDesc->UintInstructionCount = d3d11Desc.UintInstructionCount;
+ pDesc->StaticFlowControlCount = d3d11Desc.StaticFlowControlCount;
+ pDesc->DynamicFlowControlCount = d3d11Desc.DynamicFlowControlCount;
+ pDesc->MacroInstructionCount = d3d11Desc.MacroInstructionCount;
+ pDesc->ArrayInstructionCount = d3d11Desc.ArrayInstructionCount;
+ pDesc->CutInstructionCount = d3d11Desc.CutInstructionCount;
+ pDesc->EmitInstructionCount = d3d11Desc.EmitInstructionCount;
+ pDesc->GSOutputTopology = D3D10_PRIMITIVE_TOPOLOGY(d3d11Desc.GSOutputTopology);
+ pDesc->GSMaxOutputVertexCount = d3d11Desc.GSMaxOutputVertexCount;
+ return S_OK;
+ }
+
+
+ ID3D10ShaderReflectionConstantBuffer* STDMETHODCALLTYPE
+ D3D10ShaderReflection::GetConstantBufferByIndex(
+ UINT Index) {
+ return FindConstantBuffer(m_d3d11->GetConstantBufferByIndex(Index));
+ }
+
+
+ ID3D10ShaderReflectionConstantBuffer* STDMETHODCALLTYPE
+ D3D10ShaderReflection::GetConstantBufferByName(
+ LPCSTR Name) {
+ return FindConstantBuffer(m_d3d11->GetConstantBufferByName(Name));
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10ShaderReflection::GetInputParameterDesc(
+ UINT ParameterIndex,
+ D3D10_SIGNATURE_PARAMETER_DESC* pDesc) {
+ D3D11_SIGNATURE_PARAMETER_DESC d3d11Desc;
+ HRESULT hr = m_d3d11->GetInputParameterDesc(ParameterIndex, &d3d11Desc);
+
+ if (FAILED(hr))
+ return hr;
+
+ ConvertSignatureParameterDesc(&d3d11Desc, pDesc);
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10ShaderReflection::GetOutputParameterDesc(
+ UINT ParameterIndex,
+ D3D10_SIGNATURE_PARAMETER_DESC* pDesc) {
+ D3D11_SIGNATURE_PARAMETER_DESC d3d11Desc;
+ HRESULT hr = m_d3d11->GetOutputParameterDesc(ParameterIndex, &d3d11Desc);
+
+ if (FAILED(hr))
+ return hr;
+
+ ConvertSignatureParameterDesc(&d3d11Desc, pDesc);
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE D3D10ShaderReflection::GetResourceBindingDesc(
+ UINT ResourceIndex,
+ D3D10_SHADER_INPUT_BIND_DESC* pDesc) {
+ D3D11_SHADER_INPUT_BIND_DESC d3d11Desc;
+ HRESULT hr = m_d3d11->GetResourceBindingDesc(
+ ResourceIndex, &d3d11Desc);
+
+ if (FAILED(hr))
+ return hr;
+
+ pDesc->Name = d3d11Desc.Name;
+ pDesc->Type = D3D10_SHADER_INPUT_TYPE(d3d11Desc.Type);
+ pDesc->BindPoint = d3d11Desc.BindPoint;
+ pDesc->BindCount = d3d11Desc.BindCount;
+ pDesc->uFlags = d3d11Desc.uFlags;
+ pDesc->ReturnType = D3D10_RESOURCE_RETURN_TYPE(d3d11Desc.ReturnType);
+ pDesc->Dimension = D3D10_SRV_DIMENSION (d3d11Desc.Dimension);
+ pDesc->NumSamples = d3d11Desc.NumSamples;
+ return S_OK;
+ }
+
+
+ ID3D10ShaderReflectionConstantBuffer* D3D10ShaderReflection::FindConstantBuffer(
+ ID3D11ShaderReflectionConstantBuffer* pConstantBuffer) {
+ if (!pConstantBuffer)
+ return nullptr;
+
+ auto entry = m_constantBuffers.find(pConstantBuffer);
+
+ if (entry == m_constantBuffers.end()) {
+ entry = m_constantBuffers.emplace(
+ std::piecewise_construct,
+ std::forward_as_tuple(pConstantBuffer),
+ std::forward_as_tuple(pConstantBuffer)).first;
+ }
+
+ return &entry->second;
+ }
+
+
+ void D3D10ShaderReflection::ConvertSignatureParameterDesc(
+ const D3D11_SIGNATURE_PARAMETER_DESC* pSrcDesc,
+ D3D10_SIGNATURE_PARAMETER_DESC* pDstDesc) {
+ pDstDesc->SemanticName = pSrcDesc->SemanticName;
+ pDstDesc->SemanticIndex = pSrcDesc->SemanticIndex;
+ pDstDesc->Register = pSrcDesc->Register;
+ pDstDesc->SystemValueType = D3D10_NAME(pSrcDesc->SystemValueType);
+ pDstDesc->ComponentType = D3D10_REGISTER_COMPONENT_TYPE(pSrcDesc->ComponentType);
+ pDstDesc->Mask = pSrcDesc->Mask;
+ pDstDesc->ReadWriteMask = pSrcDesc->ReadWriteMask;
+ }
+
+} \ No newline at end of file
generated by cgit v1.2.3 (git 2.39.1) at 2024-08-12 02:06:28 +0000