GeneratorPtr Session::create_generator_from_node(TiXmlElement* element, Region* region){
fsom::DebugStream << "Attempting to create generator"<<std::endl;
GeneratorPtr gen = GeneratorPtr(new Generator(Generator::GEN_Sine,dspCreationStruct(region)));
TiXmlElement* basicInfoElement = element->FirstChildElement("BasicInfo");
if(basicInfoElement){
fsom::DebugStream << "Generator basic info found"<<std::endl;
int genType,noiseState;
std::string path = basicInfoElement->Attribute("Path");
basicInfoElement->QueryIntAttribute("GenType",&genType);
basicInfoElement->QueryIntAttribute("NoiseState",&noiseState);
Generator::GeneratorType type = Generator::GeneratorType(genType);
gen->set_generator_voice(type);
gen->set_noise_state(noiseState);
gen->set_file_path(path);
fsom::DebugStream << "noise state for gen set to "<<noiseState<<std::endl;
fsom::DebugStream << "gen type = "<<genType<<std::endl;
}
TiXmlElement * child = element->FirstChildElement("Parameter");
while(child){
fsom::DebugStream << "Parameter in generator found"<<std::endl;
ParameterPtr p = create_parameter_from_node(child, region);
gen->get_parameter(p->get_name())->set_value(p->get_value());
child = child->NextSiblingElement("Parameter");
}
return gen;
}
void V3Manipulator::readParameterOptions( MFnDagNode &nodeFn )
{
ParameterisedHolderInterface *pHolder = dynamic_cast<ParameterisedHolderInterface *>( nodeFn.userNode() );
if( !pHolder )
{
return;
}
ParameterPtr parameter = pHolder->plugParameter( m_plug );
CompoundObjectPtr userData = parameter->userData();
if( CompoundObjectPtr uiData = userData->member<CompoundObject>( "UI" ) )
{
// World space parameter values
if( StringDataPtr wsData = uiData->member<StringData>( "manipSpace" ) )
{
if( wsData->readable() == "world" )
{
m_worldSpace = true;
}
else if( wsData->readable() == "object" )
{
m_worldSpace = false;
}
else
{
MGlobal::displayWarning( "V3Manipulator: Ignoring invalid v3ManipSpace '"
+ MString( wsData->readable().c_str() )
+ "' for parameter '"
+ MString( parameter->name().c_str() )
+ "', using 'object'." );
}
}
}
}
SynthesisModulePtr Session::create_module_from_node(TiXmlElement* element, Region* region){
fsom::DebugStream << "Attempting to create module from node"<<std::endl;
TiXmlElement* basicInfoElement = element->FirstChildElement("BasicInfo");
SynthesisModulePtr module;
if(basicInfoElement){
fsom::DebugStream << "Module basic info found"<<std::endl;
std::string name = basicInfoElement->Attribute("Type");
module = SynthesisModuleManager::get_instance().create(name,dspCreationStruct(region));
TiXmlElement * child = element->FirstChildElement("Parameter");
while(child){
fsom::DebugStream << "Parameter in module found"<<std::endl;
ParameterPtr p = create_parameter_from_node(child, region);
module->get_parameter(p->get_name())->set_value(p->get_value());
child = child->NextSiblingElement("Parameter");
}
return module;
}
///WARNING POSSIBLE TO RETURN WITHOUT A VALUE
// SynthesisModulePtr
}
void RecurrentLayerGroup::initSubNetwork(
NeuralNetwork* rootNetwork,
const ModelConfig& config,
const std::vector<ParameterType>& parameterTypes,
bool useGpu) {
setNeedGradient(true);
network_.reset(new RecurrentGradientMachine(config_.name(), rootNetwork));
ParamInitCallback cb = [this, rootNetwork](int paramId, Parameter* para) {
para->enableSharedType(
PARAMETER_VALUE,
rootNetwork->getParameters()[paramId]->getBuf(PARAMETER_VALUE),
rootNetwork->getParameters()[paramId]->getMat(PARAMETER_VALUE));
para->enableSharedType(
PARAMETER_GRADIENT,
rootNetwork->getParameters()[paramId]->getBuf(PARAMETER_GRADIENT),
rootNetwork->getParameters()[paramId]->getMat(PARAMETER_GRADIENT));
};
network_->init(config, cb, parameterTypes, useGpu);
for (auto paramId : network_->getParameterIds()) {
ParameterPtr parameter = rootNetwork->getParameters()[paramId];
parameter->incShared();
CHECK_EQ(parameter->getDeviceId(), getDeviceId());
parameters_.push_back(parameter);
}
}
//-----------------------------------------------------------------------------
ParameterPtr Function::resolveLocalParameter(Parameter::Semantic semantic, int index,
const String& name,
GpuConstantType type)
{
ParameterPtr param;
param = getParameterByName(mLocalParameters, name);
if (param.get() != NULL)
{
if (param->getType() == type &&
param->getSemantic() == semantic &&
param->getIndex() == index)
{
return param;
}
else
{
OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
"Can not resolve local parameter due to type mismatch. Function <" + getName() + ">",
"Function::resolveLocalParameter" );
}
}
param = ParameterPtr(OGRE_NEW Parameter(type, name, semantic, index, Parameter::SPC_UNKNOWN));
addParameter(mLocalParameters, param);
return param;
}
DSPEffectPtr Session::create_effect_from_node(TiXmlElement* element,Region* region){
assert(element);
std::string typeName = element->Attribute("name");
DSPEffectPtr t = DSPManager::get_instance().create(typeName,dspCreationStruct(region));
assert(t);
TiXmlElement * meta = element->FirstChildElement("MetaData");
//TODO streamline this process of loading, specific function for loading dspeffect and region meta needed
const char* tut = meta->Attribute("TutorialLink");
t->register_meta("TutorialLink");
t->set_meta("TutorialLink",std::string(tut));
TiXmlElement * child = element->FirstChildElement("Parameter");
while(child){
ParameterPtr p = create_parameter_from_node(child, region);
t->get_parameter(p->get_name())->set_value(p->get_value());
t->get_parameter(p->get_name())->set_breakpoints(p->get_breakpoints());
child = child->NextSiblingElement("Parameter");
}
fsom::DebugStream << "Loaded effect:" << typeName << std::endl;
return t;
}
//-----------------------------------------------------------------------------
void ProgramProcessor::replaceParametersReferences(MergeParameterList& mergedParams, ParameterOperandMap& paramsRefMap)
{
for (unsigned int i=0; i < mergedParams.size(); ++i)
{
MergeParameter& curMergeParameter = mergedParams[i];
int paramBitMaskOffset = 0;
for (unsigned int j=0; j < curMergeParameter.getSourceParameterCount(); ++j)
{
ParameterPtr curSrcParam = curMergeParameter.getSourceParameter(j);
ParameterOperandMap::iterator itParamRefs = paramsRefMap.find(curSrcParam.get());
// Case the source parameter has some references
if (itParamRefs != paramsRefMap.end())
{
OperandPtrVector& srcParamRefs = itParamRefs->second;
ParameterPtr dstParameter;
// Case the source parameter is fully contained within the destination merged parameter.
if (curMergeParameter.getSourceParameterMask(j) == Operand::OPM_ALL)
{
dstParameter = curMergeParameter.getDestinationParameter(Operand::OPS_INOUT, i);
for (unsigned int op=0; op < srcParamRefs.size(); ++op)
{
Operand* srcOperandPtr = srcParamRefs[op];
int dstOpMask;
if (srcOperandPtr->getMask() == Operand::OPM_ALL)
{
// Case the merged parameter contains only one source - no point in adding special mask.
if (curMergeParameter.getSourceParameterCount() == 1)
{
dstOpMask = Operand::OPM_ALL;
}
else
{
dstOpMask = getParameterMaskByType(curSrcParam->getType()) << paramBitMaskOffset;
}
}
else
{
dstOpMask = srcOperandPtr->getMask() << paramBitMaskOffset;
}
// Replace the original source operand with a new operand the reference the new merged parameter.
*srcOperandPtr = Operand(dstParameter, srcOperandPtr->getSemantic(), dstOpMask);
}
}
}
// Update the bit mask offset.
paramBitMaskOffset += getParameterFloatCount(curSrcParam->getType());
}
}
}
//-----------------------------------------------------------------------
void GLSLProgramWriter::writeOutParameters(std::ostream& os, Function* function, GpuProgramType gpuType)
{
const ShaderParameterList& outParams = function->getOutputParameters();
ShaderParameterConstIterator itParam = outParams.begin();
ShaderParameterConstIterator itParamEnd = outParams.end();
for ( ; itParam != itParamEnd; ++itParam)
{
ParameterPtr pParam = *itParam;
if(gpuType == GPT_VERTEX_PROGRAM)
{
// GLSL vertex program has to write always gl_Position (but this is also deprecated after version 130)
if(pParam->getContent() == Parameter::SPC_POSITION_PROJECTIVE_SPACE)
{
mInputToGLStatesMap[pParam->getName()] = "gl_Position";
}
else
{
// After GLSL 1.20 varying is deprecated
if(mGLSLVersion <= 120)
{
os << "varying\t";
}
else
{
os << "out\t";
}
os << mGpuConstTypeMap[pParam->getType()];
os << "\t";
os << pParam->getName();
if (pParam->isArray() == true)
{
os << "[" << pParam->getSize() << "]";
}
os << ";" << std::endl;
}
}
else if(gpuType == GPT_FRAGMENT_PROGRAM &&
pParam->getSemantic() == Parameter::SPS_COLOR)
{
// GLSL fragment program has to write always gl_FragColor (but this is also deprecated after version 130)
// Always add gl_FragColor as an output. The name is for compatibility.
if(mGLSLVersion <= 130)
{
mInputToGLStatesMap[pParam->getName()] = "gl_FragColor";
}
else
{
os << "out vec4 fragColour;" << std::endl;
mInputToGLStatesMap[pParam->getName()] = "fragColour";
}
}
}
}
//-----------------------------------------------------------------------------
void ProgramProcessor::buildTexcoordTable(const ShaderParameterList& paramList, ShaderParameterList outParamsTable[4])
{
ShaderParameterConstIterator it = paramList.begin();
ShaderParameterConstIterator itEnd = paramList.end();
for (; it != itEnd; ++it)
{
const ParameterPtr curParam = *it;
if (curParam->getSemantic() == Parameter::SPS_TEXTURE_COORDINATES)
{
switch (curParam->getType())
{
case GCT_FLOAT1:
outParamsTable[0].push_back(curParam);
break;
case GCT_FLOAT2:
outParamsTable[1].push_back(curParam);
break;
case GCT_FLOAT3:
outParamsTable[2].push_back(curParam);
break;
case GCT_FLOAT4:
outParamsTable[3].push_back(curParam);
break;
case GCT_SAMPLER1D:
case GCT_SAMPLER2D:
case GCT_SAMPLER2DARRAY:
case GCT_SAMPLER3D:
case GCT_SAMPLERCUBE:
case GCT_SAMPLER1DSHADOW:
case GCT_SAMPLER2DSHADOW:
case GCT_MATRIX_2X2:
case GCT_MATRIX_2X3:
case GCT_MATRIX_2X4:
case GCT_MATRIX_3X2:
case GCT_MATRIX_3X3:
case GCT_MATRIX_3X4:
case GCT_MATRIX_4X2:
case GCT_MATRIX_4X3:
case GCT_MATRIX_4X4:
case GCT_INT1:
case GCT_INT2:
case GCT_INT3:
case GCT_INT4:
case GCT_UNKNOWN:
default:
break;
}
}
}
}
ParameterPtr toParameter(char* keyP,
int keyLen,
char* valP,
int valLen)
{
ParameterPtr parameter = new Parameter();
parameter->set_key(keyP, keyLen);
parameter->set_value(valP, valLen);
return parameter;
}
//-----------------------------------------------------------------------
void CGProgramWriter::writeLocalParameter(std::ostream& os, ParameterPtr parameter)
{
os << mGpuConstTypeMap[parameter->getType()];
os << "\t";
os << parameter->getName();
if (parameter->isArray() == true)
{
os << "[" << parameter->getSize() << "]";
}
}
void testSerialization(T min, T max)
{
YAML::Node node;
T def = min;
{
ParameterPtr p = factory::declareRange<T>("foo", min, max, def, 1);
p->serialize_yaml(node);
EXPECT_STREQ(p->name().c_str(), node["name"].as<std::string>().c_str());
EXPECT_STREQ("range", node["type"].as<std::string>().c_str());
}
{
ParameterPtr p = factory::makeEmpty(node["type"].as<std::string>());
ASSERT_NE(nullptr, p);
p->deserialize_yaml(node);
RangeParameterPtr range = std::dynamic_pointer_cast<RangeParameter>(p);
ASSERT_NE(nullptr, range);
EXPECT_STREQ("foo", range->name().c_str());
EXPECT_EQ(min, range->min<T>());
EXPECT_EQ(max, range->max<T>());
auto val = range->as<T>();
EXPECT_EQ(def, val);
}
SerializationBuffer buffer;
{
ParameterPtr p = factory::declareRange<T>("foo", min, max, def, 1);
ParameterSerializer::instance().serialize(*p, buffer);
}
{
StreamablePtr s = ParameterSerializer::instance().deserialize(buffer);
ASSERT_NE(nullptr, s);
ParameterPtr p = std::dynamic_pointer_cast<Parameter>(s);
ASSERT_NE(nullptr, p);
RangeParameterPtr range = std::dynamic_pointer_cast<RangeParameter>(p);
ASSERT_NE(nullptr, range);
EXPECT_STREQ("foo", range->name().c_str());
EXPECT_EQ(min, range->min<T>());
EXPECT_EQ(max, range->max<T>());
auto val = range->as<T>();
EXPECT_EQ(def, val);
}
}
void Session::load_region_parameters(TiXmlElement* element,Region* region){
TiXmlElement * child = element->FirstChildElement("Parameter");
while(child){
ParameterPtr p = create_parameter_from_node(child, region);
region->get_parameter(p->get_name())->set_value(p->get_value());
region->get_parameter(p->get_name())->set_breakpoints(p->get_breakpoints());
child = child->NextSiblingElement("Parameter");
}
}
//-----------------------------------------------------------------------------
void Function::addOutputParameter(ParameterPtr parameter)
{
// Check that parameter with the same semantic and index in output parameters list.
if (getParameterBySemantic(mOutputParameters, parameter->getSemantic(), parameter->getIndex()).get() != NULL)
{
OGRE_EXCEPT( Exception::ERR_INVALIDPARAMS,
"Parameter <" + parameter->getName() + "> has equal sematic parameter in function <" + getName() + ">",
"Function::addOutputParameter" );
}
addParameter(mOutputParameters, parameter);
}
//-----------------------------------------------------------------------------
void ProgramProcessor::generateLocalSplitParameters(Function* func, GpuProgramType progType,
MergeParameterList& mergedParams,
ShaderParameterList& splitParams, LocalParameterMap& localParamsMap)
{
// No split params created.
if (splitParams.size() == 0)
return;
// Create the local parameters + map from source to local.
for (unsigned int i=0; i < splitParams.size(); ++i)
{
ParameterPtr srcParameter = splitParams[i];
ParameterPtr localParameter = func->resolveLocalParameter(srcParameter->getSemantic(), srcParameter->getIndex(), "lsplit_" + srcParameter->getName(), srcParameter->getType());
localParamsMap[srcParameter.get()] = localParameter;
}
int invocationCounter = 0;
// Establish link between the local parameter to the merged parameter.
for (unsigned int i=0; i < mergedParams.size(); ++i)
{
MergeParameter& curMergeParameter = mergedParams[i];
for (unsigned int p=0; p < curMergeParameter.getSourceParameterCount(); ++p)
{
ParameterPtr srcMergedParameter = curMergeParameter.getSourceParameter(p);
LocalParameterMap::iterator itFind = localParamsMap.find(srcMergedParameter.get());
// Case the source parameter is split parameter.
if (itFind != localParamsMap.end())
{
// Case it is the vertex shader -> assign the local parameter to the output merged parameter.
if (progType == GPT_VERTEX_PROGRAM)
{
FunctionInvocation* curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_ASSIGN, FFP_VS_POST_PROCESS, invocationCounter++);
curFuncInvocation->pushOperand(itFind->second, Operand::OPS_IN, curMergeParameter.getSourceParameterMask(p));
curFuncInvocation->pushOperand(curMergeParameter.getDestinationParameter(Operand::OPS_OUT, i), Operand::OPS_OUT, curMergeParameter.getDestinationParameterMask(p));
func->addAtomInstance(curFuncInvocation);
}
else if (progType == GPT_FRAGMENT_PROGRAM)
{
FunctionInvocation* curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_ASSIGN, FFP_PS_PRE_PROCESS, invocationCounter++);
curFuncInvocation->pushOperand(curMergeParameter.getDestinationParameter(Operand::OPS_IN, i), Operand::OPS_IN, curMergeParameter.getDestinationParameterMask(p));
curFuncInvocation->pushOperand(itFind->second, Operand::OPS_OUT, curMergeParameter.getSourceParameterMask(p));
func->addAtomInstance(curFuncInvocation);
}
}
}
}
}
void fromParameter(ParameterPtr parameter,
char** keyP,
int* keyLenP,
char** valueP,
int* valueLenP)
{
std::string* k = parameter->mutable_key();
std::string* v = parameter->mutable_value();
*keyP = (char*) k->data();
*keyLenP = k->size();
*valueP = (char*) v->data();
*valueLenP = v->size();
}
//-----------------------------------------------------------------------------
ParameterPtr Function::resolveLocalParameter(Parameter::Semantic semantic, int index,
const Parameter::Content content,
GpuConstantType type)
{
ParameterPtr param;
param = getParameterByContent(mLocalParameters, content, type);
if (param.get() != NULL)
return param;
param = ParameterPtr(OGRE_NEW Parameter(type, "lLocalParam_" + StringConverter::toString(mLocalParameters.size()), semantic, index, content));
addParameter(mLocalParameters, param);
return param;
}
ParameterHandlerPtr CompoundParameterHandler::handler( const ParameterPtr child, bool createIfMissing )
{
HandlerMap::const_iterator it = m_handlers.find( child );
if( it!=m_handlers.end() )
{
return it->second;
}
ParameterHandlerPtr h = 0;
if( createIfMissing )
{
IECore::ConstBoolDataPtr noHostMapping = child->userData()->member<BoolData>( "noHostMapping" );
if( !noHostMapping || !noHostMapping->readable() )
{
h = ParameterHandler::create( child );
if( !h )
{
IECore::msg( IECore::Msg::Warning, "Gaffer::CompoundParameterHandler", boost::format( "Unable to create handler for parameter \"%s\" of type \"%s\"" ) % child->name() % child->typeName() );
}
}
}
m_handlers[child] = h;
return h;
}
bool CalculusUnambiguousRangeParameter::set(const uint &value)
{
ParameterPtr p = _depthCamera.getParam(MOD_F);
CalculusModulationFrequencyParameter *mfp = dynamic_cast<CalculusModulationFrequencyParameter *>(p.get());
if(!mfp)
return false;
float modulationFrequency1Minimum = mfp->getOptimalMinimum(), modulationFrequency1Maximum = mfp->getOptimalMaximum();
FrameRate r;
if(!_depthCamera._getFrameRate(r))
return false;
// No need of dealiasing?
if(value <= (uint)(4095*SPEED_OF_LIGHT/1E6f/2/(1 << 12)/modulationFrequency1Minimum))
{
float modulationFrequency1 = 4095*SPEED_OF_LIGHT/1E6f/2/(1 << 12)/value;
if(!_depthCamera._set(TG_EN, false) ||
!_depthCamera._setFrameRate(r) ||
!mfp->set(modulationFrequency1) ||
!_depthCamera._set(DEALIAS_EN, false) ||// Disable dealiasing explicitly)
!_depthCamera._set(ALT_FRM_EN, false) ||
!_depthCamera._set(SCRATCH2, value) || // Save the value in a register
!_depthCamera._set(TG_EN, true))
return false;
_value = value;
return true;
}
else
{
int rangeExtensionRatio = ceil(log2(value/(SPEED_OF_LIGHT/(2*modulationFrequency1Maximum*1E6))));
if(rangeExtensionRatio > 6)
{
logger(LOG_ERROR) << "CalculusUnambiguousRangeParameter: Desired unambiguous range is too large." << std::endl;
return false;
}
if(!_depthCamera._set(TG_EN, false) ||
!_depthCamera._set(ALT_FRM_EN, true) ||
!mfp->set(modulationFrequency1Maximum) ||
!_depthCamera._set(ALT_FREQ_SEL, rangeExtensionRatio - 1) ||
!_depthCamera._setFrameRate(r) ||
!_depthCamera._set(DEALIAS_EN, true) ||
//!UnsignedIntegerParameter::set(value) || // Save the value in a register
!_depthCamera._set(TG_EN, true))
return false;
_value = value;
return true;
}
}
// ----------------------------
WidgetBaseParameter::WidgetBaseParameter(ParameterPtr parameter)
: mParameter(parameter)
, mCallbackHandle(-42)
, mWasVisible(parameter->isVisible())
{
setContentsMargins(0, 0, 0, 0);
setObjectName("WidgetParameter");
mCallbackHandle = mParameter->addChangeOfCharacteristicsCallback(std::bind(&WidgetBaseParameter::characteristicsCallback_, this));
}
void FunctionStatement::init(void *parser, bool ref,
const vector<ParameterPtr> ¶ms,
StatementListStatementPtr body,
bool has_call_to_get_args) {
m_ref = ref;
m_params = params;
m_body = body;
m_hasCallToGetArgs = has_call_to_get_args;
const CallInfo* cit1;
void* vt1;
if (get_call_info_no_eval(cit1, vt1, m_name)) {
m_invalid =
get_call_info_builtin(cit1, vt1, m_name->data(), m_name->hash()) ? -1 : 1;
}
bool seenOptional = false;
set<string> names;
m_callInfo.m_argCount = m_closureCallInfo.m_argCount = m_params.size();
for (unsigned int i = 0; i < m_params.size(); i++) {
ParameterPtr param = m_params[i];
std::string name = param->name();
if (names.find(name) != names.end()) {
raise_notice("%s:%d %s() has 2 parameters with the same name: $%s",
m_loc.file, m_loc.line0, m_name.c_str(), name.c_str());
} else {
names.insert(name);
}
if (!seenOptional) {
if (param->isOptional()) {
seenOptional = true;
}
} else if (!param->isOptional()) {
/*
raise_notice("%s:%d %s() has required parameter after optional one: $%s",
m_loc.file, m_loc.line0, m_name.c_str(), name.c_str());
*/
param->addNullDefault(parser);
}
if (param->isRef()) {
m_callInfo.m_refFlags |= 1 << i;
m_closureCallInfo.m_refFlags |= 1 << i;
}
if (param->getIdx() == -1) {
param->setIdx(declareVariable(name));
}
}
}
//-----------------------------------------------------------------------------
void Function::addParameter(ShaderParameterList& parameterList, ParameterPtr parameter)
{
// Check that parameter with the same name doest exist in input parameters list.
if (getParameterByName(mInputParameters, parameter->getName()).get() != NULL)
{
OGRE_EXCEPT( Exception::ERR_INVALIDPARAMS,
"Parameter <" + parameter->getName() + "> already declared in function <" + getName() + ">",
"Function::addParameter" );
}
// Check that parameter with the same name doest exist in output parameters list.
if (getParameterByName(mOutputParameters, parameter->getName()).get() != NULL)
{
OGRE_EXCEPT( Exception::ERR_INVALIDPARAMS,
"Parameter <" + parameter->getName() + "> already declared in function <" + getName() + ">",
"Function::addParameter" );
}
// Add to given parameters list.
parameterList.push_back(parameter);
}
//-----------------------------------------------------------------------
void HLSLProgramWriter::writeFunctionParameter(std::ostream& os, ParameterPtr parameter)
{
os << mGpuConstTypeMap[parameter->getType()];
os << "\t";
os << parameter->getName();
if (parameter->getSemantic() != Parameter::SPS_UNKNOWN)
{
os << " : ";
os << mParamSemanticMap[parameter->getSemantic()];
if (parameter->getSemantic() != Parameter::SPS_POSITION &&
parameter->getSemantic() != Parameter::SPS_NORMAL &&
(!(parameter->getSemantic() == Parameter::SPS_COLOR && parameter->getIndex() == 0)) &&
parameter->getIndex() >= 0)
{
os << StringConverter::toString(parameter->getIndex()).c_str();
}
}
}
//-----------------------------------------------------------------------
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 ProgramProcessor::countVsTexcoordOutputs(Function* vsMain,
int& outTexCoordSlots,
int& outTexCoordFloats)
{
outTexCoordSlots = 0;
outTexCoordFloats = 0;
const ShaderParameterList& vsOutputs = vsMain->getOutputParameters();
ShaderParameterConstIterator it = vsOutputs.begin();
ShaderParameterConstIterator itEnd = vsOutputs.end();
// Grab vertex shader output information.
for (; it != itEnd; ++it)
{
const ParameterPtr curParam = *it;
if (curParam->getSemantic() == Parameter::SPS_TEXTURE_COORDINATES)
{
outTexCoordSlots++;
outTexCoordFloats += getParameterFloatCount(curParam->getType());
}
}
}
void NodeSerializer::visitParameter(const ParameterPtr& node)
{
if(node->isInout())
append(L"inout ");
if(node->isShorthandExternalName())
append(L"#");
else if(!node->getExternalName().empty())
{
append(node->getExternalName());
append(L" ");
}
append(node->getLocalName());
append(L" : ");
node->getDeclaredType()->accept(this);
}
//-----------------------------------------------------------------------------
void ProgramProcessor::MergeParameter::addSourceParameter(ParameterPtr srcParam, int mask)
{
// Case source count exceeded maximum
if (mSrcParameterCount >= 4)
{
OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
"Merged parameter source parameters overflow",
"MergeParameter::addSourceParameter");
}
mSrcParameter[mSrcParameterCount] = srcParam;
mSrcParameterMask[mSrcParameterCount] = mask;
if (mask == Operand::OPM_ALL)
{
mDstParameterMask[mSrcParameterCount] = mask;
mUsedFloatCount += getParameterFloatCount(srcParam->getType());
}
else
{
int srcParamFloatCount = Operand::getFloatCount(mask);
mDstParameterMask[mSrcParameterCount] = getParameterMaskByFloatCount(srcParamFloatCount) << mUsedFloatCount;
mUsedFloatCount += srcParamFloatCount;
}
mSrcParameterCount++;
// Case float count exceeded maximum
if (mUsedFloatCount > 4)
{
OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
"Merged parameter floats overflow",
"MergeParameter::addSourceParameter");
}
}
//-----------------------------------------------------------------------------
ParameterPtr Function::resolveInputParameter(Parameter::Semantic semantic,
int index,
const Parameter::Content content,
GpuConstantType type)
{
ParameterPtr param;
// Check if desired parameter already defined.
param = getParameterByContent(mInputParameters, content, type);
if (param.get() != NULL)
return param;
// Case we have to create new parameter.
if (index == -1)
{
index = 0;
// Find the next available index of the target semantic.
ShaderParameterIterator it;
for (it = mInputParameters.begin(); it != mInputParameters.end(); ++it)
{
if ((*it)->getSemantic() == semantic)
{
index++;
}
}
}
else
{
// Check if desired parameter already defined.
param = getParameterBySemantic(mInputParameters, semantic, index);
if (param.get() != NULL && param->getContent() == content)
{
if (param->getType() == type)
{
return param;
}
else
{
OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
"Can not resolve parameter - semantic: " + StringConverter::toString(semantic) + " - index: " + StringConverter::toString(index) + " due to type mismatch. Function <" + getName() + ">",
"Function::resolveInputParameter" );
}
}
}
// No parameter found -> create new one.
switch (semantic)
{
case Parameter::SPS_POSITION:
assert(type == GCT_FLOAT4);
param = ParameterFactory::createInPosition(index);
break;
case Parameter::SPS_BLEND_WEIGHTS:
assert(type == GCT_FLOAT4);
param = ParameterFactory::createInWeights(index);
break;
case Parameter::SPS_BLEND_INDICES:
assert(type == GCT_FLOAT4);
param = ParameterFactory::createInIndices(index);
break;
case Parameter::SPS_NORMAL:
assert(type == GCT_FLOAT3);
param = ParameterFactory::createInNormal(index);
break;
case Parameter::SPS_COLOR:
assert(type == GCT_FLOAT4);
param = ParameterFactory::createInColor(index);
break;
case Parameter::SPS_TEXTURE_COORDINATES:
param = ParameterFactory::createInTexcoord(type, index, content);
break;
case Parameter::SPS_BINORMAL:
assert(type == GCT_FLOAT3);
param = ParameterFactory::createInBiNormal(index);
break;
case Parameter::SPS_TANGENT:
assert(type == GCT_FLOAT3);
param = ParameterFactory::createInTangent(index);
break;
case Parameter::SPS_UNKNOWN:
break;
}
if (param.get() != NULL)
addInputParameter(param);
return param;
}
//-----------------------------------------------------------------------
void ProgramManager::synchronizePixelnToBeVertexOut( ProgramSet* programSet )
{
Program* vsProgram = programSet->getCpuVertexProgram();
Program* psProgram = programSet->getCpuFragmentProgram();
// first find the vertex shader
ShaderFunctionConstIterator itFunction ;
Function* vertexMain = NULL;
Function* pixelMain = NULL;
// find vertex shader main
{
const ShaderFunctionList& functionList = vsProgram->getFunctions();
for (itFunction=functionList.begin(); itFunction != functionList.end(); ++itFunction)
{
Function* curFunction = *itFunction;
if (curFunction->getFunctionType() == Function::FFT_VS_MAIN)
{
vertexMain = curFunction;
break;
}
}
}
// find pixel shader main
{
const ShaderFunctionList& functionList = psProgram->getFunctions();
for (itFunction=functionList.begin(); itFunction != functionList.end(); ++itFunction)
{
Function* curFunction = *itFunction;
if (curFunction->getFunctionType() == Function::FFT_PS_MAIN)
{
pixelMain = curFunction;
break;
}
}
}
// save the pixel program original input parameters
const ShaderParameterList pixelOriginalInParams = pixelMain->getInputParameters();
// set the pixel Input to be the same as the vertex prog output
pixelMain->deleteAllInputParameters();
// Loop the vertex shader output parameters and make sure that
// all of them exist in the pixel shader input.
// If the parameter type exist in the original output - use it
// If the parameter doesn't exist - use the parameter from the
// vertex shader input.
// The order will be based on the vertex shader parameters order
// Write output parameters.
ShaderParameterConstIterator it;
const ShaderParameterList& outParams = vertexMain->getOutputParameters();
for (it=outParams.begin(); it != outParams.end(); ++it)
{
ParameterPtr curOutParemter = *it;
ParameterPtr paramToAdd = Function::getParameterBySemantic(
pixelOriginalInParams,
curOutParemter->getSemantic(),
curOutParemter->getIndex());
if (paramToAdd.isNull())
{
// param not found - we will add the one from the vertex shader
paramToAdd = curOutParemter;
}
pixelMain->addInputParameter(paramToAdd);
}
}
//-----------------------------------------------------------------------
void CGProgramWriter::writeFunctionParameter(std::ostream& os, ParameterPtr parameter)
{
os << mGpuConstTypeMap[parameter->getType()];
os << "\t";
os << parameter->getName();
if (parameter->isArray() == true)
{
os << "[" << parameter->getSize() << "]";
}
if (parameter->getSemantic() != Parameter::SPS_UNKNOWN)
{
os << " : ";
os << mParamSemanticMap[parameter->getSemantic()];
if (parameter->getSemantic() != Parameter::SPS_POSITION &&
parameter->getSemantic() != Parameter::SPS_NORMAL &&
parameter->getSemantic() != Parameter::SPS_TANGENT &&
parameter->getSemantic() != Parameter::SPS_BLEND_INDICES &&
parameter->getSemantic() != Parameter::SPS_BLEND_WEIGHTS &&
(!(parameter->getSemantic() == Parameter::SPS_COLOR && parameter->getIndex() == 0)) &&
parameter->getIndex() >= 0)
{
os << StringConverter::toString(parameter->getIndex()).c_str();
}
}
}
