//----------------------------------------------------------------------- void HLSLProgramWriter::writeUniformParameter(std::ostream& os, UniformParameterPtr parameter) { bool isHlsl4 = Ogre::RTShader::ShaderGenerator::getSingletonPtr()->IsHlsl4(); GpuConstantType paramType = parameter->getType(); if (isHlsl4 && paramType >= GCT_SAMPLER1D && paramType <= GCT_SAMPLERCUBE) os<<mGpuConstTypeMapV4[paramType]; else os<<mGpuConstTypeMap[paramType]; os << "\t" << parameter->getName(); if (parameter->isArray() == true) { os << "[" << parameter->getSize() << "]"; } if (parameter->isSampler()) { if (isHlsl4) os << " : register(t" << parameter->getIndex() << ")"; else os << " : register(s" << parameter->getIndex() << ")"; } else if (parameter->getType() == GCT_SAMPLER_STATE) { os << " : register(s" << parameter->getIndex() << ")"; } }
//----------------------------------------------------------------------------- void Program::addParameter(UniformParameterPtr parameter) { if (getParameterByName(parameter->getName()).get() != NULL) { OGRE_EXCEPT( Exception::ERR_INVALIDPARAMS, "Parameter <" + parameter->getName() + "> already declared in program.", "Program::addParameter" ); } mParameters.push_back(parameter); }
//----------------------------------------------------------------------- void HLSLProgramWriter::writeUniformParameter(std::ostream& os, UniformParameterPtr parameter) { os << mGpuConstTypeMap[parameter->getType()]; os << "\t"; os << parameter->getName(); if (parameter->isSampler()) { os << " : register(s" << parameter->getIndex() << ")"; } }
//----------------------------------------------------------------------------- void GLSLESProgramProcessor::bindTextureSamplers(Program* pCpuProgram, GpuProgramPtr pGpuProgram) { GpuProgramParametersSharedPtr pGpuParams = pGpuProgram->getDefaultParameters(); const UniformParameterList& progParams = pCpuProgram->getParameters(); UniformParameterConstIterator itParams; // Bind the samplers. for (itParams = progParams.begin(); itParams != progParams.end(); ++itParams) { const UniformParameterPtr pCurParam = *itParams; if (pCurParam->isSampler()) { pGpuParams->setNamedConstant(pCurParam->getName(), pCurParam->getIndex()); } } }
//----------------------------------------------------------------------------- void GLSLESProgramProcessor::bindTextureSamplers(Program* pCpuProgram, GpuProgramPtr pGpuProgram) { GpuProgramParametersSharedPtr pGpuParams = pGpuProgram->getDefaultParameters(); const UniformParameterList& progParams = pCpuProgram->getParameters(); UniformParameterConstIterator itParams; // Bind the samplers. for (itParams = progParams.begin(); itParams != progParams.end(); ++itParams) { const UniformParameterPtr pCurParam = *itParams; if (pCurParam->isSampler()) { // The optimizer may remove some unnecessary parameters, so we should ignore them pGpuParams->setIgnoreMissingParams(true); pGpuParams->setNamedConstant(pCurParam->getName(), pCurParam->getIndex()); } } }
//----------------------------------------------------------------------------- UniformParameterPtr Program::resolveParameter(GpuConstantType type, int index, uint16 variability, const String& suggestedName, size_t size) { UniformParameterPtr param; if (index == -1) { index = 0; // Find the next available index of the target type. UniformParameterIterator it; for (it = mParameters.begin(); it != mParameters.end(); ++it) { if ((*it)->getType() == type && (*it)->isAutoConstantParameter() == false) { index++; } } } else { // Check if parameter already exists. param = getParameterByType(type, index); if (param.get() != NULL) { return param; } } // Create new parameter. param = ParameterFactory::createUniform(type, index, variability, suggestedName, size); addParameter(param); return param; }
//----------------------------------------------------------------------- bool FFPTransform::createCpuSubPrograms(ProgramSet* programSet) { Program* vsProgram = programSet->getCpuVertexProgram(); // Resolve World View Projection Matrix. UniformParameterPtr wvpMatrix = vsProgram->resolveAutoParameterInt(GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX, 0); if (wvpMatrix.get() == NULL) return false; Function* vsEntry = vsProgram->getEntryPointFunction(); assert(vsEntry != NULL); // Resolve input position parameter. ParameterPtr positionIn = vsEntry->resolveInputParameter(Parameter::SPS_POSITION, 0, Parameter::SPC_POSITION_OBJECT_SPACE, GCT_FLOAT4); if (positionIn.get() == NULL) return false; // Resolve output position parameter. ParameterPtr positionOut = vsEntry->resolveOutputParameter(Parameter::SPS_POSITION, 0, Parameter::SPC_POSITION_PROJECTIVE_SPACE, GCT_FLOAT4); if (positionOut.get() == NULL) return false; // Add dependency. vsProgram->addDependency(FFP_LIB_TRANSFORM); FunctionInvocation* transformFunc = OGRE_NEW FunctionInvocation(FFP_FUNC_TRANSFORM, FFP_VS_TRANSFORM, 0); transformFunc->pushOperand(wvpMatrix, Operand::OPS_IN); transformFunc->pushOperand(positionIn, Operand::OPS_IN); transformFunc->pushOperand(positionOut, Operand::OPS_OUT); vsEntry->addAtomInstace(transformFunc); return true; }
//----------------------------------------------------------------------- void CGProgramWriter::writeUniformParameter(std::ostream& os, UniformParameterPtr parameter) { os << mGpuConstTypeMap[parameter->getType()]; os << "\t"; os << parameter->getName(); if (parameter->isArray() == true) { os << "[" << parameter->getSize() << "]"; } if (parameter->isSampler()) { os << " : register(s" << parameter->getIndex() << ")"; } }
//----------------------------------------------------------------------------- UniformParameterPtr Program::resolveAutoParameterInt(GpuProgramParameters::AutoConstantType autoType, GpuConstantType type, size_t data, size_t size) { UniformParameterPtr param; // Check if parameter already exists. param = getParameterByAutoType(autoType); if (param.get() != NULL) { if (param->isAutoConstantIntParameter() && param->getAutoConstantIntData() == data) { param->setSize(std::max(size, param->getSize())); return param; } } // Create new parameter. param = UniformParameterPtr(OGRE_NEW UniformParameter(autoType, data, size, type)); addParameter(param); return param; }
bool operator()( const UniformParameterPtr& uniform, const String& name ) const { return uniform->getName() == name; }
//----------------------------------------------------------------------------- void ProgramProcessor::bindAutoParameters(Program* pCpuProgram, GpuProgramPtr pGpuProgram) { GpuProgramParametersSharedPtr pGpuParams = pGpuProgram->getDefaultParameters(); const UniformParameterList& progParams = pCpuProgram->getParameters(); UniformParameterConstIterator itParams; for (itParams=progParams.begin(); itParams != progParams.end(); ++itParams) { const UniformParameterPtr pCurParam = *itParams; const GpuConstantDefinition* gpuConstDef = pGpuParams->_findNamedConstantDefinition(pCurParam->getName()); if (gpuConstDef != NULL) { // Handle auto parameters. if (pCurParam->isAutoConstantParameter()) { if (pCurParam->isAutoConstantRealParameter()) { pGpuParams->setNamedAutoConstantReal(pCurParam->getName(), pCurParam->getAutoConstantType(), pCurParam->getAutoConstantRealData()); } else if (pCurParam->isAutoConstantIntParameter()) { pGpuParams->setNamedAutoConstant(pCurParam->getName(), pCurParam->getAutoConstantType(), pCurParam->getAutoConstantIntData()); } } // Case this is not auto constant - we have to update its variability ourself. else { gpuConstDef->variability |= pCurParam->getVariability(); // Update variability in the float map. if (gpuConstDef->isSampler() == false) { GpuLogicalBufferStructPtr floatLogical = pGpuParams->getFloatLogicalBufferStruct(); if (floatLogical.get()) { for (GpuLogicalIndexUseMap::const_iterator i = floatLogical->map.begin(); i != floatLogical->map.end(); ++i) { if (i->second.physicalIndex == gpuConstDef->physicalIndex) { i->second.variability |= gpuConstDef->variability; break; } } } } } } } }