Adds Bezier line data provider and inspector

Author: Railboy

Assets/MixedRealityToolkit/Inspectors/Utilities/Lines/DataProviders/BezierDataProviderInspector.cs

@@ -0,0 +1,151 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using Microsoft.MixedReality.Toolkit.Core.Definitions.Utilities;
+using Microsoft.MixedReality.Toolkit.Core.Utilities.Lines.DataProviders;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditorInternal;
+using UnityEngine;
+
+namespace Microsoft.MixedReality.Toolkit.Core.Inspectors.Utilities.Lines
+{
+    [CustomEditor(typeof(BezierDataProvider))]
+    public class BezierDataProviderInspector : BaseLineDataProviderInspector
+    {
+        private const float OverlappingPointThreshold = 0.015f;
+        private const float HandleSizeModifier = 0.04f;
+        private const float PickSizeModifier = 0.06f;
+
+        private static readonly HashSet<int> OverlappingPointIndexes = new HashSet<int>();
+
+        private static readonly Vector2 ControlPointButtonSize = new Vector2(16, 16);
+        private static readonly Vector2 LeftControlPointPositionOffset = Vector2.left * 12;
+        private static readonly Vector2 RightControlPointPositionOffset = Vector2.right * 24;
+
+        private static readonly Vector2 ControlPointButtonHandleOffset = Vector3.up * 24;
+
+        private static readonly GUIContent PositionContent = new GUIContent("Position");
+
+        private SerializedProperty controlPoints;
+
+        private BezierDataProvider bezierData;
+
+        private int selectedHandleIndex = -1;
+
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+
+            controlPoints = serializedObject.FindProperty("controlPoints");
+
+            bezierData = (BezierDataProvider)target;
+        }
+
+        public override void OnInspectorGUI()
+        {
+            base.OnInspectorGUI();
+            serializedObject.Update();
+
+            // We always draw line points for bezier.
+            DrawLinePoints = true;
+
+            EditorGUILayout.PropertyField(controlPoints, true);
+
+            serializedObject.ApplyModifiedProperties();
+        }
+
+        protected override void OnSceneGUI()
+        {
+            base.OnSceneGUI();
+
+            // We skip the first point as it should always remain at the GameObject's local origin (Pose.ZeroIdentity)
+            for (int i = 0; i < 4; i++)
+            {
+                bool isTangentHandle = i % 3 != 0;
+
+                serializedObject.Update();
+
+                bool isLastPoint = i == 3;
+
+                var controlPointPosition = LineData.GetPoint(i);
+                var controlPointProperty = controlPoints.FindPropertyRelative("point" + (i + 1));
+
+                // Draw our tangent lines
+                Handles.color = Color.gray;
+                if (i == 0)
+                {
+                    Handles.DrawLine(LineData.GetPoint(0), LineData.GetPoint(1));
+                }
+                else if (!isTangentHandle)
+                {
+                    Handles.DrawLine(LineData.GetPoint(i), LineData.GetPoint(i - 1));
+
+                    if (!isLastPoint)
+                    {
+                        Handles.DrawLine(LineData.GetPoint(i), LineData.GetPoint(i + 1));
+                    }
+                }
+
+                Handles.color = isTangentHandle ? Color.white : Color.green;
+                float handleSize = HandleUtility.GetHandleSize(controlPointPosition);
+
+                if (Handles.Button(controlPointPosition, Quaternion.identity, handleSize * HandleSizeModifier, handleSize * PickSizeModifier, Handles.DotHandleCap))
+                {
+                    selectedHandleIndex = i;
+                }
+
+                // Draw our handles
+                if (Tools.current == Tool.Move && selectedHandleIndex == i)
+                {
+                    EditorGUI.BeginChangeCheck();
+
+                    var newTargetPosition = Handles.PositionHandle(controlPointPosition, Quaternion.identity);
+
+                    if (EditorGUI.EndChangeCheck())
+                    {
+                        Undo.RecordObject(LineData, "Change Bezier Point Position");
+                        LineData.SetPoint(i, newTargetPosition);
+                    }
+                }
+
+                serializedObject.ApplyModifiedProperties();
+            }
+        }
+
+        private void DrawControlPointElement(Rect rect, int index, bool isActive, bool isFocused)
+        {
+            bool lastMode = EditorGUIUtility.wideMode;
+            EditorGUIUtility.wideMode = true;
+
+            var lastLabelWidth = EditorGUIUtility.labelWidth;
+            EditorGUIUtility.labelWidth = 88f;
+
+            var property = controlPoints.GetArrayElementAtIndex(index);
+            var fieldHeight = EditorGUIUtility.singleLineHeight * 0.5f;
+            var labelRect = new Rect(rect.x - 8f, rect.y + fieldHeight * 2, rect.width, EditorGUIUtility.singleLineHeight);
+            var positionRect = new Rect(rect.x, rect.y + fieldHeight, rect.width, EditorGUIUtility.singleLineHeight);
+            var rotationRect = new Rect(rect.x, rect.y + fieldHeight * 3, rect.width, EditorGUIUtility.singleLineHeight);
+
+            EditorGUI.LabelField(labelRect, $"{index + 1}");
+
+            EditorGUI.indentLevel++;
+
+            GUI.enabled = index != 0;
+
+            EditorGUI.BeginChangeCheck();
+            EditorGUI.PropertyField(positionRect, property.FindPropertyRelative("position"), PositionContent);
+            bool hasPositionChanged = EditorGUI.EndChangeCheck();
+            
+            if (hasPositionChanged)
+            {
+                EditorUtility.SetDirty(target);
+            }
+
+            GUI.enabled = true;
+            EditorGUI.indentLevel--;
+            EditorGUIUtility.wideMode = lastMode;
+            EditorGUIUtility.labelWidth = lastLabelWidth;
+        }
+    }
+}

Assets/MixedRealityToolkit/Inspectors/Utilities/Lines/DataProviders/BezierDataProviderInspector.cs.meta

@@ -0,0 +1,106 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using Microsoft.MixedReality.Toolkit.Core.Definitions.Utilities;
+using System;
+using UnityEngine;
+
+namespace Microsoft.MixedReality.Toolkit.Core.Utilities.Lines.DataProviders
+{
+    public class BezierDataProvider : BaseMixedRealityLineDataProvider
+    {
+        [Serializable]
+        private struct BezierPointSet
+        {
+            public BezierPointSet(float spread)
+            {
+                Point1 = Vector3.right * spread * 0.5f;
+                Point2 = Vector3.right * spread * 0.25f;
+                Point3 = Vector3.left * spread * 0.25f;
+                Point4 = Vector3.left * spread * 0.5f;
+            }
+
+            public Vector3 Point1;
+            public Vector3 Point2;
+            public Vector3 Point3;
+            public Vector3 Point4;
+        }
+
+        public override int PointCount { get { return 4; } }
+
+        [Header("Bezier Settings")]
+        [SerializeField]
+        private BezierPointSet controlPoints = new BezierPointSet(0.5f);
+
+        protected override Vector3 GetPointInternal(int pointIndex)
+        {
+            switch (pointIndex)
+            {
+                case 0:
+                    return controlPoints.Point1;
+
+                case 1:
+                    return controlPoints.Point2;
+
+                case 2:
+                    return controlPoints.Point3;
+
+                case 3:
+                    return controlPoints.Point4;
+
+                default:
+                    return Vector3.zero;
+            }
+        }
+
+        protected override void SetPointInternal(int pointIndex, Vector3 point)
+        {
+            switch (pointIndex)
+            {
+                case 0:
+                    controlPoints.Point1 = point;
+                    break;
+
+                case 1:
+                    controlPoints.Point2 = point;
+                    break;
+
+                case 2:
+                    controlPoints.Point3 = point;
+                    break;
+
+                case 3:
+                    controlPoints.Point4 = point;
+                    break;
+
+                default:
+                    break;
+            }
+        }
+
+        protected override Vector3 GetPointInternal(float normalizedDistance)
+        {
+            return LineUtility.InterpolateBezierPoints(controlPoints.Point1, controlPoints.Point2, controlPoints.Point3, controlPoints.Point4, normalizedDistance);
+        }
+
+        protected override float GetUnClampedWorldLengthInternal()
+        {
+            // Crude approximation
+            // TODO optimize
+            float distance = 0f;
+            Vector3 last = GetUnClampedPoint(0f);
+            for (int i = 1; i < 10; i++)
+            {
+                Vector3 current = GetUnClampedPoint((float)i / 10);
+                distance += Vector3.Distance(last, current);
+            }
+            return distance;
+        }
+
+        protected override Vector3 GetUpVectorInternal(float normalizedLength)
+        {
+            // Bezeir up vectors just use transform up
+            return transform.up;
+        }
+    }
+}