//-------------------------------------------------------------------------
bool PUOnTimeObserverTranslator::translateChildProperty( PUScriptCompiler* compiler, PUAbstractNode *node )
{
PUPropertyAbstractNode* prop = reinterpret_cast<PUPropertyAbstractNode*>(node);
PUObserver* ob = static_cast<PUObserver*>(prop->parent->context);
PUOnTimeObserver* observer = static_cast<PUOnTimeObserver*>(ob);
if (prop->name == token[TOKEN_ONTIME])
{
// Property: on_time
if (passValidatePropertyNumberOfValues(compiler, prop, token[TOKEN_ONTIME], 2))
{
std::string compareType;
float val = 0.0f;
PUAbstractNodeList::const_iterator i = prop->values.begin();
if(getString(**i, &compareType))
{
if (compareType == token[TOKEN_LESS_THAN])
{
observer->setCompare(CO_LESS_THAN);
}
else if (compareType == token[TOKEN_GREATER_THAN])
{
observer->setCompare(CO_GREATER_THAN);
}
else if (compareType == token[TOKEN_EQUALS])
{
observer->setCompare(CO_EQUALS);
}
++i;
if(getFloat(**i, &val))
{
observer->setThreshold(val);
return true;
}
}
}
}
else if (prop->name == token[TOKEN_SINCE_START_SYSTEM])
{
// Property: since_start_system
if (passValidateProperty(compiler, prop, token[TOKEN_SINCE_START_SYSTEM], VAL_BOOL))
{
bool val;
if(getBoolean(*prop->values.front(), &val))
{
observer->setSinceStartSystem(val);
return true;
}
}
}
return false;
}
//-----------------------------------------------------------------------
bool DoEnableComponentEventHandlerTranslator::translateChildProperty(ScriptCompiler* compiler, const AbstractNodePtr &node)
{
PropertyAbstractNode* prop = reinterpret_cast<PropertyAbstractNode*>(node.get());
ParticleEventHandler* evt = any_cast<ParticleEventHandler*>(prop->parent->context);
DoEnableComponentEventHandler* handler = static_cast<DoEnableComponentEventHandler*>(evt);
if (prop->name == token[TOKEN_DOENABLE_COMPONENT])
{
// Property: enable_component
if (passValidatePropertyNumberOfValues(compiler, prop, token[TOKEN_DOENABLE_COMPONENT], 3))
{
String componentType;
String name;
bool enabled = true;
AbstractNodeList::const_iterator i = prop->values.begin();
if(getString(*i, &componentType))
{
if (componentType == token[TOKEN_DOENABLE_EMITTER_COMPONENT])
{
handler->setComponentType(CT_EMITTER);
}
else if (componentType == token[TOKEN_DOENABLE_AFFECTOR_COMPONENT])
{
handler->setComponentType(CT_AFFECTOR);
}
else if (componentType == token[TOKEN_DOENABLE_OBSERVER_COMPONENT])
{
handler->setComponentType(CT_OBSERVER);
}
else if (componentType == token[TOKEN_DOENABLE_TECHNIQUE_COMPONENT])
{
handler->setComponentType(CT_TECHNIQUE);
}
++i;
if(getString(*i, &name))
{
handler->setComponentName(name);
++i;
if (getBoolean(*i, &enabled))
{
handler->setComponentEnabled(enabled);
return true;
}
}
}
}
}
return false;
}
//-------------------------------------------------------------------------
bool PUOnVelocityObserverTranslator::translateChildProperty( PUScriptCompiler* compiler, PUAbstractNode *node )
{
PUPropertyAbstractNode* prop = reinterpret_cast<PUPropertyAbstractNode*>(node);
PUObserver* ob = static_cast<PUObserver*>(prop->parent->context);
PUOnVelocityObserver* observer = static_cast<PUOnVelocityObserver*>(ob);
if (prop->name == token[TOKEN_ONVELOCITY_THRESHOLD])
{
// Property: velocity_threshold
if (passValidatePropertyNumberOfValues(compiler, prop, token[TOKEN_ONVELOCITY_THRESHOLD], 2))
{
std::string compareType;
float val = 0.0f;
PUAbstractNodeList::const_iterator i = prop->values.begin();
if(getString(**i, &compareType))
{
if (compareType == token[TOKEN_LESS_THAN])
{
observer->setCompare(CO_LESS_THAN);
}
else if (compareType == token[TOKEN_GREATER_THAN])
{
observer->setCompare(CO_GREATER_THAN);
}
else if (compareType == token[TOKEN_EQUALS])
{
observer->setCompare(CO_EQUALS);
}
++i;
if(getFloat(**i, &val))
{
observer->setThreshold(val);
return true;
}
}
}
}
return false;
}
//-------------------------------------------------------------------------
bool ScriptTranslator::passValidateProperty(Ogre::ScriptCompiler* compiler,
Ogre::PropertyAbstractNode* prop,
const Ogre::String& token,
ValidationType validationType)
{
if (!passValidatePropertyNoValues(compiler, prop, token))
{
return false;
}
bool ret = true;
switch(validationType)
{
case VAL_BOOL:
{
ret = passValidatePropertyNumberOfValues(compiler, prop, token, 1) && passValidatePropertyValidBool(compiler, prop);
}
break;
case VAL_COLOURVALUE:
{
ret = passValidatePropertyNumberOfValuesRange(compiler, prop, token, 3, 4);
}
break;
case VAL_INT:
{
ret = passValidatePropertyNumberOfValues(compiler, prop, token, 1) && passValidatePropertyValidInt(compiler, prop);
}
break;
case VAL_QUATERNION:
{
ret = passValidatePropertyNumberOfValues(compiler, prop, token, 4) && passValidatePropertyValidQuaternion(compiler, prop);
}
break;
case VAL_REAL:
{
ret = passValidatePropertyNumberOfValues(compiler, prop, token, 1) && passValidatePropertyValidReal(compiler, prop);
}
break;
case VAL_STRING:
{
ret = passValidatePropertyNumberOfValues(compiler, prop, token, 1);
}
break;
case VAL_UINT:
{
ret = passValidatePropertyNumberOfValues(compiler, prop, token, 1) && passValidatePropertyValidUint(compiler, prop);
}
break;
case VAL_VECTOR2:
{
ret = passValidatePropertyNumberOfValues(compiler, prop, token, 2) && passValidatePropertyValidVector2(compiler, prop);
}
break;
case VAL_VECTOR3:
{
ret = passValidatePropertyNumberOfValues(compiler, prop, token, 3) && passValidatePropertyValidVector3(compiler, prop);
}
break;
case VAL_VECTOR4:
{
ret = passValidatePropertyNumberOfValues(compiler, prop, token, 4) && passValidatePropertyValidVector4(compiler, prop);
}
break;
}
return ret;
}
//-----------------------------------------------------------------------
bool OnPositionObserverTranslator::translateChildProperty(ScriptCompiler* compiler, const AbstractNodePtr &node)
{
PropertyAbstractNode* prop = reinterpret_cast<PropertyAbstractNode*>(node.get());
ParticleObserver* ob = any_cast<ParticleObserver*>(prop->parent->context);
OnPositionObserver* observer = static_cast<OnPositionObserver*>(ob);
if (prop->name == token[TOKEN_ONPOSITION_X])
{
// Property: position_x
if (passValidatePropertyNumberOfValues(compiler, prop, token[TOKEN_ONPOSITION_X], 2))
{
String compareType;
Real val = 0;
AbstractNodeList::const_iterator i = prop->values.begin();
if(getString(*i, &compareType))
{
if (compareType == token[TOKEN_LESS_THAN])
{
observer->setComparePositionX(CO_LESS_THAN);
}
else if (compareType == token[TOKEN_GREATER_THAN])
{
observer->setComparePositionX(CO_GREATER_THAN);
}
else if (compareType == token[TOKEN_EQUALS])
{
observer->setComparePositionX(CO_EQUALS);
}
++i;
if(getReal(*i, &val))
{
observer->setPositionXThreshold(val);
return true;
}
}
}
}
else if (prop->name == token[TOKEN_ONPOSITION_Y])
{
// Property: position_y
if (passValidatePropertyNumberOfValues(compiler, prop, token[TOKEN_ONPOSITION_Y], 2))
{
String compareType;
Real val = 0;
AbstractNodeList::const_iterator i = prop->values.begin();
if(getString(*i, &compareType))
{
if (compareType == token[TOKEN_LESS_THAN])
{
observer->setComparePositionY(CO_LESS_THAN);
}
else if (compareType == token[TOKEN_GREATER_THAN])
{
observer->setComparePositionY(CO_GREATER_THAN);
}
else if (compareType == token[TOKEN_EQUALS])
{
observer->setComparePositionY(CO_EQUALS);
}
++i;
if(getReal(*i, &val))
{
observer->setPositionYThreshold(val);
return true;
}
}
}
}
else if (prop->name == token[TOKEN_ONPOSITION_Z])
{
// Property: position_z
if (passValidatePropertyNumberOfValues(compiler, prop, token[TOKEN_ONPOSITION_Z], 2))
{
String compareType;
Real val = 0;
AbstractNodeList::const_iterator i = prop->values.begin();
if(getString(*i, &compareType))
{
if (compareType == token[TOKEN_LESS_THAN])
{
observer->setComparePositionZ(CO_LESS_THAN);
}
else if (compareType == token[TOKEN_GREATER_THAN])
{
observer->setComparePositionZ(CO_GREATER_THAN);
}
else if (compareType == token[TOKEN_EQUALS])
{
observer->setComparePositionZ(CO_EQUALS);
}
++i;
if(getReal(*i, &val))
{
observer->setPositionZThreshold(val);
return true;
}
}
}
}
return false;
}
