Пример #1
0
	BulletSpeedOperator::BulletSpeedOperator(BulletEventSystem* eventSystem) : BulletOperator(),
		m_isOperated(false)
	{
		m_type = "speed";
		m_parent = eventSystem;
		
		m_direction = Ogre::Vector3::ZERO;
		m_speed = 0.0;

		if (createParamDictionary("BulletSpeedOperator"))
        {
			Ogre::ParamDictionary* dict = getParamDictionary();
			dict->addParameter(Ogre::ParameterDef("mode", 
				"The mode of bullet speed operator.",
				Ogre::PT_STRING),&ms_modeCmd);	  

			dict->addParameter(Ogre::ParameterDef("direction", 
				"The direction of bullet speed operator.",
				Ogre::PT_VECTOR3),&ms_directionCmd);	

			dict->addParameter(Ogre::ParameterDef("speed", 
				"The speed of bullet speed operator.",
				Ogre::PT_REAL),&ms_speedCmd);	

		}
	}
Пример #2
0
	//---------------------------------------------------------------------
	bool EffectElement::initDefaults(const String &mType)
	{		
		if (createParamDictionary(mType + "EffectElement"))
		{
			Ogre::ParamDictionary* dict = getParamDictionary();

			dict->addParameter(Ogre::ParameterDef("StartTime", 
				"the start time of this element.",
				Ogre::PT_REAL),&msStartTimeCmd);

			dict->addParameter(Ogre::ParameterDef("LifeTime", 
				"the life time of this element.",
				Ogre::PT_REAL),&msLifeTimeCmd);

			dict->addParameter(Ogre::ParameterDef("Position", 
				"the relative pos from parent.",
				Ogre::PT_VECTOR3),&msRelPosCmd);

            dict->addParameter(Ogre::ParameterDef("Orientation", 
                "the relative orientation from parent.",
                Ogre::PT_QUATERNION),&msRelOrientationCmd);

			return true;

		}
		return false;
	}
Пример #3
0
    /** Default constructor. */
    GravityAffector(Ogre::ParticleSystem *psys)
      : ParticleAffector(psys)
      , mForce(0.0f)
      , mForceType(Type_Wind)
      , mPosition(0.0f)
      , mDirection(0.0f)
    {
        mType = "Gravity";

        // Init parameters
        if(createParamDictionary("GravityAffector"))
        {
            Ogre::ParamDictionary *dict = getParamDictionary();

            Ogre::String force_title("force");
            Ogre::String force_descr("Amount of force applied to particles.");
            Ogre::String force_type_title("force_type");
            Ogre::String force_type_descr("Type of force applied to particles (point or wind).");
            Ogre::String direction_title("direction");
            Ogre::String direction_descr("Direction of wind forces.");
            Ogre::String position_title("position");
            Ogre::String position_descr("Position of point forces.");

            dict->addParameter(Ogre::ParameterDef(force_title, force_descr, Ogre::PT_REAL), &msForceCmd);
            dict->addParameter(Ogre::ParameterDef(force_type_title, force_type_descr, Ogre::PT_STRING), &msForceTypeCmd);
            dict->addParameter(Ogre::ParameterDef(direction_title, direction_descr, Ogre::PT_VECTOR3), &msDirectionCmd);
            dict->addParameter(Ogre::ParameterDef(position_title, position_descr, Ogre::PT_VECTOR3), &msPositionCmd);
        }
    }
Пример #4
0
    /** Default constructor. */
    GravityAffector(Ogre::ParticleSystem *psys)
      : ParticleAffector(psys)
      , mForce(0.0f)
      , mForceType(Type_Wind)
      , mPosition(0.0f)
      , mDirection(0.0f)
    {
        std::vector<Ogre::Bone*> bones = Ogre::any_cast<NiNodeHolder>(psys->getUserObjectBindings().getUserAny()).mBones;
        assert (!bones.empty());
        mEmitterBone = bones[0];
        Ogre::TagPoint* tag = static_cast<Ogre::TagPoint*>(mParent->getParentNode());
        mParticleBone = static_cast<Ogre::Bone*>(tag->getParent());

        mType = "Gravity";

        // Init parameters
        if(createParamDictionary("GravityAffector"))
        {
            Ogre::ParamDictionary *dict = getParamDictionary();

            Ogre::String force_title("force");
            Ogre::String force_descr("Amount of force applied to particles.");
            Ogre::String force_type_title("force_type");
            Ogre::String force_type_descr("Type of force applied to particles (point or wind).");
            Ogre::String direction_title("direction");
            Ogre::String direction_descr("Direction of wind forces.");
            Ogre::String position_title("position");
            Ogre::String position_descr("Position of point forces.");

            dict->addParameter(Ogre::ParameterDef(force_title, force_descr, Ogre::PT_REAL), &msForceCmd);
            dict->addParameter(Ogre::ParameterDef(force_type_title, force_type_descr, Ogre::PT_STRING), &msForceTypeCmd);
            dict->addParameter(Ogre::ParameterDef(direction_title, direction_descr, Ogre::PT_VECTOR3), &msDirectionCmd);
            dict->addParameter(Ogre::ParameterDef(position_title, position_descr, Ogre::PT_VECTOR3), &msPositionCmd);
        }
    }
Пример #5
0
	BulletScriptTester::BulletScriptTester(BulletEventSystem* eventSystem) : BulletTester()
	{
		m_type = "script";
		m_parent = eventSystem;
		if (createParamDictionary("BulletScriptTester"))
        { 
			Ogre::ParamDictionary* dict = getParamDictionary();
			dict->addParameter(Ogre::ParameterDef("output", 
				"The output of bullet Tester.",
				Ogre::PT_STRING),&ms_outputCmd);	
		}
	}
Пример #6
0
	bool BulletFlowSystem::initParamDictionary(void)
	{
		if (createParamDictionary("BulletFlow"))
		{
			Ogre::ParamDictionary* dict = getParamDictionary();			

			dict->addParameter(Ogre::ParameterDef("maxtime", 
				"bullet flow max time",
				Ogre::PT_REAL),&ms_maxTimeCmd);	  

			return true;
		}

		return false;
	}
Пример #7
0
VBOOL VEffect::_initDefaults()
{
	if (createParamDictionary("Effect"))
	{
		Ogre::ParamDictionary* dict = getParamDictionary();

		dict->addParameter(Ogre::ParameterDef("LifeTime", 
			"the life time of this effect.",
			Ogre::PT_REAL),&msLifeTimeCmd);		

		return VTRUE;
	}

	return VFALSE;
}
Пример #8
0
	BulletForceOperator::BulletForceOperator(BulletEventSystem* eventSystem) : BulletOperator()
	{
		m_type = "force";
		m_parent = eventSystem;

		m_isOperated = false;
		m_forceVector = Ogre::Vector3::ZERO;

		if (createParamDictionary("BulletForceOperator"))
        {
			Ogre::ParamDictionary* dict = getParamDictionary();
			dict->addParameter(Ogre::ParameterDef("forceVector", 
				"The mode of bullet speed operator.",
				Ogre::PT_VECTOR3),&ms_forceVectorCmd);	  
		}
	}
Пример #9
0
	AnimationSound::AnimationSound() :	
		mAttachTime(0.0f), mSoundName(""), mSoundHandle(-1), mPlayed(false)
	{
		if (createParamDictionary("AnimationSound"))
		{
			Ogre::ParamDictionary* dict = getParamDictionary();

			dict->addParameter(Ogre::ParameterDef("SoundName", 
				"the file name of sound.",
				Ogre::PT_STRING),&msSoundNameCmd);	

			dict->addParameter(Ogre::ParameterDef("AttachTime", 
				"the time that play sound.",
				Ogre::PT_REAL),&msAttachTimeCmd);			
		}
	}
Пример #10
0
	DLightEffect::DLightEffect(Ogre::Entity* parent)
	:AttachEffectBase(parent)
	,m_light(nullptr)
	,m_dlType(eDLightType_None)
	,m_fRadius(0)
	,m_dlPointParam(1,0,0)
	{
		m_type = eAttachEffect_DLight;
		if (InitParamDict("DLight"))
		{
			Ogre::ParamDictionary* dict = getParamDictionary();
			dict->addParameter(Ogre::ParameterDef("lighttype", "Deferred light type", Ogre::PT_INT), &m_sCmdLightType);
			dict->addParameter(Ogre::ParameterDef("radius", "Radius of point light", Ogre::PT_REAL), &m_sCmdLightRadius);
			dict->addParameter(Ogre::ParameterDef("PointAtteParam", "Attenuation info of point light", Ogre::PT_VECTOR3), &m_sCmdPointAttenParam);
		}
	}
Пример #11
0
    //---------------------------------------------------------------------
	bool AnimationEffectInfo::initParamDictionary(void)
	{
		if (createParamDictionary("AnimationEffectInfo"))
		{
			Ogre::ParamDictionary* dict = getParamDictionary();			

			dict->addParameter(Ogre::ParameterDef("AttachTime", 
				"the time that showing the effect.",
				Ogre::PT_REAL),&msAttachTimeCmd);	  

			dict->addParameter(Ogre::ParameterDef("AttachPoint", 
				"the attached bone or locator.",
				Ogre::PT_STRING),&msAttachPointCmd);	  

			dict->addParameter(Ogre::ParameterDef("EffectTemplateName", 
				"name of effect template.",
				Ogre::PT_STRING),&msEffectTemplateNameCmd);	  

			dict->addParameter(Ogre::ParameterDef("OffsetPos", 
				"offset position to the attach point.",
				Ogre::PT_VECTOR3),&msOffsetPosCmd);	  

			dict->addParameter(Ogre::ParameterDef("OffsetRotation", 
				"offset orientation to the attach point.",
				Ogre::PT_QUATERNION),&msOffsetRotationCmd);	  

			dict->addParameter(Ogre::ParameterDef("Attach", 
				"whether the effect will move along with the attach point.",
				Ogre::PT_BOOL),&msAttachCmd);	  

			return true;
		}

		return false;
	}
Пример #12
0
	MeshElement::MeshElement(const String &type, System *system) :
	EffectElement(type, system),
	mEntity(NULL),
	mMeshName(""), mMaterialName("none")
	{
		if ( initDefaults(mElementType) )
		{
			Ogre::ParamDictionary* dict = getParamDictionary();

        // Custom params      
			dict->addParameter(Ogre::ParameterDef("MeshName", 
            "the name of mesh.",
			Ogre::PT_STRING),&msMeshNameCmd);  

			dict->addParameter(Ogre::ParameterDef("Material", 
			"the name of material.",
			Ogre::PT_STRING),&msMaterialNameCmd);  
		}
	}
Пример #13
0
	BulletBirthOperator::BulletBirthOperator(BulletEventSystem* eventSystem) : BulletOperator(),
		m_birthedTimes(0.0f),m_birthTimes(0.0f),m_isOperated(false)
	{
		m_type = "birth";
		m_parent = eventSystem;

		if (createParamDictionary("BulletBirthOperator"))
        {
			Ogre::ParamDictionary* dict = getParamDictionary();
			dict->addParameter(Ogre::ParameterDef("bulletsystemname", 
				"The bulletsystemname of bullet birth operator.",
				Ogre::PT_STRING),&ms_bulletTemplateCmd);	  

			dict->addParameter(Ogre::ParameterDef("birthtimes", 
				"The times of bullet birth operator.",
				Ogre::PT_REAL),&ms_birthTimesCmd);	

		}
	}
Пример #14
0
BulletHelixOperator::BulletHelixOperator(BulletEventSystem* eventSystem) : BulletOperator()
{
    m_type = "helix";
    m_parent = eventSystem;
    m_amplitude = 0.0;
    m_frequency = 0.0;

    if (createParamDictionary("BulletHelixOperator"))
    {
        Ogre::ParamDictionary* dict = getParamDictionary();

        dict->addParameter(Ogre::ParameterDef("amplitude",
                                              "The amplitude of bullet helix operator.",
                                              Ogre::PT_REAL),&ms_amplitudeCmd);

        dict->addParameter(Ogre::ParameterDef("frequency",
                                              "The frequency of bullet helix operator.",
                                              Ogre::PT_REAL),&ms_frequencyCmd);

    }
}
Пример #15
0
    /** Default constructor. */
    GrowFadeAffector(Ogre::ParticleSystem *psys) : ParticleAffector(psys)
    {
        mGrowTime = 0.0f;
        mFadeTime = 0.0f;

        mType = "GrowFade";

        // Init parameters
        if(createParamDictionary("GrowFadeAffector"))
        {
            Ogre::ParamDictionary *dict = getParamDictionary();

            Ogre::String grow_title("grow_time");
            Ogre::String fade_title("fade_time");
            Ogre::String grow_descr("Time from begin to reach full size.");
            Ogre::String fade_descr("Time from end to shrink.");

            dict->addParameter(Ogre::ParameterDef(grow_title, grow_descr, Ogre::PT_REAL), &msGrowCmd);
            dict->addParameter(Ogre::ParameterDef(fade_title, fade_descr, Ogre::PT_REAL), &msFadeCmd);
        }
    }
Пример #16
0
	//---------------------------------------------------------------------
	bool Skill::initParamDictionary(void)
	{
		if (createParamDictionary("Skill"))
		{
			Ogre::ParamDictionary* dict = getParamDictionary();			

			dict->addParameter(Ogre::ParameterDef("Animation", 
				"name of animation.",
				Ogre::PT_STRING),&msAnimationNameCmd);	  

			dict->addParameter(Ogre::ParameterDef("BreakTime", 
				"the break time of skill.",
				Ogre::PT_STRING),&msBreakTimeCmd);	  

			dict->addParameter(Ogre::ParameterDef("HitTime", 
				"the hit time of skill.",
				Ogre::PT_STRING),&msHitTimeCmd);	  

			dict->addParameter(Ogre::ParameterDef("ShakeTime", 
				"the shake time of skill.",
				Ogre::PT_STRING),&msShakeTimeCmd);	 

            dict->addParameter(Ogre::ParameterDef("RepeatEffect", 
                "whether recreate effect when the animation is loop.",
                Ogre::PT_BOOL),&msRepeatEffectCmd);	  

			return true;
		}

		return false;
	}
Пример #17
0
    AnimationSceneLightInfo::AnimationSceneLightInfo(void) :
    mAttachTime(0.0f),
    mLastTime(0.0f),
    mFadeInTime(0.0f),
    mFadeOutTime(0.0f),
    mDestColour(Ogre::ColourValue::Black)
    {
        if (createParamDictionary("AnimationSceneLightInfo"))
        {
            Ogre::ParamDictionary* dict = getParamDictionary();

            dict->addParameter(Ogre::ParameterDef("AttachTime", 
                "the time that starting changing the light.",
                Ogre::PT_REAL),&msAttachTimeCmd);	

            dict->addParameter(Ogre::ParameterDef("LastTime", 
                "the last time that changing the light.",
                Ogre::PT_REAL),&msLastTimeCmd);			

            dict->addParameter(Ogre::ParameterDef("FadeInTime", 
                "the fade in time.",
                Ogre::PT_REAL),&msFadeInTimeCmd);

            dict->addParameter(Ogre::ParameterDef("FadeOutTime", 
                "the fade out time.",
                Ogre::PT_REAL),&msFadeOutTimeCmd);

            dict->addParameter(Ogre::ParameterDef("DestColour", 
                "the dest colour of light.",
                Ogre::PT_COLOURVALUE),&msDestColourCmd);
        }
    }
Пример #18
0
    /** Internal for initializing some defaults and parameters
    @return True if custom parameters need initialising
    */
    bool initDefaults(const Ogre::String &t)
    {
        // Defaults
        mDirection = Ogre::Vector3::UNIT_Z;
        mUp = Ogre::Vector3::UNIT_Y;
        setSize(100.0f, 100.0f, 100.0f);
        mType = t;

        // Set up parameters
        if(createParamDictionary(mType + "Emitter"))
        {
            addBaseParameters();
            Ogre::ParamDictionary *dict = getParamDictionary();

            // Custom params
            dict->addParameter(Ogre::ParameterDef("width",
                                                  "Width of the shape in world coordinates.",
                                                  Ogre::PT_REAL),
                               &msWidthCmd);
            dict->addParameter(Ogre::ParameterDef("height",
                                                  "Height of the shape in world coordinates.",
                                                  Ogre::PT_REAL),
                               &msHeightCmd);
            dict->addParameter(Ogre::ParameterDef("depth",
                                                  "Depth of the shape in world coordinates.",
                                                  Ogre::PT_REAL),
                               &msDepthCmd);

            dict->addParameter(Ogre::ParameterDef("vertical_direction",
                                                  "Vertical direction of emitted particles (in degrees).",
                                                  Ogre::PT_REAL),
                               &msVerticalDirCmd);
            dict->addParameter(Ogre::ParameterDef("vertical_angle",
                                                  "Vertical direction variance of emitted particles (in degrees).",
                                                  Ogre::PT_REAL),
                               &msVerticalAngleCmd);
            dict->addParameter(Ogre::ParameterDef("horizontal_direction",
                                                  "Horizontal direction of emitted particles (in degrees).",
                                                  Ogre::PT_REAL),
                               &msHorizontalDirCmd);
            dict->addParameter(Ogre::ParameterDef("horizontal_angle",
                                                  "Horizontal direction variance of emitted particles (in degrees).",
                                                  Ogre::PT_REAL),
                               &msHorizontalAngleCmd);

            return true;
        }
        return false;
    }
Пример #19
0
VPointLightElement::VPointLightElement(const VString &type)
	: VEffectElement(type)
	, mLight(VNULL)
	, mDiffuse(Ogre::ColourValue::White)
	, mSpecular(Ogre::ColourValue::Black)
	, mRange(1000.0f)
	, mAttenuationConstant(1.0f)
	, mAttenuationLinear(0.0f)
	, mAttenuationQuadric(0.0f)
{
	if (_initDefaults(mElementType))
	{
		Ogre::ParamDictionary *dict = getParamDictionary();   

		dict->addParameter(Ogre::ParameterDef("Diffuse", 
			"diffuse colour of point light.",
			Ogre::PT_COLOURVALUE),
			&msDiffuseCmd);

		dict->addParameter(Ogre::ParameterDef("Specular", 
			"specular colour of point light.",
			Ogre::PT_COLOURVALUE),
			&msSpecularCmd);

		dict->addParameter(Ogre::ParameterDef("Range", 
			"range of point light.",
			Ogre::PT_REAL),
			&msRangeCmd);

		dict->addParameter(Ogre::ParameterDef("AttenuationConstant", 
			"attenuation constant of point light.",
			Ogre::PT_REAL),
			&msAttenuationConstantCmd);

		dict->addParameter(Ogre::ParameterDef("AttenuationLinear", 
			"attenuation linear of point light.",
			Ogre::PT_REAL),
			&msAttenuationLinearCmd);

		dict->addParameter(Ogre::ParameterDef("AttenuationQuadric", 
			"attenuation quadric of point light.",
			Ogre::PT_REAL),
			&msAttenuationQuadricCmd);
	}
}
Пример #20
0
	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;
	}
Пример #21
0
	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);   

		}    
	}