TString UniformHLSL::uniformsHeader(ShShaderOutput outputType, const ReferencedSymbols &referencedUniforms) { TString uniforms; for (ReferencedSymbols::const_iterator uniformIt = referencedUniforms.begin(); uniformIt != referencedUniforms.end(); uniformIt++) { const TIntermSymbol &uniform = *uniformIt->second; const TType &type = uniform.getType(); const TString &name = uniform.getSymbol(); int registerIndex = declareUniformAndAssignRegister(type, name); if (outputType == SH_HLSL11_OUTPUT && IsSampler(type.getBasicType())) // Also declare the texture { uniforms += "uniform " + SamplerString(type) + " sampler_" + DecorateUniform(name, type) + ArrayString(type) + " : register(s" + str(registerIndex) + ");\n"; uniforms += "uniform " + TextureString(type) + " texture_" + DecorateUniform(name, type) + ArrayString(type) + " : register(t" + str(registerIndex) + ");\n"; } else { const TStructure *structure = type.getStruct(); const TString &typeName = (structure ? QualifiedStructNameString(*structure, false, false) : TypeString(type)); const TString ®isterString = TString("register(") + UniformRegisterPrefix(type) + str(registerIndex) + ")"; uniforms += "uniform " + typeName + " " + DecorateUniform(name, type) + ArrayString(type) + " : " + registerString + ";\n"; } } return (uniforms.empty() ? "" : ("// Uniforms\n\n" + uniforms)); }
TString UniformHLSL::interfaceBlocksHeader(const ReferencedSymbols &referencedInterfaceBlocks) { TString interfaceBlocks; for (ReferencedSymbols::const_iterator interfaceBlockIt = referencedInterfaceBlocks.begin(); interfaceBlockIt != referencedInterfaceBlocks.end(); interfaceBlockIt++) { const TType &nodeType = interfaceBlockIt->second->getType(); const TInterfaceBlock &interfaceBlock = *nodeType.getInterfaceBlock(); const TFieldList &fieldList = interfaceBlock.fields(); unsigned int arraySize = static_cast<unsigned int>(interfaceBlock.arraySize()); InterfaceBlock activeBlock(interfaceBlock.name().c_str(), arraySize, mInterfaceBlockRegister); for (unsigned int typeIndex = 0; typeIndex < fieldList.size(); typeIndex++) { const TField &field = *fieldList[typeIndex]; const TString &fullFieldName = InterfaceBlockFieldName(interfaceBlock, field); bool isRowMajor = (field.type()->getLayoutQualifier().matrixPacking == EmpRowMajor); GetInterfaceBlockFieldTraverser traverser(&activeBlock.fields, isRowMajor); traverser.traverse(*field.type(), fullFieldName); } mInterfaceBlockRegisterMap[activeBlock.name] = mInterfaceBlockRegister; mInterfaceBlockRegister += std::max(1u, arraySize); BlockLayoutType blockLayoutType = GetBlockLayoutType(interfaceBlock.blockStorage()); SetBlockLayout(&activeBlock, blockLayoutType); if (interfaceBlock.matrixPacking() == EmpRowMajor) { activeBlock.isRowMajorLayout = true; } mActiveInterfaceBlocks.push_back(activeBlock); if (interfaceBlock.hasInstanceName()) { interfaceBlocks += interfaceBlockStructString(interfaceBlock); } if (arraySize > 0) { for (unsigned int arrayIndex = 0; arrayIndex < arraySize; arrayIndex++) { interfaceBlocks += interfaceBlockString(interfaceBlock, activeBlock.registerIndex + arrayIndex, arrayIndex); } } else { interfaceBlocks += interfaceBlockString(interfaceBlock, activeBlock.registerIndex, GL_INVALID_INDEX); } } return (interfaceBlocks.empty() ? "" : ("// Interface Blocks\n\n" + interfaceBlocks)); }
TString UniformHLSL::uniformBlocksHeader(const ReferencedSymbols &referencedInterfaceBlocks) { TString interfaceBlocks; for (ReferencedSymbols::const_iterator interfaceBlockIt = referencedInterfaceBlocks.begin(); interfaceBlockIt != referencedInterfaceBlocks.end(); interfaceBlockIt++) { const TType &nodeType = interfaceBlockIt->second->getType(); const TInterfaceBlock &interfaceBlock = *nodeType.getInterfaceBlock(); // nodeType.isInterfaceBlock() == false means the node is a field of a uniform block which // doesn't have instance name, so this block cannot be an array. unsigned int interfaceBlockArraySize = 0u; if (nodeType.isInterfaceBlock() && nodeType.isArray()) { interfaceBlockArraySize = nodeType.getOutermostArraySize(); } unsigned int activeRegister = mUniformBlockRegister; mUniformBlockRegisterMap[interfaceBlock.name().c_str()] = activeRegister; mUniformBlockRegister += std::max(1u, interfaceBlockArraySize); // FIXME: interface block field names if (interfaceBlock.hasInstanceName()) { interfaceBlocks += uniformBlockStructString(interfaceBlock); } if (interfaceBlockArraySize > 0) { for (unsigned int arrayIndex = 0; arrayIndex < interfaceBlockArraySize; arrayIndex++) { interfaceBlocks += uniformBlockString(interfaceBlock, activeRegister + arrayIndex, arrayIndex); } } else { interfaceBlocks += uniformBlockString(interfaceBlock, activeRegister, GL_INVALID_INDEX); } } return (interfaceBlocks.empty() ? "" : ("// Uniform Blocks\n\n" + interfaceBlocks)); }
TString UniformHLSL::uniformsHeader(ShShaderOutput outputType, const ReferencedSymbols &referencedUniforms) { TString uniforms; for (ReferencedSymbols::const_iterator uniformIt = referencedUniforms.begin(); uniformIt != referencedUniforms.end(); uniformIt++) { const TIntermSymbol &uniform = *uniformIt->second; const TType &type = uniform.getType(); const TString &name = uniform.getSymbol(); unsigned int registerIndex = declareUniformAndAssignRegister(type, name); if (outputType == SH_HLSL11_OUTPUT && IsSampler(type.getBasicType())) // Also declare the texture { uniforms += "uniform " + SamplerString(type) + " sampler_" + DecorateUniform(name, type) + ArrayString(type) + " : register(s" + str(registerIndex) + ");\n"; uniforms += "uniform " + TextureString(type) + " texture_" + DecorateUniform(name, type) + ArrayString(type) + " : register(t" + str(registerIndex) + ");\n"; } else { const TStructure *structure = type.getStruct(); // If this is a nameless struct, we need to use its full definition, rather than its (empty) name. // TypeString() will invoke defineNameless in this case; qualifier prefixes are unnecessary for // nameless structs in ES, as nameless structs cannot be used anywhere that layout qualifiers are // permitted. const TString &typeName = ((structure && !structure->name().empty()) ? QualifiedStructNameString(*structure, false, false) : TypeString(type)); const TString ®isterString = TString("register(") + UniformRegisterPrefix(type) + str(registerIndex) + ")"; uniforms += "uniform " + typeName + " " + DecorateUniform(name, type) + ArrayString(type) + " : " + registerString + ";\n"; } } return (uniforms.empty() ? "" : ("// Uniforms\n\n" + uniforms)); }
TString UniformHLSL::interfaceBlocksHeader(const ReferencedSymbols &referencedInterfaceBlocks) { TString interfaceBlocks; for (ReferencedSymbols::const_iterator interfaceBlockIt = referencedInterfaceBlocks.begin(); interfaceBlockIt != referencedInterfaceBlocks.end(); interfaceBlockIt++) { const TType &nodeType = interfaceBlockIt->second->getType(); const TInterfaceBlock &interfaceBlock = *nodeType.getInterfaceBlock(); unsigned int arraySize = static_cast<unsigned int>(interfaceBlock.arraySize()); unsigned int activeRegister = mInterfaceBlockRegister; mInterfaceBlockRegisterMap[interfaceBlock.name().c_str()] = activeRegister; mInterfaceBlockRegister += std::max(1u, arraySize); // FIXME: interface block field names if (interfaceBlock.hasInstanceName()) { interfaceBlocks += interfaceBlockStructString(interfaceBlock); } if (arraySize > 0) { for (unsigned int arrayIndex = 0; arrayIndex < arraySize; arrayIndex++) { interfaceBlocks += interfaceBlockString(interfaceBlock, activeRegister + arrayIndex, arrayIndex); } } else { interfaceBlocks += interfaceBlockString(interfaceBlock, activeRegister, GL_INVALID_INDEX); } } return (interfaceBlocks.empty() ? "" : ("// Interface Blocks\n\n" + interfaceBlocks)); }
void UniformHLSL::uniformsHeader(TInfoSinkBase &out, ShShaderOutput outputType, const ReferencedSymbols &referencedUniforms) { if (!referencedUniforms.empty()) { out << "// Uniforms\n\n"; } // In the case of HLSL 4, sampler uniforms need to be grouped by type before the code is // written. They are grouped based on the combination of the HLSL texture type and // HLSL sampler type, enumerated in HLSLTextureSamplerGroup. TVector<TVector<const TIntermSymbol *>> groupedSamplerUniforms(HLSL_TEXTURE_MAX + 1); TMap<const TIntermSymbol *, TString> samplerInStructSymbolsToAPINames; for (auto &uniformIt : referencedUniforms) { // Output regular uniforms. Group sampler uniforms by type. const TIntermSymbol &uniform = *uniformIt.second; const TType &type = uniform.getType(); const TName &name = uniform.getName(); if (outputType == SH_HLSL_4_1_OUTPUT && IsSampler(type.getBasicType())) { HLSLTextureSamplerGroup group = TextureGroup(type.getBasicType()); groupedSamplerUniforms[group].push_back(&uniform); } else if (outputType == SH_HLSL_4_0_FL9_3_OUTPUT && IsSampler(type.getBasicType())) { unsigned int registerIndex = assignUniformRegister(type, name.getString(), nullptr); outputHLSL4_0_FL9_3Sampler(out, type, name, registerIndex); } else { if (type.isStructureContainingSamplers()) { TVector<TIntermSymbol *> samplerSymbols; TMap<TIntermSymbol *, TString> symbolsToAPINames; unsigned int arrayOfStructsSize = type.isArray() ? type.getArraySize() : 0u; type.createSamplerSymbols("angle_" + name.getString(), name.getString(), arrayOfStructsSize, &samplerSymbols, &symbolsToAPINames); for (TIntermSymbol *sampler : samplerSymbols) { const TType &samplerType = sampler->getType(); // Will use angle_ prefix instead of regular prefix. sampler->setInternal(true); const TName &samplerName = sampler->getName(); if (outputType == SH_HLSL_4_1_OUTPUT) { HLSLTextureSamplerGroup group = TextureGroup(samplerType.getBasicType()); groupedSamplerUniforms[group].push_back(sampler); samplerInStructSymbolsToAPINames[sampler] = symbolsToAPINames[sampler]; } else if (outputType == SH_HLSL_4_0_FL9_3_OUTPUT) { unsigned int registerIndex = assignSamplerInStructUniformRegister( samplerType, symbolsToAPINames[sampler], nullptr); outputHLSL4_0_FL9_3Sampler(out, samplerType, samplerName, registerIndex); } else { ASSERT(outputType == SH_HLSL_3_0_OUTPUT); unsigned int registerIndex = assignSamplerInStructUniformRegister( samplerType, symbolsToAPINames[sampler], nullptr); outputUniform(out, samplerType, samplerName, registerIndex); } } } unsigned int registerIndex = assignUniformRegister(type, name.getString(), nullptr); outputUniform(out, type, name, registerIndex); } } if (outputType == SH_HLSL_4_1_OUTPUT) { unsigned int groupTextureRegisterIndex = 0; // TEXTURE_2D is special, index offset is assumed to be 0 and omitted in that case. ASSERT(HLSL_TEXTURE_MIN == HLSL_TEXTURE_2D); for (int groupId = HLSL_TEXTURE_MIN; groupId < HLSL_TEXTURE_MAX; ++groupId) { outputHLSLSamplerUniformGroup( out, HLSLTextureSamplerGroup(groupId), groupedSamplerUniforms[groupId], samplerInStructSymbolsToAPINames, &groupTextureRegisterIndex); } } }
void UniformHLSL::uniformsHeader(TInfoSinkBase &out, ShShaderOutput outputType, const ReferencedSymbols &referencedUniforms) { if (!referencedUniforms.empty()) { out << "// Uniforms\n\n"; } // In the case of HLSL 4, sampler uniforms need to be grouped by type before the code is // written. They are grouped based on the combination of the HLSL texture type and // HLSL sampler type, enumerated in HLSLTextureSamplerGroup. TVector<TVector<const TIntermSymbol *>> groupedSamplerUniforms; groupedSamplerUniforms.resize(HLSL_TEXTURE_MAX + 1); for (auto &uniformIt : referencedUniforms) { // Output regular uniforms. Group sampler uniforms by type. const TIntermSymbol &uniform = *uniformIt.second; const TType &type = uniform.getType(); const TString &name = uniform.getSymbol(); if (outputType == SH_HLSL_4_1_OUTPUT && IsSampler(type.getBasicType())) { HLSLTextureSamplerGroup group = TextureGroup(type.getBasicType()); groupedSamplerUniforms[group].push_back(&uniform); } else if (outputType == SH_HLSL_4_0_FL9_3_OUTPUT && IsSampler(type.getBasicType())) { unsigned int registerIndex = declareUniformAndAssignRegister(type, name); out << "uniform " << SamplerString(type.getBasicType()) << " sampler_" << DecorateUniform(name, type) << ArrayString(type) << " : register(s" << str(registerIndex) << ");\n"; out << "uniform " << TextureString(type.getBasicType()) << " texture_" << DecorateUniform(name, type) << ArrayString(type) << " : register(t" << str(registerIndex) << ");\n"; } else { unsigned int registerIndex = declareUniformAndAssignRegister(type, name); const TStructure *structure = type.getStruct(); // If this is a nameless struct, we need to use its full definition, rather than its (empty) name. // TypeString() will invoke defineNameless in this case; qualifier prefixes are unnecessary for // nameless structs in ES, as nameless structs cannot be used anywhere that layout qualifiers are // permitted. const TString &typeName = ((structure && !structure->name().empty()) ? QualifiedStructNameString(*structure, false, false) : TypeString(type)); const TString ®isterString = TString("register(") + UniformRegisterPrefix(type) + str(registerIndex) + ")"; out << "uniform " << typeName << " " << DecorateUniform(name, type) << ArrayString(type) << " : " << registerString << ";\n"; } } if (outputType == SH_HLSL_4_1_OUTPUT) { unsigned int groupTextureRegisterIndex = 0; // TEXTURE_2D is special, index offset is assumed to be 0 and omitted in that case. ASSERT(HLSL_TEXTURE_MIN == HLSL_TEXTURE_2D); for (int groupId = HLSL_TEXTURE_MIN; groupId < HLSL_TEXTURE_MAX; ++groupId) { outputHLSLSamplerUniformGroup(out, HLSLTextureSamplerGroup(groupId), groupedSamplerUniforms[groupId], &groupTextureRegisterIndex); } } }