Moveable Points using Custom Attribute or Custom Editor

Unity Engine
,
1

Preface: I’m trying to create a custom attribute that draws moveable gizmos from an array or list of points (Vector2 or Vector3)

The dream would be to have something like:

[MoveablePoints]
public List<Vector2> examplePointSetList;
[MoveablePoints]
public Vector2[ ] examplePointSetArray;

…however, I don’t know how achievable something like that is. I’m not familiar with attributes.

8626974--1159242--BZ3zy.gif 8626974--1159245--ij1ue.gif

So far, I have this helper script that I use to move points around manually while debugging.
(an older version can be seen here):

    public class MovablePoints : MonoBehaviour
    {

        [Range(.01f, 1f)] public float selectionRadius = .05f;

        public bool selectionActive = true;

        public class MovablePoint
        {
            public Vector2 point;

            public MovablePoint(float x, float y)
            {
                this.point = new Vector2(x, y);
            }
            public MovablePoint(Vector2 point)
            {
                this.point = point;
            }
        }

        public class Point
        {
            public Vector2 position;
            public Vector2 offset;
            public Color color;
            public bool isMoving;

            public MovablePoint movablePoint;

            public Vector2 posRef;

            public Point(ref Vector2 position, MovablePoint movablePoint)
            {
                this.position = position;
                this.movablePoint = movablePoint;
            }

            public bool IsPointInRange(Vector2 mosPos, float selectionRadius)
            {
                float dx = Mathf.Abs(position.x - mosPos.x);
                float dy = Mathf.Abs(position.y - mosPos.y);

                if (dx > selectionRadius)
                    return false;
                if (dy > selectionRadius)
                    return false;
                if (dx + dy <= selectionRadius)
                    return true;
                if (Mathf.Pow(dx, 2) + Mathf.Pow(dy, 2) <= Mathf.Pow(selectionRadius, 2))
                    return true;
                return false;
            }

        }

        public List<Point> points = new List<Point>();

        private Vector2 clickedPos;
        private void Update()
        {
            Vector2 mosPos = Camera.main.ScreenToWorldPoint(Input.mousePosition);

            if (Input.GetMouseButtonDown(0))
            {
                clickedPos = mosPos;

                foreach (Point point in points)
                {
                    //if (IsPointInRange(point.position, mosPos) && !point.isMoving)
                    if (point.IsPointInRange(mosPos, selectionRadius))
                    {
                        point.isMoving = true;
                        point.offset = point.position - clickedPos;
                    }
                }
            }
            if (Input.GetMouseButton(0))
            {
                foreach (Point point in points)
                {
                    if (point.isMoving)
                    {
                        point.position = mosPos + point.offset;
                        point.movablePoint.point = mosPos + point.offset;
                    }
                }
            }
            if (Input.GetMouseButtonUp(0))
            {
                foreach (Point point in points)
                {
                    point.offset = Vector2.zero;
                    point.isMoving = false;
                }
            }
        }

        void OnDrawGizmos()
        {
            if (selectionActive)
            {
                Color selectionColor = Color.white;
                selectionColor.a = 0.65f;
                Handles.color = selectionColor;
                if (Input.GetAxis("Mouse ScrollWheel") > 0f && selectionRadius < 1)
                    selectionRadius += .01f;
                if (Input.GetAxis("Mouse ScrollWheel") < 0f && selectionRadius > 0)
                    selectionRadius -= .01f;

                Vector2 mosPos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
                Handles.DrawWireDisc(mosPos, new Vector3(0, 0, 1), selectionRadius);

                foreach (Point point in points)
                {
                    bool IsUnderSelectedArea = point.IsPointInRange(mosPos, selectionRadius);

                    if (point.isMoving)
                        Gizmos.color = Color.green;
                    else if (IsUnderSelectedArea)
                        Gizmos.color = Color.red;
                    else
                        Gizmos.color = Color.white;

                    Gizmos.DrawSphere(point.position, 0.05f);
                }
            }
        }
    }

Currently, it’s pretty jank as I’ve been experimenting with custom classes to store references to value types. This system is rather undesirable, and not very streamlined or intuitive.

2

Basically, the moveable points work fine. I’m trying to streamline the “subscription” process with a custom attribute, and don’t really know where to start.

3

I… don’t think this is actually possible out of the box with Unity’s property drawer system?

Namely the way you’d draw these points in the scene is to is to subscribe to SceneView.duringSceneGui, and unsubscribe when the object is no longer selected. However PropertyDrawer’s don’t have any ‘Initialise’ or similar message like a UnityEditor.Editor’s OnEnable/OnDisable messages.

Even then it would only work when the object is selected, as knowing what fields of certain objects have particular attributes at all time would be enormously non-performant.

This would be trivial with tools such as Odin Inspector that have far more feature rich drawing abilities.

4

Hmmm…

In that case, is there some way for the MoveablePoints “Points” class to keep a reference to the value that created it, and update it remotely? Meaning, update the original “Vector2” that is stored in the list.

5

I think this is another point where Unity’s UI features fall short again. Far as I know there’s no way to look ‘upwards’ to the root Unity object that a drawer is in without managing it all manually.

If you’re keen on doing this in smart ways I’d invest in Odin Inspector. Otherwise you’ll be engineering all the same stuff yourself.

6

I have Odin Inspector, (and I think I recognize you from the discord?)

Ideally, I would like to figure out how to treat the value type items in a list as reference types, or update them from within the MoveablePoints class.

I feel like it should be possible, as given a list of the “MoveablePoint” class updates automatically when the values are changed. (as it is it is a reference type.)

My thinking is that you can use the “ref” keyword to pass a value as a reference into a method, so you should be able to save and reuse that reference?

What is difference between a list of classes vs a list of structs, that you can save a reference to the objects?

7

Or better asked, “What is the difference between a reference type in a collection, and a value type in a collection”. Collections, be it arrays or lists, are reference types. Their elements can be either. The collections themselves behave as reference types, while each element behaves as appropriate.

Ergo, you can get references to specific elements should they be reference types. But not if they’re value types. You can get a reference to the entire collection, whereby updating one of its elements will be seen by anything else referencing the same collection.

Should’ve said that earlier! Could’ve had this done ages ago via Odin.

You could do something like this:

public sealed class MoveablePointsAttributeDrawer<T> : OdinAttributeDrawer<MoveablePointsAttribute, T>, IDisposeable : where T : IEnumerable<Vector2>
{
    private IEnumerable<Vector2> points;
 
    protected override void Intialize()
    {
        points = (IEnumerable<Vector2>)Property.ValueEntry.WeakSmartValue;
        UnityEditor.SceneView.duringSceneGui += DrawScenePoints;
    }
 
    private void DrawScenePoints(SceneView sceneView)
    {
       //draw points
    }
 
    public void Dispose()
    {
        UnityEditor.SceneView.duringSceneGui -= DrawScenePoints;
    }
}

Written in notepad++ so could be some errors.

But so long as you assign your points back through to Property.ValueEntry.WeakSmartValue then Odin handles dirtying the root object. You can also get a reference to the root object with Property.SerializationRoot.ValueEntry.WeakSmartValue, or dirty it with Property.MarkSerializationRootDirty();

So you can just do:

[MoveablePoints, SerializeField]
private void List<Vector2> points = new List<Vector2>();

And the scene drawing will work when the object is selected in the inspector.

Again this only works when selecting the object with these values. If you want it to be more persistent, you could set up a static class that holds onto the last selected object.

1 Like