Пример #1
0
        protected void UpdateRotAngle(float deltaTime)
        {
            if (!UseDeltaAngle)
            {
                return;
            }
            SpreadAngle = CurveAngle.Evaluate(Owner.GetElapsedTime());

            for (int i = NumVerts / 2; i < NumVerts; i++)
            {
                Verts[i] = Verts[i - NumVerts / 2] + Vector3.up * Size.y;
                Verts[i] = Vector3.RotateTowards(Verts[i], Verts[i - NumVerts / 2], SpreadAngle * Mathf.Deg2Rad, 0);
            }
        }
Пример #2
0
        public void StopSmoothly(float fadeTime)
        {
            mStopped = true;

            emitter.StopEmit();

            for (int i = 0; i < MaxENodes; i++)
            {
                EffectNode node = ActiveENodes[i];
                if (node == null)
                {
                    continue;
                }

                if (!IsNodeLifeLoop && node.GetLifeTime() < fadeTime)
                {
                    fadeTime = node.GetLifeTime() - node.GetElapsedTime();
                }


                node.Fade(fadeTime);
            }
        }
Пример #3
0
        //更新每个顶点元素的位置
        public void UpdateVertices(Vector3 eyePos)
        {
            Vector3 chainTangent;
            float   uvSegment = 0f;
            float   uvLen     = 0f;

            float trailLen = ElemLength * (MaxElements - 2);

            Vector3 mscale = Vector3.one * Owner.Owner.Owner.Scale;

            if (Head != CHAIN_EMPTY && Head != Tail)
            {
                int   laste      = Head;
                float totalUVLen = 0;
                if (IsScale)
                {
                    for (int e = Head; ; ++e)
                    {
                        if (e == MaxElements)
                        {
                            e = 0;
                        }

                        Element elem = ElementArray[e];
                        if (e * 2 >= 65536)
                        {
                            Debug.LogError("Too many elements!");
                        }

                        int nexte = e + 1;
                        if (nexte == MaxElements)
                        {
                            nexte = 0;
                        }

                        if (e == Tail)
                        {
                            break;     // last one
                        }
                        totalUVLen += (ElementArray[nexte].Position - elem.Position).magnitude;
                    }
                }

                //使用Sine波动每个元素 位置
                if (Owner.IsSine)
                {
                    float SineFreqTime = Owner.SineFreqTime;
                    float SineFreqDist = Owner.SineFreqDist;
                    float SineMag      = Owner.SineMagnitude;
                    float t            = Owner.GetElapsedTime();
                    float pi2          = 2 * Mathf.PI;
                    for (int e = Head; ; ++e)
                    {
                        if (e == MaxElements)
                        {
                            e = 0;
                        }
                        Element elem  = ElementArray[e];
                        int     nexte = e + 1;
                        if (nexte == MaxElements)
                        {
                            nexte = 0;
                        }
                        if (e == Tail)
                        {
                            break;
                        }
                        //根据 下一个顶点的位置 和 当前的顶点位置
                        Element next = ElementArray[nexte];
                        var     dir  = elem.InitPos - next.InitPos;
                        var     xDir = Vector3.Cross(dir, Vector3.up);

                        float x        = elem.Position.x;
                        float z        = elem.Position.z;
                        float dist     = Mathf.Sqrt(x * x + z * z);
                        var   virbrate = SineMag * Mathf.Sin(pi2 * SineFreqTime * t + pi2 * SineFreqDist * dist) * xDir.normalized;

                        elem.Position = elem.InitPos + virbrate;
                        elem.EndPos   = elem.InitEndPos + virbrate;
                    }
                }

                //重新计算VertexPool里面每一个顶点的世界坐标位置
                for (int e = Head; ; ++e) // until break
                {
                    // Wrap forwards
                    if (e == MaxElements)
                    {
                        e = 0;
                    }

                    Element elem = ElementArray[e];
                    if (e * 2 >= 65536)
                    {
                        Debug.LogError("Too many elements!");
                    }
                    int baseIdx = Vertexsegment.VertStart + e * 2;

                    // Get index of next item
                    int nexte = e + 1;
                    if (nexte == MaxElements)
                    {
                        nexte = 0;
                    }

                    if (e == Head)
                    {
                        // No laste, use next item
                        //chainTangent = ElementArray[nexte].Position - elem.Position;
                        chainTangent = Vector3.Scale(ElementArray[nexte].Position, mscale) - Vector3.Scale(elem.Position, mscale);
                    }
                    else if (e == Tail)
                    {
                        // No nexte, use only last item
                        //chainTangent = elem.Position - ElementArray[laste].Position;
                        chainTangent = Vector3.Scale(elem.Position, mscale) - Vector3.Scale(ElementArray[laste].Position, mscale);
                    }
                    else
                    {
                        // A mid position, use tangent across both prev and next
                        //chainTangent = ElementArray[nexte].Position - ElementArray[laste].Position;
                        chainTangent = Vector3.Scale(ElementArray[nexte].Position, mscale) - Vector3.Scale(ElementArray[laste].Position, mscale);
                    }

                    Vector3 vP1ToEye;

                    // fixed 2012.7.7 to use slash trail.
                    if (!UseFaceObject)
                    {
                        //vP1ToEye = eyePos - elem.Position;
                        vP1ToEye = eyePos - Vector3.Scale(elem.Position, mscale);
                    }
                    else
                    {
                        vP1ToEye = elem.Normal;
                    }
                    Vector3 vPerpendicular = Vector3.Cross(chainTangent, vP1ToEye);
                    vPerpendicular.Normalize();
                    vPerpendicular *= (elem.Width * 0.5f);

                    Vector3 pos0;
                    Vector3 pos1;
                    if (IsWeapon)
                    {
                        pos0 = elem.Position;
                        pos1 = elem.EndPos;
                    }
                    else
                    {
                        pos0 = elem.Position - vPerpendicular;
                        pos1 = elem.Position + vPerpendicular;
                    }



                    VertexPool pool = Vertexsegment.Pool;

                    if (IsScale)
                    {
                        if (StretchType == 0)
                        {
                            uvSegment = (uvLen / totalUVLen) * Mathf.Abs(UVDimensions.y);
                        }
                        else
                        {
                            uvSegment = (uvLen / totalUVLen) * Mathf.Abs(UVDimensions.x);
                        }
                    }
                    else
                    {
                        if (StretchType == 0)
                        {
                            uvSegment = (uvLen / trailLen) * Mathf.Abs(UVDimensions.y);
                        }
                        else
                        {
                            uvSegment = (uvLen / trailLen) * Mathf.Abs(UVDimensions.x);
                        }
                    }


                    Vector2 uvCoord = Vector2.zero;
                    // pos0
                    pool.Vertices[baseIdx] = pos0;
                    pool.Colors[baseIdx]   = Color;
                    if (StretchType == 0)
                    {
                        uvCoord.x = LowerLeftUV.x + UVDimensions.x;
                        uvCoord.y = LowerLeftUV.y - uvSegment;
                    }
                    else
                    {
                        uvCoord.x = LowerLeftUV.x + uvSegment;
                        uvCoord.y = LowerLeftUV.y;
                    }

                    pool.UVs[baseIdx] = uvCoord;
                    //pos1
                    pool.Vertices[baseIdx + 1] = pos1;
                    pool.Colors[baseIdx + 1]   = Color;
                    if (StretchType == 0)
                    {
                        uvCoord.x = LowerLeftUV.x;
                        uvCoord.y = LowerLeftUV.y - uvSegment;
                    }
                    else
                    {
                        uvCoord.x = LowerLeftUV.x + uvSegment;
                        uvCoord.y = LowerLeftUV.y - Mathf.Abs(UVDimensions.y);
                    }
                    pool.UVs[baseIdx + 1] = uvCoord;

                    if (e == Tail)
                    {
                        break; // last one
                    }
                    laste  = e;
                    uvLen += (ElementArray[nexte].Position - elem.Position).magnitude;
                } // element



                Vertexsegment.Pool.UVChanged    = true;
                Vertexsegment.Pool.VertChanged  = true;
                Vertexsegment.Pool.ColorChanged = true;
            } // segment valid?
        }