fr.jeanf.universal.player 0.7.3

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

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

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

@@ -0,0 +1,43 @@
+using UnityEngine;
+using UnityEngine.Events;
+using UnityEngine.Serialization;
+
+
+namespace jeanf.vrplayer
+{
+    [System.Serializable]
+    public class XRBaseInteractorEvent : UnityEvent<UnityEngine.XR.Interaction.Toolkit.Interactors.XRBaseInteractor>
+    {
+
+    }
+	
+    public class XRBaseInteractorListener : MonoBehaviour
+    {
+        public XRBaseInteractorEventChannelSO _channel = default;
+
+        public XRBaseInteractorEvent OnEventRaised;
+
+        private void OnEnable()
+        {
+            if (_channel != null)
+                _channel.OnEventRaised += Respond;
+        }
+
+        private void OnDisable()
+        {
+            if (_channel != null)
+                _channel.OnEventRaised -= Respond;
+        }
+
+        private void Respond(UnityEngine.XR.Interaction.Toolkit.Interactors.XRBaseInteractor value)
+        {
+            OnEventRaised?.Invoke(value);
+        }
+
+        public XRBaseInteractorListener(XRBaseInteractorEventChannelSO _channel, XRBaseInteractorEvent onEventRaised)
+        {
+            this._channel = _channel;
+            this.OnEventRaised = onEventRaised;
+        }
+    }
+}

package/Runtime/scripts/HandInteraction/HandData/XRBaseInteractorListener.cs.meta

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

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

@@ -0,0 +1,39 @@
+using System;
+using jeanf.EventSystem;
+using UnityEngine;
+using UnityEngine.Events;
+using UnityEngine.Serialization;
+using UnityEngine.XR.Interaction.Toolkit.Interactors;
+
+namespace jeanf.vrplayer
+{
+    public class XRBaseInteractorSender : MonoBehaviour
+    {
+        private XRBaseInteractor baseInteractor;
+    
+        [Header("Broadcasting on:")]
+        [SerializeField] private XRBaseInteractorEventChannelSO XRBaseInteractorMessageChannel;
+
+        public void SendXRDirectInteractor()
+        {
+            if (!baseInteractor) Debug.Log("SendXRDirectInteractor, target is null");
+            XRBaseInteractorMessageChannel.RaiseEvent(baseInteractor);
+        }
+
+        private void Update()
+        {
+            if (!baseInteractor) Debug.Log("update, target is null");
+
+            if (baseInteractor) return;
+            try
+            {
+                baseInteractor = this.transform.GetComponent<XRBaseInteractor>();
+            }
+            catch (Exception)
+            {   
+                baseInteractor = this.transform.GetComponentInChildren<XRBaseInteractor>();
+            }
+            SendXRDirectInteractor();
+        }
+    }
+}

package/Runtime/scripts/HandInteraction/HandData/XRBaseInteractorSender.cs.meta

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

package/Runtime/scripts/HandInteraction/HandData.cs

@@ -0,0 +1,14 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class HandData : MonoBehaviour
+{
+    public enum HandModelType { Left, Right}
+
+    public HandModelType handType;
+    public Transform root;
+    public Animator animator;
+    public Transform[] fingerBones;
+    
+}

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

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

package/Runtime/scripts/HandInteraction/HandData.meta

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

package/Runtime/scripts/HandInteraction/HandPoser/Hands/BaseHand.cs

@@ -0,0 +1,127 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using jeanf.EventSystem;
+using UnityEngine;
+using LitMotion;
+
+using jeanf.propertyDrawer;
+using UnityEngine.Serialization;
+
+public abstract class BaseHand : MonoBehaviour, IDebugBehaviour
+{
+    public bool isDebug
+    { 
+        get => _isDebug;
+        set => _isDebug = value; 
+    }
+    [SerializeField] private bool _isDebug = false;
+    
+    // Neutral pose for the hand
+    [SerializeField] protected Pose defaultPose = null;
+
+    // Serialized so it can be used in editor by the preview hand
+    [SerializeField] protected List<Transform> fingerRoots = new List<Transform>();
+
+    // What kind of hand is this?
+    [SerializeField] protected HandType handType = HandType.None;
+    public HandType HandType => handType;
+
+    public List<Transform> Joints { get; protected set; } = new List<Transform>();
+
+    [FormerlySerializedAs("isLerpingOverTipe")] public bool isLerpingOverTime = true;
+    [DrawIf("isLerpingOverTipe", true, ComparisonType.Equals)]
+    [SerializeField] private float lerpTime = .2f;
+
+    protected virtual void Awake()
+    {
+        Joints = CollectJoints();
+    }
+
+    protected List<Transform> CollectJoints()
+    {
+        List<Transform> joints = new List<Transform>();
+
+        foreach (Transform root in fingerRoots)
+            joints.AddRange(root.GetComponentsInChildren<Transform>());
+
+        return joints;
+    }
+
+    public List<Quaternion> GetJointRotations()
+    {
+        List<Quaternion> rotations = new List<Quaternion>();
+
+        foreach (Transform joint in Joints)
+            rotations.Add(joint.localRotation);
+
+        return rotations;
+    }
+
+    public void ApplyDefaultPose()
+    {
+        ApplyPose(defaultPose);
+    }
+    public void ApplyDefaultPoseForeSetup()
+    {
+        ApplyPoseForSetup(defaultPose);
+    }
+
+    public void ApplyPose(Pose pose)
+    {
+        if (pose == null) return;
+        //Pose name
+        if(isDebug) Debug.Log($"pose.name : {pose.name}");
+        
+        // Get the proper info using hand's type
+        HandInfo handInfo = pose.GetHandInfo(handType);
+
+        // Apply rotations 
+        if (handInfo == null) return;
+        ApplyFingerRotations(handInfo.fingerRotations);
+
+        // Position, and rotate, this differs on the type of hand
+        //ApplyOffset(handInfo.attachPosition, handInfo.attachRotation);
+    }
+    public void ApplyPoseForSetup(Pose pose)
+    {
+        if (pose == null) return;
+        // Get the proper info using hand's type
+        HandInfo handInfo = pose.GetHandInfo(handType);
+
+        // Apply rotations 
+        if (handInfo == null) return;
+        ApplyFingerRotations(handInfo.fingerRotations);
+
+        // Position, and rotate, this differs on the type of hand
+        ApplyOffset(handInfo.attachPosition, handInfo.attachRotation);
+    }
+
+    public void ApplyFingerRotations(List<Quaternion> rotations)
+    {
+        // Make sure we have the rotations for all the joints
+        if (!HasProperCount(rotations)) return;
+        // Set the local rotation of each joint
+
+        foreach (var (value, i) in Joints.Select((value, i) => ( value, i )))
+        {
+            if (!isLerpingOverTime)
+            {
+                Joints[i].localRotation = rotations[i];
+            }
+            else
+            { 
+                var from = value.localRotation;
+                var to = rotations[i];
+                LMotion.Create(from, to, lerpTime).Bind(x => Joints[i].localRotation = x);
+            }
+        }
+    }
+
+    private bool HasProperCount(List<Quaternion> rotations)
+    {
+        return Joints.Count == rotations.Count;
+    }
+
+    public abstract void ApplyOffset(Vector3 position, Quaternion rotation);
+}

package/Runtime/scripts/HandInteraction/HandPoser/Hands/BaseHand.cs.meta

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

package/Runtime/scripts/HandInteraction/HandPoser/Hands/GameplayHand.cs

@@ -0,0 +1,69 @@
+using UnityEngine;
+using UnityEngine.XR.Interaction.Toolkit;
+
+namespace jeanf.vrplayer
+{
+    public class GameplayHand : BaseHand
+{
+    // The interactor we react to
+    [SerializeField] private UnityEngine.XR.Interaction.Toolkit.Interactors.XRBaseInteractor targetInteractor = null;
+
+    private void OnEnable()
+    {
+        // Subscribe to selected events
+        targetInteractor.selectEntered.AddListener(TryApplyObjectPose);
+        targetInteractor.selectExited.AddListener(TryApplyDefaultPose);
+    }
+
+    private void OnDisable()
+    {
+        // Unsubscribe to selected events
+        targetInteractor.selectEntered.RemoveListener(TryApplyObjectPose);
+        targetInteractor.selectExited.RemoveListener(TryApplyDefaultPose);
+    }
+
+    private void TryApplyObjectPose(SelectEnterEventArgs args)
+    {
+        var interactable = args.interactableObject as UnityEngine.XR.Interaction.Toolkit.Interactables.XRBaseInteractable;
+        // Try and get pose container, and apply
+        if (interactable != null && interactable.TryGetComponent(out PoseContainer poseContainer))
+        {
+            ApplyPose(poseContainer.pose);
+        }
+    }
+
+    private void TryApplyDefaultPose(SelectExitEventArgs args)
+    {
+        var interactable = args.interactableObject as UnityEngine.XR.Interaction.Toolkit.Interactables.XRBaseInteractable;
+    
+        // Try and get pose container, and apply
+        if (interactable != null && interactable.TryGetComponent(out PoseContainer poseContainer))
+        {
+            ApplyDefaultPose();
+        }
+    }
+
+    public override void ApplyOffset(Vector3 position, Quaternion rotation)
+    {
+        // Invert since the we're moving the attach point instead of the hand
+        Vector3 finalPosition = position * -1.0f;
+        Quaternion finalRotation = Quaternion.Inverse(rotation);
+
+        // Since it's a local position, we can just rotate around zero
+        finalPosition = finalPosition.RotatePointAroundPivot(Vector3.zero, finalRotation.eulerAngles);
+
+        // Set the position and rotach of attach
+        targetInteractor.attachTransform.localPosition = finalPosition;
+        targetInteractor.attachTransform.localRotation = finalRotation;
+    }
+
+    private void OnValidate()
+    {
+        // Let's have this done automatically, but not hide the requirement
+        if (!targetInteractor)
+        {
+            targetInteractor = GetComponentInParent<UnityEngine.XR.Interaction.Toolkit.Interactors.XRBaseInteractor>();
+        }
+    }
+}
+}

package/Runtime/scripts/HandInteraction/HandPoser/Hands/GameplayHand.cs.meta

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

package/Runtime/scripts/HandInteraction/HandPoser/Hands/HandsDisplayer.cs

@@ -0,0 +1,38 @@
+using jeanf.EventSystem;
+using jeanf.vrplayer;
+using UnityEngine;
+
+public class HandsDisplayer : MonoBehaviour
+{
+    [SerializeField] GameObject rightHand;
+    [SerializeField] GameObject leftHand;
+    [SerializeField] VoidEventChannelSO changedControlSchemeChannel;
+
+    private void Awake()
+    {
+        DisplayHands();
+    }
+    private void OnEnable()
+    {
+        
+        changedControlSchemeChannel.OnEventRaised += DisplayHands; 
+    }
+
+
+
+    void DisplayHands()
+    {
+        if (BroadcastControlsStatus.controlScheme == BroadcastControlsStatus.ControlScheme.XR)
+        {
+            rightHand?.SetActive(true);
+            leftHand?.SetActive(true);
+        }
+        else
+        {
+            rightHand?.SetActive(false);
+            leftHand?.SetActive(false);
+        }
+    }
+
+
+}

package/Runtime/scripts/HandInteraction/HandPoser/Hands/HandsDisplayer.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 28e22f5c3f8c25244ae9cabddbefd64b

package/Runtime/scripts/HandInteraction/HandPoser/Hands/PreviewHand.cs

@@ -0,0 +1,61 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+[SelectionBase]
+[ExecuteInEditMode]
+public class PreviewHand : BaseHand
+{
+    public void MirrorAndApplyPose(PreviewHand sourceHand)
+    {
+        // Mirror and apply the joint values
+        List<Quaternion> mirroredRotations = MirrorJoints(sourceHand.Joints);
+        ApplyFingerRotations(mirroredRotations);
+
+        // Mirror and apply the position and rotation
+        Vector3 mirroredPosition = MirrorPosition(sourceHand.transform);
+        Quaternion mirroredRotation = MirrorRotation(sourceHand.transform);
+        ApplyOffset(mirroredPosition, mirroredRotation);
+    }
+
+    private List<Quaternion> MirrorJoints(List<Transform> joints)
+    {
+        List<Quaternion> mirroredJoints = new List<Quaternion>();
+
+        foreach (Transform joint in joints)
+        {
+            Quaternion inversedRotation = MirrorJoint(joint);
+            mirroredJoints.Add(inversedRotation);
+        }
+
+        return mirroredJoints;
+    }
+
+    private Quaternion MirrorJoint(Transform sourceTransform)
+    {
+        Quaternion mirrorRotation = sourceTransform.localRotation;
+        mirrorRotation.y *= -1.0f;
+
+        return mirrorRotation;
+    }
+
+    private Quaternion MirrorRotation(Transform sourceTransform)
+    {
+        Quaternion mirrorRotation = sourceTransform.localRotation;
+        mirrorRotation.y *= -1.0f;
+        mirrorRotation.z *= -1.0f;
+        return mirrorRotation;
+    }
+
+    private Vector3 MirrorPosition(Transform sourceTransform)
+    {
+        Vector3 mirroredPosition = sourceTransform.localPosition;
+        mirroredPosition.x *= -1.0f;
+        return mirroredPosition;
+    }
+
+    public override void ApplyOffset(Vector3 position, Quaternion rotation)
+    {
+        transform.localPosition = position;
+        transform.localRotation = rotation;
+    }
+}

package/Runtime/scripts/HandInteraction/HandPoser/Hands/PreviewHand.cs.meta

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

package/Runtime/scripts/HandInteraction/HandPoser/Hands/Support/HandInfo.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+[Serializable]
+public class HandInfo
+{
+    public Vector3 attachPosition = Vector3.zero;
+    public Quaternion attachRotation = Quaternion.identity;
+    public List<Quaternion> fingerRotations = new List<Quaternion>();
+
+    public static HandInfo Empty => new HandInfo();
+
+    public void Save(PreviewHand hand)
+    {
+        // Save position and rotation
+        attachPosition = hand.transform.localPosition;
+        attachRotation = hand.transform.localRotation;
+
+        // Save rotations from the hand's current joints
+        fingerRotations = hand.GetJointRotations();
+    }
+}

package/Runtime/scripts/HandInteraction/HandPoser/Hands/Support/HandInfo.cs.meta

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

package/Runtime/scripts/HandInteraction/HandPoser/Hands/Support/HandType.cs

@@ -0,0 +1,6 @@
+public enum HandType
+{
+    None,
+    Left,
+    Right,
+}

package/Runtime/scripts/HandInteraction/HandPoser/Hands/Support/HandType.cs.meta

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

package/Runtime/scripts/HandInteraction/HandPoser/Hands/Support.meta

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

package/Runtime/scripts/HandInteraction/HandPoser/Hands.meta

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

package/Runtime/scripts/HandInteraction/HandPoser/Pose/Pose.cs

@@ -0,0 +1,27 @@
+using UnityEngine;
+
+[SerializeField]
+[CreateAssetMenu(fileName = "NewPoseData")]
+public class Pose : ScriptableObject
+{
+    // Info for each hand
+    public HandInfo leftHandInfo = HandInfo.Empty;
+    public HandInfo rightHandInfo = HandInfo.Empty;
+
+    public HandInfo GetHandInfo(HandType handType)
+    {
+        // Return Left or Right, you can use a dictionary or different pose appliers
+        switch (handType)
+        {
+            case HandType.Left:
+                return leftHandInfo;
+            case HandType.Right:
+                return rightHandInfo;
+            case HandType.None:
+                return HandInfo.Empty;
+        }
+
+        // Return an empty 
+        return HandInfo.Empty;
+    }
+}

package/Runtime/scripts/HandInteraction/HandPoser/Pose/Pose.cs.meta

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