diff --git a/Runtime/SplineImporter.cs b/Runtime/SplineImporter.cs index f6902fa..6920002 100644 --- a/Runtime/SplineImporter.cs +++ b/Runtime/SplineImporter.cs @@ -4,187 +4,191 @@ 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 +namespace FrameJosh.SplineImporter { - public override void OnInspectorGUI() + using static SplineImporter; + using static SplineData; + + [CustomEditor(typeof(SplineImporter))] + public class SplineImporterEditor : Editor { - DrawDefaultInspector(); - - if (GUILayout.Button("Import Spline")) + public override void OnInspectorGUI() { - SplineImporter splineImporter = target as SplineImporter; + DrawDefaultInspector(); - splineImporter.name = splineImporter.splineData.name; - - SplineData splineData = JsonUtility.FromJson(splineImporter.splineData.text); - - SplineContainer splineContainer = splineImporter.GetComponent(); - - foreach (UnityEngine.Splines.Spline thisSpline in splineContainer.Splines) - splineContainer.RemoveSpline(thisSpline); - - foreach (SplineData.Spline thisDataSpline in splineData.splines) + if (GUILayout.Button("Import Spline")) { - UnityEngine.Splines.Spline thisSpline = splineContainer.AddSpline(); + SplineImporter splineImporter = target as SplineImporter; - thisSpline.Closed = thisDataSpline.closed; + splineImporter.name = splineImporter.splineData.name; - foreach (ControlPoint thisControlPoint in thisDataSpline.controlPoints) + SplineData splineData = JsonUtility.FromJson(splineImporter.splineData.text); + + SplineContainer splineContainer = splineImporter.GetComponent(); + + foreach (UnityEngine.Splines.Spline thisSpline in splineContainer.Splines) + splineContainer.RemoveSpline(thisSpline); + + foreach (SplineData.Spline thisDataSpline in splineData.splines) { - Vector3 position = PositionToVector(thisControlPoint.position); + UnityEngine.Splines.Spline thisSpline = splineContainer.AddSpline(); - Vector3 handleL = PositionToVector(thisControlPoint.handleL); + thisSpline.Closed = thisDataSpline.closed; - 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() + foreach (ControlPoint thisControlPoint in thisDataSpline.controlPoints) { - 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); + 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) + if (GUILayout.Button("Export Spline")) { - string path = "Assets" + EditorUtility.SaveFilePanel("Save .JSON", "", "New Spline.json", "json").Substring(Application.dataPath.Length); + SplineImporter splineImporter = target as SplineImporter; - if (path.Length > 0) + if (!splineImporter.splineData) { - File.WriteAllBytes(path, Encoding.ASCII.GetBytes("")); + string path = "Assets" + EditorUtility.SaveFilePanel("Save .JSON", "", "New Spline.json", "json").Substring(Application.dataPath.Length); - AssetDatabase.Refresh(); - - TextAsset textAsset = AssetDatabase.LoadAssetAtPath(path, typeof(TextAsset)) as TextAsset; - - splineImporter.splineData = textAsset; - } - else return; - } - - SplineContainer splineContainer = splineImporter.GetComponent(); - - SplineData splineData = new(); - - splineData.splines = new SplineData.Spline[splineContainer.Splines.Count]; - - List dataSplines = new(); - - foreach (UnityEngine.Splines.Spline thisSpline in splineContainer.Splines) - { - List 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() + if (path.Length > 0) { - position = position, - handleL = handleL, - handleR = handleR + 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(); + + SplineData splineData = new(); + + splineData.splines = new SplineData.Spline[splineContainer.Splines.Count]; + + List dataSplines = new(); + + foreach (UnityEngine.Splines.Spline thisSpline in splineContainer.Splines) + { + List 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 }); } - 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(); } - - 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) + [RequireComponent(typeof(SplineContainer))] + public class SplineImporter : MonoBehaviour { - return new(position.x, position.z, position.y); - } + public TextAsset splineData; - public static Position VectorToPosition(Vector3 vector) - { - return new() + public float scale = 1; + + public static Vector3 PositionToVector(Position position) { - x = vector.x, - y = vector.z, - z = vector.y - }; - } -} + return new(position.x, position.z, position.y); + } -[Serializable] -public class SplineData -{ - [Serializable] - public struct Position - { - public float x; - - public float y; - - public float z; + public static Position VectorToPosition(Vector3 vector) + { + return new() + { + x = vector.x, + y = vector.z, + z = vector.y + }; + } } [Serializable] - public struct ControlPoint + public class SplineData { - public Position position; + [Serializable] + public struct Position + { + public float x; - public Position handleL; + public float y; - public Position handleR; + public float z; + } - public float tilt; + [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]; } - [Serializable] - public struct Spline - { - public ControlPoint[] controlPoints; - - public bool closed; - } - - public Spline[] splines = new Spline[0]; -} - #endif +} diff --git a/Runtime/SplinePlus.cs b/Runtime/SplinePlus.cs index 60ecdb5..bbc6906 100644 --- a/Runtime/SplinePlus.cs +++ b/Runtime/SplinePlus.cs @@ -2,194 +2,231 @@ using Unity.Mathematics; using UnityEngine; using UnityEngine.Splines; -public class SplinePlus : MonoBehaviour +namespace FrameJosh.SplineImporter { - public SplineContainer splineContainer; - - public SplineContainer deformContainer; - - public int resolution; - - public void Evaluate(int splineIndex, float anchor, float distance, out Vector3 position, out Quaternion rotation) + public class SplinePlus : MonoBehaviour { - float t = anchor + (distance / splineContainer.Spline.GetLength()); + public SplineContainer splineContainer; - if (deformContainer) - DeformSpline(splineIndex, t, out position, out rotation); - else - EvaluateSpline(splineIndex, t, out position, out rotation); - } + public SplineContainer deformContainer; - public void Evaluate(float anchor, float distance, out Vector3 position, out Quaternion rotation) - { - float t = anchor + (distance / splineContainer.Spline.GetLength()); + public int resolution = 1; - 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++) + public void Evaluate(int splineIndex, float anchor, float distance, out Vector3 position, out Quaternion rotation) { - int resolutionScale = Mathf.CeilToInt(splineContainer.Splines[i].GetLength()) * resolution; + float t = anchor + (distance / splineContainer.Spline.GetLength()); - for (float j = 0; j <= resolutionScale; j++) + 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(int splineIndex, Vector3 point, out Vector3 position, out Quaternion rotation, out float t) + { + position = Vector3.zero; + + rotation = Quaternion.identity; + + t = 0; + + float nearestDistance = Mathf.Infinity; + + for (int i = 0; i < splineContainer.Splines.Count; i++) { - Evaluate(i, j / resolutionScale, 0, out Vector3 thisPosition, out Quaternion thisRotation); + int resolutionScale = Mathf.CeilToInt(splineContainer.Splines[i].GetLength()) * resolution; - float thisDistance = Vector3.Distance(point, thisPosition); - - if (thisDistance < nearestDistance) + for (float j = 0; j <= resolutionScale; j++) { - position = thisPosition; + Evaluate(i, j / resolutionScale, 0, out Vector3 thisPosition, out Quaternion thisRotation); - rotation = thisRotation; + float thisDistance = Vector3.Distance(point, thisPosition); - nearestDistance = thisDistance; + if (thisDistance < nearestDistance) + { + position = thisPosition; + + rotation = thisRotation; + + t = j / resolutionScale; + + nearestDistance = thisDistance; + } + } + } + } + + 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); + + float t1 = Mathf.Clamp(t, 0, 1 - (1 / (float)resolutionScale)); + + Vector3 position0 = EvaluatePoint(splineIndex, t1); + + Vector3 position1 = EvaluatePoint(splineIndex, t1 + (1 / (float)resolutionScale)); + + Vector3 difference = position1 - position0; + + rotation = Mathf.Abs(Vector3.Dot(difference, Vector3.up)) > 0 + ? Quaternion.LookRotation(difference, Vector3.up) + : 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); + + float t1 = Mathf.Clamp(t, 0, 1 - (1 / (float)resolutionScale)); + + Vector3 position0 = EvaluatePoint(t1); + + Vector3 position1 = EvaluatePoint(t1 + (1 / (float)resolutionScale)); + + Vector3 difference = position1 - position0; + + rotation = Mathf.Abs(Vector3.Dot(difference, Vector3.up)) > 0 + ? Quaternion.LookRotation(difference, Vector3.up) + : Quaternion.FromToRotation(Vector3.forward, difference); + } + + Vector3 EvaluatePoint(int splineIndex, float t) + { + ScaledEvaluate(splineContainer, splineIndex, t, out float3 position, out _, out _); + + 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) + { + splineContainer.Evaluate(t, out float3 position, out _, out _); + + 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 OnDrawGizmosSelected() + { + 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; } } } } - - 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); - - float t1 = Mathf.Clamp(t, 0, 1 - (1 / (float)resolutionScale)); - - Vector3 position0 = EvaluatePoint(splineIndex, t1); - - Vector3 position1 = EvaluatePoint(splineIndex, t1 + (1 / (float)resolutionScale)); - - Vector3 difference = position1 - position0; - - rotation = Mathf.Abs(Vector3.Dot(difference, Vector3.up)) > 0 - ? Quaternion.LookRotation(difference, Vector3.up) - : 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); - - float t1 = Mathf.Clamp(t, 0, 1 - (1 / (float)resolutionScale)); - - Vector3 position0 = EvaluatePoint(t1); - - Vector3 position1 = EvaluatePoint(t1 + (1 / (float)resolutionScale)); - - Vector3 difference = position1 - position0; - - rotation = Mathf.Abs(Vector3.Dot(difference, Vector3.up)) > 0 - ? Quaternion.LookRotation(difference, Vector3.up) - : Quaternion.FromToRotation(Vector3.forward, difference); - } - - Vector3 EvaluatePoint(int splineIndex, float t) - { - ScaledEvaluate(splineContainer, splineIndex, t, out float3 position, out _, out _); - - 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) - { - splineContainer.Evaluate(t, out float3 position, out _, out _); - - 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; - } - } - } } diff --git a/Samples/SplineEvaluateDebug.cs b/Samples/SplineEvaluateDebug.cs index f16c719..d4ea973 100644 --- a/Samples/SplineEvaluateDebug.cs +++ b/Samples/SplineEvaluateDebug.cs @@ -1,48 +1,51 @@ using Unity.Mathematics; using UnityEngine; -public class SplineEvaluateDebug : MonoBehaviour +namespace FrameJosh.SplineImporter.Samples { - [SerializeField] SplinePlus splinePlus; - - [SerializeField] float anchor; - - [SerializeField] float distance; - - [SerializeField] float cubeSize; - - [SerializeField] float matrixSize; - - void OnDrawGizmos() + public class SplineEvaluateDebug : MonoBehaviour { - if (!splinePlus) return; + [SerializeField] SplinePlus splinePlus; - splinePlus.Evaluate(anchor, distance, out Vector3 position, out Quaternion rotation); + [SerializeField] float anchor; - transform.position = position; + [SerializeField] float distance; - transform.rotation = rotation; + [SerializeField] float cubeSize; - Gizmos.DrawCube(position, Vector3.one * cubeSize); + [SerializeField] float matrixSize; - splinePlus.splineContainer.Evaluate(anchor + (distance / splinePlus.splineContainer.Spline.GetLength()), out float3 position1, out _, out _); + void OnDrawGizmos() + { + if (!splinePlus) return; - Gizmos.DrawCube(position1, Vector3.one * cubeSize); + splinePlus.Evaluate(anchor, distance, out Vector3 position, out Quaternion rotation); - splinePlus.deformContainer.Evaluate(position1.x / splinePlus.deformContainer.Spline.GetLength(), out float3 deformPosition, out _, out _); + transform.position = position; - Gizmos.DrawCube(deformPosition, Vector3.one * cubeSize); + transform.rotation = rotation; - Gizmos.color = Color.green; + Gizmos.DrawCube(position, Vector3.one * cubeSize); - Gizmos.DrawRay(position, transform.up * matrixSize); + splinePlus.splineContainer.Evaluate(anchor + (distance / splinePlus.splineContainer.Spline.GetLength()), out float3 position1, out _, out _); - Gizmos.color = Color.red; + Gizmos.DrawCube(position1, Vector3.one * cubeSize); - Gizmos.DrawRay(position, transform.right * matrixSize); + splinePlus.deformContainer.Evaluate(position1.x / splinePlus.deformContainer.Spline.GetLength(), out float3 deformPosition, out _, out _); - Gizmos.color = Color.blue; + Gizmos.DrawCube(deformPosition, Vector3.one * cubeSize); - Gizmos.DrawRay(position, transform.forward * matrixSize); + Gizmos.color = Color.green; + + Gizmos.DrawRay(position, transform.up * matrixSize); + + Gizmos.color = Color.red; + + Gizmos.DrawRay(position, transform.right * matrixSize); + + Gizmos.color = Color.blue; + + Gizmos.DrawRay(position, transform.forward * matrixSize); + } } } diff --git a/Samples/SplineNearestPointDebug.cs b/Samples/SplineNearestPointDebug.cs index 3dbf2a0..43a722c 100644 --- a/Samples/SplineNearestPointDebug.cs +++ b/Samples/SplineNearestPointDebug.cs @@ -1,17 +1,20 @@ using UnityEngine; -public class SplineNearestPointDebug : MonoBehaviour +namespace FrameJosh.SplineImporter.Samples { - [SerializeField] SplinePlus splinePlus; - - [SerializeField] float cubeSize; - - void OnDrawGizmos() + public class SplineNearestPointDebug : MonoBehaviour { - if (!splinePlus) return; + [SerializeField] SplinePlus splinePlus; - splinePlus.GetNearestPoint(transform.position, out Vector3 position, out _); + [SerializeField] float cubeSize; - Gizmos.DrawCube(position, Vector3.one * cubeSize); + void OnDrawGizmos() + { + if (!splinePlus) return; + + splinePlus.GetNearestPoint(transform.position, out Vector3 position, out _); + + Gizmos.DrawCube(position, Vector3.one * cubeSize); + } } }