Ejemplo n.º 1
0
        void InitSegmentsIfNull()
        {
            // if ((segments != null) && (segments.Length == segmentsCount) && (segments[0]!= null)) return;

            segments = new quadSegment[segmentsCount];
            for (int i = 0; i < segmentsCount; i++)
            {
                segments[i] = new quadSegment();
            }


            segmentTris = new int[(segmentsCount - 1) * 4 * 3];

            for (int segm = 0; segm < segmentsCount - 1; segm++)
            {
                int vno = segm * 3;
                int ind = segm * 3 * 4;
                segmentTris[ind] = vno; segmentTris[ind + 1] = vno + 1; segmentTris[ind + 2] = vno + 2;
                ind += 3;
                segmentTris[ind] = vno; segmentTris[ind + 1] = vno + 2; segmentTris[ind + 2] = vno + 3;     //
                ind += 3;
                segmentTris[ind] = vno + 2; segmentTris[ind + 1] = vno + 1; segmentTris[ind + 2] = vno + 4; //
                ind += 3;
                segmentTris[ind] = vno + 3; segmentTris[ind + 1] = vno + 2; segmentTris[ind + 2] = vno + 4; //
            }
        }
Ejemplo n.º 2
0
        public Mesh GetStreak(Vector3 from, Vector3 to, float width, bool head, bool tail)
        {
            InitSegmentsIfNull();

            quadSegment hsegm = segments[segmentsCount - 1];
            quadSegment tsegm = segments[0];


            Vector3 vector = to - from;
            Vector3 fromA;
            Vector3 fromB;
            Vector3 toA;
            Vector3 toB;

            Vector3 side = Vector3.Cross(vector, Vector3.forward).normalized *width / 2;

            if (!tail)
            {
                fromA = prevA;
                fromB = prevB;
            }
            else
            {
                fromA = from + side;
                fromB = from - side;
            }


            toA = to + side;
            toB = to - side;

            Vector3 dirA = toA - fromA;
            Vector3 dirB = toB - fromB;

            Vector3 offA = dirA.normalized * width * 0.5f;
            Vector3 offB = dirB.normalized * width * 0.5f;



            if (head)
            {
                hsegm.verts[0] = toA + offA;
                hsegm.verts[1] = toB + offB;
            }


            if (tail)
            {
                tsegm.verts[0] = fromA - offA;
                tsegm.verts[1] = fromB - offB;
            }



            int till = segmentsCount - (head ? 1 : 0);

            int midSegms = segmentsCount - 1 - ((tail ? 1 : 0) + (head ? 1 : 0));

            Vector3 stepA = (toA - fromA) / midSegms;
            Vector3 stepB = (toB - fromB) / midSegms;

            // Vector3 step = (to - from) / midSegms;



            for (int i = (tail ? 1 : 0); i < till; i++)
            {
                quadSegment q = segments[i];
                q.verts[0] = fromA; //from+ side;
                q.verts[1] = fromB; //from- side;

                //  from += step;
                fromA += stepA;
                fromB += stepB;
            }


            hsegm.SetSection(head ? sectionType.head : sectionType.center);
            tsegm.SetSection(tail ? sectionType.tail : sectionType.center);


            for (int i = 0; i < segmentsCount - 1; i++)
            {
                segments[i].setCenter(segments[i + 1]);
            }

            bool initing = (segmMesh == null);

            if (initing)
            {
                segmMesh = new Mesh();
            }

            segmMesh.vertices = quadSegment.VertexArrayFrom(segments);
            segmMesh.uv       = quadSegment.UVArrayFrom(segments);

            if (initing)
            {
                segmMesh.triangles = segmentTris;
            }

            prevA = toA;
            prevB = toB;

            if (debug != null)
            {
                debug.mesh = segmMesh;
            }

            segmMesh.name = "Segmant Mesh";

            return(segmMesh);
        }
Ejemplo n.º 3
0
 public void setCenter(quadSegment next)
 {
     verts[2] = (verts[0] + verts[1] + next.verts[0] + next.verts[1]) / 4;
     uv[2]    = (uv[0] + uv[1] + next.uv[0] + next.uv[1]) / 4;
 }