//-----------------------------------------------------------------------
MeshAnimationAffector::MeshAnimationAffector(ParticleSystem* psys)
:ParticleAffector(psys),
mAnimationName(""),
mAnimationLoop(false),
mAnimationSpeedFactor(1.0f)
{
mType = "MeshAnimationAffector";
// Init parameters
if (createParamDictionary("MeshAnimationAffector"))
{
ParamDictionary* dict = getParamDictionary();
dict->addParameter(ParameterDef("animation_name",
"the name of the animation.", PT_STRING),
&msAnimationNameCmd);
dict->addParameter(ParameterDef("animation_loop",
"set the looping of the animation.", PT_BOOL),
&msAnimationLoopCmd);
dict->addParameter(ParameterDef("animation_speed",
"set the speed factor of the animation.", PT_REAL),
&msAnimationSpeedFactorCmd);
}
}
//-----------------------------------------------------------------------
D3D10HLSLProgram::D3D10HLSLProgram(ResourceManager* creator, const String& name,
ResourceHandle handle, const String& group, bool isManual,
ManualResourceLoader* loader, D3D10Device & device)
: HighLevelGpuProgram(creator, name, handle, group, isManual, loader)
, mpMicroCode(NULL), mErrorsInCompile(false), mConstantBuffer(NULL), mDevice(device),
mpIShaderReflection(NULL), mShaderReflectionConstantBuffer(NULL), mpVertexShader(NULL)//, mpConstTable(NULL)
{
if ("Hatch_ps_hlsl" == name)
{
mpMicroCode = NULL;
}
ZeroMemory(&mConstantBufferDesc, sizeof(mConstantBufferDesc)) ;
ZeroMemory(&mShaderDesc, sizeof(mShaderDesc)) ;
if (createParamDictionary("D3D10HLSLProgram"))
{
setupBaseParamDictionary();
ParamDictionary* dict = getParamDictionary();
dict->addParameter(ParameterDef("entry_point",
"The entry point for the HLSL program.",
PT_STRING),&msCmdEntryPoint);
dict->addParameter(ParameterDef("target",
"Name of the assembler target to compile down to.",
PT_STRING),&msCmdTarget);
dict->addParameter(ParameterDef("preprocessor_defines",
"Preprocessor defines use to compile the program.",
PT_STRING),&msCmdPreprocessorDefines);
dict->addParameter(ParameterDef("column_major_matrices",
"Whether matrix packing in column-major order.",
PT_BOOL),&msCmdColumnMajorMatrices);
}
}
//-----------------------------------------------------------------------
RotationAffector::RotationAffector(ParticleSystem* psys) :
ParticleAffector(psys),
mRotationSpeedRangeStart(0),
mRotationSpeedRangeEnd(0),
mRotationRangeStart(0),
mRotationRangeEnd(0)
{
mType = "Rotator";
// Init parameters
if (createParamDictionary("RotationAffector"))
{
ParamDictionary* dict = getParamDictionary();
dict->addParameter(ParameterDef("rotation_speed_range_start",
"The start of a range of rotation speed to be assigned to emitted particles.", PT_REAL),
&msRotationSpeedRangeStartCmd);
dict->addParameter(ParameterDef("rotation_speed_range_end",
"The end of a range of rotation speed to be assigned to emitted particles.", PT_REAL),
&msRotationSpeedRangeEndCmd);
dict->addParameter(ParameterDef("rotation_range_start",
"The start of a range of rotation angles to be assigned to emitted particles.", PT_REAL),
&msRotationRangeStartCmd);
dict->addParameter(ParameterDef("rotation_range_end",
"The end of a range of rotation angles to be assigned to emitted particles.", PT_REAL),
&msRotationRangeEndCmd);
}
}
//-----------------------------------------------------------------
//-----------------------------------------------------------------
ParamDictionary FromXml(const XML::Node* in_element)
{
ParamDictionary result;
for(auto param = Core::XMLUtils::GetFirstChildElement(in_element); param != nullptr; param = Core::XMLUtils::GetNextSiblingElement(param))
{
std::string key;
std::string value;
for(auto attrib = Core::XMLUtils::GetFirstAttribute(param); attrib != nullptr; attrib = Core::XMLUtils::GetNextAttribute(attrib))
{
if (XMLUtils::GetName(attrib) == "key")
{
key = Core::XMLUtils::GetValue(attrib);
}
else if (XMLUtils::GetName(attrib) == "value")
{
value = attrib->value();
}
}
if(key.length() > 0 && value.length() > 0)
{
result.SetValue(key, value);
}
}
return result;
}
//-----------------------------------------------------------------------
MeshParticleRenderer::MeshParticleRenderer() :
mMaterialName(""),
mMeshName(""),
mWorldSpace(false),
mParticleSystemNode(NULL),
mMeshRotation(false),
mMeshSizeChanged(false),
mDefaultWidth(1.0f),
mDefaultHeight(1.0f),
mMeshOrientationType(MOT_ORIENTED_ORIGIN),
mNextPoolIndex(0)
{
if (createParamDictionary("MeshParticleRenderer"))
{
ParamDictionary* dict = getParamDictionary();
dict->addParameter(ParameterDef("mesh_name",
"the name of the mesh.",
PT_STRING),
&msMeshNameCmd);
dict->addParameter(ParameterDef("orientation_type",
"the orientation type of mesh particle,"
"'oriented_origin' means particles are oriened origin direction,"
"'oriented_self' means particles are oriented around their own direction.",
PT_STRING),
&msOrientationTypeCmd);
}
_freeParticleMeshVisualDatas();
}
//-----------------------------------------------------------------------
FireExtinguisherAffector::FireExtinguisherAffector(ParticleSystem* psys)
: ParticleAffector(psys)
{
mType = "FireExtinguisher";
// defaults
mEffectiveness = 1.0;
mEfaf = 0;
// Set up parameters
if (createParamDictionary("FireExtinguisherAffector"))
{
addBaseParameters();
// Add extra paramaters
ParamDictionary* dict = getParamDictionary();
dict->addParameter(ParameterDef("effectiveness",
"How effective is your fire extinguisher? Anything higher than one is more effective than water while everything lower than one is less effective than water.",
PT_REAL), &msEffectivenessCmd);
}
// get fire affector factory
ParticleSystemManager::ParticleAffectorFactoryIterator pafi = ParticleSystemManager::getSingleton().getAffectorFactoryIterator();
ParticleAffectorFactory *paf;
while(pafi.hasMoreElements())
{
paf = pafi.getNext();
if ( paf->getName() == "ExtinguishableFire" )
{
mEfaf = (ExtinguishableFireAffectorFactory *)paf;
break;
}
}
if (!mEfaf) LOG("ERROR: Couldn't find an ExtinguishableFireAffectorFactory instance. Was it registered in the content manager?");
}
//-----------------------------------------------------------------------
bool AreaEmitter::initDefaults(const String& t)
{
// called by the constructor as initDefaults("Type")
// Defaults
mDirection = Vector3::UNIT_Z;
mUp = Vector3::UNIT_Y;
setSize(100,100,100);
mType = t;
// Set up parameters
if (createParamDictionary(mType + "Emitter"))
{
addBaseParameters();
ParamDictionary* dict = getParamDictionary();
// Custom params
dict->addParameter(ParameterDef("width",
"Width of the shape in world coordinates.",
PT_REAL),&msWidthCmd);
dict->addParameter(ParameterDef("height",
"Height of the shape in world coordinates.",
PT_REAL),&msHeightCmd);
dict->addParameter(ParameterDef("depth",
"Depth of the shape in world coordinates.",
PT_REAL),&msDepthCmd);
return true;
}
return false;
}
//-----------------------------------------------------------------------
DeflectorPlaneAffector::DeflectorPlaneAffector(ParticleSystem* psys)
: ParticleAffector(psys)
{
mType = "DeflectorPlane";
// defaults
mPlanePoint = Vector3::ZERO;
mPlaneNormal = Vector3::UNIT_Y;
mBounce = 1.0;
// Set up parameters
if (createParamDictionary("DeflectorPlaneAffector"))
{
addBaseParameters();
// Add extra paramaters
ParamDictionary* dict = getParamDictionary();
dict->addParameter(ParameterDef("plane_point",
"A point on the deflector plane. Together with the normal vector it defines the plane.",
PT_VECTOR3), &msPlanePointCmd);
dict->addParameter(ParameterDef("plane_normal",
"The normal vector of the deflector plane. Together with the point it defines the plane.",
PT_VECTOR3), &msPlaneNormalCmd);
dict->addParameter(ParameterDef("bounce",
"The amount of bouncing when a particle is deflected. 0 means no deflection and 1 stands for 100 percent reflection.",
PT_REAL), &msBounceCmd);
}
}
//-----------------------------------------------------------------------
ColourFaderAffector::ColourFaderAffector(ParticleSystem* psys) : ParticleAffector(psys)
{
mRedAdj = mGreenAdj = mBlueAdj = mAlphaAdj = 0;
mType = "ColourFader";
// Init parameters
if (createParamDictionary("ColourFaderAffector"))
{
ParamDictionary* dict = getParamDictionary();
dict->addParameter(ParameterDef("red",
"The amount by which to adjust the red component of particles per second.",
PT_REAL), &msRedCmd);
dict->addParameter(ParameterDef("green",
"The amount by which to adjust the green component of particles per second.",
PT_REAL), &msGreenCmd);
dict->addParameter(ParameterDef("blue",
"The amount by which to adjust the blue component of particles per second.",
PT_REAL), &msBlueCmd);
dict->addParameter(ParameterDef("alpha",
"The amount by which to adjust the alpha component of particles per second.",
PT_REAL), &msAlphaCmd);
}
}
//-----------------------------------------------------------------------
CgProgram::CgProgram(ResourceManager* creator, const String& name,
ResourceHandle handle, const String& group, bool isManual,
ManualResourceLoader* loader, CGcontext context)
: HighLevelGpuProgram(creator, name, handle, group, isManual, loader),
mCgContext(context),
mSelectedCgProfile(CG_PROFILE_UNKNOWN), mCgArguments(0), mParametersMapSizeAsBuffer(0)
{
if (createParamDictionary("CgProgram"))
{
setupBaseParamDictionary();
ParamDictionary* dict = getParamDictionary();
dict->addParameter(ParameterDef("entry_point",
"The entry point for the Cg program.",
PT_STRING),&msCmdEntryPoint);
dict->addParameter(ParameterDef("profiles",
"Space-separated list of Cg profiles supported by this profile.",
PT_STRING),&msCmdProfiles);
dict->addParameter(ParameterDef("compile_arguments",
"A string of compilation arguments to pass to the Cg compiler.",
PT_STRING),&msCmdArgs);
}
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
GLSLESProgram::GLSLESProgram(ResourceManager* creator,
const String& name, ResourceHandle handle,
const String& group, bool isManual, ManualResourceLoader* loader)
: HighLevelGpuProgram(creator, name, handle, group, isManual, loader)
, mGLShaderHandle(0)
, mGLProgramHandle(0)
, mCompiled(0)
#if !OGRE_NO_GLES2_GLSL_OPTIMISER
, mIsOptimised(false)
, mOptimiserEnabled(false)
#endif
{
if (createParamDictionary("GLSLESProgram"))
{
setupBaseParamDictionary();
ParamDictionary* dict = getParamDictionary();
dict->addParameter(ParameterDef("preprocessor_defines",
"Preprocessor defines use to compile the program.",
PT_STRING),&msCmdPreprocessorDefines);
#if !OGRE_NO_GLES2_GLSL_OPTIMISER
dict->addParameter(ParameterDef("use_optimiser",
"Should the GLSL optimiser be used. Default is false.",
PT_BOOL),&msCmdOptimisation);
#endif
}
// Manually assign language now since we use it immediately
mSyntaxCode = "glsles";
}
//-----------------------------------------------------------------------
ColourInterpolatorAffector::ColourInterpolatorAffector(ParticleSystem* psys)
: ParticleAffector(psys)
{
for (int i=0;i<MAX_STAGES;i++)
{
// set default colour to transparent grey, transparent since we might not want to display the particle here
// grey because when a colour component is 0.5f the maximum difference to another colour component is 0.5f
mColourAdj[i] = ColourValue(0.5f, 0.5f, 0.5f, 0.0f);
mTimeAdj[i] = 1.0f;
}
mType = "ColourInterpolator";
// Init parameters
if (createParamDictionary("ColourInterpolatorAffector"))
{
ParamDictionary* dict = getParamDictionary();
for (int i=0;i<MAX_STAGES;i++)
{
msColourCmd[i].mIndex = i;
msTimeCmd[i].mIndex = i;
StringUtil::StrStreamType stage;
stage << i;
String colour_title = String("colour") + stage.str();
String time_title = String("time") + stage.str();
String colour_descr = String("Stage ") + stage.str() + String(" colour.");
String time_descr = String("Stage ") + stage.str() + String(" time.");
dict->addParameter(ParameterDef(colour_title, colour_descr, PT_COLOURVALUE), &msColourCmd[i]);
dict->addParameter(ParameterDef(time_title, time_descr, PT_REAL), &msTimeCmd[i]);
}
}
}
//-----------------------------------------------------------------------
DirectionRandomiserAffector::DirectionRandomiserAffector(ParticleSystem* psys)
: ParticleAffector(psys)
{
mType = "DirectionRandomiser";
// defaults
mRandomness = 1.0;
mScope = 1.0;
mKeepVelocity = false;
// Set up parameters
if (createParamDictionary("DirectionRandomiserAffector"))
{
addBaseParameters();
// Add extra paramaters
ParamDictionary* dict = getParamDictionary();
dict->addParameter(ParameterDef("randomness",
"The amount of randomness (chaos) to apply to the particle movement.",
PT_REAL), &msRandomnessCmd);
dict->addParameter(ParameterDef("scope",
"The percentage of particles which is affected.",
PT_REAL), &msScopeCmd);
dict->addParameter(ParameterDef("keep_velocity",
"Detemines whether the velocity of the particles is changed.",
PT_BOOL), &msKeepVelocityCmd);
}
}
//-----------------------------------------------------------------------
LinearForceAffector::LinearForceAffector(ParticleSystem* psys)
:ParticleAffector(psys)
{
mType = "LinearForce";
// Default to gravity-like
mForceApplication = FA_ADD;
mForceVector.x = mForceVector.z = 0;
mForceVector.y = -100;
// Set up parameters
if (createParamDictionary("LinearForceAffector"))
{
addBaseParameters();
// Add extra paramaters
ParamDictionary* dict = getParamDictionary();
dict->addParameter(ParameterDef("force_vector",
"The vector representing the force to apply.",
PT_VECTOR3),&msForceVectorCmd);
dict->addParameter(ParameterDef("force_application",
"How to apply the force vector to particles.",
PT_STRING),&msForceAppCmd);
}
}
void ExternalTextureSource::addBaseParams()
{
if( mDictionaryName == "NotAssigned" )
OGRE_EXCEPT(Exception::ERR_FILE_NOT_FOUND,
"Plugin " + mPlugInName +
" needs to override default mDictionaryName",
"ExternalTextureSource::addBaseParams");
//Create Dictionary Here
if (createParamDictionary( mDictionaryName ))
{
ParamDictionary* dict = getParamDictionary();
dict->addParameter(ParameterDef("filename",
"A source for the texture effect (only certain plugins require this)"
, PT_STRING),
&ExternalTextureSource::msCmdInputFile);
dict->addParameter(ParameterDef("frames_per_second",
"How fast should playback be (only certain plugins use this)"
, PT_INT),
&ExternalTextureSource::msCmdFramesPerSecond);
dict->addParameter(ParameterDef("play_mode",
"How the playback starts(only certain plugins use this)"
, PT_STRING),
&ExternalTextureSource::msCmdPlayMode);
dict->addParameter(ParameterDef("set_T_P_S",
"Set the technique, pass, and state level of this texture_unit (eg. 0 0 0 )"
, PT_STRING),
&ExternalTextureSource::msCmdTecPassState);
}
}
//-----------------------------------------------------------------
//-----------------------------------------------------------------
std::string ToString(const ParamDictionary& in_dict)
{
std::string result;
for(auto it = in_dict.begin(); it != in_dict.end(); ++it)
{
result.append(it->first+"="+it->second+";");
}
return result;
}
//-----------------------------------------------------------------------
ScaleAffector::ScaleAffector() {
mScaleAdj = 0;
mType = "Scaler";
// Init parameters
if (createParamDictionary("ScaleAffector")) {
ParamDictionary* dict = getParamDictionary();
dict->addParameter(ParameterDef("rate",
"The amount by which to adjust the x and y scale components of particles per second.",
PT_REAL), &msScaleCmd);
}
}
//-----------------------------------------------------------------------
ColourImageAffector::ColourImageAffector(ParticleSystem* psys)
:ParticleAffector(psys), mColourImageLoaded(false)
{
mType = "ColourImage";
// Init parameters
if (createParamDictionary("ColourImageAffector"))
{
ParamDictionary* dict = getParamDictionary();
dict->addParameter(ParameterDef("image", "image where the colours come from", PT_STRING), &msImageCmd);
}
}
//-----------------------------------------------------------------------
RingEmitter::RingEmitter(ParticleSystem* psys)
: AreaEmitter(psys)
{
if (initDefaults("Ring"))
{
// Add custom parameters
ParamDictionary* pDict = getParamDictionary();
pDict->addParameter(ParameterDef("inner_width", "Parametric value describing the proportion of the "
"shape which is hollow.", PT_REAL), &msCmdInnerX);
pDict->addParameter(ParameterDef("inner_height", "Parametric value describing the proportion of the "
"shape which is hollow.", PT_REAL), &msCmdInnerY);
}
// default is half empty
setInnerSize(0.5,0.5);
}
//-----------------------------------------------------------------------
ColourFaderAffector2::ColourFaderAffector2(ParticleSystem* psys) : ParticleAffector(psys)
{
mRedAdj1 = mGreenAdj1 = mBlueAdj1 = mAlphaAdj1 = 0;
mRedAdj2 = mGreenAdj2 = mBlueAdj2 = mAlphaAdj2 = 0;
mType = "ColourFader2";
StateChangeVal = 1; // Switch when there is 1 second left on the TTL
// Init parameters
if (createParamDictionary("ColourFaderAffector2"))
{
ParamDictionary* dict = getParamDictionary();
// Phase 1
dict->addParameter(ParameterDef("red1",
"The amount by which to adjust the red component of particles per second.",
PT_REAL), &msRedCmd1);
dict->addParameter(ParameterDef("green1",
"The amount by which to adjust the green component of particles per second.",
PT_REAL), &msGreenCmd1);
dict->addParameter(ParameterDef("blue1",
"The amount by which to adjust the blue component of particles per second.",
PT_REAL), &msBlueCmd1);
dict->addParameter(ParameterDef("alpha1",
"The amount by which to adjust the alpha component of particles per second.",
PT_REAL), &msAlphaCmd1);
// Phase 2
dict->addParameter(ParameterDef("red2",
"The amount by which to adjust the red component of particles per second.",
PT_REAL), &msRedCmd2);
dict->addParameter(ParameterDef("green2",
"The amount by which to adjust the green component of particles per second.",
PT_REAL), &msGreenCmd2);
dict->addParameter(ParameterDef("blue2",
"The amount by which to adjust the blue component of particles per second.",
PT_REAL), &msBlueCmd2);
dict->addParameter(ParameterDef("alpha2",
"The amount by which to adjust the alpha component of particles per second.",
PT_REAL), &msAlphaCmd2);
// State Change Value
dict->addParameter(ParameterDef("state_change",
"When the particle has this much time to live left, it will switch to state 2.",
PT_REAL), &msStateCmd);
}
}
//-----------------------------------------------------------------
//-----------------------------------------------------------------
ParamDictionary FromString(const std::string& in_string)
{
ParamDictionary result;
u32 start = 0;
std::string key;
std::string value;
for(u32 i=0; i<in_string.size(); ++i)
{
const char c = in_string[i];
// Any of these characters
if(c == '\t' || c == '\n' || c == '\r' || c == '=' || c == ';'|| (c == ' ' && key.empty()))
{
if(start == i)
{
start = i + 1;
continue;
}
if(key.empty())
{
key.assign(in_string.begin() + start, in_string.begin()+i);
while(in_string[start] != '=' && start < in_string.size())
start++;
i = start - 1;
}
else if(value.empty())
{
while(in_string[start] == ' ' && start < in_string.size())
start++;
value.assign(in_string.begin() + start, in_string.begin()+i);
result.SetValue(key, value);
key.clear();
value.clear();
}
start = i + 1;
continue;
}
}
return result;
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
UnifiedHighLevelGpuProgram::UnifiedHighLevelGpuProgram(
ResourceManager* creator, const String& name, ResourceHandle handle,
const String& group, bool isManual, ManualResourceLoader* loader)
:HighLevelGpuProgram(creator, name, handle, group, isManual, loader)
{
if (createParamDictionary("UnifiedHighLevelGpuProgram"))
{
setupBaseParamDictionary();
ParamDictionary* dict = getParamDictionary();
dict->addParameter(ParameterDef("delegate",
"Additional delegate programs containing implementations.",
PT_STRING),&msCmdDelegate);
}
}
bool StringInterface::setParameter(const String& name, const String& value)
{
// Get dictionary
ParamDictionary* dict = getParamDictionary();
if (dict)
{
// Look up command object
ParamCommand* cmd = dict->getParamCommand(name);
if (cmd)
{
cmd->doSet(this, value);
return true;
}
}
// Fallback
return false;
}
//-----------------------------------------------------------------------
void PanelOverlayElement::addBaseParameters(void)
{
OverlayContainer::addBaseParameters();
ParamDictionary* dict = getParamDictionary();
dict->addParameter(ParameterDef("uv_coords",
"The texture coordinates for the texture. 1 set of uv values."
, PT_STRING),
&msCmdUVCoords);
dict->addParameter(ParameterDef("tiling",
"The number of times to repeat the background texture."
, PT_STRING),
&msCmdTiling);
dict->addParameter(ParameterDef("transparent",
"Sets whether the panel is transparent, i.e. invisible itself "
"but it's contents are still displayed."
, PT_BOOL),
&msCmdTransparent);
}
//-----------------------------------------------------------------------------
void GpuProgram::setupBaseParamDictionary(void)
{
ParamDictionary* dict = getParamDictionary();
dict->addParameter(
ParameterDef("type", "'vertex_program', 'geometry_program', 'fragment_program', 'hull_program', 'domain_program', 'compute_program'",
PT_STRING), &msTypeCmd);
dict->addParameter(
ParameterDef("syntax", "Syntax code, e.g. vs_1_1", PT_STRING), &msSyntaxCmd);
dict->addParameter(
ParameterDef("includes_skeletal_animation",
"Whether this vertex program includes skeletal animation", PT_BOOL),
&msSkeletalCmd);
dict->addParameter(
ParameterDef("includes_morph_animation",
"Whether this vertex program includes morph animation", PT_BOOL),
&msMorphCmd);
dict->addParameter(
ParameterDef("includes_pose_animation",
"The number of poses this vertex program supports for pose animation", PT_INT),
&msPoseCmd);
dict->addParameter(
ParameterDef("uses_vertex_texture_fetch",
"Whether this vertex program requires vertex texture fetch support.", PT_BOOL),
&msVTFCmd);
dict->addParameter(
ParameterDef("manual_named_constants",
"File containing named parameter mappings for low-level programs.", PT_BOOL),
&msManNamedConstsFileCmd);
dict->addParameter(
ParameterDef("uses_adjacency_information",
"Whether this geometry program requires adjacency information from the input primitives.", PT_BOOL),
&msAdjacencyCmd);
dict->addParameter(
ParameterDef("compute_group_dimensions",
"The number of process groups created by this compute program.", PT_VECTOR3),
&msComputeGroupDimsCmd);
}
//-----------------------------------------------------------------------
GLSLProgram::GLSLProgram(ResourceManager* creator,
const String& name, ResourceHandle handle,
const String& group, bool isManual, ManualResourceLoader* loader)
: HighLevelGpuProgram(creator, name, handle, group, isManual, loader)
{
// add parameter command "attach" to the material serializer dictionary
if (createParamDictionary("GLSLProgram"))
{
setupBaseParamDictionary();
ParamDictionary* dict = getParamDictionary();
dict->addParameter(ParameterDef("attach",
"name of another GLSL program needed by this program",
PT_STRING),&msCmdAttach);
}
// Manually assign language now since we use it immediately
mSyntaxCode = "glsl";
// want scenemanager to pass on surface and light states to the rendersystem
mPassSurfaceAndLightStates = true;
}
//-----------------------------------------------------------------
//-----------------------------------------------------------------
void ToXml(const ParamDictionary& in_dict, XML::Node* out_element)
{
XML::Document* doc = out_element->document();
out_element->name(doc->allocate_string("Params"));
for(auto it = in_dict.begin(); it != in_dict.end(); ++it)
{
XML::Attribute* keyAttribute = out_element->document()->allocate_attribute();
keyAttribute->name(out_element->document()->allocate_string("key"));
keyAttribute->value(out_element->document()->allocate_string(it->first.c_str()));
XML::Attribute* valueAttribute = out_element->document()->allocate_attribute();
valueAttribute->name(out_element->document()->allocate_string("value"));
valueAttribute->value(out_element->document()->allocate_string(it->second.c_str()));
XML::Node* node = out_element->document()->allocate_node(rapidxml::node_type::node_element);
node->name(doc->allocate_string("Param"));
node->append_attribute(keyAttribute);
node->append_attribute(valueAttribute);
out_element->append_node(node);
}
}
//---------------------------------------------------------------------
void TextAreaOverlayElement::addBaseParameters(void)
{
OverlayElement::addBaseParameters();
ParamDictionary* dict = getParamDictionary();
dict->addParameter(ParameterDef("char_height",
"Sets the height of the characters in relation to the screen."
, PT_REAL),
&msCmdCharHeight);
dict->addParameter(ParameterDef("space_width",
"Sets the width of a space in relation to the screen."
, PT_REAL),
&msCmdSpaceWidth);
dict->addParameter(ParameterDef("font_name",
"Sets the name of the font to use."
, PT_STRING),
&msCmdFontName);
dict->addParameter(ParameterDef("colour",
"Sets the colour of the font (a solid colour)."
, PT_STRING),
&msCmdColour);
dict->addParameter(ParameterDef("colour_bottom",
"Sets the colour of the font at the bottom (a gradient colour)."
, PT_STRING),
&msCmdColourBottom);
dict->addParameter(ParameterDef("colour_top",
"Sets the colour of the font at the top (a gradient colour)."
, PT_STRING),
&msCmdColourTop);
dict->addParameter(ParameterDef("alignment",
"Sets the alignment of the text: 'left', 'center' or 'right'."
, PT_STRING),
&msCmdAlignment);
}
//-----------------------------------------------------------------------
ExtinguishableFireAffector::ExtinguishableFireAffector(ParticleSystem* psys)
: ParticleAffector(psys), mPsys(psys)
{
mType = "ExtinguishableFire";
// defaults
mMiddlePoint = Vector3::ZERO;
mRadius = 1.0;
mIntensity = 3000.0;
originalIntensity = mIntensity;
mIntensityGrowth = 10;
mMaxIntensity = 4000.0;
updateIntensityRequired = false;
firstFrame = true;
// Set up parameters
if (createParamDictionary("ExtinguishableFireAffector"))
{
addBaseParameters();
// Add extra paramaters
ParamDictionary* dict = getParamDictionary();
dict->addParameter(ParameterDef("middle_point",
"The middle point of the sphere on which water particles will interact.",
PT_VECTOR3), &msMiddlePointCmd);
dict->addParameter(ParameterDef("intensity",
"The amount of water particles that a fire can withstand before being extinguished.",
PT_REAL), &msIntensityCmd);
dict->addParameter(ParameterDef("max_intensity",
"The maximum intensity the fire can grow to.",
PT_REAL), &msMaxIntensityCmd);
dict->addParameter(ParameterDef("intensity_growth",
"The amount by which the intensity of the fire grows per second.",
PT_REAL), &msMaxIntensityCmd);
dict->addParameter(ParameterDef("radius",
"The radius of the sphere.",
PT_REAL), &msRadiusCmd);
}
// predefine objectInstanceName
objectInstanceName = "unknown";
ScriptEngine::getSingleton().fireEvent(objectInstanceName, mIntensity);
}
RibbonRenderer::RibbonRenderer()
: mRibbonSet(NULL)
, mWorldSpace(false)
, mNextRibbonIndex(0)
{
if (createParamDictionary("RibbonRenderer"))
{
ParamDictionary* dict = getParamDictionary();
dict->addParameter(ParameterDef("head_alpha",
"the alpha value of the head of ribbon.",
PT_REAL),
&msRibbonHeadAlphaCmd);
dict->addParameter(ParameterDef("tail_alpha",
"the alpha value of the tail of ribbon.",
PT_REAL),
&msRibbonTailAlphaCmd);
dict->addParameter(ParameterDef("head_width_scale",
"the width scale value of the head of ribbon.",
PT_REAL),
&msRibbonHeadWidthScaleCmd);
dict->addParameter(ParameterDef("tail_width_scale",
"the width scale value of the tail of ribbon.",
PT_REAL),
&msRibbonTailWidthScaleCmd);
dict->addParameter(ParameterDef("element_count",
"the element count of the ribbon.",
PT_UNSIGNED_INT),
&msRibbonElementCountCmd);
}
mRibbonSet = new RibbonSet("", 15);
}
