PolarEmitter::PolarEmitter(ParticleSystem* psys) : ParticleEmitter(psys) , mRadiusMin(0.0f) , mRadiusStep(0.0f) , mRadiusMax(0.0f) , mThetaMin(0.0f) , mThetaStep(0.0f) , mThetaMax(0.0f) , mPhiMin(0.0f) , mPhiStep(0.0f) , mPhiMax(0.0f) , mThetaTotal(0.0f) , mPhiTotal(0.0f) , mRadiusTotal(0.0f) , mUsePolarStep(false) , mFlipYZAxis(false) , mResetRadiusCount(0) , mResetRadius(false) , mCurrentResetRadiusCount(0) { mType = "PolarEmitter"; // Set up parameters if (createParamDictionary("PolarEmitter")) { addBaseParameters(); // Add extra paramaters ParamDictionary* dict = getParamDictionary(); dict->addParameter(ParameterDef("radius_start", "The vector representing the force to apply.", PT_REAL),&msRadiusMinCmd); dict->addParameter(ParameterDef("radius_step", "The vector representing the force to apply.", PT_REAL),&msRadiusStepCmd); dict->addParameter(ParameterDef("radius_end", "The vector representing the force to apply.", PT_REAL),&msRadiusMaxCmd); dict->addParameter(ParameterDef("theta_start", "The vector representing the force to apply.", PT_REAL),&msThetaMinCmd); dict->addParameter(ParameterDef("theta_step", "The vector representing the force to apply.", PT_REAL),&msThetaStepCmd); dict->addParameter(ParameterDef("theta_end", "The vector representing the force to apply.", PT_REAL),&msThetaMaxCmd); dict->addParameter(ParameterDef("phi_start", "The vector representing the force to apply.", PT_REAL),&msPhiMinCmd); dict->addParameter(ParameterDef("phi_step", "The vector representing the force to apply.", PT_REAL),&msPhiStepCmd); dict->addParameter(ParameterDef("phi_end", "The vector representing the force to apply.", PT_REAL),&msPhiMaxCmd); dict->addParameter(ParameterDef("use_polar_step", "The vector representing the force to apply.", PT_BOOL),&msUsePolarStepCmd); dict->addParameter(ParameterDef("flip_yz_axis", "The vector representing the force to apply.", PT_BOOL),&msFlipYZAxisCmd); dict->addParameter(ParameterDef("reset_radius_count", "when you use the radius step, this value can control the radius reset" "by emitting reset_radius_count particles.", PT_INT),&msResetRadiusCountCmd); dict->addParameter(ParameterDef("reset_radius", "when you use the radius step, this value can control the radius reset.", PT_BOOL),&msResetRadiusCmd); } }
//----------------------------------------------------------------------- void ParticleEmitter::addBaseParameters(void) { ParamDictionary* dict = getParamDictionary(); dict->addParameter(ParameterDef("angle", "The angle up to which particles may vary in their initial direction " "from the emitters direction, in degrees." , PT_REAL), &msAngleCmd); dict->addParameter(ParameterDef("colour", "The colour of emitted particles.", PT_COLOURVALUE), &msColourCmd); dict->addParameter(ParameterDef("colour_range_start", "The start of a range of colours to be assigned to emitted particles.", PT_COLOURVALUE), &msColourRangeStartCmd); dict->addParameter(ParameterDef("colour_range_end", "The end of a range of colours to be assigned to emitted particles.", PT_COLOURVALUE), &msColourRangeEndCmd); dict->addParameter(ParameterDef("direction", "The base direction of the emitter." , PT_VECTOR3), &msDirectionCmd); dict->addParameter(ParameterDef("emission_rate", "The number of particles emitted per second." , PT_REAL), &msEmissionRateCmd); dict->addParameter(ParameterDef("position", "The position of the emitter relative to the particle system center." , PT_VECTOR3), &msPositionCmd); dict->addParameter(ParameterDef("velocity", "The initial velocity to be assigned to every particle, in world units per second." , PT_REAL), &msVelocityCmd); dict->addParameter(ParameterDef("velocity_min", "The minimum initial velocity to be assigned to each particle." , PT_REAL), &msMinVelocityCmd); dict->addParameter(ParameterDef("velocity_max", "The maximum initial velocity to be assigned to each particle." , PT_REAL), &msMaxVelocityCmd); dict->addParameter(ParameterDef("time_to_live", "The lifetime of each particle in seconds." , PT_REAL), &msTTLCmd); dict->addParameter(ParameterDef("time_to_live_min", "The minimum lifetime of each particle in seconds." , PT_REAL), &msMinTTLCmd); dict->addParameter(ParameterDef("time_to_live_max", "The maximum lifetime of each particle in seconds." , PT_REAL), &msMaxTTLCmd); dict->addParameter(ParameterDef("duration", "The length of time in seconds which an emitter stays enabled for." , PT_REAL), &msDurationCmd); dict->addParameter(ParameterDef("duration_min", "The minimum length of time in seconds which an emitter stays enabled for." , PT_REAL), &msMinDurationCmd); dict->addParameter(ParameterDef("duration_max", "The maximum length of time in seconds which an emitter stays enabled for." , PT_REAL), &msMaxDurationCmd); dict->addParameter(ParameterDef("repeat_delay", "If set, after disabling an emitter will repeat (reenable) after this many seconds." , PT_REAL), &msRepeatDelayCmd); dict->addParameter(ParameterDef("repeat_delay_min", "If set, after disabling an emitter will repeat (reenable) after this minimum number of seconds." , PT_REAL), &msMinRepeatDelayCmd); dict->addParameter(ParameterDef("repeat_delay_max", "If set, after disabling an emitter will repeat (reenable) after this maximum number of seconds." , PT_REAL), &msMaxRepeatDelayCmd); }
BillboardSetElement::BillboardSetElement(const String &type, System *system) : EffectElement(type, system), mBillboardSet(NULL), mBillboardColour(Ogre::ColourValue::White), mScaleIntervalTime(0.1f), mSizeChanged(false), mBillboardCount(5), mBillboardMaterial("BaseWhiteNoLighting"), mBillboardInterval(10.0f), mBillboardWidth(100.0f), mBillboardHeight(100.0f), mAlphaValue(1.0f), mColourChanged(false), mStacks(1), mSlices(1), mTexIntervalTime(0.1f), mCurrentTexIntervalTime(0.0f) { for (int i=0; i<MAX_STAGES; ++i) { mBillboardScale[i] = Ogre::Vector3(1.0f, 1.0f, 1.0f); } if ( initDefaults(mElementType) ) { Ogre::ParamDictionary* dict = getParamDictionary(); // Custom params dict->addParameter(Ogre::ParameterDef("BillboardColour", "BillboardColour", Ogre::PT_COLOURVALUE), &msBillboardColourCmd); dict->addParameter(Ogre::ParameterDef("BillboardAlpha", "Billboard Alpha Value of first point and second point.", Ogre::PT_REAL),&msBillboardAlphaCmd); dict->addParameter(Ogre::ParameterDef("BillboardCount", "the life time of the vertex.", Ogre::PT_INT),&msBillboardCountCmd); dict->addParameter(Ogre::ParameterDef("Material", "alpha factor of head point.", Ogre::PT_STRING),&msBillboardMaterialCmd); dict->addParameter(Ogre::ParameterDef("BillboardInterval", "alpha factor of tail point.", Ogre::PT_REAL),&msBillboardIntervalCmd); dict->addParameter(Ogre::ParameterDef("BillboardHeight", "alpha factor of tail point.", Ogre::PT_REAL),&msBillboardHeightCmd); dict->addParameter(Ogre::ParameterDef("BillboardWidth", "alpha factor of tail point.", Ogre::PT_REAL),&msBillboardWidthCmd); for (int i=0;i<MAX_STAGES;i++) { msBillboardScaleCmd[i].mIndex = i; Ogre::StringUtil::StrStreamType stage; stage << i; String colour_title = String("BillboardScale") + stage.str(); String colour_descr = String("Stage ") + stage.str() + String(" BillboardScale of first point and second point."); dict->addParameter(Ogre::ParameterDef(colour_title, colour_descr, Ogre::PT_VECTOR3), &msBillboardScaleCmd[i]); } dict->addParameter(Ogre::ParameterDef("ScaleIntervalTime", "the interval time of changing scale.", Ogre::PT_REAL),&msScaleIntervalTimeCmd); dict->addParameter(Ogre::ParameterDef("stacks", "the stacks of texture coordinates.", Ogre::PT_UNSIGNED_LONG), &msStacksCmd); dict->addParameter(Ogre::ParameterDef("slices", "the slices of texture coordinates.", Ogre::PT_UNSIGNED_LONG), &msSlicesCmd); dict->addParameter(Ogre::ParameterDef("TexIntervalTime", "the interval time of changing texture index.", Ogre::PT_REAL),&msTexIntervalTimeCmd); } }
//----------------------------------------------------------------------- TexCoordBillboardParticleRenderer::TexCoordBillboardParticleRenderer() { if (createParamDictionary("TexCoordBillboardParticleRenderer")) { ParamDictionary* dict = getParamDictionary(); dict->addParameter(ParameterDef("billboard_type", "The type of billboard to use. 'point' means a simulated spherical particle, " "'oriented_common' means all particles in the set are oriented around common_direction, " "'oriented_self' means particles are oriented around their own direction, " "'perpendicular_common' means all particles are perpendicular to common_direction, " "and 'perpendicular_self' means particles are perpendicular to their own direction.", PT_STRING), &msBillboardTypeCmd); dict->addParameter(ParameterDef("billboard_origin", "This setting controls the fine tuning of where a billboard appears in relation to it's position. " "Possible value are: 'top_left', 'top_center', 'top_right', 'center_left', 'center', 'center_right', " "'bottom_left', 'bottom_center' and 'bottom_right'. Default value is 'center'.", PT_STRING), &msBillboardOriginCmd); dict->addParameter(ParameterDef("billboard_rotation_type", "This setting controls the billboard rotation type. " "'vertex' means rotate the billboard's vertices around their facing direction." "'texcoord' means rotate the billboard's texture coordinates. Default value is 'texcoord'.", PT_STRING), &msBillboardRotationTypeCmd); dict->addParameter(ParameterDef("common_direction", "Only useful when billboard_type is oriented_common or perpendicular_common. " "When billboard_type is oriented_common, this parameter sets the common orientation for " "all particles in the set (e.g. raindrops may all be oriented downwards). " "When billboard_type is perpendicular_common, this parameter sets the perpendicular vector for " "all particles in the set (e.g. an aureola around the player and parallel to the ground).", PT_VECTOR3), &msCommonDirectionCmd); dict->addParameter(ParameterDef("common_up_vector", "Only useful when billboard_type is perpendicular_self or perpendicular_common. This " "parameter sets the common up-vector for all particles in the set (e.g. an aureola around " "the player and parallel to the ground).", PT_VECTOR3), &msCommonUpVectorCmd); dict->addParameter(ParameterDef("point_rendering", "Set whether or not particles will use point rendering " "rather than manually generated quads. This allows for faster " "rendering of point-oriented particles although introduces some " "limitations too such as requiring a common particle size." "Possible values are 'true' or 'false'.", PT_BOOL), &msPointRenderingCmd); dict->addParameter(ParameterDef("accurate_facing", "Set whether or not particles will be oriented to the camera " "based on the relative position to the camera rather than just " "the camera direction. This is more accurate but less optimal. " "Cannot be combined with point rendering.", PT_BOOL), &msAccurateFacingCmd); dict->addParameter(ParameterDef("speed_relatived_size_factor", "Sets the factor of the particle size relative to speed. If greater " "than zero, the particle size are relative to its speed as well as " "this factor. Otherwise, the particle rendering use its own size " "only. This parameters applies only to 'oriented_self' billboards. " "Default to zero as particle size unrelated to speed", PT_REAL), &msSpeedRelativedSizeFactorCmd); dict->addParameter(ParameterDef("stacks", "the stacks of texture coordinates.", PT_UNSIGNED_LONG), &msStacksCmd); dict->addParameter(ParameterDef("slices", "the slices of texture coordinates.", PT_UNSIGNED_LONG), &msSlicesCmd); dict->addParameter(ParameterDef("repeat_times", "the repeat times of the colour interpolate.", PT_REAL), &msRepeatTimesCmd); } mStacks = 1; mSlices = 1; mRepeatTimes = 1.0f; }
//----------------------------------------------------------------------- BillboardParticleRenderer::BillboardParticleRenderer() { if (createParamDictionary("BillboardParticleRenderer")) { ParamDictionary* dict = getParamDictionary(); dict->addParameter(ParameterDef("billboard_type", "The type of billboard to use. 'point' means a simulated spherical particle, " "'oriented_common' means all particles in the set are oriented around common_direction, " "'oriented_self' means particles are oriented around their own direction, " "'perpendicular_common' means all particles are perpendicular to common_direction, " "and 'perpendicular_self' means particles are perpendicular to their own direction.", PT_STRING), &msBillboardTypeCmd); dict->addParameter(ParameterDef("billboard_origin", "This setting controls the fine tuning of where a billboard appears in relation to it's position. " "Possible value are: 'top_left', 'top_center', 'top_right', 'center_left', 'center', 'center_right', " "'bottom_left', 'bottom_center' and 'bottom_right'. Default value is 'center'.", PT_STRING), &msBillboardOriginCmd); dict->addParameter(ParameterDef("billboard_rotation_type", "This setting controls the billboard rotation type. " "'vertex' means rotate the billboard's vertices around their facing direction." "'texcoord' means rotate the billboard's texture coordinates. Default value is 'texcoord'.", PT_STRING), &msBillboardRotationTypeCmd); dict->addParameter(ParameterDef("common_direction", "Only useful when billboard_type is oriented_common or perpendicular_common. " "When billboard_type is oriented_common, this parameter sets the common orientation for " "all particles in the set (e.g. raindrops may all be oriented downwards). " "When billboard_type is perpendicular_common, this parameter sets the perpendicular vector for " "all particles in the set (e.g. an aureola around the player and parallel to the ground).", PT_VECTOR3), &msCommonDirectionCmd); dict->addParameter(ParameterDef("common_up_vector", "Only useful when billboard_type is perpendicular_self or perpendicular_common. This " "parameter sets the common up-vector for all particles in the set (e.g. an aureola around " "the player and parallel to the ground).", PT_VECTOR3), &msCommonUpVectorCmd); dict->addParameter(ParameterDef("point_rendering", "Set whether or not particles will use point rendering " "rather than manually generated quads. This allows for faster " "rendering of point-oriented particles although introduces some " "limitations too such as requiring a common particle size." "Possible values are 'true' or 'false'.", PT_BOOL), &msPointRenderingCmd); dict->addParameter(ParameterDef("accurate_facing", "Set whether or not particles will be oriented to the camera " "based on the relative position to the camera rather than just " "the camera direction. This is more accurate but less optimal. " "Cannot be combined with point rendering.", PT_BOOL), &msAccurateFacingCmd); } // Create billboard set mBillboardSet = OGRE_NEW BillboardSet("", 0, true); // World-relative axes mBillboardSet->setBillboardsInWorldSpace(true); }
//----------------------------------------------------------------------- RevolutionAffector::RevolutionAffector(ParticleSystem* psys) :ParticleAffector(psys) { mType = "Revolution"; mRotateAxis = Ogre::Vector3::UNIT_Y; mRotationSpeed = 0.0f; 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 mRadiusIncrementAdj[i] = 0.0f; mTimeAdj[i] = 1.0f; } mRepeatTimes = 1.0f; mCenterOffsetMin = Ogre::Vector3::ZERO; mCenterOffsetMax = Ogre::Vector3::ZERO; mUseRadiusIncrementScale = false; mRadiusIncrement = 0.0f; // Default to gravity-like // Set up parameters if (createParamDictionary("RevolutionAffector")) { addBaseParameters(); // Add extra paramaters ParamDictionary* dict = getParamDictionary(); dict->addParameter(ParameterDef("rotation_speed", "the speed of particle circle rotation.", PT_REAL),&msRotationSpeedCmd); dict->addParameter(ParameterDef("rotation_axis", "The vector representing the force to apply.", PT_VECTOR3),&msRotationAxisCmd); dict->addParameter(ParameterDef("radius_increment", "the speed of particle circle rotation.", PT_REAL),&msRadiusIncrementCmd); dict->addParameter(ParameterDef("center_offset_min", "The vector representing the force to apply.", PT_VECTOR3),&msCenterOffsetMinCmd); dict->addParameter(ParameterDef("center_offset_max", "The vector representing the force to apply.", PT_VECTOR3),&msCenterOffsetMaxCmd); for (int i=0;i<MAX_STAGES;i++) { msRadiusIncrementAdjustCmd[i].mIndex = i; msTimeCmd[i].mIndex = i; StringUtil::StrStreamType stage; stage << i; String speed_title = String("radius_increment_scale") + stage.str(); String time_title = String("time") + stage.str(); String speed_descr = String("Stage ") + stage.str() + String(" RadiusIncrementScale."); String time_descr = String("Stage ") + stage.str() + String(" time."); dict->addParameter(ParameterDef(speed_title, speed_descr, PT_REAL), &msRadiusIncrementAdjustCmd[i]); dict->addParameter(ParameterDef(time_title, time_descr, PT_REAL), &msTimeCmd[i]); } dict->addParameter(ParameterDef("use_radius_increment_scale", "the repeat times of the colour interpolate.", PT_BOOL), &msUseRadiusIncrementScaleCmd); dict->addParameter(ParameterDef("repeat_times", "the repeat times of the colour interpolate.", PT_REAL), &msRepeatTimesCmd); } }
ShaderParticleRenderer::ShaderParticleRenderer() : mDefaultParticleSize(1, 1) , mKeepInLocalSpace(false) , mParentNode(NULL) , mParentIsTagPoint(false) , mSortMode(SM_DISTANCE) , mLightListUpdated(0) , mRadius(0.0f) , mRenderQueueID(RENDER_QUEUE_MAIN) , mVertexFormatTexture(false) , mVertexFormatSize(false) , mVertexFormatRotation(false) , mVertexFormatRotationSpeed(false) , mVertexFormatDirection(false) , mVertexFormatColour(false ) , mVertexFormatTTL(false) , mVertexFormatTotalTTL(false) , mVertexFormatTimeFragment(false) , mVertexFormatTimeFragmentInv(false) , mVertexSize(0) { if (createParamDictionary("ShaderParticleRenderer")) { ParamDictionary* dict = getParamDictionary(); dict->addParameter(ParameterDef("diffuse_colour", "Adds diffuse colour to vertex format (type = float4)", PT_BOOL), &msVertexFmtColour); dict->addParameter(ParameterDef("texture_coord", "Adds general texture coordinate to vertex format (type = float2)", PT_BOOL), &msVertexFmtTexture); dict->addParameter(ParameterDef("particle_size", "Adds particle size to vertex format (type = float2)", PT_BOOL), &msVertexFmtSize); dict->addParameter(ParameterDef("particle_rotation", "Adds particle rotation (in radians) to vertex format (type = float1)" "note: if particle_rotation_speed present in script, they are packed together as float2", PT_BOOL), &msVertexFmtRotation); dict->addParameter(ParameterDef("particle_rotation_speed", "Adds particle rotation speed (in radians/s) to vertex format (type = float1)" "note: if particle_rotation present in script, they are packed together as float2", PT_BOOL), &msVertexFmtRotationSpeed); dict->addParameter(ParameterDef("particle_direction", "Adds particle direction to vertex format (type = float3)" "note: it represent particle speed", PT_BOOL), &msVertexFmtDirection); dict->addParameter(ParameterDef("time_to_live", "Adds particle current time to live to vertex format (type = float1)" "note: this parameter can be packed with total_time_to_live, time_frag and time_frag_inv", PT_BOOL), &msVertexFmtTTL); dict->addParameter(ParameterDef("total_time_to_live", "Adds particle total time to live to vertex format (type = float1)" "note: this parameter can be packed with time_to_live, time_frag and time_frag_inv", PT_BOOL), &msVertexFmtTotalTTL); dict->addParameter(ParameterDef("time_frag", "Adds particle time fragment to vertex format (type = float1), which is ratio between ttl and total ttl" "note: this parameter can be packed with time_to_live, total_time_to_live and time_frag_inv", PT_BOOL), &msVertexFmtTimeFrag); dict->addParameter(ParameterDef("time_frag_inv", "Adds particle inverse time fragment to vertex format (type = float1), which is 1.0f - time_frag" "note: this parameter can be packed with time_to_live, total_time_to_live and time_frag", PT_BOOL), &msVertexFmtTimeFragInv); } mVertexData = OGRE_NEW VertexData; mIndexData = OGRE_NEW IndexData; mTexCoordTable[0] = Vector2(0, 0); mTexCoordTable[1] = Vector2(1, 0); mTexCoordTable[2] = Vector2(1, 1); mTexCoordTable[3] = Vector2(0, 1); }
//----------------------------------------------------------------------- MeshRotationAffector::MeshRotationAffector(ParticleSystem* psys) :ParticleAffector(psys), mYawRotationSpeedRangeStart(0), mYawRotationSpeedRangeEnd(0), mYawRotationRangeStart(0), mYawRotationRangeEnd(0), mPitchRotationSpeedRangeStart(0), mPitchRotationSpeedRangeEnd(0), mPitchRotationRangeStart(0), mPitchRotationRangeEnd(0), mRollRotationSpeedRangeStart(0), mRollRotationSpeedRangeEnd(0), mRollRotationRangeStart(0), mRollRotationRangeEnd(0) { mType = "MeshRotator"; // Init parameters if (createParamDictionary("MeshRotationAffector")) { ParamDictionary* dict = getParamDictionary(); dict->addParameter(ParameterDef("yaw_rotation_speed_range_start", "The start of a range of yaw rotation speed to be assigned to emitted particles.", PT_REAL), &msYawRotationSpeedRangeStartCmd); dict->addParameter(ParameterDef("yaw_rotation_speed_range_end", "The end of a range of yaw rotation speed to be assigned to emitted particles.", PT_REAL), &msYawRotationSpeedRangeEndCmd); dict->addParameter(ParameterDef("yaw_rotation_range_start", "The start of a range of yaw rotation angles to be assigned to emitted particles.", PT_REAL), &msYawRotationRangeStartCmd); dict->addParameter(ParameterDef("yaw_rotation_range_end", "The end of a range of yaw rotation angles to be assigned to emitted particles.", PT_REAL), &msYawRotationRangeEndCmd); dict->addParameter(ParameterDef("pitch_rotation_speed_range_start", "The start of a range of pitch rotation speed to be assigned to emitted particles.", PT_REAL), &msPitchRotationSpeedRangeStartCmd); dict->addParameter(ParameterDef("pitch_rotation_speed_range_end", "The end of a range of pitch rotation speed to be assigned to emitted particles.", PT_REAL), &msPitchRotationSpeedRangeEndCmd); dict->addParameter(ParameterDef("pitch_rotation_range_start", "The start of a range of pitch rotation angles to be assigned to emitted particles.", PT_REAL), &msPitchRotationRangeStartCmd); dict->addParameter(ParameterDef("pitch_rotation_range_end", "The end of a range of pitch rotation angles to be assigned to emitted particles.", PT_REAL), &msPitchRotationRangeEndCmd); dict->addParameter(ParameterDef("roll_rotation_speed_range_start", "The start of a range of roll rotation speed to be assigned to emitted particles.", PT_REAL), &msRollRotationSpeedRangeStartCmd); dict->addParameter(ParameterDef("roll_rotation_speed_range_end", "The end of a range of roll rotation speed to be assigned to emitted particles.", PT_REAL), &msRollRotationSpeedRangeEndCmd); dict->addParameter(ParameterDef("roll_rotation_range_start", "The start of a range of roll rotation angles to be assigned to emitted particles.", PT_REAL), &msRollRotationRangeStartCmd); dict->addParameter(ParameterDef("roll_rotation_range_end", "The end of a range of roll rotation angles to be assigned to emitted particles.", PT_REAL), &msRollRotationRangeEndCmd); } }
BeamElement::BeamElement(const String &type, System *system) : EffectElement(type, system), mNumBillboardElements(10), mNoiseXMin(0.0f), mNoiseXMax(0.0f), mNoiseYMin(0.0f), mNoiseYMax(0.0f), mNoiseZMin(0.0f), mNoiseZMax(0.0f), mDestPos(Ogre::Vector3::UNIT_Y), // 初始位置 mWidth(10.0f), mBillboardChain(NULL), mMaterialName("BaseWhiteNoLighting"), mFrequency(20.0f), mFrequencyTime(0.0f) { if ( initDefaults(mElementType) ) { Ogre::ParamDictionary* dict = getParamDictionary(); // Custom params dict->addParameter(Ogre::ParameterDef("NoiseXMin", "min noise of x axis.", Ogre::PT_REAL),&msNoiseXMinCmd); dict->addParameter(Ogre::ParameterDef("NoiseXMax", "max noise of x axis.", Ogre::PT_REAL),&msNoiseXMaxCmd); dict->addParameter(Ogre::ParameterDef("NoiseYMin", "min noise of y axis.", Ogre::PT_REAL),&msNoiseYMinCmd); dict->addParameter(Ogre::ParameterDef("NoiseYMax", "max noise of y axis.", Ogre::PT_REAL),&msNoiseYMaxCmd); dict->addParameter(Ogre::ParameterDef("NoiseZMin", "min noise of z axis.", Ogre::PT_REAL),&msNoiseZMinCmd); dict->addParameter(Ogre::ParameterDef("NoiseZMax", "max noise of z axis.", Ogre::PT_REAL),&msNoiseZMaxCmd); dict->addParameter(Ogre::ParameterDef("NumElements", "the num of billboard chain elements.", Ogre::PT_INT),&msNumElementsCmd); dict->addParameter(Ogre::ParameterDef("Width", "width of billboard.", Ogre::PT_REAL),&msWidthCmd); dict->addParameter(Ogre::ParameterDef("Colour", "The colour of emitted particles.", Ogre::PT_COLOURVALUE), &msColourCmd); dict->addParameter(Ogre::ParameterDef("ColourRangeStart", "The start of a range of colours to be assigned to emitted particles.", Ogre::PT_COLOURVALUE), &msColourRangeStartCmd); dict->addParameter(Ogre::ParameterDef("ColourRangeEnd", "The end of a range of colours to be assigned to emitted particles.", Ogre::PT_COLOURVALUE), &msColourRangeEndCmd); dict->addParameter(Ogre::ParameterDef("Material", "name of beam material.", Ogre::PT_STRING),&msMaterialCmd); dict->addParameter(Ogre::ParameterDef("Frequency", "frequency of billboard.", Ogre::PT_REAL),&msFrequencyCmd); } mColourRangeStart = mColourRangeEnd = Ogre::ColourValue::White; }