Пример #1
0
    private void addCursorTransform()
    {
        knotNormals.Add(cursorTransform.up);
        knotBinormals.Add(cursorTransform.forward);
        knotTangents.Add(cursorTransform.right);
        knotRadius.Add(cursorTransform.GetComponent <ProcShape>().m_Radius);

        knotLengths.Add(spline.Length());
    }
Пример #2
0
    private void addCursorTransform()
    {
        knotNormals.Add(cursorTransform.up);
        knotBinormals.Add(cursorTransform.forward);
        knotTangents.Add(cursorTransform.right);
        knotLengths.Add(spline.Length());

        ProcSection ps = cursorTransform.GetComponent <ProcSection>();

        knotHeight.Add(ps.m_Height);
        knotWidth.Add(ps.m_Width);
        knotThickness.Add(ps.m_Thickness);
    }
Пример #3
0
    public void BuildMeshTrail(Vector3 pos)
    {
        // Checks and update the spline path for cursor
        List <Knot> knots = splineSide.knots;
        Vector3     point = pos;

        knots[knots.Count - 1].position = point;
        knots[knots.Count - 2].position = point;

        if (Vector3.Distance(knots[knots.Count - 3].position, point) > trackLength &&
            Vector3.Distance(knots[knots.Count - 4].position, point) > trackLength) // point exceeds length path travelled
        {
            // add knot and the normals at the point
            knots.Add(new Knot(point));
            splineSide.Parametrize();
            knotLengths.Add(splineSide.Length());
            knotLengths.RemoveAt(0);

            CreateMeshTrail(0); // update mesh
        }
    }
Пример #4
0
        private void RenderMesh()
        {
            if (advancedParameters.nbSegmentToParametrize == 0)
            {
                spline.Parametrize();
            }
            else
            {
                spline.Parametrize(spline.NbSegments - advancedParameters.nbSegmentToParametrize, spline.NbSegments);
            }

            float length = Mathf.Max(spline.Length() - 0.1f, 0);

            int nbQuad = ((int)(1f / width * length)) + 1 - quadOffset;

            if (allocatedNbQuad < nbQuad)    //allocate more memory for the mesh
            {
                Reallocate(nbQuad);
                length = Mathf.Max(spline.Length() - 0.1f, 0);
                nbQuad = ((int)(1f / width * length)) + 1 - quadOffset;
            }

            int   startingQuad = lastStartingQuad;
            float lastDistance = startingQuad * width + quadOffset * width;

            maxInstanciedTriCount = System.Math.Max(maxInstanciedTriCount, (nbQuad - 1) * NbTriIndexPerQuad);

            Vector3 n = normal;

            if (dynamicNormalUpdate)
            {
                if (n == Vector3.zero)
                {
                    n = (transform.position - Camera.main.transform.position).normalized;
                }

                for (int i = 0; i < normals.Length; i++)
                {
                    normals[i] = n;
                }
            }

            CatmullRomSpline.Marker marker = new CatmullRomSpline.Marker();
            spline.PlaceMarker(marker, lastDistance);

            Vector3 lastPosition = spline.GetPosition(marker);
            Vector3 lastTangent  = spline.GetTangent(marker);
            Vector3 lastBinormal = CatmullRomSpline.ComputeBinormal(lastTangent, n);

            int drawingEnd = meshDisposition == MeshDisposition.Fragmented ? nbQuad - 1 : nbQuad - 1;



            float startingDist = lastDistance;

            for (int i = startingQuad; i < drawingEnd; i++)
            {
                float distance         = lastDistance + width;
                int   firstVertexIndex = i * NbVertexPerQuad;
                int   firstTriIndex    = i * NbTriIndexPerQuad;

                spline.MoveMarker(marker, distance);

                Vector3 position = spline.GetPosition(marker);
                Vector3 tangent  = spline.GetTangent(marker);
                Vector3 binormal = CatmullRomSpline.ComputeBinormal(tangent, n);

                float h = FadeMultiplier(lastDistance, length);
                float h2 = FadeMultiplier(distance, length);
                float rh = h * height, rh2 = h2 * height;

                if (fadeType == FadeType.Alpha || fadeType == FadeType.None)
                {
                    rh  = h > 0 ? height : 0;
                    rh2 = h2 > 0 ? height : 0;
                }

                if (meshDisposition == MeshDisposition.Continuous)
                {
                    vertices[firstVertexIndex]     = transform.InverseTransformPoint(lastPosition - origin + (lastBinormal * (rh * 0.5f)));
                    vertices[firstVertexIndex + 1] = transform.InverseTransformPoint(lastPosition - origin + (-lastBinormal * (rh * 0.5f)));
                    vertices[firstVertexIndex + 2] = transform.InverseTransformPoint(position - origin + (binormal * (rh2 * 0.5f)));
                    vertices[firstVertexIndex + 3] = transform.InverseTransformPoint(position - origin + (-binormal * (rh2 * 0.5f)));

                    uv[firstVertexIndex]     = new Vector2(lastDistance / height, 1);
                    uv[firstVertexIndex + 1] = new Vector2(lastDistance / height, 0);
                    uv[firstVertexIndex + 2] = new Vector2(distance / height, 1);
                    uv[firstVertexIndex + 3] = new Vector2(distance / height, 0);
                }
                else
                {
                    Vector3 pos = lastPosition + (lastTangent * width * -0.5f) - origin;

                    vertices[firstVertexIndex]     = transform.InverseTransformPoint(pos + (lastBinormal * (rh * 0.5f)));
                    vertices[firstVertexIndex + 1] = transform.InverseTransformPoint(pos + (-lastBinormal * (rh * 0.5f)));
                    vertices[firstVertexIndex + 2] = transform.InverseTransformPoint(pos + (lastTangent * width) + (lastBinormal * (rh * 0.5f)));
                    vertices[firstVertexIndex + 3] = transform.InverseTransformPoint(pos + (lastTangent * width) + (-lastBinormal * (rh * 0.5f)));

                    uv[firstVertexIndex]     = new Vector2(0, 1);
                    uv[firstVertexIndex + 1] = new Vector2(0, 0);
                    uv[firstVertexIndex + 2] = new Vector2(1, 1);
                    uv[firstVertexIndex + 3] = new Vector2(1, 0);
                }

                float relLength = length - startingDist;
                uv2[firstVertexIndex]     = new Vector2((lastDistance - startingDist) / relLength, 1);
                uv2[firstVertexIndex + 1] = new Vector2((lastDistance - startingDist) / relLength, 0);
                uv2[firstVertexIndex + 2] = new Vector2((distance - startingDist) / relLength, 1);
                uv2[firstVertexIndex + 3] = new Vector2((distance - startingDist) / relLength, 0);

                triangles[firstTriIndex]     = firstVertexIndex;
                triangles[firstTriIndex + 1] = firstVertexIndex + 1;
                triangles[firstTriIndex + 2] = firstVertexIndex + 2;
                triangles[firstTriIndex + 3] = firstVertexIndex + 2;
                triangles[firstTriIndex + 4] = firstVertexIndex + 1;
                triangles[firstTriIndex + 5] = firstVertexIndex + 3;

                colors[firstVertexIndex]     = vertexColor;
                colors[firstVertexIndex + 1] = vertexColor;
                colors[firstVertexIndex + 2] = vertexColor;
                colors[firstVertexIndex + 3] = vertexColor;

                if (fadeType == FadeType.Alpha || fadeType == FadeType.Both)
                {
                    colors[firstVertexIndex].a     *= h;
                    colors[firstVertexIndex + 1].a *= h;
                    colors[firstVertexIndex + 2].a *= h2;
                    colors[firstVertexIndex + 3].a *= h2;
                }

                lastPosition = position;
                lastTangent  = tangent;
                lastBinormal = binormal;
                lastDistance = distance;
            }

            for (int i = (nbQuad - 1) * NbTriIndexPerQuad; i < maxInstanciedTriCount; i++) //clear a few tri ahead
            {
                triangles[i] = 0;
            }

            lastStartingQuad = advancedParameters.lengthToRedraw == 0 ?
                               System.Math.Max(0, nbQuad - ((int)(maxLength / width) + 5)) :
                               System.Math.Max(0, nbQuad - ((int)(advancedParameters.lengthToRedraw / width) + 5));

            mesh.Clear();
            mesh.vertices  = vertices;
            mesh.uv        = uv;
            mesh.uv2       = uv2;
            mesh.triangles = triangles;
            mesh.colors    = colors;
            mesh.normals   = normals;
        }
Пример #5
0
 private void addCursorTransform()
 {
     knotBinormals.Add(cursorTransform.forward * lineCursor.transform.localScale.z);
     knotLengths.Add(spline.Length());
 }
Пример #6
0
    public void CreateMeshTrail()
    {
        // creates a new mesh builder for generating mesh
        meshBuilder = new MeshBuilder();

        // find the max count of control points
        int max = 0;

        for (int i = 0; i < lineList.Count; ++i)
        {
            if (max < lineList[i].Count)
            {
                max = lineList[i].Count;
            }
        }

        // redistribute points for lines with smaller number of control points
        for (int i = 0; i < lineList.Count; ++i)
        {
            // if line does not have enough control points
            if (max > lineList[i].Count)
            {
                List <Vector3> l     = new List <Vector3>();
                float          frac1 = 0;
                float          frac2 = 0;
                int            index = 1;

                // add beginning point
                l.Add(lineList[i][0]);

                // interpolate between two points
                for (int j = 1; j < lineList[i].Count; ++j)
                {
                    frac1 = (float)index / (max - 1);
                    frac2 = (float)j / (lineList[i].Count - 1);

                    // if the point is distributed between the 2 control point
                    while (frac1 < frac2)
                    {
                        Vector3 diff = (lineList[i][j] - lineList[i][j - 1]);
                        l.Add(lineList[i][j - 1] + diff * frac1);
                        ++index;
                        frac1 = (float)index / (max - 1);
                    }
                    // endpoint of the 2 control point
                    l.Add(lineList[i][j]);
                    ++index;
                }
                lineList[i] = l;
            }
        }


        if (smooth) // create smooth sections
        {
            List <Vector3> listA;

            CatmullRomSpline spline;
            splineList = new List <CatmullRomSpline>();
            // generate the splines
            for (int j = 0; j < lineList[0].Count; ++j) // cycle the jth point of all lines
            {
                spline = new CatmullRomSpline();
                for (int i = 0; i < lineList.Count; ++i) // cycle through all the lines
                {
                    listA = lineList[i];

                    if (i == 0 || i == lineList.Count - 1)
                    {
                        for (int n = 0; n < 3; ++n)
                        {
                            spline.knots.Add(new Knot(listA[j]));
                        }
                    }
                    else
                    {
                        spline.knots.Add(new Knot(listA[j]));
                    }
                }
                spline.Parametrize();
                splineList.Add(spline);
            }

            // find the maxlength for division
            float maxLength = -1;
            for (int i = 0; i < splineList.Count; ++i)
            {
                if (maxLength < splineList[i].Length())
                {
                    maxLength = splineList[i].Length();
                }
            }


            float trackLength = 0.01f;
            int   maxCount    = (int)(maxLength / trackLength);
            int   total       = 0;
            int   offset      = 1;
            CatmullRomSpline.Marker marker = new CatmullRomSpline.Marker();

            // Render the trail, spline by spline
            Vector3 posA;
            Vector3 posB;
            Vector3 tangentA;
            Vector3 tangentB;

            // NOTE: Creates SEPARATE quad spline
            // Quad 0: spline 0 and spline 1
            // Quad 1: spline 1 and spline 2
            // Quad 2: spline 2 and spline 3 .. etc
            for (int i = 0; i < splineList.Count - 1; ++i)
            {
                CatmullRomSpline splineA = splineList[i];
                CatmullRomSpline splineB = splineList[i + 1];
                for (int j = offset; j < maxCount; ++j)
                {
                    // grab positions and tangents
                    splineA.PlaceMarker(marker, j * splineA.Length() / maxCount);
                    posA     = splineA.GetPosition(marker);
                    tangentA = splineA.GetTangent(marker);

                    splineB.PlaceMarker(marker, j * splineB.Length() / maxCount);
                    posB     = splineB.GetPosition(marker);
                    tangentB = splineB.GetTangent(marker);

                    // calculate the normals
                    Vector3 normalA = Vector3.Cross((posA - posB), tangentA).normalized;
                    Vector3 normalB = Vector3.Cross(tangentB, (posB - posA)).normalized;

                    // build the splines
                    BuildQuadSpline(meshBuilder, posA, posB, normalA, normalB, total, false);
                }

                // update offset for rendering separate quad splines
                total = meshBuilder.Vertices.Count;
            }
        }
        else // create smooth sections
        {
            List <Vector3> listA;
            List <Vector3> listB;

            int total = 0;
            for (int j = 0; j < lineList[0].Count - 1; ++j)
            {
                for (int i = 0; i < lineList.Count - 1; ++i)
                {
                    listA = lineList[i];
                    listB = lineList[i + 1];
                    BuildQuad(meshBuilder, listA[j], listB[j], listA[j + 1], listB[j + 1], total);
                }
                total = meshBuilder.Vertices.Count;
            }
        }

        BuildMesh();
    }
Пример #7
0
    // create mesh for LINEAR extrusion
    public void CreateMeshTrail(Vector3 bn, float nValue, Vector3 normPos)
    {
        // throws out previous mesh if nValue is set
        List <Knot> knots = spline.knots;

        CatmullRomSpline.Marker marker = new CatmullRomSpline.Marker();

        meshBuilder = new MeshBuilder();
        Vector3 position = new Vector3(0, 0, 0);

        // makes points based on the distance segments
        int begin = 0;
        int end   = (int)(spline.Length() / trackLength);

        int offset      = 5;
        int totalPoints = end - begin - offset;

        totalPoints *= 2;

        // IMPORTANT!!! : DEPENDS UPON THE CONSTRAINTS
        // calculates the normal in order to determine the render direction
        // place the marker at spline to get distance

        bool reverse = true;

        // Restarts rendering if a volume is being generated

        if (nValue <= -0.01f || nValue >= 0.01f)
        {
            meshBuilder = new MeshBuilder();

            spline.PlaceMarker(marker, trackLength * offset);

            Vector3 diffSide = new Vector3(bn.x, 0, 0);

            print("Normal: " + normPos);
            print("Tangent: " + spline.GetTangent(marker));
            print("Side: " + diffSide);
            print("Cross: " + Vector3.Cross(spline.GetTangent(marker), normPos));

            reverse = !(Vector3.Dot(Vector3.Cross(spline.GetTangent(marker), normPos), diffSide) > 0);

            if (reverse)
            {
                print("REVERSE!");
            }
            else
            {
                print("FORWARD!");
            }
        }

        Vector3 sidePos = Vector3.zero;

        // iterate through the entire path of the spline
        for (int j = 0; j < 2; ++j)
        {
            if (j == 1)
            {
                sidePos = bn;
            }

            for (int i = begin + offset; i < end; ++i)
            {
                // place the marker at spline to get distance
                spline.PlaceMarker(marker, trackLength * i);

                // get the variable needed for the point on spline
                position = spline.GetPosition(marker) + sidePos;

                Vector3 tangent = spline.GetTangent(marker);

                Vector3 normal = normPos;

                // build or update mesh
                if (nValue > -0.01f && nValue < 0.01f)
                {
                    if (j >= meshBuilder.Vertices.Count / totalPoints)
                    {
                        BuildQuadSpline(meshBuilder, position, normal, totalPoints, Vector3.zero, Vector3.zero, 0, reverse);
                    }
                    else
                    {
                        UpdateQuadSpline(meshBuilder, position, normal, totalPoints, Vector3.zero, Vector3.zero, i - offset, 0, reverse);
                    }
                }
                else
                {
                    Vector3 startPos = Vector3.zero;
                    Vector3 endPos   = normPos;

                    if (j >= meshBuilder.Vertices.Count / totalPoints)
                    {
                        BuildQuadSpline(meshBuilder, position, normal, totalPoints, startPos, endPos, 0, reverse);
                    }
                    else
                    {
                        UpdateQuadSpline(meshBuilder, position, normal, totalPoints, startPos, endPos, i - offset, 0, reverse);
                    }
                }
            }
        }

        // detect if there is a structure or not
        if (nValue <= -0.01f || nValue >= 0.01f)
        {
            int p = meshBuilder.Vertices.Count;

            // build sides out of the spline
            Vector3 startPos = Vector3.zero;
            Vector3 endPos   = bn;

            for (int j = 0; j < 2; ++j)
            {
                for (int i = begin + offset; i < end; ++i)
                {
                    // place the marker at spline to get distance
                    spline.PlaceMarker(marker, trackLength * i);

                    // get the variable needed for the point on spline
                    position = spline.GetPosition(marker);
                    if (j == 1)
                    {
                        position += normPos;
                    }

                    Vector3 tangent = spline.GetTangent(marker);

                    Vector3 normal = Vector3.Cross(tangent, normPos).normalized;

                    BuildQuadSpline(meshBuilder, position, normal, totalPoints, endPos, startPos, p, reverse);
                }
            }

            p = meshBuilder.Vertices.Count;

            // build caps out of the side spline
            spline.PlaceMarker(marker, trackLength * offset);
            startPos = spline.GetPosition(marker);
            Vector3 startTangent = spline.GetTangent(marker);

            if (nValue < 0)
            {
                startTangent *= -1;
            }

            spline.PlaceMarker(marker, trackLength * (end - 1));
            endPos = spline.GetPosition(marker);

            BuildQuadSpline(meshBuilder, Vector3.zero, startTangent, 4, startPos, endPos, p, reverse);
            BuildQuadSpline(meshBuilder, bn, startTangent, 4, startPos, endPos, p, reverse);

            BuildQuadSpline(meshBuilder, normPos, startTangent, 4, startPos, endPos, p, reverse);
            BuildQuadSpline(meshBuilder, normPos + bn, startTangent, 4, startPos, endPos, p, reverse);
        }

        filter.sharedMesh = meshBuilder.CreateMesh();
    }