//-------------------------------------------------------------------------
void PUAffectorTranslator::translate(PUScriptCompiler* compiler, PUAbstractNode *node)
{
PUObjectAbstractNode* obj = reinterpret_cast<PUObjectAbstractNode*>(node);
PUObjectAbstractNode* parent = obj->parent ? reinterpret_cast<PUObjectAbstractNode*>(obj->parent) : 0;
// The name of the obj is the type of the affector
// Remark: This can be solved by using a listener, so that obj->values is filled with type + name. Something for later
std::string type;
if(!obj->name.empty())
{
type = obj->name;
}
//// Get the factory
//ParticleAffectorFactory* particleAffectorFactory = ParticleSystemManager::getSingletonPtr()->getAffectorFactory(type);
//if (!particleAffectorFactory)
//{
// compiler->addError(ScriptCompiler::CE_INVALIDPARAMETERS, obj->file, obj->line);
// return;
//}
PUScriptTranslator *particleAffectorTranlator = PUAffectorManager::Instance()->getTranslator(type);
if (!particleAffectorTranlator) return;
//// Create the affector
//mAffector = ParticleSystemManager::getSingletonPtr()->createAffector(type);
//if (!mAffector)
//{
// compiler->addError(ScriptCompiler::CE_INVALIDPARAMETERS, obj->file, obj->line);
// return;
//}
_affector = PUAffectorManager::Instance()->createAffector(type);
if (!_affector) return;
_affector->setAffectorType(type);
if (parent && parent->context)
{
PUParticleSystem3D* system = static_cast<PUParticleSystem3D*>(parent->context);
system->addAffector(_affector);
}
// The first value is the (optional) name
std::string name;
if(!obj->values.empty())
{
getString(*obj->values.front(), &name);
_affector->setName(name);
}
// Set it in the context
obj->context = _affector;
// Run through properties
for(PUAbstractNodeList::iterator i = obj->children.begin(); i != obj->children.end(); ++i)
{
if((*i)->type == ANT_PROPERTY)
{
PUPropertyAbstractNode* prop = reinterpret_cast<PUPropertyAbstractNode*>((*i));
if (prop->name == token[TOKEN_ENABLED])
{
// Property: enabled
if (passValidateProperty(compiler, prop, token[TOKEN_ENABLED], VAL_BOOL))
{
bool val;
if(getBoolean(*prop->values.front(), &val))
{
_affector->setEnabled(val);
}
}
}
else if (prop->name == token[TOKEN_POSITION])
{
// Property: position
if (passValidateProperty(compiler, prop, token[TOKEN_POSITION], VAL_VECTOR3))
{
Vec3 val;
if(getVector3(prop->values.begin(), prop->values.end(), &val))
{
//mAffector->position = val;
//mAffector->originalPosition = val;
_affector->setLocalPosition(val);
}
}
}
else if (prop->name == token[TOKEN_AFFECTOR_MASS])
{
if (passValidateProperty(compiler, prop, token[TOKEN_AFFECTOR_MASS], VAL_REAL))
{
float val = 0.0f;
if(getFloat(*prop->values.front(), &val))
{
_affector->setMass(val);
}
}
}
else if (prop->name == token[TOKEN_AFFECTOR_SPECIALISATION])
{
if (passValidateProperty(compiler, prop, token[TOKEN_AFFECTOR_SPECIALISATION], VAL_STRING))
{
std::string val;
if(getString(*prop->values.front(), &val))
{
if (val == token[TOKEN_AFFECTOR_SPEC_DEFAULT])
{
_affector->setAffectSpecialisation(PUAffector::AFSP_DEFAULT);
}
else if (val == token[TOKEN_AFFECTOR_SPEC_TTL_INCREASE])
{
_affector->setAffectSpecialisation(PUAffector::AFSP_TTL_INCREASE);
}
else if (val == token[TOKEN_AFFECTOR_SPEC_TTL_DECREASE])
{
_affector->setAffectSpecialisation(PUAffector::AFSP_TTL_DECREASE);
}
}
}
}
else if (prop->name == token[TOKEN_AFFECTOR_EXCLUDE_EMITTER])
{
if (passValidatePropertyNoValues(compiler, prop, token[TOKEN_AFFECTOR_EXCLUDE_EMITTER]))
{
for(PUAbstractNodeList::iterator j = prop->values.begin(); j != prop->values.end(); ++j)
{
std::string val;
if(getString(**j, &val))
{
_affector->addEmitterToExclude(val);
}
}
}
}
else if (particleAffectorTranlator->translateChildProperty(compiler, *i))
{
// Parsed the property by another translator; do nothing
}
else
{
errorUnexpectedProperty(compiler, prop);
}
}
else if((*i)->type == ANT_OBJECT)
{
if (particleAffectorTranlator->translateChildObject(compiler, *i))
{
// Parsed the object by another translator; do nothing
}
else
{
processNode(compiler, *i);
}
}
else
{
errorUnexpectedToken(compiler, *i);
}
}
}
//-------------------------------------------------------------------------
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;
}
//-------------------------------------------------------------------------
void SystemTranslator::translate(ScriptCompiler* compiler, const AbstractNodePtr &node)
{
ObjectAbstractNode* obj = reinterpret_cast<ObjectAbstractNode*>(node.get());
if(obj->name.empty())
{
compiler->addError(ScriptCompiler::CE_OBJECTNAMEEXPECTED, obj->file, obj->line);
return;
}
// Create a particle system with the given name
mSystem = ParticleSystemManager::getSingletonPtr()->createParticleSystemTemplate(obj->name, compiler->getResourceGroup());
if (!mSystem)
{
compiler->addError(ScriptCompiler::CE_INVALIDPARAMETERS, obj->file, obj->line);
return;
}
obj->context = Any(mSystem);
for(AbstractNodeList::iterator i = obj->children.begin(); i != obj->children.end(); ++i)
{
if((*i)->type == ANT_PROPERTY)
{
PropertyAbstractNode* prop = reinterpret_cast<PropertyAbstractNode*>((*i).get());
if (prop->name == token[TOKEN_PS_ITERATION_INTERVAL])
{
// Property: iteration_interval
if (passValidateProperty(compiler, prop, token[TOKEN_PS_ITERATION_INTERVAL], VAL_REAL))
{
Real val = 0.0f;
if(getReal(prop->values.front(), &val))
{
mSystem->setIterationInterval(val);
}
}
}
else if (prop->name == token[TOKEN_PS_NONVIS_UPDATE_TIMEOUT])
{
// Property: nonvisible_update_timeout
if (passValidateProperty(compiler, prop, token[TOKEN_PS_NONVIS_UPDATE_TIMEOUT], VAL_REAL))
{
Real val = 0.0f;
if(getReal(prop->values.front(), &val))
{
mSystem->setNonVisibleUpdateTimeout(val);
}
}
}
else if (prop->name == token[TOKEN_PS_FIXED_TIMEOUT])
{
// Property: fixed_timeout
if (passValidateProperty(compiler, prop, token[TOKEN_PS_FIXED_TIMEOUT], VAL_REAL))
{
Real val = 0.0f;
if(getReal(prop->values.front(), &val))
{
mSystem->setFixedTimeout(val);
}
}
}
else if (prop->name == token[TOKEN_PS_LOD_DISTANCES])
{
// Property: lod_distances
if (passValidatePropertyNoValues(compiler, prop, token[TOKEN_PS_LOD_DISTANCES]))
{
for(AbstractNodeList::iterator j = prop->values.begin(); j != prop->values.end(); ++j)
{
Real val = 0.0f;
if(getReal(*j, &val))
{
mSystem->addLodDistance(val);
}
else
{
compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line,
"PU Compiler: lod_distances expects only numbers as arguments");
}
}
}
}
else if (prop->name == token[TOKEN_PS_MAIN_CAMERA_NAME])
{
// Property: main_camera_name
if (passValidateProperty(compiler, prop, token[TOKEN_PS_MAIN_CAMERA_NAME], VAL_STRING))
{
String val;
if(getString(prop->values.front(), &val))
{
mSystem->setMainCameraName(val);
}
}
}
else if (prop->name == token[TOKEN_PS_SMOOTH_LOD])
{
// Property: smooth_lod
if (passValidateProperty(compiler, prop, token[TOKEN_PS_SMOOTH_LOD], VAL_BOOL))
{
bool val;
if(getBoolean(prop->values.front(), &val))
{
mSystem->setSmoothLod(val);
}
}
}
else if (prop->name == token[TOKEN_PS_FAST_FORWARD])
{
// Property: fast_forward
if (passValidateProperty(compiler, prop, token[TOKEN_PS_SCALE], VAL_VECTOR2))
{
Vector2 val;
if(getVector2(prop->values.begin(), prop->values.end(), &val))
{
mSystem->setFastForward(val.x, val.y);
}
}
}
else if (prop->name == token[TOKEN_PS_SCALE])
{
// Property: scale
if (passValidateProperty(compiler, prop, token[TOKEN_PS_SCALE], VAL_VECTOR3))
{
Vector3 val;
if(getVector3(prop->values.begin(), prop->values.end(), &val))
{
mSystem->setScale(val);
}
}
}
else if (prop->name == token[TOKEN_PS_SCALE_VELOCITY])
{
// Property: scale_velocity
if (passValidateProperty(compiler, prop, token[TOKEN_PS_ITERATION_INTERVAL], VAL_REAL))
{
Real val = 0.0f;
if(getReal(prop->values.front(), &val))
{
mSystem->setScaleVelocity(val);
}
}
}
else if (prop->name == token[TOKEN_PS_SCALE_TIME])
{
// Property: scale_time
if (passValidateProperty(compiler, prop, token[TOKEN_PS_SCALE_TIME], VAL_REAL))
{
Real val = 0.0f;
if(getReal(prop->values.front(), &val))
{
mSystem->setScaleTime(val);
}
}
}
else if (prop->name == token[TOKEN_KEEP_LOCAL])
{
// Property: keep_local
if (passValidateProperty(compiler, prop, token[TOKEN_KEEP_LOCAL], VAL_BOOL))
{
bool val;
if(getBoolean(prop->values.front(), &val))
{
mSystem->setKeepLocal(val);
}
}
}
else if (prop->name == token[TOKEN_PS_TIGHT_BOUNDING_BOX])
{
// Property: tight_bounding_box
if (passValidateProperty(compiler, prop, token[TOKEN_PS_TIGHT_BOUNDING_BOX], VAL_BOOL))
{
bool val;
if(getBoolean(prop->values.front(), &val))
{
mSystem->setTightBoundingBox(val);
}
}
}
else if (prop->name == token[TOKEN_PS_CATEGORY])
{
// Property: category
if (passValidateProperty(compiler, prop, token[TOKEN_PS_CATEGORY], VAL_STRING))
{
String val;
if(getString(prop->values.front(), &val))
{
mSystem->setCategory(val);
}
}
}
else if (prop->name == token[TOKEN_USE_ALIAS])
{
// Property: use_alias
// The alias can only be a technique
if (passValidateProperty(compiler, prop, token[TOKEN_USE_ALIAS], VAL_STRING))
{
String val;
if(getString(prop->values.front(), &val))
{
IAlias* alias = ParticleSystemManager::getSingletonPtr()->getAlias(val);
if (alias->getAliasType() == IAlias::AT_TECHNIQUE)
{
ParticleTechnique* technique = static_cast<ParticleTechnique*>(alias);
ParticleTechnique* newTechnique = ParticleSystemManager::getSingletonPtr()->cloneTechnique(technique);
mSystem->addTechnique(newTechnique);
}
}
}
}
else
{
errorUnexpectedProperty(compiler, prop);
}
}
else if((*i)->type == ANT_OBJECT)
{
processNode(compiler, *i);
}
else
{
errorUnexpectedToken(compiler, *i);
}
}
}
