feat(Runtime): Support user-definable CustomProcessor

Summary: This change adds support for a `CustomProcessor`, which needs a reference to a class that inherits from `CustomProcessorBehavior`. Each custom `CustomProcessorBehavior` implementation can be implemented by a user so that they can define their own IK.

Reviewed By: andkim-meta

Differential Revision:
D75054156

Privacy Context Container: L1117747

fbshipit-source-id: 89196c4fa366df0654eea05ba893e3a5a1570ed5

Author: sohailshafiiWk

Editor/Native/Scripts/Retargeting/Processors/CustomProcessorDrawer.cs

@@ -0,0 +1,82 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+using UnityEditor;
+using UnityEngine;
+
+namespace Meta.XR.Movement.Retargeting.Editor
+{
+    /// <summary>
+    /// Renders an instance of <see cref="CustomProcessor"/>.
+    /// </summary>
+    [CustomPropertyDrawer(typeof(CustomProcessor))]
+    public class CustomProcessorDrawer : PropertyDrawer
+    {
+        private static readonly (string propertyName, GUIContent label)[] _propertiesToDraw =
+        {
+            ("_weight", new GUIContent("Weight")),
+            ("_customBehavior", new GUIContent("Custom Behavior"))
+        };
+
+        /// <inheritdoc cref="PropertyDrawer.OnGUI"/>
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            EditorGUI.BeginProperty(position, label, property);
+            var foldoutRect = new Rect(
+                position.x,
+                position.y - EditorGUIUtility.singleLineHeight * 1.1f,
+                position.width,
+                EditorGUIUtility.singleLineHeight);
+            var isFoldoutExpanded = property.FindPropertyRelative("_isFoldoutExpanded");
+            isFoldoutExpanded.boolValue = EditorGUI.Foldout(foldoutRect, isFoldoutExpanded.boolValue, GUIContent.none);
+
+            if (!isFoldoutExpanded.boolValue)
+            {
+                EditorGUI.EndProperty();
+                return;
+            }
+
+            EditorGUI.indentLevel++;
+            var elementVerticalSpacing = GetVerticalSpacing();
+            for (var i = 0; i < _propertiesToDraw.Length; i++)
+            {
+                var propertyRect = new Rect(
+                    position.x,
+                    position.y + elementVerticalSpacing * i,
+                    position.width,
+                    EditorGUIUtility.singleLineHeight);
+
+                var serializedProperty = property.FindPropertyRelative(_propertiesToDraw[i].propertyName);
+                var serializedLabel = _propertiesToDraw[i].label;
+                if (i == 0)
+                {
+                    EditorGUI.PropertyField(propertyRect, serializedProperty, serializedLabel);
+                }
+                else
+                {
+                    EditorGUI.ObjectField(propertyRect, serializedProperty, serializedLabel);
+                }
+            }
+
+            EditorGUI.indentLevel--;
+            EditorGUI.EndProperty();
+        }
+
+        /// <inheritdoc cref="PropertyDrawer.GetPropertyHeight"/>
+        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+        {
+            if (!property.FindPropertyRelative("_isFoldoutExpanded").boolValue)
+            {
+                return EditorGUIUtility.standardVerticalSpacing;
+            }
+
+            var verticalSpacing = GetVerticalSpacing();
+            var numberOfProperties = _propertiesToDraw.Length;
+            return verticalSpacing * numberOfProperties;
+        }
+
+        private float GetVerticalSpacing()
+        {
+            return EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+        }
+    }
+}

Editor/Native/Scripts/Retargeting/Processors/CustomProcessorDrawer.cs.meta

@@ -41,6 +41,8 @@ private SerializedProperty GetProcessorTypeProperty(SerializedProperty property)
                     return property.FindPropertyRelative("_locomotionProcessor");
                 case TargetProcessor.ProcessorType.CCDIK:
                     return property.FindPropertyRelative("_ccdProcessor");
+                case TargetProcessor.ProcessorType.Custom:
+                    return property.FindPropertyRelative("_customProcessor");
                 default:
                     return null;
             }

Editor/Native/Scripts/Retargeting/Processors/TargetProcessorContainerDrawer.cs

@@ -25,7 +25,8 @@ public enum ProcessorType
             Animation,
             HipPinning,
             Locomotion,
-            CCDIK
+            CCDIK,
+            Custom
         }
 
         /// <summary>

Runtime/Native/Scripts/Retargeting/TargetProcessor.cs

@@ -52,6 +52,12 @@ public class TargetProcessorContainer
         [SerializeField]
         protected CCDSkeletalProcessor _ccdProcessor;
 
+        /// <summary>
+        /// A user-defined, custom processor.
+        /// </summary>
+        [SerializeField]
+        protected CustomProcessor _customProcessor;
+
         /// <summary>
         /// Returns the current <see cref="TargetProcessor"/> based on the current type
         /// saved.
@@ -71,6 +77,8 @@ public TargetProcessor GetCurrentProcessor()
                     return _locomotionProcessor;
                 case TargetProcessor.ProcessorType.CCDIK:
                     return _ccdProcessor;
+                case TargetProcessor.ProcessorType.Custom:
+                    return _customProcessor;
                 default:
                     return null;
             }

Runtime/Native/Scripts/Retargeting/TargetProcessorContainer.cs

@@ -0,0 +1,48 @@
+// (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+using System;
+using Unity.Collections;
+using UnityEngine;
+using static Meta.XR.Movement.MSDKUtility;
+
+namespace Meta.XR.Movement.Retargeting
+{
+    /// <summary>
+    /// A custom processor that a user can define.
+    /// </summary>
+    [Serializable]
+    public class CustomProcessor : TargetProcessor
+    {
+        /// <summary>
+        /// Component that is associated with custom processor implementation.
+        /// </summary>
+        [SerializeField]
+        protected CustomProcessorBehavior _customBehavior;
+
+        /// <inheritdoc />
+        public override void Initialize(CharacterRetargeter retargeter)
+        {
+            _customBehavior.Initialize(retargeter);
+        }
+
+        /// <inheritdoc />
+        public override void Destroy()
+        {
+            _customBehavior.Destroy();
+        }
+
+        /// <inheritdoc />
+        public override void UpdatePose(ref NativeArray<NativeTransform> pose)
+        {
+            _customBehavior.UpdatePose(ref pose, _weight);
+        }
+
+        /// <inheritdoc />
+        public override void LateUpdatePose(
+            ref NativeArray<NativeTransform> currentPose,
+            ref NativeArray<NativeTransform> targetPoseLocal)
+        {
+            _customBehavior.LateUpdatePose(ref currentPose, ref targetPoseLocal, _weight);
+        }
+    }
+}

Runtime/Native/Scripts/Retargeting/TargetProcessors/CustomProcessor.cs

@@ -0,0 +1,53 @@
+// (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+using Unity.Collections;
+using UnityEngine;
+using static Meta.XR.Movement.MSDKUtility;
+
+namespace Meta.XR.Movement.Retargeting
+{
+    /// <summary>
+    /// Behavior class referenced by <see cref="CustomProcessor"/>. Inherit to define your own.
+    /// </summary>
+    public class CustomProcessorBehavior : MonoBehaviour
+    {
+        /// <summary>
+        /// Initializes the processor.
+        /// </summary>
+        /// <param name="retargeter">The native retargeter.</param>
+        public virtual void Initialize(CharacterRetargeter retargeter)
+        {
+        }
+
+        /// <summary>
+        /// Destroys the processor.
+        /// </summary>
+        public virtual void Destroy()
+        {
+        }
+
+        /// <summary>
+        /// Processes the retargeted pose values in Update.
+        /// </summary>
+        /// <param name="pose">The pose that the constraint needs to affect.</param>
+        /// <param name="weight">Weight.</param>
+        public virtual void UpdatePose(
+            ref NativeArray<NativeTransform> pose,
+            float weight)
+        {
+        }
+
+        /// <summary>
+        /// Processes the target pose values in LateUpdate.
+        /// </summary>
+        /// <param name="currentPose">The current pose.</param>
+        /// <param name="targetPose">The target pose to be updated by the constraint.</param>
+        /// <param name="weight">Weight.</param>
+        public virtual void LateUpdatePose(
+            ref NativeArray<NativeTransform> currentPose,
+            ref NativeArray<NativeTransform> targetPose,
+            float weight)
+        {
+        }
+    }
+}