Feedback Splines Feedback

A few things after using the package for a bit.

• As mentioned, the gizmos don't always update. Looks like an issue with the cache table in SplineGizmoUtility.
• NativeSpline should have an job Dispose method: `JobHandle Dispose(JobHandle inputDeps)`
• When using the spline tool, it's annoying selecting points in Bezier mode (without their tangents) in order to move a groups of points. All selection operations operate on all elements, so it can be hard to grab what you want, especially on a large spline. Maybe separate modes or have alternate selection modes with modifier keys?
• There's currently no way to modify a group of points or tangents at the same time. I want to be able to select 5 points and zero out their Y positions for example.
• The only way to reset the tangents on a point back to "auto" is to reset the whole spline back to Catmull Rom. There should be a button that can recalculate tangents for a selection of points.

Overall it's pretty nice to work with though!

 

Just tried Unity's native spline solution... First thoughts? It's pretty good!
Most of my issues we're already voiced in this thread, but one thing I absolutely want/need is a 2D mode.

In 2D Mode:

1. All 'knot' rotations are constrained to an orientation that makes sense for 2D (e.g. rotated 90 degrees in the Y axis).
2. Tangent handles have their x-axis positions locked to zero.
3. 'Knot' positions have their z-axis positions locked to zero.

Heck, you probably could even generalize the system into entirely optional sets of toggles that would constrain the spline in different ways for different use cases. (e.g. force 'knot' roll to always face 'up', constrain 'knot' positions on any world axis, constrain tangent handles to certain axes only, etc).

 

Hi,
Thanks Unity for the spline system, loving it so far!!

btw, @kaarrrllll would it be possible to add a scale attribute to each knot, so that they could be modified by the standard scale tool? It would be great to access this value from other scripts. For example using per knot scale to control the width of roads.

A future request might be to attach arbitrary data per knot, but having the scale attribute would be a huge benefit in the short term.

Thanks for any info on this request!

 

Hi,
Great tool!

@kaarrrllll .
I use the SplineAnimate component.
I change the speed at runtime.
If I change the speed from 5 to 10, the object will immediately spring further on the spline.
If I change the speed from 5 to 2.5, the object will immediately spring backward on the spline.

It's not practical for real-world scenario (for exemple : a runner on a road).

Any idea how to change this behaviour?

Best,

Vincent

 

A bit dissapointed by the look of splines in the latest package. Looking way noiser than before with all this rings. I get that you wanted to better show the 3d rotation of knots and it's ok, but can you revert tangents gizmo to circle again as it was before? I see no point in them of being rings, it's just visual noise(and they hurt my eyes with how they aliased). So my suggestion to change this

to this:

 

Anyone else having issues with Undo/Redo? We have a script that has an spline variable. It is an ISplineProvider to enable the spline editor.

All works fine generally, but things seem to go wrong when you duplicate the object. I delete all the knots on the duplicated objects, add some new ones, move some around, and when I press Ctrl + Z to undo, say, a move operation, a whole bunch of the knots snap to 0,0,0, and the rest snap back to where they used to be before I deleted the knots.

 

I'm really into this spline tool, but I have this one issue that's really hanging me up. I'm trying to utilize the SplineData class with custom struct data, but the UI fails to render. It looks like the SplineDataPropertyDrawer is assuming that the custom struct I am using is only 1 singleLineHeight. This makes it impossible to use in the editor. I'll have to create custom property drawers that reduce the fields to one line for any data point types I want to expose.

Maybe there is a better way to do this?

Using Splines package Version 1.0.1 in Unity 2021.3.5f1

 

Another request. It would be great to set a per-spline color. Splines are helpful for all kinds of in scene debugging, also it gets confusing when there are a lot of overlapping splines..

 

I'm trying out the Spline tool and have run into a few issues.

I have a spline (AutoSmooth) generated at runtime and then in script attempting to change a single knot from AutoSmooth to Mirrored and then set its In & Out tangents, the curve refuses to update it's tangents.
Is there some voodoo that I'm missing as it's possible via the visual tools?

 

It would be useful to make the following method in SplineUtility public:

Code (CSharp):

1. static float3 EvaluateUpVector<T>(this T spline, int curveIndex, float curveT) where T : ISpline

Also, it would be useful to have a NativeSpline constructor that takes a NativeArray<BezierKnot> or such as an input. I'm very new to unity, so might misunderstand things, but as far as I can see at the moment, there seems to be no way to construct a native spline from a job?

On a very related node, it would be useful to have some utility to subdivide a spline. I think the current functionality to create meshes/extrude splines all work on sampling. I've implemented simple subdivision to make sure my created vertices are within a configurable error bound to the actual spline, which I think would help to generate lower poly meshes. I'd guess that'll be a relatively common use case too, so maybe worth adding something like this to the library.

 

Hi @kaarrrllll , I'm trying to manipulate the spline's knots by code in the editor. Using package version 1.0.1 and Unity 2021.3.2f1. It renders with the updates in the scene view. But as soon as I press play the changes are overwritten by some old version (sitting in the cache somewhere?).

I've tried to manipulate the spline directly by using the array accessor:

Code (CSharp):

1. spline[index] = new BezierKnot(...);

and by clearing the whole thing, then adding the new Knots:

Code (CSharp):

1. spline.Clear();
2. spline.Add(new BezierKnot(...));

and by setting the _splineContainer's Spline property afterwards:

Code (CSharp):

1. var copy = _splineContainer.Spline.ToArray();
2. _splineContainer.Spline = new Spline(copy, _splineContainer.Spline.Closed);

It seems I need to interact with the SplineContainer's Inspector, e.g. by toggling the Closed property for the changes to persist.

Edit: 3 Minutes later. Setting the SplineContainer dirty works wonders:

Code (CSharp):

1. UnityEditor.EditorUtility.SetDirty(_splineContainer);

Maybe the container could detect when the spline is dirtied automatically?[/code]

 

More of a general C# implementation question. But your SplineUtility extension methods use generics:

Code (CSharp):

1. public static bool Evaluate<T>(this T spline, float t, out float3 position, out float3 tangent, out float3 upVector)
2.     where T : ISpline

These are implementations, so not sure what value the generics add and why not just extend ISpline? Curious on the thinking of requiring generics.

 

Hi, newbie here. Currently having issues with SplineInstantiate component. Assigning GameObject to ItemsToInstantiate list does not render the objects along the spline. On sample scene the meshes are rendered but once the GameObject in ItemsToInstantiate is changed same old meshes are still rendered. Tried clearing and regenerating with provided action buttons but to no success, tried Ctrl+R also. Anyone else having similar problem?

Using Unity 2022.2.0b7.2193 with Splines 2.0.0-pre.2

 

This happens for me as well. The only way to get something to work is to copy it's component from the example scene, any newly setup component fails to work.

 

I'm curious if there's a way to add a callback to a spline for changes. i.e. splineContainer.onValidate += MyCustomHandler. I have a custom editor for objects, where each object may have any number of spline containers referenced, so when I select a spline and edit it, I'd like my editor to instantly know that a specific spline was changed, rather than what I'm currently assuming I'll need to do (either periodically checking each reference with EditorUtility.IsDirty, or storing copy of data and comparing). Or.. if there's a way to do that already for anything, knowing how would be even better
Edit: I was able to solve this for now.. though it's not ideal.

Spoiler

..by making splines children of the object, adding a component to each spline, which gets the object in parent and then adds itself to a nonserialized .modifiedSplines List property of that if not already in it.. then, in the custom editor window's SceneView.duringSceneGui call, if that object's list isn't empty it applies any necessary changes and clears the list. However, I'm currently using OnDrawGizmosSelected, which means I'm applying any changes to the object every time the SceneView updates while the spline is selected or being edited, regardless of whether anything was actually changed. Anyway.. it'll do until someone knows/shares a way to get a callback on changes to a spline to fire in a custom editor window.

Edit: Found a spline.changed event (which was what I asked about re .onValidate thing), but it says deprecated
Edit: What I ended up going with was cloning the package, removing sealed from the SplineContainer class and changing OnSplineChanged to protected virtual. In my component I override that and call base.OnSplineChanged then flag the component as changed for my editor. So this gets me the callback I needed. But if it can be done with vanilla package I would prefer to know how, vs. having to do this again when updating to newer releases.

 

How can I add new nodes at the beginning or the end of a spline without creating anew one? And how can I insert nodes into an existing spline?

 

Hmmm. Thanks. Not sure I follow that. Wouldn't

Code (CSharp):

1. public static bool Evaluate(this ISpline spline, float t, out float3 position, out float3 tangent, out float3 upVector)

constrain the generic type? Or does this have to do with the C# to C++ layer that Unity uses?

 

The issue is that if

ISpline

is a value type it will be boxed and as a result allocate memory (for the boxing object.)

 

Great. Thanks. That makes sense.

 

How can I get t on the spline for a given BezierKnot / knot index?

 

Feature request: Subdivision with an API. Should be on the entire spline and also over selected knots. I coded it myself, but would be nice to have in general.

 

Feature request: Proportional knot movement with falloff curve, similar to how Blender has it

 

Is there a way to use 'V" (i.e. snap to vertex) when using the 'knot placement' tool @kaarrrllll / @gabrielw_unity ? I can roughly place knots where I need them and then go back through and snap them, but it would be way more efficient to do it in the first pass?

 

Feature (or bug). Selecting a knot in the editor should select the knot in the Inspector and vice versa.

 

How can I get the selected knots? SplineSelection.cs isn't public.

 

Splines 2.0 in the package manager does not compile- it's missing some colors for the UI. (tried in fresh project, etc. 2022.2b8)

 

Figured it out myself. You go into spline edit mode, then click on that "add" icon and then click on the node you wish to extend from, ie first or last. Like so:

Inserting is similar, but you click on the spline itself, ie at the insertion point

 

BTW, are there any plans to make spline width more of a visual thing? A lot of components want it (rivers, paths, roads, etc), but having it tucked away in a separate, numbers only interface is really limiting since you have to line up the knot numbers and edit a field instead of just dragging a handle.

 

Seems fixed with the 2.0 version of the Splines and Unity 2022.2b

 

Thanks, I combined MicroVerse and its Spline usage with River Auto Material. I'm not aware of other assets that use the new Unity Splines, but MicroVerse really is something to show them off with

 

Actually, that's exactly what I'm looking for. Thanks!

Keeping the spline separate from add on data makes a lot of sense, but I think both this and LoftMesh should be elevated from the samples into the main package (much like SplineInstantiate is). I can copy them into my own project and add new compute buffers for them, etc, but I suspect the concept of width and creating a mesh to be pretty common use cases, and this way lots of different assets can rely on those components being available.

For instance, if I buy a road asset, and an AI asset that does cars which try to stay on a track, both of which use a copy of the width component, you'd have a potential collision, or if separately namespaced multiple potentially incompatible versions, etc.. Or people having to install the samples which seems a bit off.

 

@gabrielw_unity Any plans to include script for bending user meshes by spline? I think it's also a common requirement

 

Can you elaborate on 'greyboxing tools'!? Is this ProBuilder related or something else?

 

Also the spline width component doesn't properly handle multiple splines in the container, instead it only works for the last one in the Splines list.

 

I want to add a script on the spline to add a position according to certain game objects.

Since there can be multiple splines in one spline object and in each splines are multiple knots.
Do I have to find a right spline first and add a knot there? if so can I get an example of script adding a knot with certain position to a spline

 

There seem to be no examples or cases where multiple splines are handled. Even iterating over the spline list and calling the editor functions on them only works for the last spline in the list, and SplineSelection is a private class so not something I can use without reflection. I would expect that changing OnToolGUI to loop through the splines would work:

Code (CSharp):

1.  
2. public override void OnToolGUI(EditorWindow window)
3.         {
4.             var splineDataTarget = target as SplinePath;
5.             if (splineDataTarget == null || splineDataTarget.spline == null)
6.                 return;
7.  
8.             Undo.RecordObject(splineDataTarget, "Modifying Width SplineData");
9.  
10.             // loop through all splines and draw the editors, not just the first one
11.             foreach (var spline in splineDataTarget.spline.Splines)
12.             {
13.                 SplinePath.SplineWidthEntry e = splineDataTarget.FindSplineWidths(spline);
14.  
15.                 var nativeSpline = new NativeSpline(spline, splineDataTarget.spline.transform.localToWorldMatrix);
16.              
17.                 Handles.color = Color.blue;
18.                 m_DisableHandles = false;
19.  
20.                 //User defined handles to manipulate width
21.                 DrawDataPoints(nativeSpline, e.knotWidths);
22.  
23.                 //Using the out-of the box behaviour to manipulate indexes
24.                 nativeSpline.DataPointHandles(e.knotWidths);
25.             }
26.         }

But it does not- only the last spline in the list can have data points added to it. And since there's no concept I can find to get access to which spline in a container the user is interacting with, I can't just show the editor for that spline. Is it possible within the current framework to make the tools/SpineData components work with multiple splines in a container? Because it's not really seeming like it.

Also, it would have been nicer if SplineData had some way to identify which spline it's associated with. Currently I'm storing them in a little List<Holder> with a reference to the spline it belongs to, which I then have to synchronize in my editor (ie: Remove when a spline gets deleted, etc). It works, but feels like multiple splines were not really thought about when writing any of this.

 

Also, how am I supposed to identify a SplineData with one of the splines inside the Spline Containers spline list? Spline itself is just a class wrapper around List<BezierCurve>, so if you create some kind of class like:

Code (CSharp):

1. [System.Serializable]
2.         public class SplineWidthEntry
3.         {
4.             public Spline spline;
5.             public SplineData<float> knotWidths = new SplineData<float>();
6.         }

and then some function like:

Code (CSharp):

1. public SplineWidthEntry FindSplineWidths(Spline s)
2.         {
3.             foreach (var se in splineWidths)
4.             {
5.                 if (Object.ReferenceEquals(se.spline, s))
6.                     return se;
7.             }
8.             return null;
9.         }

Then Unity will serialize the entire spline instead of just a reference to it - which means the FindSplineWidths function will not succeed after serialization because they are now two copies of the spline instead of 1. Further, [SerializedReference] won't work on the Spline either because it's a List<T> type.

 

Ok, so I guess SplineData<T> is just not production ready, and likely never will be with no one left to fix it:

1. Changing a spline's knot count will fundamentally break the data in the SplineData<T> class, because it's stored by knots, and when a knot gets added or removed, the data on the spline moves to new positions on the spline, fundamentally breaking the users data.
2. When working with multiple splines, there is no way to synchronize the data between the spline inside a container and the SplineData<T> reliably. You can do it by index, but if you do, then someone deleting a spline in the container will mean the spline data gets shifted to different splines than it was for, completely breaking the users data.
3. You have to completely rewrite the spline editing classes to work with multiple splines, as the ones included in the package don't work.


Really? This is what you call production ready and when you move to pull the team off of working on it?

You'd have been way better off simply not allowing multiple splines in a single container, and not writing a SplineData<T> class at all. That way at least what was there would work, instead of being a mess which is only going to cause huge issues in a real production. I'm basically forced to not support multiple splines in a container now because the system isn't production ready and will only cause user complaints - and I still have the issue with #1.

 

This means nothing coming from someone working at Unity.

People have been complaining for YEARS that Unity releases features then instantly abandons them (meaning: only makes the bare minimum bug fixes and improvements, and obvious issues at release remain for the lifetime of the feature, because Unity refuses to iterate on features.

All those features were "supported".

So to anyone that is looking to use this: if it fits your use case, great, use it. If you hit any sort of wall (and I'm assuming if your use case isn't trivial, you will), then abandon it with the same haste that Unity "supports" its features.

Don't fall for the "this is pretty good for a first release, I'm sure they will keep improving it". They won't, whatever issue you have with it, will remain an issue forever, or at the very least, for years.