//-----------------------------------------------------------------------
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;
}
}
}
}
}
}
}
}
