Example #1
0
        public static Vector3 GetTangent(this SplineSegment s, float naturalT)
        {
            var up  = s.GetUpVector(naturalT);
            var rot = s.GetRotation(naturalT);

            up = rot * up;

            return(Vector3.Cross(s.GetDeltaOnSpline(naturalT), up));
        }
Example #2
0
        // Distorts a mesh along a spline
        public static Mesh DistortAlongSpline(this Mesh sourceMesh, SplineSegment spline, Matrix4x4 meshTransform,
                                              float splineStartTime = 0, float splineEndTime = 1, float snapDistance = 0,
                                              SplineSegment.ESplineInterpolation splineInterpolation = SplineSegment.ESplineInterpolation.Natural)
        {
            var result = new Mesh();
            var verts  = new List <Vector3>(sourceMesh.vertices);

            var meshBounds = new Bounds();

            for (var i = 0; i < verts.Count; i++)
            {
                verts[i] = meshTransform.MultiplyPoint3x4(verts[i]);
                if (i == 0)
                {
                    meshBounds.center = verts[i];
                }
                else
                {
                    meshBounds.Encapsulate(verts[i]);
                }
            }
            //DebugHelper.DrawCube(meshBounds.center, meshBounds.extents, Quaternion.identity, Color.white, 20);

            var splineLength = spline.Length;
            var colors       = new Color[verts.Count];

            // Transform vert from mesh space to spline-axis space
            for (var i = verts.Count - 1; i >= 0; i--)
            {
                var vert = verts[i];

                // First is finding the vert on the spline axis
                var normalizedVert = vert - meshBounds.min;
                // Normalized vert tells us where it falls on the splines 't' axis
                normalizedVert = new Vector3(
                    normalizedVert.x / Mathf.Max(float.Epsilon, meshBounds.size.x),
                    normalizedVert.y / Mathf.Max(float.Epsilon, meshBounds.size.y),
                    normalizedVert.z / Mathf.Max(float.Epsilon, meshBounds.size.z));
                var t = Mathf.Lerp(splineStartTime, splineEndTime, normalizedVert.x);

                var dist = t * splineLength;
                if (dist < snapDistance)
                {
                    t = 0;
                }

                var distRemaining = splineLength - dist;
                if (distRemaining < snapDistance)
                {
                    t = 1;
                }

                t = Mathf.Clamp01(t);

                var natT = t;
                if (splineInterpolation == SplineSegment.ESplineInterpolation.Uniform)
                {
                    natT = spline.UniformToNaturalTime(t);
                }

                //var rotation = spline.GetRotation(natT);
                var tangent       = spline.GetTangent(natT);
                var splineForward = Quaternion.LookRotation(tangent, spline.GetUpVector(natT));
                //var axisRotation = GetAxisRotation(axis);

                //var uniformT = spline.NaturalToUniformTime(t);
                var pointAlongSpline = /*transform.worldToLocalMatrix**/ spline.GetUniformPointOnSpline(t);

                //var vectorFromAxis = GetVectorFromAxis(vert, axis);
                //var splineAdjustedVert = vert - vectorFromAxis;

                verts[i]  = pointAlongSpline + splineForward * new Vector3(0, vert.y, vert.z);
                colors[i] = Color.Lerp(Color.black, Color.white, t);
            }

            result.SetVertices(verts);
            result.colors = colors;
            result.SetTriangles(sourceMesh.GetTriangles(0), 0);
            result.SetUVs(0, new List <Vector2>(sourceMesh.uv));
            return(result);
        }