Пример #1
0
 public override void Initialize(EffectNode node)
 {
     base.Initialize(node);
     SetUVCoord(Node.LowerLeftUV, Node.UVDimensions);
     SetColor(Node.Color);
     SetRotation(Node.OriRotateAngle);
 }
Пример #2
0
 public JetAffector(float mag, MAGTYPE type, AnimationCurve curve,EffectNode node)
     : base(node, AFFECTORTYPE.JetAffector)
 {
     Mag = mag;
     MType = type;
     MagCurve = curve;
 }
Пример #3
0
 void OnPlaneCollision(Xft.CollisionParam param)
 {
     //GameObject g = param.CollideObject;
     //Vector3 pos = param.CollidePos;
     Xft.EffectNode ef = param.effectNode;
     ef.SetBounce();
     //Debug.Log("collision is "+g+" "+pos);
 }
 public TurbulenceFieldAffector(Transform obj,float atten, bool useMax, float maxDist, EffectNode node)
     : base(node, AFFECTORTYPE.TurbulenceAffector)
 {
     TurbulenceObj = obj;;
     UseMaxDistance = useMax;
     MaxDistance = maxDist;
     MaxDistanceSqr = MaxDistance * MaxDistance;
 }
Пример #5
0
 public GravityAffector(GAFTTYPE gtype, bool isacc, Vector3 dir, EffectNode node)
     : base(node, AFFECTORTYPE.GravityAffector)
 {
     GType = gtype;
     Dir = dir;
     Dir.Normalize();
     IsAccelerate = isacc;
 }
Пример #6
0
 public Cone AddCone(Vector2 size, int numSegment, float angle, Vector3 dir, int uvStretch, float maxFps, bool usedelta, AnimationCurve deltaAngle, EffectNode owner)
 {
     VertexSegment segment = GetVertices((numSegment + 1) * 2, numSegment * 6);
     Cone f = new Cone(segment, size, numSegment, angle, dir, uvStretch, maxFps);
     f.UseDeltaAngle = usedelta;
     f.CurveAngle = deltaAngle;
     f.Owner = owner;
     return f;
 }
Пример #7
0
 public DragAffector(Transform dragObj, bool useDir, Vector3 dir,float mag, bool useMaxDist, float maxDist, float atten, EffectNode node)
     : base(node, AFFECTORTYPE.DragAffector)
 {
     DragObj = dragObj;
     UseDirection = useDir;
     Direction = dir;
     Magnitude = mag;
     UseMaxDistance = useMaxDist;
     MaxDistance = maxDist;
     Attenuation = atten;
 }
Пример #8
0
 public ColorAffector(Color[] colorArr, float gradualLen, COLOR_GRADUAL_TYPE type, EffectNode node)
     : base(node, AFFECTORTYPE.ColorAffector)
 {
     ColorArr = colorArr;
     OriColorArr = new Color[ColorArr.Length];
     ColorArr.CopyTo(OriColorArr, 0);
     CType = type;
     GradualLen = gradualLen;
     if (GradualLen < 0)
         IsNodeLife = true;
 }
Пример #9
0
 public TurbulenceFieldAffector(Transform obj, MAGTYPE mtype, float mag, AnimationCurve curve, float atten, bool useMax, float maxDist, EffectNode node)
     : base(node, AFFECTORTYPE.TurbulenceAffector)
 {
     TurbulenceObj = obj;
     MType = mtype;
     Magnitude = mag;
     MagCurve = curve;
     UseMaxDistance = useMax;
     MaxDistance = maxDist;
     MaxDistanceSqr = MaxDistance * MaxDistance;
 }
Пример #10
0
 public GravityAffector(Transform obj, GAFTTYPE gtype, MAGTYPE mtype,bool isacc, Vector3 dir, float mag,AnimationCurve curve,EffectNode node)
     : base(node, AFFECTORTYPE.GravityAffector)
 {
     GType = gtype;
     MType = mtype;
     Magnitude = mag;
     MagCurve = curve;
     Dir = dir;
     Dir.Normalize();
     GravityObj = obj;
     IsAccelerate = isacc;
 }
Пример #11
0
        public ColorAffector(EffectLayer owner, EffectNode node)
            : base(node, AFFECTORTYPE.ColorAffector)
        {
            mOwner = owner;
            if (owner.ColorGradualTimeLength < 0)
                IsNodeLife = true;

            if (mOwner.ColorChangeType == COLOR_CHANGE_TYPE.Random)
            {
                mRandomKey = Random.Range(0f,1f);
            }
        }
Пример #12
0
 public Vector3 GetEmitRotation(EffectNode node)
 {
     Vector3 ret = Vector3.zero;
     //Set Direction:
     if (Layer.DirType == DIRECTION_TYPE.Sphere)
     {
         ret = node.GetOriginalPos() - Layer.DirCenter.position;
         if (ret == Vector3.zero)
         {
             //use random rotation.
             Vector3 r = Vector3.up;
             Quaternion rot = Quaternion.Euler(Random.Range(0, 360), Random.Range(0, 360), Random.Range(0, 360));
             ret = rot * r;
         }
     }
     else if (Layer.DirType == DIRECTION_TYPE.Planar)
     {
         ret = Layer.OriVelocityAxis;
     }
     else if (Layer.DirType == DIRECTION_TYPE.Cone)
     {
         //if emit uniform circle, the rotation should be spread from the center.
         if (Layer.EmitType == (int)EMITTYPE.CIRCLE && Layer.EmitUniform)
         {
             Vector3 dir;
             if (!Layer.SyncClient)
                 dir = node.Position - (node.GetRealClientPos() + Layer.EmitPoint);
             else
                 dir = node.Position - Layer.EmitPoint;
             Vector3 target = Vector3.RotateTowards(dir, Layer.CircleDir, (90 - Layer.AngleAroundAxis) * Mathf.Deg2Rad, 1);
             Quaternion rot = Quaternion.FromToRotation(dir, target);
             ret = rot * dir;
         }
         else
         {
             //first, rotate y around z 30 degrees
             Quaternion rotY = Quaternion.Euler(0, 0, Layer.AngleAroundAxis);
             //second, rotate around y 360 random dir;
             Quaternion rotAround = Quaternion.Euler(0, Random.Range(0, 360), 0);
             //last, rotate the dir to OriVelocityAxis
             Quaternion rotTo = Quaternion.FromToRotation(Vector3.up, Layer.OriVelocityAxis);
             ret = rotTo * rotAround * rotY * Vector3.up;
         }
     }
     else if (Layer.DirType == DIRECTION_TYPE.Cylindrical)
     {
         Vector3 dir = node.GetOriginalPos() - Layer.DirCenter.position;
         float dist = Vector3.Dot(Layer.OriVelocityAxis, dir);
         ret = dir - dist * Layer.OriVelocityAxis.normalized;
     }
     return  ret;
 }
Пример #13
0
        public override void Initialize(EffectNode node)
        {
            base.Initialize(node);
            SetColor(Node.Color);
            SetRotation(Node.OriRotateAngle);
            SetScale(Node.OriScaleX, Node.OriScaleY);
            SetUVCoord(Node.LowerLeftUV, Node.UVDimensions);

            //if (Node.Owner.DirType != DIRECTION_TYPE.Sphere)
            //    SetDirection(Node.Owner.ClientTransform.rotation * Node.OriDirection);
            //else
                SetDirection(Node.OriDirection);
        }
Пример #14
0
        public EffectNode dummyNode;//will not be added to the activenode list. so will not be rendered, just to calc uv anim.

        public void Init(EffectLayer owner)
        {
            Owner = owner;
            Vertexsegment = owner.GetVertexPool().GetRopeVertexSeg(owner.MaxENodes);

            dummyNode = new EffectNode(0, owner.ClientTransform, false, owner);
            List<Affector> afts = owner.InitAffectors(dummyNode);
            dummyNode.SetAffectorList(afts);
            dummyNode.SetRenderType(4);

            //use infinite life.
            dummyNode.Init(Vector3.zero, 0f, -1f, 0, 1f, 1f, Color.clear, Vector2.zero, Vector2.one);
        }
Пример #15
0
 public BombAffector(Transform obj, BOMBTYPE gtype, MAGTYPE mtype,BOMBDECAYTYPE dtype, float mag, AnimationCurve curve,
     float decay, Vector3 axis, EffectNode node)
     : base(node, AFFECTORTYPE.BombAffector)
 {
     BombType = gtype;
     MType = mtype;
     DecayType = dtype;
     Magnitude = mag;
     MagCurve = curve;
     Decay = decay;
     BombAxis = axis;
     BombAxis.Normalize();
     BombObj = obj;
 }
Пример #16
0
        protected void ClearNodeVert(EffectNode node)
        {
            int baseIdx = Vertexsegment.VertStart + node.Index * 2;

            VertexPool pool = Vertexsegment.Pool;

            pool.Vertices[baseIdx] = Owner.ClientTransform.position;
            pool.Colors[baseIdx] = Color.clear;

            pool.Vertices[baseIdx + 1] = Owner.ClientTransform.position;
            pool.Colors[baseIdx + 1] = Color.clear;

            pool.VertChanged = true;
            pool.ColorChanged = true;
        }
Пример #17
0
 public AirFieldAffector(Transform airObj, Vector3 dir, float atten, bool useMaxdist, 
     float maxDist,bool enableSpread, float spread, float inhV, bool inhRot, EffectNode node)
     : base(node, AFFECTORTYPE.AirFieldAffector)
 {
     AirObj = airObj;
     Direction = dir.normalized;
     Attenuation = atten;
     UseMaxDistance = useMaxdist;
     MaxDistance = maxDist;
     MaxDistanceSqr = MaxDistance * MaxDistance;
     EnableSpread = enableSpread;
     Spread = spread;
     InheritVelocity = inhV;
     InheritRotation = inhRot;
     LastFieldPos = AirObj.position;
 }
Пример #18
0
        public CustomMesh(VertexPool.VertexSegment segment, Mesh mesh,Vector3 dir, float maxFps,EffectNode owner)
        {
            MyMesh = mesh;

            m_owner = owner;

            MeshVerts =  new Vector3[mesh.vertices.Length];

            mesh.vertices.CopyTo(MeshVerts,0);

            Vertexsegment = segment;
            MyDirection = dir;
            Fps = 1f / maxFps;
            SetPosition(Vector3.zero);
            InitVerts();
        }
Пример #19
0
        public VortexAffector(Transform obj, MAGTYPE mtype, float mag, AnimationCurve vortexCurve, Vector3 dir, bool inhRot, EffectNode node)
            : base(node, AFFECTORTYPE.VortexAffector)
        {
            VortexCurve = vortexCurve;
            Direction = dir;
            InheritRotation = inhRot;
            VortexObj = obj;
            MType = mtype;
            Magnitude = mag;

            //ver 1.2.1
            if (node.Owner.IsRandomVortexDir) {
                Direction.x = Random.Range (-1f, 1f);
                Direction.y = Random.Range (-1f, 1f);
                Direction.z = Random.Range (-1f, 1f);
            }
            Direction.Normalize ();
        }
Пример #20
0
		public VortexAffector (Transform obj, Vector3 dir, bool inhRot, EffectNode node)
            : base(node, AFFECTORTYPE.VortexAffector)
		{

			Direction = dir;
			InheritRotation = inhRot;
			VortexObj = obj;



			//ver 1.2.1
			if (node.Owner.IsRandomVortexDir) {
				Direction.x = Random.Range (-1f, 1f);
				Direction.y = Random.Range (-1f, 1f);
				Direction.z = Random.Range (-1f, 1f);
			}
			Direction.Normalize ();
            IsFirst = true;
		}
Пример #21
0
        public void SetEmitPosition(EffectNode node)
        {
            Vector3 retPos = Vector3.zero;
            if (Layer.EmitType == (int)EMITTYPE.BOX)
            {
                Vector3 center = Layer.EmitPoint;
                float x = Random.Range(center.x - Layer.BoxSize.x / 2, center.x + Layer.BoxSize.x / 2);
                float y = Random.Range(center.y - Layer.BoxSize.y / 2, center.y + Layer.BoxSize.y / 2);
                float z = Random.Range(center.z - Layer.BoxSize.z / 2, center.z + Layer.BoxSize.z / 2);
                retPos.x = x; retPos.y = y; retPos.z = z;
                if (!Layer.SyncClient)
                {
                    if (!Layer.BoxInheritRotation)
                        retPos = Layer.ClientTransform.position + retPos;
                    else
                        retPos = Layer.ClientTransform.rotation * retPos + Layer.ClientTransform.position;
                }
                else
                {
                    if (Layer.BoxInheritRotation)
                        retPos = Layer.ClientTransform.rotation * retPos;
                }
            }
            else if (Layer.EmitType == (int)EMITTYPE.POINT)
            {
                retPos = Layer.EmitPoint;
                if (!Layer.SyncClient)
                {
                    retPos = Layer.ClientTransform.position + Layer.EmitPoint;
                }
            }
            else if (Layer.EmitType == (int)EMITTYPE.SPHERE)
            {
                retPos = Layer.EmitPoint;
                if (!Layer.SyncClient)
                {//同步的话在NodeUpdate里会更新位置
                    retPos = Layer.ClientTransform.position + Layer.EmitPoint;
                }
                Vector3 r = Vector3.up * Layer.Radius;
                Quaternion rot = Quaternion.Euler(Random.Range(0, 360), Random.Range(0, 360), Random.Range(0, 360));
                retPos = rot * r + retPos;
            }
            //Line direction is based on client transform's rotation.
            else if (Layer.EmitType == (int)EMITTYPE.LINE)
            {
                Vector3 left = Layer.EmitPoint + Layer.ClientTransform.forward * Layer.LineLengthLeft;
                Vector3 right = Layer.EmitPoint + Layer.ClientTransform.forward * Layer.LineLengthRight;
                Vector3 dir = right - left;

                float length;
                if (Layer.EmitUniform)
                {
                    float p = (float)(node.Index + 1) / Layer.MaxENodes;
                    length = dir.magnitude * p;
                }
                else
                {
                    length = Random.Range(0, dir.magnitude);
                }

                retPos = left + dir.normalized * length;
                if (!Layer.SyncClient)
                    retPos = Layer.ClientTransform.position + retPos;
            }
            else if (Layer.EmitType == (int)EMITTYPE.CIRCLE)
            {
                float rangle;
                if (Layer.EmitUniform)
                {
                    float p = (float)(node.Index + 1) / Layer.MaxENodes;
                    rangle = 360 * p;
                }
                else
                {
                    rangle = Random.Range(0, 360);
                }
                Quaternion rotY = Quaternion.Euler(0, rangle, 0);
                Vector3 v = rotY * (Vector3.right * Layer.Radius);
                Quaternion rotTo = Quaternion.FromToRotation(Vector3.up, Layer.ClientTransform.rotation * Layer.CircleDir);
                retPos = rotTo * v;
                if (!Layer.SyncClient)
                    retPos = Layer.ClientTransform.position + retPos + Layer.EmitPoint;
                else
                    retPos = retPos + Layer.EmitPoint;
            }
            else if (Layer.EmitType == (int)EMITTYPE.Mesh)
            {
                if (Layer.EmitMesh == null)
                {
                    Debug.LogWarning("please set a mesh to the emitter.");
                    return;
                }
                int index = 0;
                if (Layer.EmitMeshType == 0)
                {
                    int vertCount = Layer.EmitMesh.vertexCount;
                    if (Layer.EmitUniform)
                        index = (node.Index) % (vertCount - 1);
                    else
                        index = Random.Range(0, vertCount - 1);
                    retPos = Layer.EmitMesh.vertices[index];
                    if (!Layer.SyncClient)
                        retPos = Layer.ClientTransform.position + retPos + Layer.EmitPoint;
                    else
                        retPos = retPos + Layer.EmitPoint;
                }
                else if (Layer.EmitMeshType == 1)
                {
                    Vector3[] verts = Layer.EmitMesh.vertices;
                    int triCount = Layer.EmitMesh.triangles.Length / 3;
                    if (Layer.EmitUniform)
                        index = (node.Index) % (triCount - 1);
                    else
                        index = Random.Range(0, triCount - 1);
                    int vid1 = Layer.EmitMesh.triangles[index * 3 + 0];
                    int vid2 = Layer.EmitMesh.triangles[index * 3 + 1];
                    int vid3 = Layer.EmitMesh.triangles[index * 3 + 2];
                    retPos = (verts[vid1] + verts[vid2] + verts[vid3]) / 3;
                    if (!Layer.SyncClient)
                        retPos = Layer.ClientTransform.position + retPos + Layer.EmitPoint;
                    else
                        retPos = retPos + Layer.EmitPoint;
                }
            }
            node.SetLocalPosition(retPos);
        }
Пример #22
0
        public List<Affector> InitAffectors(EffectNode node)
        {
            List<Affector> AffectorList = new List<Affector>();

            if (UVAffectorEnable)
            {
                UVAnimation uvAnim = new UVAnimation();
                if (UVType == 1)
                {
                    float perWidth = OriUVDimensions.x / Cols;
                    float perHeight = Mathf.Abs(OriUVDimensions.y / Rows);
                    Vector2 cellSize = new Vector2(perWidth, perHeight);
                    uvAnim.BuildUVAnim(OriTopLeftUV, cellSize, Cols, Rows, Cols * Rows);
                }
                UVDimension = uvAnim.UVDimensions[0];
                UVTopLeft = uvAnim.frames[0];

                if (uvAnim.frames.Length != 1)
                {
                    uvAnim.loopCycles = LoopCircles;
                    Affector aft = new UVAffector(uvAnim, UVTime, node, RandomStartFrame);
                    AffectorList.Add(aft);
                }
            }
            else
            {
                UVDimension = OriUVDimensions;
                UVTopLeft = OriTopLeftUV;
            }


            if (RotAffectorEnable && RotateType != RSTYPE.NONE)
            {
                Affector aft;
                if (RotateType == RSTYPE.NONE)
                    aft = new RotateAffector(DeltaRot, node);
                else
                    aft = new RotateAffector(RotateType, node);
                AffectorList.Add(aft);
            }
            if (ScaleAffectorEnable && ScaleType != RSTYPE.NONE)
            {
                Affector aft;

                if (ScaleType == RSTYPE.NONE)
                    aft = new ScaleAffector(DeltaScaleX, DeltaScaleY, node);
                else
                    aft = new ScaleAffector(ScaleType, node);

                AffectorList.Add(aft);
            }
            if (ColorAffectorEnable /*&& ColorAffectType != 0*/)
            {
                ColorAffector aft = new ColorAffector(this, node);
                AffectorList.Add(aft);
            }
            if (JetAffectorEnable)
            {
                Affector aft = new JetAffector(JetMag, JetMagType, JetCurve, node);
                AffectorList.Add(aft);
            }
            if (VortexAffectorEnable)
            {
                Affector aft;
                aft = new VortexAffector(VortexObj, VortexDirection, VortexInheritRotation, node);

                AffectorList.Add(aft);
            }
            if (UVRotAffectorEnable)
            {
                Affector aft;

                float xscroll = UVRotXSpeed;
                float yscroll = UVRotYSpeed;
                if (RandomUVRotateSpeed)
                {
                    xscroll = Random.Range(UVRotXSpeed, UVRotXSpeedMax);
                    yscroll = Random.Range(UVRotYSpeed, UVRotYSpeedMax);
                }

                aft = new UVRotAffector(xscroll, yscroll, node);
                AffectorList.Add(aft);
            }

            if (UVScaleAffectorEnable)
            {
                Affector aft = new UVScaleAffector(node);
                AffectorList.Add(aft);
            }

            if (GravityAffectorEnable)
            {
                Affector aft;
                aft = new GravityAffector(GravityObject, GravityAftType, IsGravityAccelerate, GravityDirection, node);
                AffectorList.Add(aft);

                if (GravityAftType == GAFTTYPE.Spherical && GravityObject == null)
                {
                    Debug.LogWarning("Gravity Object is missing, automatically set to effect layer self:" + gameObject.name);
                    GravityObject = transform;
                }

            }
            if (AirAffectorEnable)
            {
                Affector aft = new AirFieldAffector(AirObject, AirDirection, AirAttenuation, AirUseMaxDistance,
                    AirMaxDistance, AirEnableSpread, AirSpread, AirInheritVelocity, AirInheritRotation, node);
                AffectorList.Add(aft);
            }
            if (BombAffectorEnable)
            {
                Affector aft = new BombAffector(BombObject, BombType, BombDecayType, BombMagnitude, BombDecay, BombAxis, node);
                AffectorList.Add(aft);
            }
            if (TurbulenceAffectorEnable)
            {
                Affector aft = new TurbulenceFieldAffector(TurbulenceObject, TurbulenceAttenuation, TurbulenceUseMaxDistance, TurbulenceMaxDistance, node);
                AffectorList.Add(aft);
            }
            if (DragAffectorEnable)
            {
                Affector aft = new DragAffector(DragObj, DragUseDir, DragDir, DragMag, DragUseMaxDist, DragMaxDist, DragAtten, node);
                AffectorList.Add(aft);
            }

            if (SineAffectorEnable)
            {
                Affector aft = new SineAffector(node);
                AffectorList.Add(aft);
            }
            return AffectorList;
        }
Пример #23
0
 public virtual void Initialize(EffectNode node)
 {
     Node = node;
 }
Пример #24
0
 public void RemoveActiveNode(EffectNode node)
 {
     if (AvailableNodeCount == MaxENodes)
     {
         Debug.LogError("something wrong with removing node!");
         return;
     }
         
     if (ActiveENodes[node.Index] == null) //already removed
         return;
     ActiveENodes[node.Index] = null;
     AvailableENodes[node.Index] = node;
     AvailableNodeCount++;
 }
Пример #25
0
 public GravityAffector(Transform obj, GAFTTYPE gtype, MAGTYPE mtype, bool isacc, Vector3 dir, float mag, AnimationCurve curve, EffectNode node)
     : base(node, AFFECTORTYPE.GravityAffector)
 {
     GType     = gtype;
     MType     = mtype;
     Magnitude = mag;
     MagCurve  = curve;
     Dir       = obj.rotation * dir;
     Dir.Normalize();
     GravityObj   = obj;
     IsAccelerate = isacc;
 }
Пример #26
0
 public RotateAffector(float delta, EffectNode node)
     : base(node, AFFECTORTYPE.RotateAffector)
 {
     RType = RSTYPE.SIMPLE;
     Delta = delta;
 }
Пример #27
0
 public override void Initialize(EffectNode node)
 {
     base.Initialize(node);
     SetUVCoord(node.LowerLeftUV, node.UVDimensions);
     SetColor(node.Color);
     SetHeadPosition(node.GetRealClientPos() + node.Position /*+ node.OriDirection.normalized * node.Owner.TailDistance*/);
     ResetElementsPos();
     mLastClientPos = node.Owner.ClientTransform.position;
 }
Пример #28
0
        //consider node life if TimeLen < 0;
        public float Evaluate(float time, EffectNode node)
        {

            float len = TimeLen;

            if (len < 0f)
                len = node.GetLifeTime();

            float t = time / len;

            if (t > 1f)
            {
                if (WrapType == WRAP_TYPE.CLAMP)
                {
                    t = 1f;
                }
                else if (WrapType == WRAP_TYPE.LOOP)
                {
                    int d = Mathf.FloorToInt(t);
                    t = t - (float)d;
                }
                else
                {
                    int n = Mathf.CeilToInt(t);
                    int d = Mathf.FloorToInt(t);
                    if (n % 2 == 0)
                    {
                        t = (float)n - t;
                    }
                    else
                    {
                        t = t - (float)d;
                    }
                }
            }
            return Curve01.Evaluate(t) * MaxValue;
        }
Пример #29
0
 public Affector(EffectNode node, AFFECTORTYPE type)
 {
     Node = node;
     Type = type;
 }
Пример #30
0
        protected void Init()
        {
            //added 2012.6.24
            InitCollision();

            Owner = transform.parent.gameObject.GetComponent<XffectComponent>();
            if (Owner == null)
                Debug.LogError("you must set EffectLayer to be XffectComponent's child.");

            //fixed 2012.6.2. ignoring the red errors.
            if (ClientTransform == null)
            {
                Debug.LogWarning("effect layer: " + gameObject.name + " haven't assign a client transform, automaticly set to itself.");
                ClientTransform = transform;
            }
            AvailableENodes = new EffectNode[MaxENodes];
            ActiveENodes = new EffectNode[MaxENodes];
            for (int i = 0; i < MaxENodes; i++)
            {
                EffectNode n = new EffectNode(i, ClientTransform, SyncClient, this);
                List<Affector> afts = InitAffectors(n);
                n.SetAffectorList(afts);

                n.SetRenderType(RenderType);

                AvailableENodes[i] = n;
            }


            if (RenderType == 4)
            {
                RopeDatas.Init(this);
            }

            AvailableNodeCount = MaxENodes;
            emitter = new Emitter(this);

            mStopped = false;
        }
Пример #31
0
 public RotateAffector(RSTYPE type, EffectNode node)
     : base(node,AFFECTORTYPE.RotateAffector)
 {
     RType = type;
 }
Пример #32
0
        public void AddActiveNode(EffectNode node)
        {
            if (AvailableNodeCount == 0)
                Debug.LogError("out index!");
            if (AvailableENodes[node.Index] == null) //already added
                return;
            ActiveENodes[node.Index] = node;
            AvailableENodes[node.Index] = null;
            AvailableNodeCount--;

            node.TotalIndex = TotalAddedCount++;
        }
Пример #33
0
 public SineAffector(Vector3 force, bool modifyPos, float maxFreq, float minFreq, EffectNode node)
     : base(node, AFFECTORTYPE.SineAffector)
 {
     SineForce   = force;
     ModifyPos   = modifyPos;
     SineMaxFreq = maxFreq;
     SineMinFreq = minFreq;
     SineFreq    = SineMinFreq;
 }