fr.jeanf.universal.player 0.7.3

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

@@ -0,0 +1,76 @@
+using jeanf.EventSystem;
+using UnityEngine;
+using UnityEngine.XR.Interaction.Toolkit;
+using UnityEngine.XR.Interaction.Toolkit.Interactables;
+
+namespace jeanf.vrplayer
+{
+    public class PoseContainer : MonoBehaviour, IDebugBehaviour
+    {
+        public bool isDebug
+        {
+            get => _isDebug;
+            set => _isDebug = value;
+        }
+        [SerializeField] private bool _isDebug = false;
+        // The pose is when this object is grabbed
+        public Pose pose = null;
+    
+        // The interactor we react to
+        private XRGrabInteractable _grabInteractable;
+
+        [Header("Left attach transform")]
+        [SerializeField] private Vector3 leftAttachPosition;
+        [SerializeField] private Vector3 leftAttachRotation;
+        
+        [Header("Right attach transform")]
+        [SerializeField] private Vector3 rightAttachPosition;
+        [SerializeField] private Vector3 rightAttachRotation;
+
+        [Header("Listening On")]
+        VoidEventChannelSO leftHandHovered;
+        VoidEventChannelSO rightHandHovered;
+        private void Awake()
+        {
+            _grabInteractable = GetComponent<XRGrabInteractable>();
+        }
+
+        public void SetAttachTransform_Left() => SetAttachTransform(HandType.Left);
+        public void SetAttachTransform_Right() => SetAttachTransform(HandType.Right);
+        public void SetAttachTransform(HandType handSide)
+        {
+            switch (handSide)
+            {
+                case HandType.Left:
+                    _grabInteractable.attachTransform.localPosition = leftAttachPosition;
+                    _grabInteractable.attachTransform.localEulerAngles = leftAttachRotation;
+                    break;
+                case HandType.Right:
+                    _grabInteractable.attachTransform.localPosition = rightAttachPosition;
+                    _grabInteractable.attachTransform.localEulerAngles = rightAttachRotation;
+                    break;
+            }
+        }
+
+
+
+        //public void SetAttachTransform(HandInfo handInfo)
+        //{
+        //    //Debug.Log("SetAttachTransform");
+        //    //if (_grabInteractable == null)
+        //    //{
+        //    //    _grabInteractable = GetComponent<XRGrabInteractable>();
+        //    //}
+        //    //// in case there is no attatch transform in the Grab Interactable
+        //    //if (_grabInteractable.attachTransform == null)
+        //    //    Instantiate(new GameObject("attachTransform"), _grabInteractable.transform);
+
+        //    //_grabInteractable.attachTransform.position = handInfo.attachPosition;
+        //    //_grabInteractable.attachTransform.rotation = handInfo.attachRotation;
+
+        //    //if (_isDebug) Debug.Log($"attach transform pos: [{handInfo.attachPosition}], rot: [{handInfo.attachRotation.eulerAngles}] ");
+        //}
+
+    }
+}
+

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

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

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

@@ -0,0 +1,93 @@
+using UnityEngine;
+
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+[ExecuteInEditMode]
+public class HandManager : MonoBehaviour
+{
+    // The hand prefabs we're using
+    [SerializeField] private bool hideHands = true;
+    [SerializeField] private GameObject leftHandPrefab = null;
+    [SerializeField] private GameObject rightHandPrefab = null;
+
+    // The references to the hands being manipulated
+    public PreviewHand LeftHand { get; private set; } = null;
+    public PreviewHand RightHand { get; private set; } = null;
+    public bool HandsExist => LeftHand && RightHand;
+
+    private void OnEnable()
+    {
+        CreateHandPreviews();
+    }
+
+    private void OnDisable()
+    {
+        DestroyHandPreviews();
+    }
+
+    private void CreateHandPreviews()
+    {
+        // Create both hands
+        LeftHand = CreateHand(leftHandPrefab);
+        RightHand = CreateHand(rightHandPrefab);
+    }
+
+    private PreviewHand CreateHand(GameObject prefab)
+    {
+        // Create the hand
+        GameObject handObject = Instantiate(prefab, transform);
+
+        // If we want to hide the hand, this prevents accidental manual deletion
+        if (hideHands)
+            handObject.hideFlags = HideFlags.HideInHierarchy | HideFlags.DontSave;
+
+        // Get the preview to save
+        return handObject.GetComponent<PreviewHand>();
+    }
+
+    private void DestroyHandPreviews()
+    {
+        // Make sure to destroy the gameobjects
+        #if UNITY_EDITOR
+        DestroyImmediate(LeftHand.gameObject);
+        DestroyImmediate(RightHand.gameObject);
+        #endif
+    }
+
+    public void UpdateHands(Pose pose, Transform parentTransform)
+    {
+        // Child the hands to the object we're working with, simplifies everything
+        LeftHand.transform.parent = parentTransform;
+        RightHand.transform.parent = parentTransform;
+
+        // Pose 'em!
+        LeftHand.ApplyPose(pose);
+        RightHand.ApplyPose(pose);
+    }
+    public void UpdateHandsForSetup(Pose pose, Transform parentTransform)
+    {
+        // Child the hands to the object we're working with, simplifies everything
+        if (!LeftHand || !RightHand) return;
+        LeftHand.transform.parent = parentTransform;
+        RightHand.transform.parent = parentTransform;
+
+        // Pose 'em!
+        LeftHand.ApplyPoseForSetup(pose);
+        RightHand.ApplyPoseForSetup(pose);
+    }
+
+    public void SavePose(Pose pose)
+    {
+        // Mark object as dirty for saving
+        #if UNITY_EDITOR
+        EditorUtility.SetDirty(pose);
+        #endif
+
+        // Copy the hand info into
+        pose.leftHandInfo.Save(LeftHand);
+        pose.rightHandInfo.Save(RightHand);
+    }
+
+}

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

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

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

@@ -0,0 +1,110 @@
+using UnityEngine;
+
+
+#if UNITY_EDITOR
+using UnityEditor;
+using UnityEditor.SceneManagement;
+#endif
+
+namespace jeanf.vrplayer
+{
+    [ExecuteInEditMode]
+    public class SelectionHandler : MonoBehaviour
+    {
+        public UnityEngine.XR.Interaction.Toolkit.Interactables.XRBaseInteractable CurretInteractable { get; private set; } = null;
+
+        public bool CheckForNewInteractable()
+        {
+            // First see if we have an interactable to use
+            UnityEngine.XR.Interaction.Toolkit.Interactables.XRBaseInteractable newInteractable = GetInteractable();
+
+            // Update if different
+            bool isDifferent = IsDifferentInteractable(CurretInteractable, newInteractable);
+            CurretInteractable = isDifferent ? newInteractable : CurretInteractable;
+
+            return isDifferent;
+        }
+
+        private UnityEngine.XR.Interaction.Toolkit.Interactables.XRBaseInteractable GetInteractable()
+        {
+            // Set up the stuff now
+            UnityEngine.XR.Interaction.Toolkit.Interactables.XRBaseInteractable newInteractable = null;
+            GameObject selectedObject = null;
+
+            #if UNITY_EDITOR
+            selectedObject = Selection.activeGameObject;
+            #endif
+
+            // If we have an object selected
+            if (selectedObject)
+            {
+                // Does it have an interactable component
+                if (selectedObject.TryGetComponent(out UnityEngine.XR.Interaction.Toolkit.Interactables.XRBaseInteractable interactable))
+                    newInteractable = interactable;
+            }
+
+            return newInteractable;
+        }
+
+        private bool IsDifferentInteractable(UnityEngine.XR.Interaction.Toolkit.Interactables.XRBaseInteractable currentInteractable, UnityEngine.XR.Interaction.Toolkit.Interactables.XRBaseInteractable newInteractable)
+        {
+            // Assume it's the same
+            bool isDifferent = false;
+
+            // If we're selecting on object for the first time, it's true
+            if (!currentInteractable)
+                isDifferent = true;
+
+            // If we have a stored object, and we select a new one
+            if (currentInteractable && newInteractable)
+                isDifferent = currentInteractable != newInteractable;
+
+            return isDifferent;
+        }
+
+        public GameObject SetObjectPose(Pose pose)
+        {
+            GameObject selectedObject = null;
+
+            #if UNITY_EDITOR
+            selectedObject = Selection.activeGameObject;
+            #endif
+
+            if (selectedObject)
+            {
+                // Check if the object has a container to put a pose into
+                if (selectedObject.TryGetComponent(out PoseContainer poseContainer))
+                {
+                    // Set the pose, mark as dirty to save
+                    poseContainer.pose = pose;
+
+                    // Mark scene for saving
+                    MarkActiveSceneAsDirty();
+                }
+            }
+
+            return selectedObject;
+        }
+
+        public Pose TryGetPose(GameObject targetObject)
+        {
+            Pose pose = null;
+
+            if (targetObject)
+            {
+                // Check if the object has a container to take a pose from
+                if (targetObject.TryGetComponent(out PoseContainer poseContainer))
+                    pose = poseContainer.pose;
+            }
+
+            return pose;
+        }
+
+        private void MarkActiveSceneAsDirty()
+        {
+            #if UNITY_EDITOR
+            EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene());
+            #endif
+        }
+    }
+}

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

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

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

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

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

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

package/Runtime/scripts/HandInteraction/HandPoser/Utility/Extensions.cs

@@ -0,0 +1,11 @@
+using UnityEngine;
+
+public static class Extensions
+{
+    public static Vector3 RotatePointAroundPivot(this Vector3 point, Vector3 pivot, Vector3 angles)
+    {
+        Vector3 direction = point - pivot;
+        direction = Quaternion.Euler(angles) * direction;
+        return direction + pivot;
+    }
+}

package/Runtime/scripts/HandInteraction/HandPoser/Utility/Extensions.cs.meta

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

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

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

package/Runtime/scripts/HandInteraction/HandPoser.meta

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

package/Runtime/scripts/HandInteraction/HandVibration.cs

@@ -0,0 +1,35 @@
+using jeanf.EventSystem;
+using UnityEngine;
+using UnityEngine.XR.Interaction.Toolkit;
+using UnityEngine.XR.Interaction.Toolkit.Inputs.Haptics;
+public class HandVibration : MonoBehaviour
+{
+    [SerializeField] HapticImpulsePlayer leftHandHapticImpulse;
+    [SerializeField] HapticImpulsePlayer rightHandHapticImpulse;
+    [Range(0.01f, 1.0f)][SerializeField] float amplitude;
+    [Range(0.01f, 1.0f)][SerializeField] float duration;
+
+    [Header("Listening On")]
+    [SerializeField] StringEventChannelSO hapticFeedbackOnSpecificHandSO;
+    private void OnEnable()
+    {
+        hapticFeedbackOnSpecificHandSO.OnEventRaised += TriggerHapticFeedback;
+    }
+
+    private void OnDisable()
+    {
+        hapticFeedbackOnSpecificHandSO.OnEventRaised += TriggerHapticFeedback;
+    }
+    private void TriggerHapticFeedback(string hand)
+    {
+        switch (hand)
+        {
+            case "Right":
+                rightHandHapticImpulse.SendHapticImpulse(amplitude, duration);
+                break;
+            case "Left":
+                leftHandHapticImpulse.SendHapticImpulse(amplitude, duration);
+                break;
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8c8b4115e1573a547b163e056a26bf0a

package/Runtime/scripts/HandInteraction/HandsAppearanceManager.cs

@@ -0,0 +1,212 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using jeanf.EventSystem;
+using LitMotion;
+using UnityEngine.InputSystem;
+
+namespace jeanf.vrplayer
+{
+    using jeanf.propertyDrawer;
+    [ExecuteAlways]
+    public class HandsAppearanceManager : MonoBehaviour
+    {
+        [SerializeField] private bool isDebug = false;
+        
+        [Header("Settings")]
+        [SerializeField] private float blendTime = 1.0f;
+        private float _blendValue = 100.0f;
+        [Range(0,100)]
+        [SerializeField] private float gender = 100.0f;
+
+        public float Gender
+        {
+            get => gender;
+            set => gender = value;
+        }
+
+        [Range(0,100)]
+        [SerializeField] private float bodyMass = 100.0f;
+        
+        public float BodyMass
+        {
+            get => bodyMass;
+            set => bodyMass = value;
+        }
+        [Range(0,1)]
+        [SerializeField] private float skinDarkness = 1.0f;
+        public float SkinDarkness
+        {
+            get => skinDarkness;
+            set => skinDarkness = value;
+        }
+        [SerializeField] private Color lightSkinColor;
+        [SerializeField] private Color darkSkinColor;
+        [Range(0,1)]
+        [SerializeField] private float gloveValue = 1.0f;
+
+        private MotionHandle _gloveHandle;
+        
+        [Header("Hands detected")]
+        [SerializeField] private List<SkinnedMeshRenderer> _hands = new List<SkinnedMeshRenderer>();
+
+        [Header("States")]
+        [ReadOnly] [SerializeField] private bool isGlove = false;
+        [ReadOnly] [SerializeField] private bool isHandVisible = true;
+        [ReadOnly] [SerializeField] private bool lastHandVisibility = true;
+        [ReadOnly] [SerializeField] private bool canUpdate = false;
+
+
+        private float tolerance = 0.01f;
+
+        [Header("Action binding")]
+        [SerializeField] private InputActionReference shiftTypeHandAction;
+        
+        //[SerializeField] private Material skin;
+        //[SerializeField] private Material nail;
+        private static readonly int SkinBaseColor = Shader.PropertyToID("_BaseColor");
+        //private static readonly int SkinDarness = Shader.PropertyToID("_SkinDarkness");
+        private static readonly int _gloveValue = Shader.PropertyToID("_Switch_Gloves");
+
+        [SerializeField] private readonly int _genderValue = Shader.PropertyToID("_Switch_Woman");
+        //[Range(0,100)]
+        //[SerializeField] private float nailDarkness = 10f;
+
+
+        [Header("Listening on:")]
+        [SerializeField] private BoolEventChannelSO gloveStateChannel;
+
+        //[SerializeField] private BoolEventChannelSO hmdStateChannel;
+        private void OnEnable()
+        {
+            BlendableHand.AddHand += AddHand;
+            BlendableHand.RemoveHand += RemoveHand;
+            gloveStateChannel.OnEventRaised += SetGloveState;
+            //hmdStateChannel.OnEventRaised += SetUpdateState;
+        }
+
+        private void OnDisable() => Unsubscribe();
+        private void OnDestroy() => Unsubscribe();
+
+        private void Unsubscribe()
+        {
+            _hands.Clear();
+            _hands.TrimExcess();
+            BlendableHand.AddHand -= AddHand;
+            BlendableHand.RemoveHand -= RemoveHand;
+            gloveStateChannel.OnEventRaised -= SetGloveState;
+            //hmdStateChannel.OnEventRaised -= SetUpdateState;
+        }
+
+        private void Update()
+        {
+            if(BroadcastControlsStatus.controlScheme == BroadcastControlsStatus.ControlScheme.XR)
+            {
+                SetHandsVisibility(true);
+                SetHandMaterials(_hands, gender * 0.01f);
+                SetGloveValue(_hands, gloveValue);
+                SetGender(_hands, gender);
+                SetBodyMass(_hands, bodyMass);
+                SetSkinDarkness(_hands, skinDarkness);
+            }
+            //SetBlendValueFromGender(gender);
+        }
+        private void AddHand(SkinnedMeshRenderer hand)
+        {
+            if (!_hands.Contains(hand))
+            {
+                _hands.Add(hand);
+                SetGender(_hands, gender);
+                SetHandsVisibility(isHandVisible);
+            }
+
+        }
+        private void RemoveHand(SkinnedMeshRenderer hand)
+        {
+            if(_hands.Count > 0 && _hands.Contains(hand)) _hands.Remove(hand);
+        }
+
+        
+        private void SetBlendValueFromGender(bool gender)
+        {
+            _blendValue = gender ? 100f : 0f;
+        }
+
+        
+        private void SetGender(List<SkinnedMeshRenderer> hands, float value)
+        {
+            foreach (var hand in hands)
+            {
+                hand.SetBlendShapeWeight(0, value);
+            }
+        }
+        
+        private void SetBodyMass(List<SkinnedMeshRenderer> hands, float value)
+        {
+            foreach (var hand in hands)
+            {
+                hand.SetBlendShapeWeight(2, value);
+            }
+        }
+
+
+        private void SetHandMaterials(List<SkinnedMeshRenderer> hands, float value)
+        {
+            if(hands.Count < 1) return;
+            foreach (var hand in hands)
+            {
+                hand.sharedMaterial.SetFloat(_genderValue, value);
+            }
+        }
+
+        private void SetSkinDarkness(List<SkinnedMeshRenderer> hands, float skinDarness)
+        {
+            if(hands.Count < 1) return;
+            var blend = Color.Lerp(lightSkinColor, darkSkinColor, skinDarkness);
+            foreach (var hand in hands)
+            {
+                hand.sharedMaterials[0].SetColor(SkinBaseColor, blend);
+            }
+        }
+
+        private void SetGloveValue(List<SkinnedMeshRenderer> hands, float value)
+        {
+            if(hands.Count < 1) return;
+            foreach (var mat in hands.SelectMany(hand => hand.sharedMaterials))
+            {
+                mat.SetFloat(_gloveValue, value);
+            }
+        }
+        
+        private void LerpGloveTowardsValue(float goalValue, float blendTime)
+        {
+            _gloveHandle = LMotion.Create(gloveValue,goalValue,blendTime)
+                .Bind(x => gloveValue = x);
+        }
+
+        public void SetGloveState(bool state)
+        {
+            if(isDebug) Debug.Log($"glove state {state}");
+            isGlove = state;
+            var goalValue = isGlove ? 1 : 0;
+            LerpGloveTowardsValue(goalValue, blendTime);
+        }
+
+        public void SetUpdateState(bool updateState)
+        {
+            isHandVisible = updateState;
+            canUpdate = updateState;
+        }
+
+        public void SetHandsVisibility(bool state)
+        {
+            foreach (var hand in _hands)
+            {
+                hand.enabled = state;
+            }
+
+            lastHandVisibility = state;
+        }
+    }
+}

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

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

package/Runtime/scripts/HandInteraction/HandsStateController.cs

@@ -0,0 +1,32 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace jeanf.vrplayer 
+{
+    public class HandsStateController : MonoBehaviour
+    {
+        [SerializeField] GameObject hand_left;
+        [SerializeField] GameObject hand_right;
+        private void Awake()
+        {
+            SetHandsState(false);
+        }
+        void OnEnable()
+        {
+            //BroadcastHmdStatus.hmdStatus += SetHandsState;
+        }
+        void OnDestroy() => Unsubscribe();
+        void OnDisable() => Unsubscribe();
+        void Unsubscribe()
+        {
+            //BroadcastHmdStatus.hmdStatus -= SetHandsState;
+        }
+
+        public void SetHandsState(bool state)
+        {
+            hand_left.SetActive(state);
+            hand_right.SetActive(state);
+        }
+    }
+}

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

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