fr.jeanf.universal.player 0.7.3

package/Runtime/scripts/HandInteraction/Editor/PoseWindow.cs

@@ -0,0 +1,258 @@
+#if UNITY_EDITOR
+using UnityEditor;
+using UnityEditor.SceneManagement;
+#endif
+
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace jeanf.vrplayer
+{
+#if !UNITY_EDITOR
+public class PoseWindow {}
+#endif
+#if UNITY_EDITOR
+    public class PoseWindow : EditorWindow
+    {
+        // The pose we're editing
+        private Pose activePose = null;
+
+        // Root object
+        private GameObject poseHelper = null;
+
+        // Functionality
+        private HandManager handManager = null;
+        private SelectionHandler selectionHandler = null;
+
+        private void OnEnable()
+        {
+            CreatePoseHelper();
+            Selection.selectionChanged += UpdateSelection;
+            EditorApplication.playModeStateChanged += CloseWindow;
+            EditorSceneManager.sceneClosing += CloseWindow;
+        }
+
+        private void OnDisable()
+        {
+            DestroyPoseHelper();
+            Selection.selectionChanged -= UpdateSelection;
+            EditorApplication.playModeStateChanged -= CloseWindow;
+            EditorSceneManager.sceneClosing -= CloseWindow;
+        }
+
+        void CreatePoseHelper()
+        {
+            if (!poseHelper)
+            {
+                // Get the manager from resources
+                Object helperPrefab = Resources.Load("PoseHelper");
+
+                // Instantiate it into the scene, mark as not to save
+                poseHelper = (GameObject)PrefabUtility.InstantiatePrefab(helperPrefab);
+                poseHelper.hideFlags = HideFlags.DontSave;
+
+                // Get functionality
+                selectionHandler = poseHelper.GetComponent<SelectionHandler>();
+                handManager = poseHelper.GetComponent<HandManager>();
+
+                // Set initial selection setup
+                UpdateSelection();
+            }
+        }
+
+        private void DestroyPoseHelper()
+        {
+            DestroyImmediate(poseHelper);
+        }
+
+        private void CloseWindow(PlayModeStateChange stateChange)
+        {
+            if (stateChange == PlayModeStateChange.ExitingEditMode)
+                Close();
+        }
+
+        private void CloseWindow(Scene scene, bool removingScene)
+        {
+            if (removingScene)
+                Close();
+        }
+
+        private void OnInspectorUpdate()
+        {
+            Repaint();
+        }
+
+        private void OnGUI()
+        {
+            GUIStyle labelStyle = EditorStyles.label;
+            labelStyle.alignment = TextAnchor.MiddleCenter;
+
+            string poseName = activePose ? activePose.name : "No Pose";
+            GUILayout.Label(poseName, labelStyle);
+
+            using (new EditorGUI.DisabledScope(activePose))
+            {
+                if (GUILayout.Button("Create Pose"))
+                    CreatePose();
+
+                if (GUILayout.Button("Refresh Pose"))
+                    RefreshPose();
+            }
+
+            using (new EditorGUI.DisabledScope(!activePose))
+            {
+                if (GUILayout.Button("Clear Pose"))
+                    ClearPose();
+            }
+
+            using (new EditorGUI.DisabledScope(!handManager.HandsExist))
+            {
+                PreviewHand leftHand = handManager.LeftHand;
+                PreviewHand rightHand = handManager.RightHand;
+                float objectWidth = EditorGUIUtility.currentViewWidth * 0.5f;
+
+                // Hand labels
+                using (new GUILayout.HorizontalScope())
+                {
+                    GUILayout.Label("Left Hand", labelStyle, GUILayout.Width(objectWidth));
+                    GUILayout.Label("Right Hand", labelStyle, GUILayout.Width(objectWidth));
+                }
+
+                // Toggle buttons
+                using (new GUILayout.HorizontalScope())
+                {
+                    if (GUILayout.Button("Toggle", GUILayout.Width(objectWidth)))
+                        ToggleHand(leftHand);
+
+                    if (GUILayout.Button("Toggle", GUILayout.Width(objectWidth)))
+                        ToggleHand(rightHand);
+                }
+
+                // Buttons that require a pose
+                using (new EditorGUI.DisabledScope(!activePose))
+                {
+                    using (new GUILayout.HorizontalScope())
+                    {
+                        if (GUILayout.Button("Mirror L > R", GUILayout.Width(objectWidth)))
+                            MirrorPose(leftHand, rightHand);
+
+                        if (GUILayout.Button("Mirror R > L", GUILayout.Width(objectWidth)))
+                            MirrorPose(rightHand, leftHand);
+                    }
+
+                    using (new GUILayout.HorizontalScope())
+                    {
+                        if (GUILayout.Button("Undo Changes", GUILayout.Width(objectWidth)))
+                            UndoChanges(leftHand);
+
+                        if (GUILayout.Button("Undo Changes", GUILayout.Width(objectWidth)))
+                            UndoChanges(rightHand);
+                    }
+
+                    using (new GUILayout.HorizontalScope())
+                    {
+                        if (GUILayout.Button("Reset", GUILayout.Width(objectWidth)))
+                            ResetPose(leftHand);
+
+                        if (GUILayout.Button("Reset", GUILayout.Width(objectWidth)))
+                            ResetPose(rightHand);
+                    }
+                }
+            }
+
+            using (new EditorGUI.DisabledScope(!activePose))
+            {
+                GUILayout.Label("Remember to Save!", labelStyle);
+
+                if (GUILayout.Button("Save Pose"))
+                    handManager.SavePose(activePose);
+            }
+        }
+
+        private void CreatePose()
+        {
+            // Create the new asset
+            activePose = CreatePoseAsset();
+
+            // Give the pose to the object we have selected
+            GameObject targetObject = selectionHandler.SetObjectPose(activePose);
+
+            // Update the hands
+            handManager.UpdateHandsForSetup(activePose, targetObject.transform);
+        }
+
+        Pose CreatePoseAsset()
+        {
+            // Create new scriptable object
+            Pose pose = CreateInstance<Pose>();
+
+            // Store the asset
+            string path = AssetDatabase.GenerateUniqueAssetPath("Assets/NewPoseData.asset");
+            AssetDatabase.CreateAsset(pose, path);
+
+            return pose;
+        }
+
+        private void UpdateSelection()
+        {
+            if (selectionHandler.CheckForNewInteractable())
+                UpdateActivePose(Selection.activeGameObject);
+        }
+
+        private void RefreshPose()
+        {
+            // Get the object we have selected
+            GameObject currentObject = selectionHandler.CurretInteractable.gameObject;
+            UpdateActivePose(currentObject);
+        }
+
+        private void UpdateActivePose(GameObject targetObject)
+        {
+            // Get pose from container, update hands
+            activePose = selectionHandler.TryGetPose(targetObject);
+
+            // If we have a pose, update the hands
+            if(activePose)
+                handManager.UpdateHandsForSetup(activePose, targetObject.transform);
+        }
+
+        private void ClearPose()
+        {
+            selectionHandler.SetObjectPose(null);
+            activePose = null;
+        }
+
+        private void ToggleHand(PreviewHand hand)
+        {
+            Undo.RecordObject(hand.gameObject, "Toggle Hand");
+            bool isActive = !hand.gameObject.activeSelf;
+            hand.gameObject.SetActive(isActive);
+        }
+
+        private void ResetPose(PreviewHand hand)
+        {
+            Undo.RecordObject(hand.transform, "Reset Pose");
+            hand.ApplyDefaultPoseForeSetup();
+        }
+
+        private void UndoChanges(PreviewHand hand)
+        {
+            Undo.RecordObject(hand.transform, "Undo Changes");
+            hand.ApplyPoseForSetup(activePose);
+        }
+
+        private void MirrorPose(PreviewHand sourceHand, PreviewHand targetHand)
+        {
+            Undo.RecordObject(targetHand.transform, "Mirror Pose");
+            targetHand.MirrorAndApplyPose(sourceHand);
+        }
+
+        public static void Open(Pose pose)
+        {
+            PoseWindow window = GetWindow<PoseWindow>("Hand Poser");
+            window.activePose = pose;
+        }
+    }
+#endif
+
+}

package/Runtime/scripts/HandInteraction/Editor/PoseWindow.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2c3a29c0649d63f458261f2af58b3343
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/scripts/HandInteraction/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 03a83577a6b65164abb6026290199535
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/scripts/HandInteraction/GetPrimaryInHandItemWithVRController.cs

@@ -0,0 +1,212 @@
+using System;
+using System.Collections.Generic;
+using jeanf.EventSystem;
+using jeanf.propertyDrawer;
+using UnityEngine;
+using UnityEngine.InputSystem;
+using Debug = UnityEngine.Debug;
+
+namespace jeanf.vrplayer
+{
+        public enum IpadState
+        {
+            Disabled,
+            InLeftHand,
+            InRightHand,
+        }
+    public class GetPrimaryInHandItemWithVRController : MonoBehaviour, IDebugBehaviour
+    {
+        public bool isDebug
+        { 
+            get => _isDebug;
+            set => _isDebug = value; 
+        }
+        [SerializeField] private bool _isDebug = false;
+        [Header("Inputs")]
+        [SerializeField] private InputActionReference drawPrimaryItem_LeftHand;
+        [SerializeField] private InputActionReference drawPrimaryItem_RightHand;
+
+
+        [Header("Hands Information")]
+        [SerializeField] private Transform _leftHand;
+        [SerializeField] private Transform _rightHand;
+        [SerializeField] private HandPoseManager _leftHandPoseManager;
+        [SerializeField] private HandPoseManager _rightHandPoseManager;
+
+        [SerializeField] private Pose primaryItemPose;
+        
+        [Header("PrimaryItem")] 
+        public Transform primaryItem;
+        [SerializeField] private BoolEventChannelSO _PrimaryItemStateChannel;
+        [SerializeField] private StringEventChannelSO _primaryItemStateWithUsedHandChannel;
+        [SerializeField] private VoidEventChannelSO _leftGrab;
+        [SerializeField] private VoidEventChannelSO _rightGrab;
+        [SerializeField] private VoidEventChannelSO _noGrab;
+        public static event Action<IpadState> OnIpadStateChanged;
+        [Header("Hands Positions")] 
+        [SerializeField] private PoseContainer _poseContainer;
+        
+        [SerializeField] private List<SkinnedMeshRenderer> _hands = new List<SkinnedMeshRenderer>();
+
+
+        private IpadState _ipadState = IpadState.Disabled;
+
+
+        private void OnEnable()
+        {
+            //BlendableHand.AddHand += AddHand;
+            //BlendableHand.RemoveHand += RemoveHand;
+            
+            drawPrimaryItem_LeftHand.action.performed += ctx=> SetIpadStateForLeftHand(primaryItemPose.leftHandInfo);
+            drawPrimaryItem_RightHand.action.performed += ctx=> SetIpadStateForRightHand(primaryItemPose.rightHandInfo);
+            _primaryItemStateWithUsedHandChannel.OnEventRaised += ctx => SetIpadStateForASpecificHand(ctx);;
+            TakeObject.OnVrGrabSwapPrimaryItem += ReceiveGrabSide;
+        }
+
+        private void OnDestroy() => Unsubscribe();
+        private void OnDisable() => Unsubscribe();
+
+        private void Unsubscribe()
+        {
+            _hands.Clear();
+            _hands.TrimExcess();
+            
+            BlendableHand.AddHand -= null;
+            BlendableHand.RemoveHand -= null;
+            drawPrimaryItem_LeftHand.action.performed -= null;
+            drawPrimaryItem_RightHand.action.performed -= null;
+            _primaryItemStateWithUsedHandChannel.OnEventRaised -= ctx => SetIpadStateForASpecificHand(ctx);
+            TakeObject.OnVrGrabSwapPrimaryItem -= ReceiveGrabSide;
+        }
+
+
+        //private void AddHand(SkinnedMeshRenderer hand)
+        //{
+        //    if (_hands.Contains(hand)) return;
+        //    _hands.Add(hand);
+        //    var handPoseManager = hand.transform.parent.transform.parent.GetComponent<HandPoseManager>() == null? hand.transform.parent.GetComponent<HandPoseManager>(): hand.transform.parent.transform.parent.GetComponent<HandPoseManager>();
+        //    var handType = handPoseManager.HandType;
+        //    if(isDebug) Debug.Log($"handType {handType}");
+        //    if(isDebug && handPoseManager) Debug.Log($"handPoseManager {handPoseManager.HandType}");
+        //    switch (handType)
+        //    {
+        //        case HandType.Left:
+        //            _leftHand = hand.gameObject.transform;
+        //            _leftHandPoseManager = handPoseManager;
+        //            break;
+        //        case HandType.Right:
+        //            _rightHand = hand.gameObject.transform;
+        //            _rightHandPoseManager = handPoseManager;
+        //            break;
+        //        case HandType.None:
+        //        default:
+        //            throw new ArgumentOutOfRangeException();
+        //    }
+        //}
+        //private void RemoveHand(SkinnedMeshRenderer hand)
+        //{
+        //    if(_hands.Count > 0 && _hands.Contains(hand)) _hands.Remove(hand);
+        //    _leftHand = null;
+        //    _rightHand = null;
+        //    _leftHandPoseManager = null;
+        //    _rightHandPoseManager = null;
+        //    _noGrab.RaiseEvent();
+        //}
+
+        public InputActionReference GetActiveHand()
+        {
+            if (_ipadState is IpadState.InLeftHand)
+            {
+                return drawPrimaryItem_LeftHand;
+            }
+            else if (_ipadState is IpadState.InRightHand)
+            {
+                return drawPrimaryItem_RightHand;
+            }
+            else
+            {
+                return null;
+            }
+        }
+
+        public void SetIpadStateForLeftHand(HandInfo handInfo)
+        {
+            if (_ipadState is IpadState.Disabled or IpadState.InRightHand)
+            {
+                SetIpadStateForASpecificHand(handInfo, _leftHand);
+                _ipadState = IpadState.InLeftHand;
+                _leftGrab.RaiseEvent();
+                if(_leftHandPoseManager) _leftHandPoseManager.ApplyPose(primaryItemPose);
+                //_poseContainer.SetAttachTransform_Left();
+                if (!_rightHandPoseManager) return;
+                _rightHandPoseManager.ApplyDefaultPose();
+                _noGrab.RaiseEvent();
+                OnIpadStateChanged.Invoke(_ipadState);  
+                _PrimaryItemStateChannel.RaiseEvent(true);
+            }
+            else
+            {
+                _ipadState = IpadState.Disabled;
+                _PrimaryItemStateChannel.RaiseEvent(false);
+                OnIpadStateChanged.Invoke(_ipadState);
+                if (_leftHandPoseManager) _leftHandPoseManager.ApplyDefaultPose();
+            }
+        }
+        public void SetIpadStateForRightHand(HandInfo handInfo)
+        {
+            if (_ipadState is IpadState.Disabled or IpadState.InLeftHand)
+            {
+                SetIpadStateForASpecificHand(handInfo, _rightHand.transform);
+                _ipadState = IpadState.InRightHand;
+                _rightGrab.RaiseEvent();
+                if(_rightHandPoseManager) _rightHandPoseManager.ApplyPose(primaryItemPose);
+                //_poseContainer.SetAttachTransform_Right();
+                if (!_leftHandPoseManager) return;
+                _leftHandPoseManager.ApplyDefaultPose();
+                _noGrab.RaiseEvent();
+                OnIpadStateChanged.Invoke(_ipadState);
+                _PrimaryItemStateChannel.RaiseEvent(true);
+            }
+            else
+            {
+                _ipadState = IpadState.Disabled;
+                _PrimaryItemStateChannel.RaiseEvent(false);
+                OnIpadStateChanged.Invoke(_ipadState);
+                if(_rightHandPoseManager) _rightHandPoseManager.ApplyDefaultPose();
+            }
+        }
+        public void SetIpadStateForASpecificHand(HandInfo handInfo, Transform parent)
+        {
+            if(!primaryItem) return;
+            primaryItem.SetParent(parent);
+            primaryItem.localPosition = handInfo.attachPosition;
+            primaryItem.localRotation = handInfo.attachRotation;
+        }
+
+        private void ReceiveGrabSide(string str)
+        {
+            if (!primaryItem) return;
+            if (str == "RightHand")
+            {
+                SetIpadStateForASpecificHand(primaryItemPose.leftHandInfo, _leftHand.transform);
+            }
+            else if (str == "LeftHand")
+            {
+                SetIpadStateForASpecificHand(primaryItemPose.rightHandInfo, _rightHand.transform);
+            }
+        }
+        public void SetIpadStateForASpecificHand(string hand)
+        {
+            if (!primaryItem) return;
+            if (hand.Contains("LeftHand"))
+            {
+                SetIpadStateForRightHand(primaryItemPose.rightHandInfo);
+            }
+            else if (hand.Contains("RightHand"))
+            {
+                SetIpadStateForLeftHand(primaryItemPose.leftHandInfo);
+            }
+        }
+    }
+}
+

package/Runtime/scripts/HandInteraction/GetPrimaryInHandItemWithVRController.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0536dff838919554b97f24d874c8b558
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/scripts/HandInteraction/GrabHandPose.cs

@@ -0,0 +1,101 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Serialization;
+using UnityEngine.XR.Interaction.Toolkit;
+
+public class GrabHandPose : MonoBehaviour
+{
+    public HandData rightHandPose;
+
+    private Vector3 currentHandPosition;
+    private Vector3 targetHandPosition;
+    private Quaternion currentHandRotation;
+    private Quaternion targetHandRotation;
+
+    private Quaternion[] currentFingerBoneRotations;
+    private Quaternion[] targetFingerBoneRotations;
+
+    private HandData GrabbingHandData;
+    
+    // Start is called before the first frame update
+    void Start()
+    {
+        UnityEngine.XR.Interaction.Toolkit.Interactables.XRGrabInteractable grabInteractable = GetComponent<UnityEngine.XR.Interaction.Toolkit.Interactables.XRGrabInteractable>();
+        
+        grabInteractable.selectEntered.AddListener(SetupPose);
+        grabInteractable.selectExited.AddListener(UnSetPose);
+        
+        rightHandPose.gameObject.SetActive(false);
+    }
+
+    private void SetupPose(BaseInteractionEventArgs arg)
+    {
+        if (arg.interactorObject is UnityEngine.XR.Interaction.Toolkit.Interactors.XRDirectInteractor)
+        {
+            //HandData handData = arg.interactorObject.transform.GetComponentInChildren<HandData>();
+            HandData handData = GrabbingHandData;
+            //HandData handData = arg.interactorObject.transform.GetComponentInParent<HandData>();
+            //Debug.Log($"arg.interactorObject.transform.gameObject.name : {arg.interactorObject.transform.gameObject.name}");
+            //Debug.Log($"handData : {handData}");
+            //Debug.Log($"handData gameObject : {handData.gameObject.name}");
+            handData.animator.enabled = false;
+            
+            StoreHandData(handData, rightHandPose);
+            SetHandData(handData, targetHandPosition, targetHandRotation, targetFingerBoneRotations);
+        }
+    }
+    
+    private void UnSetPose(BaseInteractionEventArgs arg)
+    {
+        if (arg.interactorObject is UnityEngine.XR.Interaction.Toolkit.Interactors.XRDirectInteractor)
+        {
+            HandData handData = GrabbingHandData;
+            handData.animator.enabled = true;
+            
+            SetHandData(handData, currentHandPosition, currentHandRotation, currentFingerBoneRotations);
+        }
+    }
+
+    public void StoreHandData(HandData currentHand, HandData targetHand)
+    {
+        //currentHandPosition = new Vector3(currentHand.root.localPosition.x / currentHand.root.localScale.x, currentHand.root.localPosition.y / currentHand.root.localScale.y, currentHand.root.localPosition.z / currentHand.root.localScale.z);
+        //targetHandPosition = new Vector3(targetHand.root.localPosition.x / targetHand.root.localScale.x, targetHand.root.localPosition.y / targetHand.root.localScale.y, targetHand.root.localPosition.z / targetHand.root.localScale.z);
+
+        currentHandPosition = currentHand.root.localPosition;
+        targetHandPosition = targetHand.root.localPosition;
+        
+        currentHandRotation = currentHand.root.localRotation;
+        targetHandRotation = targetHand.root.localRotation;
+
+        currentFingerBoneRotations = new Quaternion[currentHand.fingerBones.Length];
+        targetFingerBoneRotations = new Quaternion[targetHand.fingerBones.Length];
+
+        for (int i = 0; i < currentHand.fingerBones.Length; i++)
+        {
+            currentFingerBoneRotations[i] = currentHand.fingerBones[i].localRotation;
+            targetFingerBoneRotations[i] = targetHand.fingerBones[i].localRotation;
+        }
+    }
+
+    public void SetHandData(HandData h, Vector3 newPosition, Quaternion newRotation, Quaternion[] newBonesRotation)
+    {
+        SetObjectPosition(transform, h.root);
+
+        for (int i = 0; i < newBonesRotation.Length; i++)
+        {
+            h.fingerBones[i].localRotation = newBonesRotation[i];
+        }
+    }
+
+    public void SetHandDataComponent(HandData handData)
+    {
+        GrabbingHandData = handData;
+    }
+
+    public void SetObjectPosition(Transform obj, Transform offset)
+    {
+        obj.localPosition = offset.localPosition * -1;
+        obj.rotation = offset.rotation;
+    }
+}

package/Runtime/scripts/HandInteraction/GrabHandPose.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a74cefb4d4179bb42af620e81a02dd26
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/scripts/HandInteraction/HandData/Left XR Direct Interactor Event Channel SO.asset

@@ -0,0 +1,16 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 6764578043988ca4890c630631edc2f1, type: 3}
+  m_Name: Left XR Direct Interactor Event Channel SO
+  m_EditorClassIdentifier: 
+  _guid: 
+  description: 

package/Runtime/scripts/HandInteraction/HandData/Left XR Direct Interactor Event Channel SO.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0066aba6691a7734a94b1e9c74e7d8e2
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/scripts/HandInteraction/HandData/Right XR Direct Interactor Event Channel SO.asset

@@ -0,0 +1,16 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 6764578043988ca4890c630631edc2f1, type: 3}
+  m_Name: Right XR Direct Interactor Event Channel SO
+  m_EditorClassIdentifier: 
+  _guid: 
+  description: 

package/Runtime/scripts/HandInteraction/HandData/Right XR Direct Interactor Event Channel SO.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e65f25bfe0f34264a8dff83dfac263ff
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/scripts/HandInteraction/HandData/XRBaseInteractorEventChannelSO.cs

@@ -0,0 +1,18 @@
+using jeanf.EventSystem;
+using UnityEngine;
+using UnityEngine.Events;
+
+
+namespace jeanf.vrplayer
+{
+    [CreateAssetMenu(menuName = "Events/XRBaseInteractor Event Channel")]
+    public class XRBaseInteractorEventChannelSO : DescriptionBaseSO
+    {
+        public UnityAction<UnityEngine.XR.Interaction.Toolkit.Interactors.XRBaseInteractor> OnEventRaised;
+
+        public void RaiseEvent(UnityEngine.XR.Interaction.Toolkit.Interactors.XRBaseInteractor value)
+        {
+            OnEventRaised?.Invoke(value);
+        }
+    }
+}