Official Unity Splines

That sounds great! Thanks

 

Another question @ThomasLopez

Do you also open "EditorSplinesUtility.ReverseFlow"?

I have the following scenario:



I build the level with multiple tiles.
Each tile has its own Spline.
Via some code I connect all tiles into a final spline.

That works well until the rotation of a tile leads to being reverse.
As you can see in the picture, the spline, starting from bottom left, flows to the right.
However, in the corner due to rotation of that tile, the flow is being reversed, which is wrong.

To solve that, I can select the corner tile in the editor, then a knot and finally select "Reverse Spline Flow". After that, everything is correct.

It would be nice to do this in the code as well, but the said API ("EditorSplinesUtility.ReverseFlow") is internal. Sure, I can copy it's code but I prefer reusing heavy work due to some maths being involved.

Thanks!

 

Hello. Splines have been working great for me until yesterday. Now instead of creating a single spline with knots when I click, it creates multiple splines that are not connected. Did I change a setting somewhere that I don't know about? How can I return to clicking to add nodes?

 

This package really is a pleasure to use, big fan of the UX.

For a personal project I've prototyped some C^2 continuous splines that others might find useful:

• B-Splines: https://github.com/Ohmnivore/com.not-unity.bsplines
• Yuksel Splines (C^2 & interpolating ): https://github.com/Ohmnivore/com.not-unity.yuksel-splines

 

I'm not seeing Splines 2.3 for Unity 2022.3.1f1 LTS as an update available in the Package Manger. Am I missing something? Was this update withdrawn?

 

So one thing that's been bugging me for ages about the spline package and how it integrates with my code is that it thinks we care about splines. We don't - users don't care about splines, I don't care about splines, what we care about is the path we are making in the terrain, the road, the way a camera or car might move down a path, etc. So the current workflow for editing, say, a road is:

- Select the road from the hierarchy
- Find the tool bar and select the game object and switch it to spline edit mode
- Now you can see the spline, find the knot on it you want to edit
- Make sure you select the knot and not the tangent
- Move the knot

If you want to add a new knot, then you have additional steps to change into the add more, or SplineData<T> edit mode, etc.

This is basically a lot of mode shifts, and makes the editing feel clunky. What I want is:

- User selects knot on the road and moves it.

What this means:

- The spline tool is set to always show the knots
- There is no mode shifts involved, selecting a knot means you want to edit it, like any other object you'd edit in Unity

I want to edit the "road", not the spline. I want to move the roads control points, not the splines. The spline is just the mathematical construct behind resolving these needs, not the need itself.

I also want the knots being created or edited to make sense within the context they are used. For instance, I don't want my road to roll 45 degrees around the spline creating an impossible bank, I want it flat or within the parameters of what a normal road is. I could interpolate the data of the spline to disallow roll, but what I really want is to allow it, but only when the user wants it, not when they just click out a path and get it by accident.

What we're currently experimenting with to combat this:
- Drawing selectable knots over the spline's control points ourselves
- When the user selects the (fake) knot, we pass through to select the spline knot and putting the user into spline edit mode for that knot. This has the bonus of not accidentally selecting tangents.
- When the user adjusts a knot (the actual spline one), we apply various post processing filters to it to prevent roll (which can be disabled)

What we run into issues with:
- Various bits of the editing API being sealed or private
- We're essentially rewriting large parts of the editor framework
- Eventually we might have to replace the whole thing if there are issues we can't find a way around.
- All this hoop jumping takes a lot of development time
- I have already spent more time on trying to work around spline issues than it would have taken me to write a spline package for my needs.

When you extrapolate this out to other potential tools we find similar kinds of issues. If we were creating a camera path, we'd want to do that from the camera's point of view, not from a spline in the scene so much. We'd want to avoid certain types of data in our spline (roll), or easily prevent things like crinkles in the spline path caused by tangent shifts. A small thing like that can have a huge affect on the experience but not be easily seen in the spline, and difficult to edit out.

So what I'd like to see:
- Continue to open up the API so we're not fighting with it.
- Try to view the spline system as something we use for a greater reason, not for the sake of the spline, and build out ways to customize and filter the data easily for such things.
- Extendable knot data. Ideally my splines never have roll unless the users want it, so they turn off "roll protection" on the knots they want to allow it for. (This might be able to be done with SplineData<T>, but sounds like a synchronization nightmare).
- Make it possible to easily reduce modality- I don't want spline edit mode, add point mode, 4 spline data modes, etc. I want road editing mode, and camera path editing mode, etc. I want control over when data is drawn, so I can draw the knots at all times, but not the handles (maybe the pass through trick is right here, but some settings for what the spline draws when unselected or selected would be way simpler). I want to be able to get the user to whatever mode they need to be in from script instead of having to teach them 7 steps to get there.

 

After further reviewing of this topic. Looks like Curvy Splines 8 is the best unofficial option for Unity spline manipulation, even if there is an extra cost. Thanks Unity for the splines feature. We have that as a fallback for now. We are also looking forward to watching that package mature.

 

Any examples of this stuff being used yet? I've noticed a bunch of new API calls, but the docs are pretty thin on how these are supposed to be used.

So what I am doing now is just post processing out the roll when a spline is edited - as an option (users can turn it off on the cases where they want roll). This works well, but obviously the user can still attempt to roll the spline by rotating the knot. In an ideal world that wouldn't be possible but this is good enough for now at least.

For direct manipulation, I'm using gizmo's to draw my own control points:

Code (CSharp):

1. static GizmoType splineEditMode = GizmoType.Pickable | GizmoType.Selected | GizmoType.Active | GizmoType.InSelectionHierarchy;
2.  
3.         [DrawGizmo(GizmoType.Active | GizmoType.Pickable | GizmoType.NonSelected | GizmoType.Selected)]
4.         static void RenderExtraGizmo(Road editorTarget, GizmoType gizmoType)
5.         {
6.             if ((gizmoType & GizmoType.Pickable) == GizmoType.Pickable || gizmoType == splineEditMode)
7.             {
8.                 SelectSpline(editorTarget.splineContainer);
9.             }
10.  
11.             SplineContainer splineContainer = editorTarget.splineContainer;
12.  
13.             if (splineContainer == null)
14.                 return;
15.  
16.             Color prevColor = Gizmos.color;
17.             Gizmos.color = new Color(0, 0, 1, 0.5f);
18.             foreach (Spline spline in splineContainer.Splines)
19.             {
20.                 if (spline.Count > 0)
21.                 {
22.                     for (int i = 1; i < spline.Count; ++i)
23.                     {
24.                         Gizmos.DrawSphere(splineContainer.transform.TransformPoint(spline[i].Position), 0.5f);
25.                     }
26.  
27.                 }
28.             }
29.             Gizmos.color = prevColor;
30.         }

and when the user clicks on one, I do:

Code (CSharp):

1. static void SelectSpline(SplineContainer spline)
2.         {
3.             if (spline != null)
4.             {
5.                 Selection.activeGameObject = spline.gameObject;
6.                 ActiveEditorTracker.sharedTracker.RebuildIfNecessary();
7.                 ToolManager.SetActiveContext<SplineToolContext>();
8.                 ToolManager.SetActiveTool<SplineMoveTool>();
9.                 //EditorSplineUtility.SetKnotPlacementTool();
10.             }
11.         }

However, while this lets me click on the gizmo and get right into spline move mode, I can't seem to get it to let me click on a different spline's gizmo as it won't trigger the click on the gizmo while in spline edit mode. And obviously I'd prefer better handling than this hack - being able to click-drag to go directly into add point mode and dragging out a new knot, for instance. Handles would give me that, but they don't show up when the object is not selected. Is there something new in the 2.3 API that can help here?

 

Also, I would love the ability to shut off the users capability to create multiple splines in one spline container. In my current use case, there is no valid reason to do this, as splines should never intersect or share points but rather get constructed between game object based anchor points.

 

How can I get the normalized time of a given knot? I thought I could iterate over the knots/length like this:

Code (CSharp):

1. float len = splinePath.GetLength();
2. float runningTotalLen = 0f;
3. for (int i = 0; i < splinePath.Count; i++)
4. {
5.        data[i].normalizedTime = runningTotalLen / len;
6.        runningTotalLen += splinePath.GetCurveLength(i);
7. }

to build an array of knot times, but in my tests I've found this to be not entirely accurate. The results are slightly off, but I need a more accurate result for what I'm trying to do.

I want to make a SplineAnimate follow the path, but stop exactly on each point for a short delay. I do this by setting the SplineAnimate.NormalizedTime when it passes the time I calculate using the above code. In testing, the SplineAnimate is stopping shortly after the position of the knot, so I think the calculations above are returning inaccurate results.

Is there an API way to get an accurate normalized time of a knot?

 

Thanks for the help, Thomas. As some feedback for splines, I think that method is a bit confusing, especially in terms of the docs. I saw it before I posted asking for help, and had dismissed as not what I was looking for. In the docs, the parameter 't' is described as "Interpolation in the original PathIndexUnit". This made me think it was only useful for converting between normalized values, I never considered that a float value could be passed in as a knot index.

Overall, I think making some well-named wrappers for more common functions (like getting the normalized time of a knot), and adding them to the SplineUtility class would be useful for people that don't have an in-depth knowledge of spline terminology.

 

The gizmo approach would work, except when you go to select a different spline while in spline edit mode via this method you don't get a gizmo callback for clicking on the gizmo, because it's not triggered while you're in spline edit mode. So right now it feels great to get into editing, but once you're in edit mode you feel a little trapped to that spline until you realize you have to exit spline edit mode and then select another spline from game object mode.

Thanks for taking the time to write this! So if I understand correctly, this gets run regardless of if the spline is selected or not, but then I basically have to rewrite all the spline rendering and manipulation controls myself? That seems like a lot of potentially changing code to replicate with splines still in development - is there any way I can fall through to the existing code for 90% of it?

Once your in edit mode the spline controls work fine- the issue is that if you go to select a different spline via it's gizmo, the gizmo code does not get triggered so the selection is ignored. The work around is to go back to game object mode, then select the other spline, which is clunky.

 

How should I apply the NormalizedTime value of the SplineAnimate component, when using PingPong loop type?

I've noticed that during the 'forward' part of the ping-pong, setting the NormalizedTime value works as expected. However, during the 'reverse' half of the ping-pong, setting NormalizedTime makes it start moving forward again, but I want it to continue on its reverse direction. Is there some trick to making it remember that it's in the back half of the ping-pong?

 

I seem to be missing some basic spline tools from my tool bar. I only seem to have the draw spline tool and width (if available). I tried updating my spline package from 2.2.1 to 2.3.0 along with samples but change. I'm unable to add knots to existing splines which is pretty crippling.
I recently upgraded the project from 2021 LST to 2022 LTS.
Any ides what might cause this or how to enable the other tools?

 

Thanks for your help. For information purposes, what I needed it for is this: I'm making a system where a platform moves along a linear spline, but has the ability to stop and wait at various knots along the spline. The issue was, it needs to stop precisely at the knot point, of course the animator would overshoot a varying amount depending on frame rate. So I am using NormalTime to "teleport" it back a tiny amount, then pause it, so it stays in the perfect position.

After looking at your code example and experimenting, I've reduced it to:

Code (CSharp):

1. splineFollower.NormalizedTime = desiredNormalizedTime + (splineFollower.NormalizedTime >= 1f ? 1f : 0f);

The NormalizedTime value is very odd for ping pong loops. The first half runs from 0-1 (makes sense), but the second half runs from 2 to 1 (unexpected!).

Also, it would be great if we could set MaxSpeed to negative numbers (or maybe set a boolean) to reverse the direction of the SplineAnimate movement.

 

I am currently using ElapsedTime to control the behavior of an GameObject in the scene. However, there is a bug in which ElapsedTime being set to 0 after being set to the max time, places the GameObject at the end of the spline instead of the start. This issue is easily replicable by setting the value manually in the Editor. This issue also occurs in script.

 

Awesome.

 

@ThomasLopez

I think I've tracked down why I was seeing values going from 2 to 1 in the back half of a ping-pong.

In my code, I was making the SplineAnimate wait at the last knot in the spline, and to do this I was setting the NormalizedTime to 1f to set a precise location. I think the issue then lies on line 542 of SplineAnimate.cs, at the end of the CalculateNormalizedTime(float deltaTime) method...

Code (CSharp):

1. m_NormalizedTime = Mathf.Floor(m_NormalizedTime) + t;

This line is setting m_NormalizedTime to 2f only when it is already exactly 1f. 99% of the time this would never happen, but I made it happen every time.

 

I need help understanding if this is expected behavior or a bug (2022.3.2f1 LTS, Spline V 2.2.1). I have made a test script to illustrate my issue.

Spoiler

Code (CSharp):

1. using System;
2. using Unity.Mathematics;
3. using UnityEngine;
4. using UnityEngine.Splines;
5.  
6. public class SplineTest: MonoBehaviour
7. {
8.     [NonSerialized]
9.     Spline spline;
10.     private void OnDrawGizmos ()
11.     {
12.         var container = GetComponent<SplineContainer> ();
13.         if (container == null)
14.         {
15.             container = this.gameObject.AddComponent<SplineContainer> ();
16.             container.Spline.Add (new BezierKnot (new float3 (1f, 0f, 0f)));
17.             container.Spline.Add (new BezierKnot (new float3 (0f, -10f, 0f)));
18.             container.Spline.Add (new BezierKnot (new float3 (0f, -25f, 0f)));
19.             container.Spline.Add (new BezierKnot (new float3 (-1f, -47f, 0f)));
20.             container.Spline.Add (new BezierKnot (new float3 (0f, -100f, 0f)));
21.             container.Spline.Add (new BezierKnot (new float3 (10f, -100f, 0f)));
22.             container.Spline.Add (new BezierKnot (new float3 (20f, -100f, 0f)));
23.             container.Spline.Add (new BezierKnot (new float3 (30f, -100f, 0f)));
24.             container.Spline.Add (new BezierKnot (new float3 (30f, -100f, 10f)));
25.             container.Spline.Add (new BezierKnot (new float3 (30f, -100f, 20f)));
26.             container.Spline.Add (new BezierKnot (new float3 (30f, -100f, 30f)));
27.             container.Spline.Add (new BezierKnot (new float3 (30f, -90f, 30f)));
28.             container.Spline.Add (new BezierKnot (new float3 (30f, -60f, 30f)));
29.         }
30.  
31.         var spl = container.Spline;
32.         bool init = false;
33.         if (spline == null)
34.         {
35.             spline = new Spline ();
36.             init = true;
37.         }
38.         float3 center = transform.position;
39.         //Quaternion rot;
40.         for (int iB = 0; iB < spl.Count; iB++)
41.         {
42.             BezierKnot curveKnot;
43.             float3 dir1, dir2;
44.             float3 current = spl[iB].Position;
45.             if (iB == 0)
46.             {
47.                 dir1 = math.normalize (spl[iB + 1].Position - current);
48.                 dir2 = -dir1;
49.             } else
50.             {
51.                 dir1 = math.normalize (current - spl[iB - 1].Position);
52.                 dir2 = -dir1;
53.             }
54.  
55.             curveKnot = new BezierKnot (current, dir1, dir2);
56.  
57.             if (init)
58.             {
59.                 spline.Add (curveKnot);
60.             } else
61.             {
62.                 spline[iB] = curveKnot;
63.             }
64.         }
65.  
66.  
67.         float3 position, tangent, upVector;
68.         spline.Evaluate (0f, out position, out tangent, out upVector);
69.         float3 prevPosition = (float3) transform.position + position;
70.         for (float i = 0; i <= 1f; i += .01f)
71.         {
72.             spline.Evaluate (i, out position, out tangent, out upVector);
73.             position = position + (float3) transform.position;
74.  
75.             Gizmos.color = Color.green;
76.             Gizmos.DrawLine (prevPosition + 1f, position + 1f);
77.             if (float.IsNaN (upVector.x))
78.             {//We have a NaN value, output something to illustrate bad region
79.                 Gizmos.color = Color.red;
80.                 upVector = new float3 (3f, 3f, 3f);
81.             } else
82.             {
83.                 Gizmos.color = Color.blue;
84.             }
85.             Gizmos.DrawLine (position + 1f, position + upVector + 1f);
86.             prevPosition = position;
87.         }
88.     }
89. }
90.  

Basically, every time that multiple knots are directly vertical of each other, the value of upVector from

spline.evaluate(t, out position, out tangent, out upVector)

results in a NaN float3 (Illustrated in my screenshot with diagonally outwards red lines).

To me this reads as a bug for the following reasons.
1) the upVector isn't up, so there shouldn't be some non vector/divide by zero mathiness going on as far as I know.
2) I can concieve of some expected value to be output for upVector (in this case, something like

new float3(1f, 0f, 0f)

but really anything perpendicular to that axis would probably make sense).
3) upVector isn't a useful value to use if it sometimes returns NaN.

Is this expected output? If so, what should I be doing to mitigate this.

In my case, I'm building a somewhat tube shaped mesh following a spline, and using the upVector multiplied by a changing radius and then rotated a discrete number of times around that position in order to offset my spline from the center position given by my position spline.

If my tube is pointing directly downards nothing gets generated due to NaN vectors.

 

This is an observation...the SplineContainer's EvaluatePosition (2022.3.1f1) call allocs 32B of GC for every call. I know that isn't much but over time with several entities traveling over splines things can get dodgy.

 

Getting in to using the Spline tool more. Unity has needed something like this for a long time.
My primary focus right now is VFX. Splines come in handy for all kinds of effects.

I have this stylized flowing water shader applied to the extruded mesh of a spline. I'm noticing the UVs are not normalized, something very useful to have for shaders.




In the images above, the blue should automatically scale to the end, but it's dependent on the length of the spline. Could this information be provided in another channel?

The length could be baked in, allowing it to be used for normalizing the UV in the shader, or other things as well. It could be passed in manually, but it feels like it should be available somewhere.

 

SplineAnimation not ready for use on start.
I want to make some configs on start and then invoke Play, but it not working.
It begin work only on next frame.
example

Code (CSharp):

1.     public class WagonAnimation : MonoBehaviour
2.     {
3.         [field: SerializeField] public float DistanceBetween { get; private set; }
4.  
5.         [SerializeField] private SplineAnimate _splineAnimate;
6.  
7.         private void OnValidate() => _splineAnimate = _splineAnimate ? _splineAnimate : GetComponent<SplineAnimate>();
8.  
9.         private IEnumerator Start()
10.         {
11.             yield return null;
12.             Activate();
13.         }
14.  
15.         public void Activate()
16.         {
17.             var length = _splineAnimate.Container.CalculateLength();
18.             var totalTime = _splineAnimate.Duration;
19.             var firstWagon = transform.parent.GetChild(0).GetComponent<WagonAnimation>();
20.             var index = transform.GetSiblingIndex();
21.             _splineAnimate.ElapsedTime = Time.time + index * (firstWagon.DistanceBetween / length) * totalTime;
22.             _splineAnimate.Play();
23.         }
24.     }

Spline v2.2.1

p.s. it happens only on scene start, other game objects which started after working correctly

 

I have worked around this issue by checking if upVector is NaN, then I do

upVector = cross(tangent, new float3(0,0,1));

I still feel like I shouldn't have to be doing this. Am I crazy?

 

Also noticing when copy-pasting a spline, it will constantly revert back and forth between the original and any changes you make. Seems like it's not letting go of a reference.



^Notice the spline shape doesn't match. The straight cylinder is what I copied and started modifying, and I was sure to change the references, too.



^When I hit play, or toggle the extrusion, it fixes itself.



A closer look at the assigned Spline (which is correct, and updated to the copy).




Even though the Spline that is assigned to Spline Extrude is correct, as it's the new copy, the mesh seems to swap back and forth anyways. The geometry doesn't update if you animate the extrusion range, either.

 

Amazing stuff. Can't wait to see what you do with splines and particles!

@Unity, in "fixing" this, could you provide both: referenced copies and unique copies? That way we can do fancy animations by changing the origins and rotations of replicants and animating one of them, or all of them.

EDIT: Addendum.

for the newer workers at Unity, or those that have worked primarily in code, this guy: @Mirza-Beig is one of the greatest exponents of visual effects and training in how to use visual effects within Unity, and has been for quite some time. His works are truly inspiring and educational, and often right at the cutting edge of what's been possible with Unity. He is not your average Unity user: https://www.youtube.com/c/MirzaBeig

If he's intrigued by inbuilt splines, there's probably lots of very good reasons for that, and enormous potential about to be unleashed. So please take any suggestions or improvements ideas he has under very serious consideration, as we'll all benefit from them.

Thank you, Mirza. Have learnt a lot from you!

 

Alhamdulillah. And I didn't even remember that account! Must have been around the time I started using Unity myself. For reference, I'm just creating a visual step-wise tutorial for spline-based shaders (flow), like this stylized 'stream' of water. It could just as well be a laser.





While the extrusion range works in the editor, it doesn't work at runtime if animated via an animator/animation clip.



Combined with the issue of the UVs, it limits what can be done in terms of VFX. With the updated UVs, at least I could clip the geometry in the shader itself (likely faster, because the geometry can be static at this point), but the extra complexity from having to pass the length manually is not intuitive.

Currently using Unity 2022.3.0 with Splines 2.3.0 added from the manager by name.

 

I have a very interesting use of the spline package. Perhaps more developments are possible in the future.
To do so, the following are the functions necessary for spline, which I felt while using the spline package.

1. Components that procedurally create meshes or objects, such as <SplineInstantiate> and <SplineExtrude>, must have a function such as Apply() as a C# API and inspector button. <SplineInstantiate> will expose the instances in a hierarchy view. And <SplineExtrude> will save the created mesh as an asset. Of course, when the work is done, the existing component should be removed or disabled.

2. The rotation offset function of <SplineInstantiate> requires snapping. If you have a rect column, you might want to snap the y angle to 90 to properly avoid repeating.

3. <SplineExtrude> must support various shapes, not just simple tube shapes. One of the spline samples already has a custom script that draws roads, but it looks like it needs to be integrated into <SplineExtrude>.

4. The decal must be rendered along the spline. This is very useful for detail work, such as drawing Pavestone on a bumpy terrain, or drawing long tire skidmarks.

5. At each point on the spline, not only the tangent, but also the direction of the normal must be exposed as a vector. If a point is perfectly vertical on flat ground, the normal of it would be (0, 1, 0). This is more intuitive than dealing with tangents. And should be able to edit the normals of all points at once.

Thanks to everyone developing splines for their hard work.
I hope that good features will continue to be updated in the future.

 

Hello
I want the prefabs with spline instantiate to always move in the direction I choose, how can I do that? thank you...

 

@jbooth posted a very interesting article about (Unity) Splines:

https://medium.com/@jasonbooth_86226/optimizing-spline-operations-d48b5f8fede4

 

Optimizations for SplineUtility- I'd submit a bug, but QA would just bounce it unless I shoot a video about it. And you don't take git PRs, so..

Code (CSharp):

1.             var currentPos = spline.EvaluatePosition(fromT);
2.             resultPointT = fromT;
3.  
4.             var forwardSearch = relativeDistance >= 0;
5.             var residual = math.abs(relativeDistance);
6.             float linearDistance = 0;
7.             float3 point = spline.EvaluatePosition(fromT);

You sample evaluate spline twice here, when the same value is used in either case.

Code (CSharp):

1. if (resultPointT > 1f) //forward search
2.                 {
3.                     resultPointT = 1f;
4.                     point = spline.EvaluatePosition(1f);
5.                 }
6.                 else if (resultPointT < 0f) //backward search
7.                 {
8.                     resultPointT = 0f;
9.                     point = spline.EvaluatePosition(0f);
10.                 }
11.  
12.                 point = spline.EvaluatePosition(resultPointT);

Again, you call evaluate position twice when you don't need to. Just setting resultPointT is enough.

 

Hi everyone,

I'm trying to find a way of being able to move items that are instantiated on the spline around the spline itself, similiar to how a gameobject with Spline Animate works.

I've tried adding the Spline Animate component to those items, but no luck (also tried making the an item a prefab)
For that matter, how would you give the Instantiated Items colliders etc? I'm getting up to speed with DOTS so I take it that item instantiates are rendered through the ecs renderer and don't work like GameObjects?

My second idea is to get the positions from the instantiates and then instantiate prefabs in the positions with all the desired components. Although that feels unncessarily complex. Could someone point me to the right APIs if that is in fact the way to go?

 

Sory if it's a stupid question but how to rotate the whole spline using C# to make it copy the transform rotation? There's no way to make it work in Local space instead of World space?