fr.jeanf.universal.player 0.7.3

package/Runtime/scripts/Gaze/FPSCameraMovement.cs

@@ -0,0 +1,224 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using jeanf.EventSystem;
+using UnityEngine;
+using UnityEngine.InputSystem;
+using UnityEngine.Serialization;
+using jeanf.validationTools;
+
+namespace jeanf.vrplayer
+{
+    public class FPSCameraMovement : MonoBehaviour, IDebugBehaviour, IValidatable
+    {
+        public bool isDebug
+        {
+            get => _isDebug;
+            set => _isDebug = value;
+        }
+        [SerializeField] private bool _isDebug = false;
+
+        public bool IsValid { get; private set; }
+
+        private Vector2 _inputView;
+
+        public float mouseSensitivity
+        {
+            get { return _mouseSensitivity; }
+            set
+            {
+                if (isDebug) Debug.Log($"Mouse sensitivity set to {value}");
+                _mouseSensitivity = value;
+            }
+        }
+
+        [Range(0, 100.0f)][SerializeField] private float _mouseSensitivity = 45.0f;
+        [Range(0, 500.0f)][SerializeField] private float _gamepadSensitivity = 45.0f;
+        float sensitivity;
+        [SerializeField] private InputActionReference mouseXY;
+        public InputActionReference mouseXYInputAction {
+            get { return mouseXY; }
+            set { mouseXY = value; }
+        }
+        private static bool _canLook = true;
+        [Space(10)]
+        [SerializeField][Validation("A reference to the Player's Camera is required.")]
+        public Camera playerCamera;
+        [SerializeField][Validation("A reference to the cameraOffset is required.")]
+        private Transform cameraOffset;
+
+        public Transform CameraOffset { get { return cameraOffset; } }
+        private Transform _originalCameraOffset;
+        [SerializeField] private bool _isHmdActive = false;
+        [SerializeField] private float min = -60.0f;
+        [SerializeField] private float max = 75.0f;
+
+
+        private Vector2 _rotation = Vector2.zero;
+        private bool _cameraOffsetReset = false;
+        /*
+        [Header("Broadcasting on:")]
+        [SerializeField] private BoolEventChannelSO _canLookStateChannel;
+        //[SerializeField] private VoidEventChannelSO _invertPrimaryItemStateChannel;
+        */
+
+        [Header("Listening on:")]
+        [SerializeField] private BoolEventChannelSO mouselookStateChannel;
+        [SerializeField] private VoidEventChannelSO mouselookCameraReset;
+        [SerializeField] private TeleportEventChannelSO teleportEventChannel;
+        [SerializeField] private VoidEventChannelSO controlSchemeChangeEventChannel;
+        private bool cameraIsMoving;
+        private Vector2 moveValue;
+
+        private void Awake()
+        {
+            _originalCameraOffset = cameraOffset;
+            Init();
+        }
+
+        private void OnEnable()
+        {
+            mouseXY.action.performed += ctx => SetCameraMovement(ctx.ReadValue<Vector2>() * Time.smoothDeltaTime * .25f, true);
+            mouseXY.action.canceled += ctx => SetCameraMovement(ctx.ReadValue<Vector2>() * Time.smoothDeltaTime * .25f, false);
+            mouselookStateChannel.OnEventRaised += SetMouseState;
+            mouselookCameraReset.OnEventRaised += ResetCameraSettings;
+            teleportEventChannel.OnEventRaised += _ => ResetCameraSettings();
+            controlSchemeChangeEventChannel.OnEventRaised += ResetCameraOffset;
+
+        }
+
+        private void SetCameraMovement(Vector2 movement, bool cameraIsMoving)
+        {
+            moveValue = movement;
+            this.cameraIsMoving = cameraIsMoving;
+        }
+
+        private void OnDisable() => Unsubscribe();
+        private void OnDestroy() => Unsubscribe();
+
+        private void Unsubscribe()
+        {
+            mouseXY.action.performed += ctx => SetCameraMovement(ctx.ReadValue<Vector2>() * Time.smoothDeltaTime * .25f, true);
+            mouseXY.action.canceled += ctx => SetCameraMovement(ctx.ReadValue<Vector2>() * Time.smoothDeltaTime * .25f, false);
+            mouselookStateChannel.OnEventRaised -= SetMouseState;
+            mouselookCameraReset.OnEventRaised -= ResetCameraSettings;
+            teleportEventChannel.OnEventRaised -= _ => ResetCameraSettings();
+            controlSchemeChangeEventChannel.OnEventRaised -= ResetCameraOffset;
+
+        }
+
+
+        public void Init()
+        {
+            _canLook = !_isHmdActive;
+
+            ResetCameraSettings();
+
+        }
+
+
+
+        public void ResetCameraSettings()
+        {
+            if (BroadcastControlsStatus.controlScheme != BroadcastControlsStatus.ControlScheme.XR) SetMouseState(true);
+            playerCamera.fieldOfView = 60f;
+            _rotation = Vector2.zero;
+            cameraOffset.localPosition = _originalCameraOffset.localPosition;
+            cameraOffset.localRotation = _originalCameraOffset.localRotation;
+        }
+
+        public void ResetCameraOffset()
+        {
+            if (BroadcastControlsStatus.controlScheme == BroadcastControlsStatus.ControlScheme.XR)
+            {
+                cameraOffset.localPosition = Vector3.zero;
+                cameraOffset.localRotation = Quaternion.identity;
+            }
+        }
+
+        private void SetCursor(bool state)
+        {
+            Init();
+            _isHmdActive = state;
+        }
+
+        private void LateUpdate()
+        {
+
+            if (cameraIsMoving && (moveValue.x != 0 || moveValue.y != 0))
+            {
+                LookAround(moveValue);
+            }
+        }
+        private void LookAround(Vector2 inputView)
+        {
+            if (!_canLook) return;
+            if (BroadcastControlsStatus.controlScheme == BroadcastControlsStatus.ControlScheme.Gamepad)
+            {
+                sensitivity = _gamepadSensitivity;
+                
+            }
+            if (BroadcastControlsStatus.controlScheme == BroadcastControlsStatus.ControlScheme.KeyboardMouse)
+            {
+                sensitivity = _mouseSensitivity;
+                
+
+            }
+            else if (BroadcastControlsStatus.controlScheme == BroadcastControlsStatus.ControlScheme.XR) return;
+
+            if(isDebug) Debug.Log($"Mouse inputView value : ({inputView.x}:{inputView.y})");
+            _rotation.y += inputView.x * sensitivity;
+            _rotation.x += -inputView.y * sensitivity;
+            _rotation.x = Mathf.Clamp(_rotation.x, min, max);
+
+            cameraOffset.transform.localRotation = Quaternion.Euler(_rotation.x, _rotation.y, 0);
+        }
+        
+        public void SetMouseState(bool state)
+        {
+            if((_isDebug)) Debug.Log($"CanLook: {state}");
+            _canLook = state;
+            //_canLookStateChannel.RaiseEvent(!state);
+        }
+
+
+        public void InvertMouseLookState()
+        {
+            _canLook = !_canLook;
+            //_invertPrimaryItemStateChannel.RaiseEvent();
+        }
+
+        #if UNITY_EDITOR
+        private void OnValidate()
+        {
+            var invalidObjects = new List<object>();
+            var errorMessages = new List<string>();
+            var validityCheck = true;
+            
+            invalidObjects.Clear();
+            if (playerCamera == null)
+            {
+                invalidObjects.Add(playerCamera);
+                errorMessages.Add("No Camera set");
+                validityCheck = false;
+            }
+            else if (cameraOffset == null)
+            {
+                invalidObjects.Add(cameraOffset);
+                errorMessages.Add("No CameraOffset set");
+                validityCheck = false;
+            }
+            
+
+            IsValid = validityCheck;
+            if(!IsValid) return;
+
+            if (IsValid && !Application.isPlaying) return;
+            for(var i = 0 ; i < invalidObjects.Count ; i++)
+            {
+                Debug.LogError($"Error: {errorMessages[i]} " , this.gameObject);
+            }
+        }
+        #endif
+    }
+}

package/Runtime/scripts/Gaze/FPSCameraMovement.cs.meta

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

package/Runtime/scripts/Gaze/NoPeeking.cs

@@ -0,0 +1,60 @@
+using jeanf.EventSystem;
+using UnityEngine;
+using UnityEngine.Serialization;
+
+namespace jeanf.vrplayer
+{
+    public class NoPeeking : MonoBehaviour, IDebugBehaviour
+    {
+        public bool isDebug
+        { 
+            get => _isDebug;
+            set => _isDebug = value; 
+        }
+        [SerializeField] private bool _isDebug = false;
+        
+        [SerializeField] private LayerMask collisionLayer;
+        [SerializeField] private float sphereCheckSize = .15f;
+
+        private bool isHeadInWall = false;
+        private bool isHeadInWallLastValue = false;
+        
+        [SerializeField] private bool isSceneLoading = false;
+        private void FixedUpdate()
+        {
+            if (isSceneLoading)
+            {
+                isHeadInWall = true;
+            }
+            else
+            {
+                if (isDebug) Debug.Log("NoPeeking - made it through the return");
+                if (Physics.CheckSphere(transform.position, sphereCheckSize, collisionLayer, QueryTriggerInteraction.Ignore))
+                {
+                    isHeadInWall = true;
+                }
+                else
+                {
+                    isHeadInWall = false;
+                }
+            }
+            
+            FadeMask.FadeValue(isHeadInWall);
+            if(isDebug) Debug.Log($"isHeadInWall: {isHeadInWall}");
+        }
+
+        #if UNITY_EDITOR
+        private void OnDrawGizmos()
+        {
+            Gizmos.color = new Color(0f, 1f, 0f, .75f);
+            Gizmos.DrawSphere(transform.position, sphereCheckSize);
+        }
+        #endif
+
+        public void SetCanFadeOutValue(bool value)
+        {
+            isSceneLoading = value;
+            if (isDebug) Debug.Log($"SetCanFadeOutValue - isSceneLoading: {isSceneLoading}");
+        }
+    }
+}

package/Runtime/scripts/Gaze/NoPeeking.cs.meta

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

package/Runtime/scripts/Gaze.meta

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

package/Runtime/scripts/HandInteraction/BlendableHand.cs

@@ -0,0 +1,30 @@
+using UnityEngine;
+
+namespace jeanf.vrplayer
+{
+    [RequireComponent(typeof(SkinnedMeshRenderer))]
+    public class BlendableHand : MonoBehaviour
+    {
+        public delegate void UpdateBlendableHandList(SkinnedMeshRenderer hand);
+        public static UpdateBlendableHandList AddHand;
+        public static UpdateBlendableHandList RemoveHand;
+    
+        private SkinnedMeshRenderer _hand;
+
+        private void Awake()
+        {
+            _hand = GetComponent<SkinnedMeshRenderer>() == null ? GetComponentInChildren<SkinnedMeshRenderer>() : GetComponent<SkinnedMeshRenderer>();
+        }
+
+        private void OnEnable()
+        {
+            AddHand?.Invoke(_hand);
+        }
+
+        private void OnDisable()
+        {
+            RemoveHand?.Invoke(_hand);
+        }
+    }
+}
+

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

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

package/Runtime/scripts/HandInteraction/Core/Hand.cs

@@ -0,0 +1,50 @@
+using UnityEngine;
+
+[RequireComponent(typeof(Animator))]
+public class Hand : MonoBehaviour
+{
+    private Animator animator;
+    private float gripTarget;
+    private float triggerTarget;
+    private float gripCurrent;
+    private float triggerCurrent;
+    [SerializeField] private float speed = 10.0f;
+    
+    private string animatorGripParam = "grip";
+    private string animatorTriggerParam = "trigger";
+    
+    private void Start()
+    {
+        animator = GetComponent<Animator>();
+    }
+
+    private void Update()
+    {
+        AnimateHand();
+    }
+
+    public void SetGrip(float value)
+    {
+        gripTarget = value;
+    }
+
+    public void SetTrigger(float readValue)
+    {
+        triggerTarget = readValue;
+    }
+
+    private void AnimateHand()
+    {
+        if (triggerCurrent != triggerTarget)
+        {
+            triggerCurrent = Mathf.MoveTowards(triggerCurrent, triggerTarget, Time.deltaTime * speed);
+            animator.SetFloat(animatorTriggerParam, triggerCurrent);
+        }
+        
+        if (gripCurrent != gripTarget)
+        {
+            gripCurrent = Mathf.MoveTowards(gripCurrent, gripTarget, Time.deltaTime * speed);
+            animator.SetFloat(animatorGripParam, gripCurrent);
+        }
+    }
+}

package/Runtime/scripts/HandInteraction/Core/Hand.cs.meta

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

package/Runtime/scripts/HandInteraction/Core/HandController.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.XR.Interaction.Toolkit;
+
+[RequireComponent(typeof(ActionBasedController))]
+public class HandController : MonoBehaviour
+{
+    private ActionBasedController _controller; 
+    [SerializeField] private Hand _hand;
+
+    private void Start()
+    {
+        _controller = GetComponent<ActionBasedController>();
+        _hand = GetComponentInChildren<Hand>();
+    }
+
+    private void Update()
+    {
+        if(!_hand) _hand = GetComponentInChildren<Hand>();
+        else
+        {
+            _hand.SetGrip(_controller.selectAction.action.ReadValue<float>());
+            _hand.SetTrigger(_controller.activateAction.action.ReadValue<float>());
+        }
+
+    }
+}

package/Runtime/scripts/HandInteraction/Core/HandController.cs.meta

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

package/Runtime/scripts/HandInteraction/Core/HandPoseManager.cs

@@ -0,0 +1,105 @@
+using jeanf.EventSystem;
+using UnityEngine;
+using UnityEngine.Events;
+using UnityEngine.XR.Interaction.Toolkit;
+
+namespace  jeanf.vrplayer
+{
+    public class HandPoseManager : BaseHand
+    {
+        // The interactor we react to
+        public UnityEngine.XR.Interaction.Toolkit.Interactors.XRBaseInteractor targetInteractor = null;
+
+        private bool wasInitialized = false;
+
+        public UnityEvent grabAction;
+        public UnityEvent ungrabAction;
+
+        private void OnEnable()
+        {
+           //Debug.Log(this.gameObject.name + " start " + targetInteractor.name);
+            Init();
+
+        }
+
+        
+
+        private void Init()
+        {
+            // Subscribe to selected events
+            //getDirectInteractor?.Invoke(handType,ref targetInteractor);
+            if(isDebug) Debug.Log($"targetInteractor : {targetInteractor.name}");
+            if (!targetInteractor)
+                return;
+
+            //targetInteractor.onSelectEntered.AddListener(TryApplyObjectPose);
+            //targetInteractor.onSelectExited.AddListener(TryApplyDefaultPose);
+            targetInteractor.selectEntered.AddListener(TryApplyObjectPose);
+            targetInteractor.selectExited.AddListener(TryApplyDefaultPose);
+
+            wasInitialized = true;
+        }
+
+        private void OnDisable()
+        {
+            if (!wasInitialized) return;
+            if (!targetInteractor) return;
+            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.TryGetComponent(out PoseContainer poseContainer)) return;
+            grabAction.Invoke();
+            if(isDebug) Debug.Log($"Pose name : {poseContainer.pose.name}");
+            //move AttachTransform
+            //AplyPose
+            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.TryGetComponent(out PoseContainer poseContainer)) return;
+            ungrabAction.Invoke();
+            ApplyDefaultPose();
+        }
+
+        public override void ApplyOffset(Vector3 position, Quaternion rotation)
+        {
+            if(isDebug) Debug.Log($"ApplyOffset to: [{position}], [{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>();
+            }
+        }
+
+        public void SetXRDirectInteractor(UnityEngine.XR.Interaction.Toolkit.Interactors.XRBaseInteractor xrBaseInteractor)
+        {
+            targetInteractor = xrBaseInteractor;
+            Init();
+        }
+    }
+}

package/Runtime/scripts/HandInteraction/Core/HandPoseManager.cs.meta

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