예제 #1
0
 public VertexSegment(int start, int count, int istart, int icount, VertexPool pool)
 {
     VertStart = start;
     VertCount = count;
     IndexCount = icount;
     IndexStart = istart;
     Pool = pool;
 }
예제 #2
0
파일: Cone.cs 프로젝트: sylafrs/rugby
        public Cone(VertexPool.VertexSegment segment, Vector2 size, int numseg, float angle, Vector3 dir, int uvStretch, float maxFps)
        {
            Vertexsegment = segment;
            Size = size;
            Direction = dir;
            UVStretch = uvStretch;
            Fps = 1f / maxFps;
            SetColor(Color.white);

            NumSegment = numseg;
            SpreadAngle = angle;
            OriSpreadAngle = angle;

            InitVerts();
        }
예제 #3
0
        private void InitMeshObj()
        {
            mMeshObj       = new GameObject("_XWeaponTrailMesh: " + gameObject.name);
            mMeshObj.layer = gameObject.layer;
            mMeshObj.SetActive(true);
            var filter   = mMeshObj.AddComponent <MeshFilter>();
            var renderer = mMeshObj.AddComponent <MeshRenderer>();

            renderer.castShadows             = false;
            renderer.receiveShadows          = false;
            renderer.renderer.sharedMaterial = MyMaterial;
            filter.sharedMesh = new Mesh();
            mVertexPool       = new VertexPool(filter.sharedMesh, MyMaterial);
            mVertexSegment    = mVertexPool.GetVertices(Granularity * 3, (Granularity - 1) * 12);
            UpdateIndices();
        }
예제 #4
0
파일: CustomMesh.cs 프로젝트: sylafrs/rugby
        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();
        }
예제 #5
0
        private void InitMeshObj()
        {
            this.mMeshObj       = new GameObject("_XWeaponTrailMesh: " + base.gameObject.name);
            this.mMeshObj.layer = base.gameObject.layer;
            this.mMeshObj.SetActive(true);
            MeshFilter   filter   = this.mMeshObj.AddComponent <MeshFilter>();
            MeshRenderer renderer = this.mMeshObj.AddComponent <MeshRenderer>();

            renderer.castShadows    = false;
            renderer.receiveShadows = false;
            renderer.GetComponent <Renderer>().sharedMaterial = this.MyMaterial;
            filter.sharedMesh   = new Mesh();
            this.mVertexPool    = new VertexPool(filter.sharedMesh, this.MyMaterial);
            this.mVertexSegment = this.mVertexPool.GetVertices(this.Granularity * 3, (this.Granularity - 1) * 12);
            this.UpdateIndices();
        }
예제 #6
0
        void LateUpdate()
        {
            //make sure each mesh position is always zero.
            for (int i = 0; i < MeshList.Count; i++)
            {
                GameObject obj = MeshList[i];
                if (obj != null)
                {
                    obj.transform.position = Vector3.zero;
                    obj.transform.rotation = Quaternion.identity;
                }
            }


            for (int i = 0; i < MatList.Count; i++)
            {
                VertexPool vp = MatList[i];
                vp.LateUpdate();
            }


            if (ElapsedTime > LifeTime && LifeTime >= 0)
            {
                DoFinish();
            }
            else if (LifeTime < 0 && EflList.Count > 0)
            {
                //Xffect LifeTime < 0, 且又是EmitByRate的话,会自动判断是否已经没有活动节点,没有则自动Deactive()。
                float deltaTime      = (float)(CurTime - LastTime);
                bool  allEfLFinished = true;

                for (int i = 0; i < EflList.Count; i++)
                {
                    EffectLayer el = EflList[i];
                    if (!el.EmitOver(deltaTime))
                    {
                        allEfLFinished = false;
                    }
                }

                if (allEfLFinished)
                {
                    DoFinish();
                }
            }
        }
예제 #7
0
        public RibbonTrail(VertexPool.VertexSegment segment, Camera mainCam, bool useFaceObj, Transform faceobj, float width, int maxelemnt, float len, Vector3 pos, int stretchType, float maxFps)
        {
            if (maxelemnt <= 2)
            {
                Debug.LogError("ribbon trail's maxelement should > 2!");
            }
            MaxElements = maxelemnt;
            Vertexsegment = segment;
            ElementArray = new Element[MaxElements];
            Head = Tail = CHAIN_EMPTY;

            OriHeadPos = pos;

            SetTrailLen(len);
            UnitWidth = width;
            HeadPosition = pos;
            StretchType = stretchType;

            Vector3 dir;
            if (UseFaceObject)
                dir = faceobj.position - HeadPosition;
            else
                dir = Vector3.zero;

            Element dtls = new Element(HeadPosition, UnitWidth);
            dtls.Normal = dir.normalized;
            IndexDirty = false;
            Fps = 1f / maxFps;

            // Add the start position
            AddElememt(dtls);
            // Add another on the same spot, this will extend
            Element dtls2 = new Element(HeadPosition, UnitWidth);
            dtls2.Normal = dir.normalized;
            AddElememt(dtls2);

            //Use ElementPool to reduce gc alloc!
            for (int i = 0; i < MaxElements; i++)
            {
                ElementPool.Add(new Element(HeadPosition, UnitWidth));
            }

            MainCam = mainCam;
            UseFaceObject = useFaceObj;
            FaceObject = faceobj;
        }
예제 #8
0
        //x for displacement control
        //y for dissolve control.
        public override void ApplyShaderParam(float x, float y)
        {
            Vector2 param = Vector2.one;

            param.x = x;
            param.y = y;

            VertexPool pool  = Vertexsegment.Pool;
            int        index = Vertexsegment.VertStart;

            for (int i = 0; i < Vertexsegment.VertCount; i++)
            {
                pool.UVs2[index + i] = param;
            }

            Vertexsegment.Pool.UV2Changed = true;
        }
예제 #9
0
        void UpdateMeshObj()
        {
            //make sure each mesh position is always zero.
            for (int i = 0; i < MeshList.Count; i++)
            {
                GameObject obj = MeshList[i];
                if (obj != null)
                {
                    obj.transform.position = Vector3.zero;
                    obj.transform.rotation = Quaternion.identity;
                }
            }

            if (MergeSameMaterialMesh)
            {
                //ElementAt() STILL CAUSE GC ALLOC!! SO WE CAN'T AVOID GC ALLOC IN DICTIONARY?
                //for (int i = 0; i < MatDic.Count; i++)
                //{
                //    KeyValuePair<string,VertexPool> pair = MatDic.ElementAt(i);
                //    pair.Value.LateUpdate();
                //}

                //foreach (KeyValuePair<string, VertexPool> pair in MatDic)
                //{
                //    pair.Value.LateUpdate();
                //}

                //Thanks to Ali Abdul-Karim's solution, no gc alloced now.
                var enumerator = MatDic.GetEnumerator();
                while (enumerator.MoveNext())
                {
                    var element = enumerator.Current;
                    // loop body goes here
                    element.Value.LateUpdate();
                }
            }
            else
            {
                for (int i = 0; i < MatList.Count; i++)
                {
                    VertexPool vp = MatList[i];
                    vp.LateUpdate();
                }
            }
        }
예제 #10
0
파일: Decal.cs 프로젝트: frozen4/UnityPlus
        void RetreiveDecalMesh()
        {
            VertexPool pool   = mVertexsegment.Pool;
            int        index  = mVertexsegment.IndexStart;
            int        vindex = mVertexsegment.VertStart;

            int vcount = mVertexsegment.VertCount;
            int icount = mVertexsegment.IndexCount;

            Matrix4x4 localToWorldMatrix;
            Vector3   temp = Node.Owner.transform.position;

            Node.Owner.transform.position = Node.CurWorldPos;
            localToWorldMatrix            = Node.Owner.transform.localToWorldMatrix;
            Node.Owner.transform.position = temp;
            MyColor = Color.white;

            //if the vert is not enough, just return..
            for (int i = 0; i < bufVertices.Count; i++)
            {
                if (i >= vcount)
                {
                    break;
                }

                Vector3 v1 = localToWorldMatrix.MultiplyPoint(bufVertices[i]);
                pool.Vertices[vindex + i] = v1;

                pool.UVs[i + vindex] = bufTexCoords[i];

                pool.Colors[vindex + i] = MyColor;
            }

            for (int i = 0; i < bufIndices.Count; i++)
            {
                if (i >= icount)
                {
                    break;
                }

                pool.Indices[i + index] = bufIndices[i] + vindex;
            }

            pool.IndiceChanged = pool.VertChanged = pool.UVChanged = pool.ColorChanged = true;
        }
예제 #11
0
        public void UpdateColor()
        {
            VertexPool pool  = mVertexsegment.Pool;
            int        index = mVertexsegment.VertStart;

            int vcount = mVertexsegment.VertCount;

            for (int i = 0; i < bufVertices.Count; i++)
            {
                if (i >= vcount)
                {
                    break;
                }

                pool.Colors[index + i] = MyColor;
            }
            mVertexsegment.Pool.ColorChanged = true;
        }
예제 #12
0
        public void UpdateUV()
        {
            VertexPool pool  = Vertexsegment.Pool;
            int        index = Vertexsegment.VertStart;
            float      uvSeg = UVDimensions.x / NumSegment;

            for (int i = 0; i < NumSegment + 1; i++)
            {
                pool.UVs[index + i]    = LowerLeftUV;
                pool.UVs[index + i].x += i * uvSeg;
            }
            for (int i = NumSegment + 1; i < NumVerts; i++)
            {
                pool.UVs[index + i]    = LowerLeftUV + Vector2.up * UVDimensions.y;
                pool.UVs[index + i].x += (i - NumSegment - 1) * uvSeg;
            }
            Vertexsegment.Pool.UVChanged = true;
        }
예제 #13
0
        public void Transform()
        {
            if (Node.Owner.RotAffectorEnable || OriRotAngle != 0f)
            {
                UpdateVerts();
            }

            Quaternion rot;

            if (Node.Owner.AlwaysSyncRotation)
            {
                rot = Quaternion.FromToRotation(Vector3.up, Node.Owner.transform.rotation * Direction);
            }
            else
            {
                rot = Quaternion.FromToRotation(Vector3.up, Direction);
            }

            for (int i = 0; i < NumSegment + 1; i++)
            {
                VertsTemp[i] = Verts[i] * Scale.x;
                VertsTemp[i] = rot * VertsTemp[i];
                VertsTemp[i] = VertsTemp[i] + Position;
            }

            for (int i = NumSegment + 1; i < NumVerts; i++)
            {//注意只扩大Y轴。
                //VertsTemp[i] = Verts[i];
                VertsTemp[i]   = Verts[i] * Scale.x;
                VertsTemp[i].y = Verts[i].y * Scale.y;
                VertsTemp[i]   = rot * VertsTemp[i];
                VertsTemp[i]   = VertsTemp[i] + Position;
            }
            VertexPool pool  = Vertexsegment.Pool;
            int        index = Vertexsegment.VertStart;

            for (int i = 0; i < NumVerts; i++)
            {
                pool.Vertices[index + i] = VertsTemp[i];
            }
        }
예제 #14
0
        public void Transform()
        {
            Quaternion rot = Quaternion.FromToRotation(Vector3.up, MyDirection);

            Vector3 scale = Vector3.one;

            scale.x = scale.z = MyScale.x;
            scale.y = MyScale.y;

            LocalMat.SetTRS(Vector3.zero, rot * MyRotation, scale);

            WorldMat.SetTRS(MyPosition, Quaternion.identity, Vector3.one);
            Matrix4x4 mat = WorldMat * LocalMat;

            VertexPool pool = Vertexsegment.Pool;

            for (int i = Vertexsegment.VertStart; i < Vertexsegment.VertStart + Vertexsegment.VertCount; i++)
            {
                pool.Vertices[i] = mat.MultiplyPoint3x4(MeshVerts[i - Vertexsegment.VertStart]);
            }
        }
예제 #15
0
        void InitMeshObj()
        {
            //create a new mesh obj
            mMeshObj       = new GameObject("_XWeaponTrailMesh: " + gameObject.name);
            mMeshObj.layer = gameObject.layer;
            mMeshObj.SetActive(true);
            MeshFilter   mf = mMeshObj.AddComponent <MeshFilter>();
            MeshRenderer mr = mMeshObj.AddComponent <MeshRenderer>();

            mr.castShadows             = false;
            mr.receiveShadows          = false;
            mr.renderer.sharedMaterial = MyMaterial;
            mf.sharedMesh = new Mesh();

            //init vertexpool
            mVertexPool    = new VertexPool(mf.sharedMesh, MyMaterial);
            mVertexSegment = mVertexPool.GetVertices(Granularity * 3, (Granularity - 1) * 12);


            UpdateIndices();
        }
예제 #16
0
        public override void Update(float deltaTime)
        {
            //if (Node.Owner.ColorAffectorEnable || Node.mIsFade)
            SetColor(Node.Color);
            if (Node.Owner.UVAffectorEnable || Node.Owner.UVRotAffectorEnable || Node.Owner.UVScaleAffectorEnable)
            {
                SetUVCoord(Node.LowerLeftUV, Node.UVDimensions);
            }
            SetPosition(Node.CurWorldPos);

            if (UVChanged)
            {
                UpdateUV();
            }
            if (ColorChanged)
            {
                UpdateColor();
            }
            UVChanged = ColorChanged = false;
            UpdateCenterPos();

            mRadius = Node.Scale.x * Node.Owner.SpriteWidth * Node.OriScaleX;
            //set radius to shader!!!
            VertexPool pool  = Vertexsegment.Pool;
            int        index = Vertexsegment.VertStart;
            Vector2    param = Vector2.one;

            param.x = mRadius;

            //set rotation!
            param.y = ((float)Node.OriRotateAngle + Node.RotateAngle) * Mathf.PI / 180f;


            pool.UVs2[index + 0]          = param;
            pool.UVs2[index + 1]          = param;
            pool.UVs2[index + 2]          = param;
            pool.UVs2[index + 3]          = param;
            Vertexsegment.Pool.UV2Changed = true;
        }
예제 #17
0
        public void UpdateUV()
        {
            VertexPool pool  = Vertexsegment.Pool;
            int        index = Vertexsegment.VertStart;

            if (UVDimensions.y > 0)
            {                                                                       //From     Lower-Left
                pool.UVs[index + 0] = LowerLeftUV + Vector2.up * UVDimensions.y;    // Upper-left
                pool.UVs[index + 1] = LowerLeftUV;                                  // Lower-left
                pool.UVs[index + 2] = LowerLeftUV + Vector2.right * UVDimensions.x; // Lower-right
                pool.UVs[index + 3] = LowerLeftUV + UVDimensions;                   // Upper-right
            }
            else
            {// From Upper Left
                pool.UVs[index + 0] = LowerLeftUV;
                pool.UVs[index + 1] = LowerLeftUV + Vector2.up * UVDimensions.y;
                pool.UVs[index + 2] = LowerLeftUV + UVDimensions;
                pool.UVs[index + 3] = LowerLeftUV + Vector2.right * UVDimensions.x;
            }

            Vertexsegment.Pool.UVChanged = true;
        }
예제 #18
0
        private void UpdateVertex()
        {
            VertexPool pool = this.mVertexSegment.Pool;

            for (int i = 0; i < this.Granularity; i++)
            {
                int   index = this.mVertexSegment.VertStart + (i * 3);
                float num3  = ((float)i) / ((float)this.Granularity);
                float tl    = num3 * this.mFadeT;
                if ((int)FengGameManagerMKII.settings[360] == 0)
                {
                    tl = num3 * 1.5f;
                }
                Vector2 zero    = Vector2.zero;
                Vector3 vector2 = this.mSpline.InterpolateByLen(tl);
                Vector3 vector3 = this.mSpline.InterpolateNormalByLen(tl);
                Vector3 vector4 = vector2 + ((Vector3)((vector3.normalized * this.mTrailWidth) * 0.5f));
                Vector3 vector5 = vector2 - ((Vector3)((vector3.normalized * this.mTrailWidth) * 0.5f));
                pool.Vertices[index] = vector4;
                pool.Colors[index]   = this.MyColor;
                zero.x                   = 0f;
                zero.y                   = num3;
                pool.UVs[index]          = zero;
                pool.Vertices[index + 1] = vector2;
                pool.Colors[index + 1]   = this.MyColor;
                zero.x                   = 0.5f;
                zero.y                   = num3;
                pool.UVs[index + 1]      = zero;
                pool.Vertices[index + 2] = vector5;
                pool.Colors[index + 2]   = this.MyColor;
                zero.x                   = 1f;
                zero.y                   = num3;
                pool.UVs[index + 2]      = zero;
            }
            this.mVertexSegment.Pool.UVChanged    = true;
            this.mVertexSegment.Pool.VertChanged  = true;
            this.mVertexSegment.Pool.ColorChanged = true;
        }
예제 #19
0
        //x for displacement control
        //y for dissolve control.
        public override void ApplyShaderParam(float x, float y)
        {
            //haven't retrieve the verts.
            if (mVertexsegment == null)
            {
                return;
            }

            Vector2 param = Vector2.one;

            param.x = x;
            param.y = y;

            VertexPool pool  = mVertexsegment.Pool;
            int        index = mVertexsegment.VertStart;

            for (int i = 0; i < mVertexsegment.VertCount; i++)
            {
                pool.UVs2[index + i] = param;
            }

            mVertexsegment.Pool.UV2Changed = true;
        }
예제 #20
0
파일: Sprite.cs 프로젝트: hibaby/wowboss
        public Sprite(VertexPool.VertexSegment segment, float width, float height, STYPE type, ORIPOINT oripoint, Camera cam, int uvStretch, float maxFps,bool simple)
        {
            UVChanged = ColorChanged = false;
            MyTransform.position = Vector3.zero;
            MyTransform.rotation = Quaternion.identity;
            LocalMat = WorldMat = Matrix4x4.identity;
            Vertexsegment = segment;
            UVStretch = uvStretch;

            LastMat = Matrix4x4.identity;
            ElapsedTime = 0f;
            Fps = 1f / maxFps;
            Simple = simple;

            OriPoint = oripoint;

            RotateAxis = Vector3.zero;
            SetSizeXZ(width, height);
            RotateAxis.y = 1;
            Type = type;
            MainCamera = cam;
            ResetSegment();
        }
예제 #21
0
        public void UpdateUV()
        {
            VertexPool pool   = Vertexsegment.Pool;
            int        vindex = Vertexsegment.VertStart;

            for (int i = 0; i < m_oriUvs.Length; i++)
            {
                Vector2 curScale = LowerLeftUV + Vector2.Scale(m_oriUvs[i], UVDimensions);

                //fix wrap : repeat.
                if (curScale.x > UVDimensions.x + LowerLeftUV.x)
                {
                    float delta = curScale.x - UVDimensions.x - LowerLeftUV.x;

                    delta = Mathf.Repeat(delta, UVDimensions.x + LowerLeftUV.x);

                    curScale.x = LowerLeftUV.x + delta * UVDimensions.x;
                }

                pool.UVs[i + vindex] = curScale;
            }

            Vertexsegment.Pool.UVChanged = true;
        }
예제 #22
0
        private void UpdateIndices()
        {
            VertexPool pool = mVertexSegment.Pool;

            for (int i = 0; i < Granularity - 1; i++)
            {
                int num  = mVertexSegment.VertStart + i * 3;
                int num2 = mVertexSegment.VertStart + (i + 1) * 3;
                int num3 = mVertexSegment.IndexStart + i * 12;
                pool.Indices[num3]      = num2;
                pool.Indices[num3 + 1]  = num2 + 1;
                pool.Indices[num3 + 2]  = num;
                pool.Indices[num3 + 3]  = num2 + 1;
                pool.Indices[num3 + 4]  = num + 1;
                pool.Indices[num3 + 5]  = num;
                pool.Indices[num3 + 6]  = num2 + 1;
                pool.Indices[num3 + 7]  = num2 + 2;
                pool.Indices[num3 + 8]  = num + 1;
                pool.Indices[num3 + 9]  = num2 + 2;
                pool.Indices[num3 + 10] = num + 2;
                pool.Indices[num3 + 11] = num + 1;
            }
            pool.IndiceChanged = true;
        }
예제 #23
0
        void UpdateMeshObj()
        {
            //make sure each mesh position is always zero.
            for (int i = 0; i < MeshList.Count; i++)
            {
                GameObject obj = MeshList[i];
                if (obj != null)
                {
                    obj.transform.position = Vector3.zero;
                    obj.transform.rotation = Quaternion.identity;
                }
            }

            if (MergeSameMaterialMesh)
            {
                //ElementAt() STILL CAUSE GC ALLOC!! SO WE CAN'T AVOID GC ALLOC IN DICTIONARY?
                //for (int i = 0; i < MatDic.Count; i++)
                //{
                //    KeyValuePair<string,VertexPool> pair = MatDic.ElementAt(i);
                //    pair.Value.LateUpdate();
                //}

                foreach (KeyValuePair <string, VertexPool> pair in MatDic)
                {
                    pair.Value.LateUpdate();
                }
            }
            else
            {
                for (int i = 0; i < MatList.Count; i++)
                {
                    VertexPool vp = MatList[i];
                    vp.LateUpdate();
                }
            }
        }
예제 #24
0
        private void UpdateIndices()
        {
            VertexPool pool = this.mVertexSegment.Pool;

            for (int i = 0; i < (this.Granularity - 1); i++)
            {
                int num2  = this.mVertexSegment.VertStart + (i * 3);
                int num3  = this.mVertexSegment.VertStart + ((i + 1) * 3);
                int index = this.mVertexSegment.IndexStart + (i * 12);
                pool.Indices[index]      = num3;
                pool.Indices[index + 1]  = num3 + 1;
                pool.Indices[index + 2]  = num2;
                pool.Indices[index + 3]  = num3 + 1;
                pool.Indices[index + 4]  = num2 + 1;
                pool.Indices[index + 5]  = num2;
                pool.Indices[index + 6]  = num3 + 1;
                pool.Indices[index + 7]  = num3 + 2;
                pool.Indices[index + 8]  = num2 + 1;
                pool.Indices[index + 9]  = num3 + 2;
                pool.Indices[index + 10] = num2 + 2;
                pool.Indices[index + 11] = num2 + 1;
            }
            pool.IndiceChanged = true;
        }
예제 #25
0
        void LateUpdate()
        {
            //make sure each mesh position is always zero.
            for (int i = 0; i < MeshList.Count; i++)
            {
                GameObject obj = MeshList[i];
                if (obj != null)
                {
                    obj.transform.position = Vector3.zero;
                    obj.transform.rotation = Quaternion.identity;
                }
            }


            if (MergeSameMaterialMesh)
            {
                //ElementAt() STILL CAUSE GC ALLOC!! SO WE CAN'T AVOID GC ALLOC IN DICTIONARY?
                //for (int i = 0; i < MatDic.Count; i++)
                //{
                //    KeyValuePair<string,VertexPool> pair = MatDic.ElementAt(i);
                //    pair.Value.LateUpdate();
                //}

                foreach (KeyValuePair <string, VertexPool> pair in MatDic)
                {
                    pair.Value.LateUpdate();
                }
            }
            else
            {
                for (int i = 0; i < MatList.Count; i++)
                {
                    VertexPool vp = MatList[i];
                    vp.LateUpdate();
                }
            }

            if (ElapsedTime > LifeTime && LifeTime >= 0)
            {
                DoFinish();
            }
            else if (LifeTime < 0 && EflList.Count > 0)
            {
                //Xffect LifeTime < 0, 且又是EmitByRate的话,会自动判断是否已经没有活动节点,没有则自动Deactive()。
                float deltaTime      = (float)(CurTime - LastTime);
                bool  allEfLFinished = true;

                for (int i = 0; i < EflList.Count; i++)
                {
                    EffectLayer el = EflList[i];
                    if (!el.EmitOver(deltaTime))
                    {
                        allEfLFinished = false;
                    }
                }

                if (allEfLFinished)
                {
                    DoFinish();
                }
            }
        }
예제 #26
0
        //this function should be very optimized
        public void Transform()
        {
            LocalMat.SetTRS(Vector3.zero, Rotation, ScaleVector);

            if (Type == STYPE.BILLBOARD)
            {
                Transform t;
                t = MainCamera.transform;
                MyTransform.LookAt(MyTransform.position + t.rotation * Vector3.up, t.rotation * Vector3.back);
            }
            WorldMat.SetTRS(MyTransform.position, MyTransform.rotation, Vector3.one);
            Matrix4x4 mat = WorldMat * LocalMat;

            VertexPool pool  = Vertexsegment.Pool;
            int        index = Vertexsegment.VertStart;

            Vector3 v1w = mat.MultiplyPoint3x4(v1);
            Vector3 v2w = mat.MultiplyPoint3x4(v2);
            Vector3 v3w = mat.MultiplyPoint3x4(v3);
            Vector3 v4w = mat.MultiplyPoint3x4(v4);

            if (Type == STYPE.BILLBOARD_SELF)
            {
                Vector3 headElem = Vector3.zero;
                Vector3 tailElem = Vector3.zero;
                float   vWidth   = 0f;
                if (UVStretch == 0)
                {
                    headElem = (v1w + v4w) / 2;
                    tailElem = (v2w + v3w) / 2;
                    vWidth   = (v4w - v1w).magnitude;
                }
                else
                {
                    headElem = (v1w + v2w) / 2;
                    tailElem = (v4w + v3w) / 2;
                    vWidth   = (v2w - v1w).magnitude;
                }

                Vector3 chainTangent = headElem - tailElem;

                Vector3 vP1ToEye        = MainCamera.transform.position - headElem;
                Vector3 vPerpendicular1 = Vector3.Cross(chainTangent, vP1ToEye);
                vPerpendicular1.Normalize();
                vPerpendicular1 *= (vWidth * 0.5f);

                Vector3 vP2ToEye        = MainCamera.transform.position - tailElem;
                Vector3 vPerpendicular2 = Vector3.Cross(chainTangent, vP2ToEye);
                vPerpendicular2.Normalize();
                vPerpendicular2 *= (vWidth * 0.5f);

                if (UVStretch == 0)
                {
                    v1w = headElem - vPerpendicular1;
                    v4w = headElem + vPerpendicular1;
                    v2w = tailElem - vPerpendicular2;
                    v3w = tailElem + vPerpendicular2;
                }
                else
                {
                    v1w = headElem - vPerpendicular1;
                    v2w = headElem + vPerpendicular1;
                    v4w = tailElem - vPerpendicular2;
                    v3w = tailElem + vPerpendicular2;
                }
            }

            pool.Vertices[index + 0] = v1w;
            pool.Vertices[index + 1] = v2w;
            pool.Vertices[index + 2] = v3w;
            pool.Vertices[index + 3] = v4w;
        }
예제 #27
0
 public Decal(VertexPool pool)
 {
     mPool       = pool;
     buffPolygon = new DecalPolygon();
 }
예제 #28
0
        //this function should be very optimized
        public void Transform()
        {
            // 2017.03.23 法师技能中断线,Node.MyCamera == null,抛异常
            if (Node == null || Node.MyCamera == null)
            {
                return;
            }

            LocalMat.SetTRS(Vector3.zero, Rotation, ScaleVector);

            Transform t = Node.MyCamera.transform;

            if (Type == STYPE.BILLBOARD)
            {
                MyTransform.LookAt(t.rotation * Vector3.up, t.rotation * Vector3.back);
            }
            else if (Type == STYPE.BILLBOARD_Y)
            {
                Vector3 diff = t.position - MyTransform.position;
                diff.y = 0f;
                MyTransform.LookAt(Vector3.up, diff);
            }
            else if (Type == STYPE.XY)
            {
                if (Node.Owner.AlwaysSyncRotation)
                {
                    MyTransform.rotation = Node.Owner.transform.rotation * MyTransform.rotation;
                }
            }

            WorldMat.SetTRS(MyTransform.position, MyTransform.rotation, Vector3.one);
            Matrix4x4 mat = WorldMat * LocalMat;

            VertexPool pool  = Vertexsegment.Pool;
            int        index = Vertexsegment.VertStart;

            Vector3 v1w = mat.MultiplyPoint3x4(v1);
            Vector3 v2w = mat.MultiplyPoint3x4(v2);
            Vector3 v3w = mat.MultiplyPoint3x4(v3);
            Vector3 v4w = mat.MultiplyPoint3x4(v4);


            if (Type == STYPE.BILLBOARD_SELF)
            {
                Vector3 headElem = Vector3.zero;
                Vector3 tailElem = Vector3.zero;
                float   vWidth   = 0f;

                Vector3 mscale = Vector3.one * (Node.Owner.Owner.Scale);

                if (Node.Owner.SpriteUVStretch == UV_STRETCH.Vertical)
                {
                    headElem = (v1w + v4w) / 2;
                    tailElem = (v2w + v3w) / 2;
                    vWidth   = (v4w - v1w).magnitude;
                }
                else
                {
                    headElem = (v1w + v2w) / 2;
                    tailElem = (v4w + v3w) / 2;
                    vWidth   = (v2w - v1w).magnitude;
                }

                Vector3 chainTangent = headElem - tailElem;

                //fixed ver 2.1.2: the scale may influence the direction!
                //Vector3 vP1ToEye = MainCamera.transform.position - headElem;
                Vector3 vP1ToEye        = t.position - Vector3.Scale(headElem, mscale);
                Vector3 vPerpendicular1 = Vector3.Cross(chainTangent, vP1ToEye);
                vPerpendicular1.Normalize();
                vPerpendicular1 *= (vWidth * 0.5f);

                //Vector3 vP2ToEye = MainCamera.transform.position - tailElem;
                Vector3 vP2ToEye        = t.position - Vector3.Scale(tailElem, mscale);
                Vector3 vPerpendicular2 = Vector3.Cross(chainTangent, vP2ToEye);
                vPerpendicular2.Normalize();
                vPerpendicular2 *= (vWidth * 0.5f);

                //Debug.DrawRay(MainCamera.transform.position,-vP2ToEye * 1000f,Color.red,10f);

                if (Node.Owner.SpriteUVStretch == UV_STRETCH.Vertical)
                {
                    v1w = headElem - vPerpendicular1;
                    v4w = headElem + vPerpendicular1;
                    v2w = tailElem - vPerpendicular2;
                    v3w = tailElem + vPerpendicular2;
                }
                else
                {
                    v1w = headElem - vPerpendicular1;
                    v2w = headElem + vPerpendicular1;
                    v4w = tailElem - vPerpendicular2;
                    v3w = tailElem + vPerpendicular2;
                }
            }


            pool.Vertices[index + 0].Set(v1w.x, UseCustomHeight ? h1 : v1w.y, v1w.z);
            pool.Vertices[index + 1].Set(v2w.x, UseCustomHeight ? h2 : v2w.y, v2w.z);
            pool.Vertices[index + 2].Set(v3w.x, UseCustomHeight ? h3 : v3w.y, v3w.z);
            pool.Vertices[index + 3].Set(v4w.x, UseCustomHeight ? h4 : v4w.y, v4w.z);
        }
예제 #29
0
        void UpdateVertices()
        {
            VertexPool pool         = mVertexSegment.Pool;
            Vector3    chainTangent = Vector3.zero;


            Vector3 eyePos = Node.MyCamera.transform.position;

            for (int i = 0; i < mElementList.Count; i++)
            {
                Element elem = mElementList[i];

                int     baseIdx   = mVertexSegment.VertStart + i * 3;
                Vector2 uvCoord   = Vector2.zero;
                float   uvSegment = (float)i / (mLastValidElemIndex);

                if (i > mLastValidElemIndex)
                {
                    Vector3 lastPos = mElementList[mLastValidElemIndex].Position;

                    //ignore this segment:
                    pool.Vertices[baseIdx] = lastPos;
                    pool.Colors[baseIdx]   = Color.clear;
                    uvCoord.x         = 0f;
                    uvCoord.y         = 1f;
                    pool.UVs[baseIdx] = uvCoord;

                    //pos
                    pool.Vertices[baseIdx + 1] = lastPos;
                    pool.Colors[baseIdx + 1]   = Color.clear;
                    uvCoord.x             = 0.5f;
                    uvCoord.y             = 1f;
                    pool.UVs[baseIdx + 1] = uvCoord;

                    //pos1
                    pool.Vertices[baseIdx + 2] = lastPos;
                    pool.Colors[baseIdx + 2]   = Color.clear;
                    uvCoord.x             = 1f;
                    uvCoord.y             = 1f;
                    pool.UVs[baseIdx + 2] = uvCoord;

                    continue;
                }

                if (i == 0)
                {
                    //tail
                    Element prevElem = mElementList[i + 1];
                    chainTangent = elem.Position - prevElem.Position;
                }
                else if (i == mLastValidElemIndex)
                {
                    //head
                    Element nextElem = mElementList[i - 1];
                    chainTangent = nextElem.Position - elem.Position;
                }
                else
                {
                    //mid
                    Element nextElem = mElementList[i - 1];
                    Element prevElem = mElementList[i + 1];
                    chainTangent = nextElem.Position - prevElem.Position;
                }



                Vector3 vP1ToEye = eyePos - elem.Position;


                Vector3 vPerpendicular = Vector3.Cross(chainTangent, vP1ToEye);
                vPerpendicular.Normalize();
                vPerpendicular *= (elem.Width * 0.5f * Node.Scale.x * Node.OriScaleX);


                Vector3 pos  = elem.Position;
                Vector3 pos0 = elem.Position - vPerpendicular;
                Vector3 pos1 = elem.Position + vPerpendicular;



                // pos0
                pool.Vertices[baseIdx] = pos0;
                pool.Colors[baseIdx]   = mColor;
                uvCoord.x         = 0f;
                uvCoord.y         = uvSegment;
                pool.UVs[baseIdx] = uvCoord;

                //pos
                pool.Vertices[baseIdx + 1] = pos;
                pool.Colors[baseIdx + 1]   = mColor;
                uvCoord.x             = 0.5f;
                uvCoord.y             = uvSegment;
                pool.UVs[baseIdx + 1] = uvCoord;

                //pos1
                pool.Vertices[baseIdx + 2] = pos1;
                pool.Colors[baseIdx + 2]   = mColor;
                uvCoord.x             = 1f;
                uvCoord.y             = uvSegment;
                pool.UVs[baseIdx + 2] = uvCoord;
            }

            mVertexSegment.Pool.UVChanged    = true;
            mVertexSegment.Pool.VertChanged  = true;
            mVertexSegment.Pool.ColorChanged = true;
        }
 void InitMeshObj()
 {
     //init vertexpool
     mVertexPool = new VertexPool(MyMaterial, this);
     mVertexSegment = mVertexPool.GetVertices(Granularity * 3, (Granularity - 1) * 12);
     UpdateIndices();
 }
예제 #31
0
        public void UpdateVertices()
        {
            float uvSegment = 0f;
            float uvLen     = 0f;

            //NOTE: ONLY USE THE DUMMY NODE'S UV CHANGE
            Vector2 LowerLeftUV  = dummyNode.LowerLeftUV;
            Vector2 UVDimensions = dummyNode.UVDimensions;

            // change to lower left coord?
            UVDimensions.y = -UVDimensions.y;
            LowerLeftUV.y  = 1f - LowerLeftUV.y;


            float totalUVLen = Owner.RopeUVLen;

            if (Owner.RopeFixUVLen)
            {
                float t = 0;
                for (int i = 0; i < NodeList.Count - 1; i++)
                {
                    t += (NodeList[i + 1].GetWorldPos() - NodeList[i].GetWorldPos()).magnitude;
                }
                totalUVLen = t;
            }


            for (int i = NodeList.Count - 1; i >= 0; i--)
            {
                EffectNode node = NodeList[i];

                EffectNode prevNode = i + 1 < NodeList.Count ? NodeList[i + 1] : null;

                EffectNode nextNode = i - 1 >= 0 ? NodeList[i - 1] : null;

                Vector3 chainTangent;

                if (nextNode == null)
                {
                    //tail node
                    chainTangent = node.GetWorldPos() - prevNode.GetWorldPos();
                }
                else if (prevNode == null)
                {
                    //head node
                    chainTangent = nextNode.GetWorldPos() - node.GetWorldPos();
                }
                else
                {
                    chainTangent = nextNode.GetWorldPos() - prevNode.GetWorldPos();
                }



                Vector3 eyePos   = Owner.MyCamera.transform.position;
                Vector3 vP1ToEye = eyePos - node.GetWorldPos();

                Vector3 vPerpendicular = Vector3.Cross(chainTangent, vP1ToEye);
                vPerpendicular.Normalize();
                vPerpendicular *= (Owner.RopeWidth * 0.5f * node.Scale.x);

                //Debug.DrawRay(node.GetWorldPos(), vPerpendicular, Color.red, 1f);

                Vector3 pos0 = node.GetWorldPos() - vPerpendicular;
                Vector3 pos1 = node.GetWorldPos() + vPerpendicular;

                VertexPool pool = Vertexsegment.Pool;
                //if (Owner.StretchType == 0)
                uvSegment = (uvLen / totalUVLen) * Mathf.Abs(UVDimensions.y);
                // else
                // uvSegment = (uvLen / totalUVLen) * Mathf.Abs(UVDimensions.x);
                Vector2 uvCoord = Vector2.zero;
                int     baseIdx = Vertexsegment.VertStart + node.Index * 2;

                pool.Vertices[baseIdx] = pos0;
                pool.Colors[baseIdx]   = node.Color;
                //if (Owner.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]   = node.Color;
                //if (Owner.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 (nextNode != null)
                {
                    uvLen += (nextNode.GetWorldPos() - node.GetWorldPos()).magnitude;
                }
                else
                {
                    uvLen += (node.GetWorldPos() - prevNode.GetWorldPos()).magnitude;
                }
            }

            Vertexsegment.Pool.UVChanged    = true;
            Vertexsegment.Pool.VertChanged  = true;
            Vertexsegment.Pool.ColorChanged = true;
        }
예제 #32
0
        public void UpdateVertices(Vector3 eyePos)
        {
            Vector3 chainTangent;
            float   uvSegment = 0f;
            float   uvLen     = 0f;

            float trailLen = ElemLength * (MaxElements - 2);

            //Element headElem = ElementArray[Head];
            //int nextElemIdx = Head + 1;
            //if (nextElemIdx == MaxElements)
            //    nextElemIdx = 0;
            //Element nextElem = ElementArray[nextElemIdx];
            //float headLen = (headElem.Position - nextElem.Position).magnitude;
            //float trailLen = ElemLength * (ElemCount - 2) + headLen;

            if (Head != CHAIN_EMPTY && Head != Tail)
            {
                int laste = Head;
                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;
                    }
                    else if (e == Tail)
                    {
                        // No nexte, use only last item
                        chainTangent = elem.Position - ElementArray[laste].Position;
                    }
                    else
                    {
                        // A mid position, use tangent across both prev and next
                        chainTangent = ElementArray[nexte].Position - ElementArray[laste].Position;
                    }

                    Vector3 vP1ToEye;

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

                    Vector3 pos0 = elem.Position - vPerpendicular;
                    Vector3 pos1 = elem.Position + vPerpendicular;


                    VertexPool pool = Vertexsegment.Pool;

                    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?
        }
예제 #33
0
        void InitMeshObj()
        {
            //create a new mesh obj
            mMeshObj = new GameObject("_XWeaponTrailMesh: " + gameObject.name);
            mMeshObj.layer = gameObject.layer;
            mMeshObj.SetActive(true);
            MeshFilter mf = mMeshObj.AddComponent<MeshFilter>();
            MeshRenderer mr = mMeshObj.AddComponent<MeshRenderer>();
            mr.castShadows = false;
            mr.receiveShadows = false;
            mr.GetComponent<Renderer>().sharedMaterial = MyMaterial;
            mf.sharedMesh = new Mesh();

            //init vertexpool
            mVertexPool = new VertexPool(mf.sharedMesh, MyMaterial);
            mVertexSegment = mVertexPool.GetVertices(Granularity * 3, (Granularity - 1) * 12);

            UpdateIndices();
        }
예제 #34
0
 public Decal(VertexPool pool)
 {
     mPool = pool;
     buffPolygon = new DecalPolygon();
 }
예제 #35
0
        //this function should be very optimized
        public void Transform()
        {
            LocalMat.SetTRS(Vector3.zero, Rotation, ScaleVector);

            Transform t = MainCamera.transform;

            if (Type == STYPE.BILLBOARD)
            {
                MyTransform.LookAt(t.rotation * Vector3.up, t.rotation * Vector3.back);
            }
            else if (Type == STYPE.BILLBOARD_Y)
            {
                Vector3 diff = t.position - MyTransform.position;
                diff.y = 0f;
                MyTransform.LookAt(Vector3.up, diff);
            }
            WorldMat.SetTRS(MyTransform.position, MyTransform.rotation, Vector3.one);
            Matrix4x4 mat = WorldMat * LocalMat;

            VertexPool pool  = Vertexsegment.Pool;
            int        index = Vertexsegment.VertStart;

            Vector3 v1w = mat.MultiplyPoint3x4(v1);
            Vector3 v2w = mat.MultiplyPoint3x4(v2);
            Vector3 v3w = mat.MultiplyPoint3x4(v3);
            Vector3 v4w = mat.MultiplyPoint3x4(v4);


            if (Type == STYPE.BILLBOARD_SELF)
            {
                Vector3 headElem = Vector3.zero;
                Vector3 tailElem = Vector3.zero;
                float   vWidth   = 0f;

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

                if (UVStretch == 0)
                {
                    headElem = (v1w + v4w) / 2;
                    tailElem = (v2w + v3w) / 2;
                    vWidth   = (v4w - v1w).magnitude;
                }
                else
                {
                    headElem = (v1w + v2w) / 2;
                    tailElem = (v4w + v3w) / 2;
                    vWidth   = (v2w - v1w).magnitude;
                }

                Vector3 chainTangent = headElem - tailElem;

                //fixed ver 2.1.2: the scale may influence the direction!
                //Vector3 vP1ToEye = MainCamera.transform.position - headElem;
                Vector3 vP1ToEye        = MainCamera.transform.position - Vector3.Scale(headElem, mscale);
                Vector3 vPerpendicular1 = Vector3.Cross(chainTangent, vP1ToEye);
                vPerpendicular1.Normalize();
                vPerpendicular1 *= (vWidth * 0.5f);

                //Vector3 vP2ToEye = MainCamera.transform.position - tailElem;
                Vector3 vP2ToEye        = MainCamera.transform.position - Vector3.Scale(tailElem, mscale);
                Vector3 vPerpendicular2 = Vector3.Cross(chainTangent, vP2ToEye);
                vPerpendicular2.Normalize();
                vPerpendicular2 *= (vWidth * 0.5f);

                //Debug.DrawRay(MainCamera.transform.position,-vP2ToEye * 1000f,Color.red,10f);

                if (UVStretch == 0)
                {
                    v1w = headElem - vPerpendicular1;
                    v4w = headElem + vPerpendicular1;
                    v2w = tailElem - vPerpendicular2;
                    v3w = tailElem + vPerpendicular2;
                }
                else
                {
                    v1w = headElem - vPerpendicular1;
                    v2w = headElem + vPerpendicular1;
                    v4w = tailElem - vPerpendicular2;
                    v3w = tailElem + vPerpendicular2;
                }
            }

            pool.Vertices[index + 0] = v1w;
            pool.Vertices[index + 1] = v2w;
            pool.Vertices[index + 2] = v3w;
            pool.Vertices[index + 3] = v4w;

            if (UseCustomHeight)
            {
                pool.Vertices[index + 0].y = h1;
                pool.Vertices[index + 1].y = h2;
                pool.Vertices[index + 2].y = h3;
                pool.Vertices[index + 3].y = h4;
            }
        }
예제 #36
0
 public SphericalBillboard(VertexPool.VertexSegment segment)
 {
     UVChanged = ColorChanged = false;
     Vertexsegment = segment;
     ResetSegment();
 }
예제 #37
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?
        }