Initial commit

Runtime/SplineImporter.cs

@@ -0,0 +1,190 @@
+#if UNITY_EDITOR
+
+using System;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Splines;
+using static SplineImporter;
+using static SplineData;
+using System.IO;
+using System.Text;
+using Unity.Mathematics;
+using System.Collections.Generic;
+
+[CustomEditor(typeof(SplineImporter))]
+public class SplineImporterEditor : Editor
+{
+    public override void OnInspectorGUI()
+    {
+        DrawDefaultInspector();
+
+        if (GUILayout.Button("Import Spline"))
+        {
+            SplineImporter splineImporter = target as SplineImporter;
+
+            splineImporter.name = splineImporter.splineData.name;
+
+            SplineData splineData = JsonUtility.FromJson<SplineData>(splineImporter.splineData.text);
+
+            SplineContainer splineContainer = splineImporter.GetComponent<SplineContainer>();
+
+            foreach (UnityEngine.Splines.Spline thisSpline in splineContainer.Splines)
+                splineContainer.RemoveSpline(thisSpline);
+
+            foreach (SplineData.Spline thisDataSpline in splineData.splines)
+            {
+                UnityEngine.Splines.Spline thisSpline = splineContainer.AddSpline();
+
+                thisSpline.Closed = thisDataSpline.closed;
+
+                foreach (ControlPoint thisControlPoint in thisDataSpline.controlPoints)
+                {
+                    Vector3 position = PositionToVector(thisControlPoint.position);
+
+                    Vector3 handleL = PositionToVector(thisControlPoint.handleL);
+
+                    Vector3 handleR = PositionToVector(thisControlPoint.handleR);
+
+                    Quaternion rotation = Quaternion.LookRotation(handleR - position, Vector3.up) * Quaternion.AngleAxis(-thisControlPoint.tilt, Vector3.forward);
+
+                    float3x3 rotationMatrix = new float3x3(rotation);
+
+                    thisSpline.Add(new()
+                    {
+                        Position = position * splineImporter.scale,
+                        Rotation = rotation,
+                        TangentIn = ((Vector3)math.mul(handleL - position, rotationMatrix)) * splineImporter.scale,
+                        TangentOut = ((Vector3)math.mul(handleR - position, rotationMatrix)) * splineImporter.scale
+                    },
+                    TangentMode.Broken);
+                }
+            }
+        }
+
+        if (GUILayout.Button("Export Spline"))
+        {
+            SplineImporter splineImporter = target as SplineImporter;
+
+            if (!splineImporter.splineData)
+            {
+                string path = "Assets" + EditorUtility.SaveFilePanel("Save .JSON", "", "New Spline.json", "json").Substring(Application.dataPath.Length);
+
+                if (path.Length > 0)
+                {
+                    File.WriteAllBytes(path, Encoding.ASCII.GetBytes(""));
+
+                    AssetDatabase.Refresh();
+
+                    TextAsset textAsset = AssetDatabase.LoadAssetAtPath(path, typeof(TextAsset)) as TextAsset;
+
+                    splineImporter.splineData = textAsset;
+                }
+                else return;
+            }
+
+            SplineContainer splineContainer = splineImporter.GetComponent<SplineContainer>();
+
+            SplineData splineData = new();
+
+            splineData.splines = new SplineData.Spline[splineContainer.Splines.Count];
+
+            List<SplineData.Spline> dataSplines = new();
+
+            foreach (UnityEngine.Splines.Spline thisSpline in splineContainer.Splines)
+            {
+                List<ControlPoint> controlPoints = new();
+
+                foreach (BezierKnot thisBezierKnot in thisSpline.Knots)
+                {
+                    Position position = VectorToPosition(thisBezierKnot.Position);
+
+                    float3x3 rotationMatrix = new float3x3(Quaternion.Inverse(thisBezierKnot.Rotation));
+
+                    Position handleL = VectorToPosition(math.mul(thisBezierKnot.TangentIn, rotationMatrix) + thisBezierKnot.Position);
+
+                    Position handleR = VectorToPosition(math.mul(thisBezierKnot.TangentOut, rotationMatrix) + thisBezierKnot.Position);
+
+                    controlPoints.Add(new()
+                    {
+                        position = position,
+                        handleL = handleL,
+                        handleR = handleR
+                    });
+                }
+
+                dataSplines.Add(new()
+                {
+                    controlPoints = controlPoints.ToArray(),
+                    closed = thisSpline.Closed
+                });
+            }
+
+            splineData.splines = dataSplines.ToArray();
+
+            File.WriteAllText(AssetDatabase.GetAssetPath(splineImporter.splineData), JsonUtility.ToJson(splineData, true));
+
+            AssetDatabase.Refresh();
+        }
+    }
+}
+
+[RequireComponent(typeof(SplineContainer))]
+public class SplineImporter : MonoBehaviour
+{
+    public TextAsset splineData;
+
+    public float scale = 1;
+
+    public static Vector3 PositionToVector(Position position)
+    {
+        return new(position.x, position.z, position.y);
+    }
+
+    public static Position VectorToPosition(Vector3 vector)
+    {
+        return new()
+        {
+            x = vector.x,
+            y = vector.z,
+            z = vector.y
+        };
+    }
+}
+
+[Serializable]
+public class SplineData
+{
+    [Serializable]
+    public struct Position
+    {
+        public float x;
+
+        public float y;
+
+        public float z;
+    }
+
+    [Serializable]
+    public struct ControlPoint
+    {
+        public Position position;
+
+        public Position handleL;
+
+        public Position handleR;
+
+        public float tilt;
+    }
+
+    [Serializable]
+    public struct Spline
+    {
+        public ControlPoint[] controlPoints;
+
+        public bool closed;
+    }
+
+    public Spline[] splines = new Spline[0];
+}
+
+#endif

Runtime/SplineImporter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d91b840f8503aaf409d992f7c89e93ed
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/SplinePlus.cs

@@ -0,0 +1,195 @@
+using Unity.Mathematics;
+using UnityEngine;
+using UnityEngine.Splines;
+
+public class SplinePlus : MonoBehaviour
+{
+    public SplineContainer splineContainer;
+
+    public SplineContainer deformContainer;
+
+    public int resolution;
+
+    public void Evaluate(int splineIndex, float anchor, float distance, out Vector3 position, out Quaternion rotation)
+    {
+        float t = anchor + (distance / splineContainer.Spline.GetLength());
+
+        if (deformContainer)
+            DeformSpline(splineIndex, t, out position, out rotation);
+        else
+            EvaluateSpline(splineIndex, t, out position, out rotation);
+    }
+
+    public void Evaluate(float anchor, float distance, out Vector3 position, out Quaternion rotation)
+    {
+        float t = anchor + (distance / splineContainer.Spline.GetLength());
+
+        if (deformContainer)
+            DeformSpline(t, out position, out rotation);
+        else
+            EvaluateSpline(t, out position, out rotation);
+    }
+
+    public void GetNearestPoint(Vector3 point, out Vector3 position, out Quaternion rotation)
+    {
+        position = Vector3.zero;
+
+        rotation = Quaternion.identity;
+
+        float nearestDistance = Mathf.Infinity;
+
+        for (int i = 0; i < splineContainer.Splines.Count; i++)
+        {
+            int resolutionScale = Mathf.CeilToInt(splineContainer.Splines[i].GetLength()) * resolution;
+
+            for (float j = 0; j <= resolutionScale; j++)
+            {
+                Evaluate(i, j / resolutionScale, 0, out Vector3 thisPosition, out Quaternion thisRotation);
+
+                float thisDistance = Vector3.Distance(point, thisPosition);
+
+                if (thisDistance < nearestDistance)
+                {
+                    position = thisPosition;
+
+                    rotation = thisRotation;
+
+                    nearestDistance = thisDistance;
+                }
+            }
+        }
+    }
+
+    void EvaluateSpline(int splineIndex, float t, out Vector3 position, out Quaternion rotation)
+    {
+        ScaledEvaluate(splineContainer, splineIndex, t, out float3 position1, out float3 tangent, out float3 upVector);
+
+        position = position1;
+
+        rotation = Quaternion.LookRotation(tangent, upVector);
+    }
+
+    void EvaluateSpline(float t, out Vector3 position, out Quaternion rotation)
+    {
+        splineContainer.Evaluate(t, out float3 position1, out float3 tangent, out float3 upVector);
+
+        position = position1;
+
+        rotation = Quaternion.LookRotation(tangent, upVector);
+    }
+
+    void DeformSpline(int splineIndex, float t, out Vector3 position, out Quaternion rotation)
+    {
+        int resolutionScale = Mathf.CeilToInt(splineContainer.Splines[splineIndex].GetLength()) * resolution;
+
+        position = EvaluatePoint(splineIndex, t, out float3 upVector);
+
+        float t1 = Mathf.Clamp(t, 0, 1 - (1 / (float)resolutionScale));
+
+        Vector3 position0 = EvaluatePoint(splineIndex, t1, out _);
+
+        Vector3 position1 = EvaluatePoint(splineIndex, t1 + (1 / (float)resolutionScale), out _);
+
+        Vector3 difference = position1 - position0;
+
+        rotation = Vector3.Dot(difference, upVector) > 0
+            ? Quaternion.LookRotation(difference, upVector)
+            : Quaternion.FromToRotation(Vector3.forward, difference);
+    }
+
+    void DeformSpline(float t, out Vector3 position, out Quaternion rotation)
+    {
+        int resolutionScale = Mathf.CeilToInt(splineContainer.CalculateLength()) * resolution;
+
+        position = EvaluatePoint(t, out float3 upVector);
+
+        float t1 = Mathf.Clamp(t, 0, 1 - (1 / (float)resolutionScale));
+
+        Vector3 position0 = EvaluatePoint(t1, out _);
+
+        Vector3 position1 = EvaluatePoint(t1 + (1 / (float)resolutionScale), out _);
+
+        Vector3 difference = position1 - position0;
+
+        rotation = Vector3.Dot(difference, upVector) > 0
+            ? Quaternion.LookRotation(difference, upVector)
+            : Quaternion.FromToRotation(Vector3.forward, difference);
+    }
+
+    Vector3 EvaluatePoint(int splineIndex, float t, out float3 upVector)
+    {
+        ScaledEvaluate(splineContainer, splineIndex, t, out float3 position, out _, out upVector);
+
+        ScaledEvaluate(deformContainer, 0, position.x / deformContainer.Spline.GetLength(), out float3 deformPosition, out float3 deformTangent, out float3 deformUpVector);
+
+        float3x3 deformMatrix = new()
+        {
+            c0 = (float3)Vector3.Normalize(Vector3.Cross(deformTangent, deformUpVector)),
+            c1 = (float3)Vector3.Normalize(deformUpVector),
+            c2 = (float3)Vector3.Normalize(deformTangent)
+        };
+
+        return deformPosition + (deformMatrix.c0 * position.z) + (deformMatrix.c1 * position.y);
+    }
+
+    Vector3 EvaluatePoint(float t, out float3 upVector)
+    {
+        splineContainer.Evaluate(t, out float3 position, out _, out upVector);
+
+        ScaledEvaluate(deformContainer, 0, position.x / deformContainer.Spline.GetLength(), out float3 deformPosition, out float3 deformTangent, out float3 deformUpVector);
+
+        float3x3 deformMatrix = new()
+        {
+            c0 = (float3)Vector3.Normalize(Vector3.Cross(deformTangent, deformUpVector)),
+            c1 = (float3)Vector3.Normalize(deformUpVector),
+            c2 = (float3)Vector3.Normalize(deformTangent)
+        };
+
+        return deformPosition + (deformMatrix.c0 * position.z) + (deformMatrix.c1 * position.y);
+    }
+
+    void ScaledEvaluate(SplineContainer splineContainer, int splineIndex, float t, out float3 position, out float3 tangent, out float3 upVector)
+    {
+        Spline spline = splineContainer.Splines[splineIndex];
+
+        if (spline == null)
+        {
+            splineContainer.Evaluate(t, out position, out tangent, out upVector);
+
+            return;
+        }
+
+        SplineUtility.Evaluate(splineContainer.Splines[splineIndex], t, out position, out tangent, out upVector);
+
+        position = splineContainer.transform.TransformPoint(position);
+
+        tangent = splineContainer.transform.TransformVector(tangent);
+
+        upVector = splineContainer.transform.TransformDirection(upVector);
+    }
+
+    void OnDrawGizmos()
+    {
+        if (!splineContainer || !deformContainer) return;
+
+        Gizmos.color = Color.green;
+
+        for (int i = 0; i < splineContainer.Splines.Count; i++)
+        {
+            Evaluate(i, 0, 0, out Vector3 position, out _);
+
+            Vector3 oldPosition = position;
+
+            int gizmoResolution = Mathf.CeilToInt(splineContainer.Splines[i].GetLength());
+
+            for (float j = 1; j <= gizmoResolution; j++)
+            {
+                Evaluate(i, j / gizmoResolution, 0, out position, out _);
+
+                Gizmos.DrawLine(oldPosition, position);
+
+                oldPosition = position;
+            }
+        }
+    }
+}

Runtime/SplinePlus.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 41eeb6f8f41efdb4eb29d6db19d12b6c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/josh.spline-importer.asmdef

@@ -0,0 +1,17 @@
+{
+    "name": "josh.spline-importer",
+    "rootNamespace": "",
+    "references": [
+        "Unity.Splines",
+        "Unity.Mathematics"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Runtime/josh.spline-importer.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: aa8af8f66b6c2db4fa61f07958e484b9
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: