void ShaderReflection::ProcessCbuffer(ID3D11ShaderReflectionConstantBuffer* cb) { D3D11_SHADER_VARIABLE_DESC svd; D3D11_SHADER_TYPE_DESC std; ID3D11ShaderReflectionVariable* var; ID3D11ShaderReflectionType* type; VarType vt; Variable v; ConstantBuffer buffer; cb->GetDesc(&buffer.desc); for(u32 j = 0; j < buffer.desc.Variables; ++j) { vt = Unknown; var = cb->GetVariableByIndex(j); type = var->GetType(); var->GetDesc(&svd); type->GetDesc(&std); switch(std.Class) { case D3D_SVC_MATRIX_COLUMNS: { if(std.Rows == 4 && std.Columns == 4) { vt = Matrix4x4; } else if(std.Rows == 3 && std.Columns == 3) { vt = Matrix3x3; } break; } case D3D_SVC_VECTOR: { if(std.Columns == 4) { vt = Vector4; } else if(std.Columns == 3) { vt = Vector3; } else if(std.Columns == 2) { vt = Vector2; } break; } case D3D_SVC_SCALAR: { if(std.Type == D3D_SVT_FLOAT) { vt = Float; } else if(std.Type == D3D_SVT_INT) { vt = Integer; } break; } default: { break; } } v.startOffset = svd.StartOffset; v.elements = std.Elements; v.name = svd.Name; v.type = vt; buffer.vars.push_back(v); } cbuffers.push_back(buffer); }
D3D11RendererVariableManager::D3D11ConstantBuffer* D3D11RendererVariableManager::loadSharedBuffer(ShaderTypeKey typeKey, ID3D11ShaderReflectionConstantBuffer* pReflectionBuffer, const D3D11_SHADER_BUFFER_DESC& sbDesc, const D3D11_BUFFER_DESC& cbDesc) { D3D11ConstantBuffer* pCB = NULL; // Check to see if the specified shared constant buffer has already been created NameBuffersMap::iterator cbIt = mNameToSharedBuffer.find(sbDesc.Name); if (cbIt != mNameToSharedBuffer.end()) { pCB = cbIt->second; if( pCB ) { pCB->addref(); } } else { ID3D11Buffer* pBuffer = NULL; HRESULT result = mRenderer.getD3DDevice()->CreateBuffer(&cbDesc, NULL, &pBuffer); RENDERER_ASSERT(SUCCEEDED(result), "Error creating D3D11 constant buffer."); if (SUCCEEDED(result)) { pCB = new D3D11ConstantBuffer(pBuffer, new PxU8[sbDesc.Size], sbDesc.Size); for (PxU32 i = 0; i < sbDesc.Variables; ++i) { ID3D11ShaderReflectionVariable* pVariable = pReflectionBuffer->GetVariableByIndex(i); D3D11_SHADER_VARIABLE_DESC vDesc; pVariable->GetDesc(&vDesc); ID3D11ShaderReflectionType* pType = pVariable->GetType(); D3D11_SHADER_TYPE_DESC tDesc; pType->GetDesc(&tDesc); mVariables.push_back(new D3D11SharedVariable(vDesc.Name, getVariableType(tDesc), vDesc.StartOffset, pCB)); mNameToSharedVariables[VariableKey(sbDesc.Name, vDesc.Name)] = mVariables.back(); } mNameToSharedBuffer[sbDesc.Name] = pCB; } } return pCB; }
void Shader::ReflectConstantBufferLayouts(ID3D11ShaderReflection* sRefl, EShaderStage type) { D3D11_SHADER_DESC desc; sRefl->GetDesc(&desc); unsigned bufSlot = 0; for (unsigned i = 0; i < desc.ConstantBuffers; ++i) { ConstantBufferLayout bufferLayout; bufferLayout.buffSize = 0; ID3D11ShaderReflectionConstantBuffer* pCBuffer = sRefl->GetConstantBufferByIndex(i); pCBuffer->GetDesc(&bufferLayout.desc); // load desc of each variable for binding on buffer later on for (unsigned j = 0; j < bufferLayout.desc.Variables; ++j) { // get variable and type descriptions ID3D11ShaderReflectionVariable* pVariable = pCBuffer->GetVariableByIndex(j); D3D11_SHADER_VARIABLE_DESC varDesc; pVariable->GetDesc(&varDesc); bufferLayout.variables.push_back(varDesc); ID3D11ShaderReflectionType* pType = pVariable->GetType(); D3D11_SHADER_TYPE_DESC typeDesc; pType->GetDesc(&typeDesc); bufferLayout.types.push_back(typeDesc); // accumulate buffer size bufferLayout.buffSize += varDesc.Size; } bufferLayout.stage = type; bufferLayout.bufSlot = bufSlot; ++bufSlot; m_CBLayouts.push_back(bufferLayout); } }
void ShaderInfo::ReflectShader(ID3D10Blob* shader) { D3D11_SHADER_DESC sd; D3DReflect(shader->GetBufferPointer(), shader->GetBufferSize(), IID_ID3D11ShaderReflection, (void**)&m_reflector); m_reflector->GetDesc(&sd); shaderDesc = sd; for(UINT i = 0; i < sd.InputParameters; i++) { //Mask gives info on how many components D3D11_SIGNATURE_PARAMETER_DESC inputparam_desc; m_reflector->GetInputParameterDesc(i, &inputparam_desc); m_inputParams.push_back(inputparam_desc); } for(UINT i = 0; i < sd.OutputParameters; i++) { D3D11_SIGNATURE_PARAMETER_DESC outputparam_desc; m_reflector->GetOutputParameterDesc(i, &outputparam_desc); m_outputParams.push_back(outputparam_desc); } for(UINT i = 0; i < sd.BoundResources; i++) { D3D11_SHADER_INPUT_BIND_DESC resource_desc; //Bind point is the register location m_reflector->GetResourceBindingDesc(i, &resource_desc); if(resource_desc.Type == D3D_SIT_CBUFFER) { Cbuffer* cbuffer = new Cbuffer(); cbuffer->input_bind_desc = resource_desc; ID3D11ShaderReflectionConstantBuffer* cb = m_reflector->GetConstantBufferByName(cbuffer->input_bind_desc.Name); cb->GetDesc(&cbuffer->buffer_desc); for(UINT j = 0; j < cbuffer->buffer_desc.Variables; j++) { Variable* var = new Variable(); ID3D11ShaderReflectionVariable* variable = cb->GetVariableByIndex(j); variable->GetDesc(&var->var); ID3D11ShaderReflectionType* type = variable->GetType(); type->GetDesc(&var->type); cbuffer->vars.push_back(var); //register cbuff vars with ShaderVars object // switch(var->type.Class) { // case D3D_SVC_MATRIX_COLUMNS: // if(var->type.Rows == 4 && var->type.Columns == 4) { // cbp->AddMatrix(var->var.Name); // } // else if(var->type.Rows == 3 && var->type.Columns == 3) { // // } // break; // case D3D_SVC_VECTOR: // if(var->type.Columns == 4) { // cbp->AddVector(var->var.Name); // } // else if(var->type.Columns == 3) { // // } // else if(var->type.Columns == 2) { // // } // break; // case D3D_SVC_SCALAR: // if(var->type.Type == D3D_SVT_FLOAT) { // cbp->AddScalar(var->var.Name); // } // break; // default: // break; // } } m_cbuffers.push_back(cbuffer); } else if(resource_desc.Type == D3D_SIT_SAMPLER) { m_samplers.push_back(resource_desc); } else if(resource_desc.Type == D3D_SIT_TEXTURE) { m_textures.push_back(resource_desc); } else { m_resources.push_back(resource_desc); } } }
bool compileHLSLShaderDx11(bx::CommandLine& _cmdLine, const std::string& _code, bx::WriterI* _writer) { BX_TRACE("DX11"); const char* profile = _cmdLine.findOption('p', "profile"); if (NULL == profile) { fprintf(stderr, "Shader profile must be specified.\n"); return false; } bool debug = _cmdLine.hasArg('\0', "debug"); uint32_t flags = D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY; flags |= debug ? D3DCOMPILE_DEBUG : 0; flags |= _cmdLine.hasArg('\0', "avoid-flow-control") ? D3DCOMPILE_AVOID_FLOW_CONTROL : 0; flags |= _cmdLine.hasArg('\0', "no-preshader") ? D3DCOMPILE_NO_PRESHADER : 0; flags |= _cmdLine.hasArg('\0', "partial-precision") ? D3DCOMPILE_PARTIAL_PRECISION : 0; flags |= _cmdLine.hasArg('\0', "prefer-flow-control") ? D3DCOMPILE_PREFER_FLOW_CONTROL : 0; flags |= _cmdLine.hasArg('\0', "backwards-compatibility") ? D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY : 0; bool werror = _cmdLine.hasArg('\0', "Werror"); if (werror) { flags |= D3DCOMPILE_WARNINGS_ARE_ERRORS; } uint32_t optimization = 3; if (_cmdLine.hasArg(optimization, 'O') ) { optimization = bx::uint32_min(optimization, BX_COUNTOF(s_optimizationLevelDx11)-1); flags |= s_optimizationLevelDx11[optimization]; } else { flags |= D3DCOMPILE_SKIP_OPTIMIZATION; } BX_TRACE("Profile: %s", profile); BX_TRACE("Flags: 0x%08x", flags); ID3DBlob* code; ID3DBlob* errorMsg; // Output preprocessed shader so that HLSL can be debugged via GPA // or PIX. Compiling through memory won't embed preprocessed shader // file path. std::string hlslfp; if (debug) { hlslfp = _cmdLine.findOption('o'); hlslfp += ".hlsl"; writeFile(hlslfp.c_str(), _code.c_str(), (int32_t)_code.size() ); } HRESULT hr = D3DCompile(_code.c_str() , _code.size() , hlslfp.c_str() , NULL , NULL , "main" , profile , flags , 0 , &code , &errorMsg ); if (FAILED(hr) || (werror && NULL != errorMsg) ) { const char* log = (char*)errorMsg->GetBufferPointer(); int32_t line = 0; int32_t column = 0; int32_t start = 0; int32_t end = INT32_MAX; if (2 == sscanf(log, "(%u,%u):", &line, &column) && 0 != line) { start = bx::uint32_imax(1, line-10); end = start + 20; } printCode(_code.c_str(), line, start, end); fprintf(stderr, "Error: 0x%08x %s\n", (uint32_t)hr, log); errorMsg->Release(); return false; } UniformArray uniforms; ID3D11ShaderReflection* reflect = NULL; hr = D3DReflect(code->GetBufferPointer() , code->GetBufferSize() , IID_ID3D11ShaderReflection , (void**)&reflect ); if (FAILED(hr) ) { fprintf(stderr, "Error: 0x%08x\n", (uint32_t)hr); return false; } D3D11_SHADER_DESC desc; hr = reflect->GetDesc(&desc); if (FAILED(hr) ) { fprintf(stderr, BX_FILE_LINE_LITERAL "Error: 0x%08x\n", (uint32_t)hr); return false; } BX_TRACE("Creator: %s 0x%08x", desc.Creator, desc.Version); BX_TRACE("Num constant buffers: %d", desc.ConstantBuffers); BX_TRACE("Input:"); uint8_t numAttrs = 0; uint16_t attrs[bgfx::Attrib::Count]; if (profile[0] == 'v') // Only care about input semantic on vertex shaders { for (uint32_t ii = 0; ii < desc.InputParameters; ++ii) { D3D11_SIGNATURE_PARAMETER_DESC spd; reflect->GetInputParameterDesc(ii, &spd); BX_TRACE("\t%2d: %s%d, vt %d, ct %d, mask %x, reg %d" , ii , spd.SemanticName , spd.SemanticIndex , spd.SystemValueType , spd.ComponentType , spd.Mask , spd.Register ); const RemapInputSemantic& ris = findInputSemantic(spd.SemanticName, spd.SemanticIndex); if (ris.m_attr != bgfx::Attrib::Count) { attrs[numAttrs] = bgfx::attribToId(ris.m_attr); ++numAttrs; } } } BX_TRACE("Output:"); for (uint32_t ii = 0; ii < desc.OutputParameters; ++ii) { D3D11_SIGNATURE_PARAMETER_DESC spd; reflect->GetOutputParameterDesc(ii, &spd); BX_TRACE("\t%2d: %s%d, %d, %d", ii, spd.SemanticName, spd.SemanticIndex, spd.SystemValueType, spd.ComponentType); } uint16_t size = 0; for (uint32_t ii = 0; ii < bx::uint32_min(1, desc.ConstantBuffers); ++ii) { ID3D11ShaderReflectionConstantBuffer* cbuffer = reflect->GetConstantBufferByIndex(ii); D3D11_SHADER_BUFFER_DESC bufferDesc; hr = cbuffer->GetDesc(&bufferDesc); size = (uint16_t)bufferDesc.Size; if (SUCCEEDED(hr) ) { BX_TRACE("%s, %d, vars %d, size %d" , bufferDesc.Name , bufferDesc.Type , bufferDesc.Variables , bufferDesc.Size ); for (uint32_t jj = 0; jj < bufferDesc.Variables; ++jj) { ID3D11ShaderReflectionVariable* var = cbuffer->GetVariableByIndex(jj); ID3D11ShaderReflectionType* type = var->GetType(); D3D11_SHADER_VARIABLE_DESC varDesc; hr = var->GetDesc(&varDesc); if (SUCCEEDED(hr) ) { D3D11_SHADER_TYPE_DESC constDesc; hr = type->GetDesc(&constDesc); if (SUCCEEDED(hr) ) { UniformType::Enum uniformType = findUniformTypeDx11(constDesc); if (UniformType::Count != uniformType && 0 != (varDesc.uFlags & D3D_SVF_USED) ) { Uniform un; un.name = varDesc.Name; un.type = uniformType; un.num = constDesc.Elements; un.regIndex = varDesc.StartOffset; un.regCount = BX_ALIGN_16(varDesc.Size)/16; uniforms.push_back(un); BX_TRACE("\t%s, %d, size %d, flags 0x%08x, %d" , varDesc.Name , varDesc.StartOffset , varDesc.Size , varDesc.uFlags , uniformType ); } else { BX_TRACE("\t%s, unknown type", varDesc.Name); } } } } } } BX_TRACE("Bound:"); for (uint32_t ii = 0; ii < desc.BoundResources; ++ii) { D3D11_SHADER_INPUT_BIND_DESC bindDesc; hr = reflect->GetResourceBindingDesc(ii, &bindDesc); if (SUCCEEDED(hr) ) { // if (bindDesc.Type == D3D_SIT_SAMPLER) { BX_TRACE("\t%s, %d, %d, %d" , bindDesc.Name , bindDesc.Type , bindDesc.BindPoint , bindDesc.BindCount ); } } } uint16_t count = (uint16_t)uniforms.size(); bx::write(_writer, count); uint32_t fragmentBit = profile[0] == 'p' ? BGFX_UNIFORM_FRAGMENTBIT : 0; for (UniformArray::const_iterator it = uniforms.begin(); it != uniforms.end(); ++it) { const Uniform& un = *it; uint8_t nameSize = (uint8_t)un.name.size(); bx::write(_writer, nameSize); bx::write(_writer, un.name.c_str(), nameSize); uint8_t type = un.type|fragmentBit; bx::write(_writer, type); bx::write(_writer, un.num); bx::write(_writer, un.regIndex); bx::write(_writer, un.regCount); BX_TRACE("%s, %s, %d, %d, %d" , un.name.c_str() , getUniformTypeName(un.type) , un.num , un.regIndex , un.regCount ); } { ID3DBlob* stripped; hr = D3DStripShader(code->GetBufferPointer() , code->GetBufferSize() , D3DCOMPILER_STRIP_REFLECTION_DATA | D3DCOMPILER_STRIP_TEST_BLOBS , &stripped ); if (SUCCEEDED(hr) ) { code->Release(); code = stripped; } } uint16_t shaderSize = (uint16_t)code->GetBufferSize(); bx::write(_writer, shaderSize); bx::write(_writer, code->GetBufferPointer(), shaderSize); uint8_t nul = 0; bx::write(_writer, nul); bx::write(_writer, numAttrs); bx::write(_writer, attrs, numAttrs*sizeof(uint16_t) ); bx::write(_writer, size); if (_cmdLine.hasArg('\0', "disasm") ) { ID3DBlob* disasm; D3DDisassemble(code->GetBufferPointer() , code->GetBufferSize() , 0 , NULL , &disasm ); if (NULL != disasm) { std::string disasmfp = _cmdLine.findOption('o'); disasmfp += ".disasm"; writeFile(disasmfp.c_str(), disasm->GetBufferPointer(), (uint32_t)disasm->GetBufferSize() ); disasm->Release(); } } if (NULL != reflect) { reflect->Release(); } if (NULL != errorMsg) { errorMsg->Release(); } code->Release(); return true; }
D3D11RendererVariableManager::D3D11ConstantBuffer* D3D11RendererVariableManager::loadBuffer(std::vector<D3D11RendererMaterial::Variable*>& variables, PxU32& variableBufferSize, ShaderTypeKey typeKey, ID3D11ShaderReflectionConstantBuffer* pReflectionBuffer, const D3D11_SHADER_BUFFER_DESC& sbDesc, const D3D11_BUFFER_DESC& cbDesc) { ID3D11Buffer* pBuffer = NULL; D3D11ConstantBuffer* pCB = NULL; HRESULT result = mRenderer.getD3DDevice()->CreateBuffer(&cbDesc, NULL, &pBuffer); RENDERER_ASSERT(SUCCEEDED(result), "Error creating D3D11 constant buffer."); if (SUCCEEDED(result)) { pCB = new D3D11ConstantBuffer(pBuffer, new PxU8[sbDesc.Size], sbDesc.Size); try { for (PxU32 i = 0; i < sbDesc.Variables; ++i) { ID3D11ShaderReflectionVariable* pVariable = pReflectionBuffer->GetVariableByIndex(i); D3D11_SHADER_VARIABLE_DESC vDesc; pVariable->GetDesc(&vDesc); ID3D11ShaderReflectionType* pType = pVariable->GetType(); D3D11_SHADER_TYPE_DESC tDesc; pType->GetDesc(&tDesc); RendererMaterial::VariableType type = getVariableType(tDesc); D3D11DataVariable* var = 0; // Search to see if the variable already exists... PxU32 numVariables = (PxU32)variables.size(); for (PxU32 j = 0; j < numVariables; ++j) { if (!strcmp(variables[j]->getName(), vDesc.Name)) { var = static_cast<D3D11DataVariable*>(variables[j]); break; } } // Check to see if the variable is of the same type. if (var) { RENDERER_ASSERT(var->getType() == type, "Variable changes type!"); } // If we couldn't find the variable... create a new variable... if (!var) { var = new D3D11DataVariable(vDesc.Name, type, variableBufferSize); variables.push_back(var); variableBufferSize += var->getDataSize(); } PxU8* varData = pCB->data + vDesc.StartOffset; var->addHandle(typeKey, varData, &(pCB->bDirty)); } } catch(...) { RENDERER_ASSERT(0, "Exception in processing D3D shader variables"); delete pCB; } } return pCB; }
bool getReflectionDataD3D11(ID3DBlob* _code, bool _vshader, UniformArray& _uniforms, uint8_t& _numAttrs, uint16_t* _attrs, uint16_t& _size, UniformNameList& unusedUniforms) { ID3D11ShaderReflection* reflect = NULL; HRESULT hr = D3DReflect(_code->GetBufferPointer() , _code->GetBufferSize() , s_compiler->IID_ID3D11ShaderReflection , (void**)&reflect ); if (FAILED(hr) ) { fprintf(stderr, "Error: D3DReflect failed 0x%08x\n", (uint32_t)hr); return false; } D3D11_SHADER_DESC desc; hr = reflect->GetDesc(&desc); if (FAILED(hr) ) { fprintf(stderr, "Error: ID3D11ShaderReflection::GetDesc failed 0x%08x\n", (uint32_t)hr); return false; } BX_TRACE("Creator: %s 0x%08x", desc.Creator, desc.Version); BX_TRACE("Num constant buffers: %d", desc.ConstantBuffers); BX_TRACE("Input:"); if (_vshader) // Only care about input semantic on vertex shaders { for (uint32_t ii = 0; ii < desc.InputParameters; ++ii) { D3D11_SIGNATURE_PARAMETER_DESC spd; reflect->GetInputParameterDesc(ii, &spd); BX_TRACE("\t%2d: %s%d, vt %d, ct %d, mask %x, reg %d" , ii , spd.SemanticName , spd.SemanticIndex , spd.SystemValueType , spd.ComponentType , spd.Mask , spd.Register ); const RemapInputSemantic& ris = findInputSemantic(spd.SemanticName, spd.SemanticIndex); if (ris.m_attr != bgfx::Attrib::Count) { _attrs[_numAttrs] = bgfx::attribToId(ris.m_attr); ++_numAttrs; } } } BX_TRACE("Output:"); for (uint32_t ii = 0; ii < desc.OutputParameters; ++ii) { D3D11_SIGNATURE_PARAMETER_DESC spd; reflect->GetOutputParameterDesc(ii, &spd); BX_TRACE("\t%2d: %s%d, %d, %d", ii, spd.SemanticName, spd.SemanticIndex, spd.SystemValueType, spd.ComponentType); } for (uint32_t ii = 0, num = bx::uint32_min(1, desc.ConstantBuffers); ii < num; ++ii) { ID3D11ShaderReflectionConstantBuffer* cbuffer = reflect->GetConstantBufferByIndex(ii); D3D11_SHADER_BUFFER_DESC bufferDesc; hr = cbuffer->GetDesc(&bufferDesc); _size = (uint16_t)bufferDesc.Size; if (SUCCEEDED(hr) ) { BX_TRACE("%s, %d, vars %d, size %d" , bufferDesc.Name , bufferDesc.Type , bufferDesc.Variables , bufferDesc.Size ); for (uint32_t jj = 0; jj < bufferDesc.Variables; ++jj) { ID3D11ShaderReflectionVariable* var = cbuffer->GetVariableByIndex(jj); ID3D11ShaderReflectionType* type = var->GetType(); D3D11_SHADER_VARIABLE_DESC varDesc; hr = var->GetDesc(&varDesc); if (SUCCEEDED(hr) ) { D3D11_SHADER_TYPE_DESC constDesc; hr = type->GetDesc(&constDesc); if (SUCCEEDED(hr) ) { UniformType::Enum uniformType = findUniformType(constDesc); if (UniformType::Count != uniformType && 0 != (varDesc.uFlags & D3D_SVF_USED) ) { Uniform un; un.name = varDesc.Name; un.type = uniformType; un.num = constDesc.Elements; un.regIndex = varDesc.StartOffset; un.regCount = BX_ALIGN_16(varDesc.Size) / 16; _uniforms.push_back(un); BX_TRACE("\t%s, %d, size %d, flags 0x%08x, %d (used)" , varDesc.Name , varDesc.StartOffset , varDesc.Size , varDesc.uFlags , uniformType ); } else { if (0 == (varDesc.uFlags & D3D_SVF_USED) ) { unusedUniforms.push_back(varDesc.Name); } BX_TRACE("\t%s, unknown type", varDesc.Name); } } } } } } BX_TRACE("Bound:"); for (uint32_t ii = 0; ii < desc.BoundResources; ++ii) { D3D11_SHADER_INPUT_BIND_DESC bindDesc; hr = reflect->GetResourceBindingDesc(ii, &bindDesc); if (SUCCEEDED(hr) ) { if (D3D_SIT_SAMPLER == bindDesc.Type) { BX_TRACE("\t%s, %d, %d, %d" , bindDesc.Name , bindDesc.Type , bindDesc.BindPoint , bindDesc.BindCount ); const char * end = strstr(bindDesc.Name, "Sampler"); if (NULL != end) { Uniform un; un.name.assign(bindDesc.Name, (end - bindDesc.Name) ); un.type = UniformType::Enum(BGFX_UNIFORM_SAMPLERBIT | UniformType::Int1); un.num = 1; un.regIndex = bindDesc.BindPoint; un.regCount = bindDesc.BindCount; _uniforms.push_back(un); } } } } if (NULL != reflect) { reflect->Release(); } return true; }
//------------------------------------------------------------------------------- // @ IvConstantTableD3D11::Create() //------------------------------------------------------------------------------- // Get the constant table for this shader //------------------------------------------------------------------------------- IvConstantTableD3D11* IvConstantTableD3D11::Create(ID3D11Device* device, ID3DBlob* code) { ID3D11ShaderReflection* pReflector = nullptr; D3DReflect(code->GetBufferPointer(), code->GetBufferSize(), IID_ID3D11ShaderReflection, (void**)&pReflector); // first get constant table IvConstantTableD3D11* table = new IvConstantTableD3D11(); ID3D11ShaderReflectionConstantBuffer* globalConstants = pReflector->GetConstantBufferByName("$Globals"); D3D11_SHADER_BUFFER_DESC constantBufferDesc = { 0 }; HRESULT hr = globalConstants->GetDesc(&constantBufferDesc); if (FAILED(hr)) { // no constants in this shader goto get_textures; } table->mBacking = new char[constantBufferDesc.Size]; table->mBackingSize = constantBufferDesc.Size; if (nullptr == table->mBacking) { delete table; pReflector->Release(); return nullptr; } for (unsigned int i = 0; i < constantBufferDesc.Variables; ++i) { ID3D11ShaderReflectionVariable* var = globalConstants->GetVariableByIndex(i); D3D11_SHADER_VARIABLE_DESC varDesc; if (FAILED(var->GetDesc(&varDesc))) { delete table; pReflector->Release(); return nullptr; } ID3D11ShaderReflectionType* type = var->GetType(); D3D11_SHADER_TYPE_DESC typeDesc; if (FAILED(type->GetDesc(&typeDesc))) { delete table; pReflector->Release(); return nullptr; } IvConstantDesc constantDesc; constantDesc.mOffset = table->mBacking + varDesc.StartOffset; if (typeDesc.Class == D3D_SVC_SCALAR && typeDesc.Type == D3D_SVT_FLOAT) { constantDesc.mType = IvUniformType::kFloatUniform; } else if (typeDesc.Class == D3D_SVC_VECTOR && typeDesc.Type == D3D_SVT_FLOAT && typeDesc.Columns == 3) { constantDesc.mType = IvUniformType::kFloat3Uniform; } else if (typeDesc.Class == D3D_SVC_VECTOR && typeDesc.Type == D3D_SVT_FLOAT && typeDesc.Columns == 4) { constantDesc.mType = IvUniformType::kFloat4Uniform; } else if ((typeDesc.Class == D3D_SVC_MATRIX_ROWS || typeDesc.Class == D3D_SVC_MATRIX_COLUMNS) && typeDesc.Type == D3D_SVT_FLOAT && typeDesc.Rows == 4 && typeDesc.Columns == 4) { constantDesc.mType = IvUniformType::kFloatMatrix44Uniform; } else { // unsupported uniform type delete table; pReflector->Release(); return nullptr; } constantDesc.mCount = typeDesc.Elements != 0 ? typeDesc.Elements : 1; table->mConstants[varDesc.Name] = constantDesc; } D3D11_BUFFER_DESC cbDesc; cbDesc.ByteWidth = constantBufferDesc.Size; cbDesc.Usage = D3D11_USAGE_DYNAMIC; cbDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; cbDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; cbDesc.MiscFlags = 0; cbDesc.StructureByteStride = 0; if (FAILED(device->CreateBuffer(&cbDesc, nullptr, &table->mBuffer))) { delete table; pReflector->Release(); return nullptr; } get_textures: // now get any textures and samplers D3D11_SHADER_DESC shaderDesc = { 0 }; hr = pReflector->GetDesc(&shaderDesc); if (FAILED(hr)) { pReflector->Release(); return table; } int resourceCount = shaderDesc.BoundResources; for (int i = 0; i < resourceCount; ++i) { D3D11_SHADER_INPUT_BIND_DESC bindingDesc = { 0 }; pReflector->GetResourceBindingDesc(i, &bindingDesc); if (bindingDesc.Type == D3D_SIT_TEXTURE && bindingDesc.ReturnType == D3D_RETURN_TYPE_FLOAT && bindingDesc.Dimension == D3D_SRV_DIMENSION_TEXTURE2D && bindingDesc.NumSamples == -1 && bindingDesc.BindCount == 1) { IvConstantDesc& constantDesc = table->mConstants[bindingDesc.Name]; constantDesc.mType = IvUniformType::kTextureUniform; constantDesc.mTextureSlot = bindingDesc.BindPoint; } else if (bindingDesc.Type == D3D_SIT_SAMPLER && bindingDesc.BindCount == 1) { char strippedName[256]; const char* samplerKeyword = strstr(bindingDesc.Name, "Sampler"); strncpy(strippedName, bindingDesc.Name, samplerKeyword - bindingDesc.Name); strippedName[samplerKeyword - bindingDesc.Name] = '\0'; IvConstantDesc& constantDesc = table->mConstants[strippedName]; constantDesc.mType = IvUniformType::kTextureUniform; constantDesc.mSamplerSlot = bindingDesc.BindPoint; } else if (bindingDesc.Type == D3D_SIT_CBUFFER && !_strnicmp(bindingDesc.Name, "$Globals", 8)) { // ignore this, we handled it above } else { // unsupported resource type delete table; pReflector->Release(); return nullptr; } } pReflector->Release(); return table; }