fr.jeanf.universal.player 0.7.3

package/Runtime/scripts/Hmd/DetectUserPresence.cs

@@ -0,0 +1,39 @@
+using UnityEngine;
+using UnityEngine.XR;
+
+public class DetectUserPresence : MonoBehaviour
+{
+    private static InputDevice headDevice;
+    public DetectUserPresence()
+    {
+        if (headDevice == null)
+        {
+            headDevice = InputDevices.GetDeviceAtXRNode(XRNode.Head);
+        }
+    }
+
+    public static bool IsHMDMounted()
+    {
+    
+        if (headDevice == null || headDevice.isValid == false)
+        {
+            headDevice = InputDevices.GetDeviceAtXRNode(XRNode.Head);
+        }
+        if (headDevice != null)
+        {
+            var presenceFeatureSupported = headDevice.TryGetFeatureValue(CommonUsages.userPresence, out var userPresent);
+            if (headDevice.isValid && presenceFeatureSupported)
+            {
+                return userPresent;
+            }
+            else
+            {
+                return false;
+            }
+        }
+        else
+        {
+            return false;
+        }
+    }
+}

package/Runtime/scripts/Hmd/DetectUserPresence.cs.meta

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

package/Runtime/scripts/Hmd.meta

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

package/Runtime/scripts/LocomotionManager.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using jeanf.EventSystem;
+using UnityEngine;
+using UnityEngine.InputSystem;
+using UnityEngine.XR.Interaction.Toolkit;
+using jeanf.validationTools;
+
+public class LocomotionManager : MonoBehaviour, IDebugBehaviour, IValidatable
+{
+    public bool isDebug
+    { 
+        get => _isDebug;
+        set => _isDebug = value; 
+    }
+    [SerializeField] private bool _isDebug = false;
+
+    public bool IsValid { get; private set; }
+
+    [Validation("A reference to InputActionAsset is required.")]
+    [SerializeField] private InputActionAsset inputActionAsset;
+    [Validation("A reference to bool event channel SO (from UI opening) is required.")]
+    [Header("Listening on:")]
+    [SerializeField] private BoolEventChannelSO isInputFieldFocused;
+    [SerializeField] private BoolEventChannelSO isLoadingScene;
+
+
+    #if UNITY_EDITOR
+    private void OnValidate()
+    {
+        var invalidObjects = new List<object>();
+        var errorMessages = new List<string>();
+        var validityCheck = true;
+
+        invalidObjects.Clear();
+
+        if (inputActionAsset == null)
+        {
+            invalidObjects.Add(inputActionAsset);
+            errorMessages.Add("No InputActionAsset set");
+            validityCheck = false;
+        }
+
+        if (isInputFieldFocused == null)
+        {
+            invalidObjects.Add(isInputFieldFocused);
+            errorMessages.Add("No Bool Event Channel set");
+            validityCheck = false;
+        }
+
+        if (isLoadingScene == null)
+        {
+            invalidObjects.Add(isLoadingScene);
+            errorMessages.Add("No Bool Event Channel set");
+            validityCheck = false;
+        }
+
+        IsValid = validityCheck;
+        if (!IsValid) return;
+
+        if (IsValid && !Application.isPlaying) return;
+        for (int i = 0; i < invalidObjects.Count; i++)
+        {
+            Debug.LogError($"Error: {errorMessages[i]} ", this.gameObject);
+        }
+    }
+    #endif
+    private void OnEnable()
+    {
+
+        isInputFieldFocused.OnEventRaised += state => SetInputActivation(state);
+        isLoadingScene.OnEventRaised += state => SetInputActivation(state);
+    }
+
+    private void OnDisable() => Unsubscribe();
+    private void OnDestroy() => Unsubscribe();
+
+    private void Unsubscribe()
+    {
+        isInputFieldFocused.OnEventRaised -= state => SetInputActivation(state);
+        isLoadingScene.OnEventRaised += state => SetInputActivation(state);
+    }
+
+
+    private void SetInputActivation(bool state)
+    {
+        if (state)
+        {
+            foreach (var actionMap in inputActionAsset.actionMaps)
+            {
+                if (actionMap == inputActionAsset.FindActionMap("FPS"))
+                {
+                    actionMap.Disable();
+                }
+            }
+        }
+
+        else
+        {
+            foreach (var actionMap in inputActionAsset.actionMaps)
+            {
+                if (actionMap == inputActionAsset.FindActionMap("FPS"))
+                {
+                    actionMap.Enable();
+                }
+            }
+        }
+    }
+}

package/Runtime/scripts/LocomotionManager.cs.meta

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

package/Runtime/scripts/MainCameraTarget.cs

@@ -0,0 +1,6 @@
+using UnityEngine;
+
+namespace jeanf.vrplayer {
+    // Empty class which will be replaced by the Camera component
+    public class MainCameraTarget : MonoBehaviour {}
+}

package/Runtime/scripts/MainCameraTarget.cs.meta

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

package/Runtime/scripts/Movement/PlayerMovement.cs

@@ -0,0 +1,98 @@
+using jeanf.EventSystem;
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+namespace jeanf.vrplayer
+{
+    public class PlayerMovement : MonoBehaviour
+    {
+        [SerializeField] InputActionReference fpsMoveAction;
+        [SerializeField] InputActionReference xrMoveAction;
+        [SerializeField] CharacterController controller;
+        [SerializeField] FPSCameraMovement mouseLook;
+        [SerializeField] BoolEventChannelSO playerIsMovingEvent;
+
+        [SerializeField] private float speed;
+        public float Speed
+        {
+            get => speed;
+            set => speed = value;
+        }
+        float gravity = 9.81f;
+        [SerializeField] float distToGround;
+        [SerializeField] float speedChangeRate;
+        bool isMoving;
+        Vector2 moveValue;
+
+
+        private void OnEnable()
+        {
+            fpsMoveAction.action.performed += ctx => SetMoveValue(ctx.ReadValue<Vector2>() * Time.smoothDeltaTime * 50f);
+            fpsMoveAction.action.performed += ctx => SetIsMoving(true);
+            //xrMoveAction.action.performed += ctx => SetIsMoving(true);
+            fpsMoveAction.action.canceled += ctx => SetMoveValue(ctx.ReadValue<Vector2>() * Time.smoothDeltaTime * 50);
+            fpsMoveAction.action.canceled += ctx => SetIsMoving(false);
+            //xrMoveAction.action.canceled += ctx => SetIsMoving(false);
+
+        }
+
+        private void OnDisable() => Unsubscribe();
+        private void OnDestroy() => Unsubscribe();
+
+        private void Unsubscribe()
+        {
+            fpsMoveAction.action.performed -= ctx => SetMoveValue(ctx.ReadValue<Vector2>() * Time.smoothDeltaTime * 50f);
+            fpsMoveAction.action.performed -= ctx => SetIsMoving(true);
+            //xrMoveAction.action.performed -= ctx => SetIsMoving(false);
+            fpsMoveAction.action.canceled -= ctx => SetMoveValue(ctx.ReadValue<Vector2>() * Time.smoothDeltaTime * 50f);
+            fpsMoveAction.action.canceled -= ctx => SetIsMoving(false);
+            //xrMoveAction.action.canceled -= ctx => SetIsMoving(false);
+
+        }
+
+        private void LateUpdate()
+        {
+            if (isMoving)
+            {
+                Move(moveValue);
+            }
+
+            
+            if (!controller.isGrounded)
+            {
+                controller.Move(new Vector3(0.0f, -gravity, 0.0f).normalized * Time.deltaTime * 10f);
+            }
+
+        }
+        private void SetMoveValue(Vector2 move)
+        {
+            moveValue = move;
+            
+        }
+
+        private bool IsGrounded()
+        {
+            return Physics.Raycast(transform.position, -Vector3.up, distToGround);
+        }
+        private void Move(Vector2 move)
+        {
+
+
+            Vector3 forward = Camera.main.transform.forward;
+            Vector3 right = Camera.main.transform.right;
+
+            Vector3 moveDirection = (forward * speed * move.y) + (right * speed * move.x);
+
+
+            
+            Vector3 finalMoveDirection = new Vector3(moveDirection.x, 0.0f, moveDirection.z);
+            controller.Move(finalMoveDirection.normalized * speed * Time.deltaTime);
+        }
+
+        private void SetIsMoving(bool isMoving)
+        {
+            this.isMoving = isMoving;
+            playerIsMovingEvent.RaiseEvent(isMoving);
+        }
+    }
+}

package/Runtime/scripts/Movement/PlayerMovement.cs.meta

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

package/Runtime/scripts/Movement.meta

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

package/Runtime/scripts/OrientObjectAlongTowardPoint.cs

@@ -0,0 +1,81 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using LitMotion;
+using UnityEngine;
+
+namespace jeanf.vrplayer
+{
+    public class OrientObjectAlongTowardPoint : MonoBehaviour
+    {
+        public bool isDebug
+        { 
+            get => _isDebug;
+            set => _isDebug = value; 
+        }
+        [SerializeField] private bool _isDebug = false;
+
+        [SerializeField] private GameObject targetPoint;
+        [SerializeField] private LayerMask layerMask;
+        [Range(0,1f)][SerializeField] private float transitionTime = .2f;
+
+
+        private bool canRotate = false;
+        private bool lastCanRotateState = false;
+        private Collider _collider;
+        private Quaternion originalRotation;
+
+        private void Update()
+        {
+            if(canRotate) OrientObjectTowardPoint();
+        }
+
+        private void OnTriggerEnter(Collider collider)
+        {
+            if (((1 << collider.gameObject.layer) & layerMask) == 0) return;
+            if(isDebug) Debug.Log($"collision enter with {collider.gameObject.name}");
+
+            _collider = collider;
+            originalRotation = _collider.gameObject.transform.localRotation;
+            OrientObjectTowardPoint();
+        }
+
+        private void OnTriggerExit(Collider collider)
+        {
+            if (((1 << collider.gameObject.layer) & layerMask) == 0) return;
+            if(isDebug) Debug.Log($"collision exit with {collider.gameObject.name}");
+            
+            canRotate = false;
+            ResetOriginalObjectRotation();
+        }
+
+
+        private void OrientObjectTowardPoint()
+        {
+            if(!_collider) return;
+
+            var direction = (targetPoint.transform.position - _collider.transform.position).normalized;
+            var lookRotation = Quaternion.LookRotation(direction);
+
+            if (!canRotate)
+            {
+                LMotion.Create(_collider.transform.rotation,lookRotation,transitionTime)
+                    .Bind(x => _collider.transform.rotation = x);
+            }
+            else
+            {
+                _collider.transform.rotation = lookRotation;
+            }
+        }
+
+        private void ResetOriginalObjectRotation()
+        {
+            if(!_collider) return;
+            
+            LMotion.Create(_collider.transform.rotation,originalRotation,transitionTime)
+                .Bind(x => _collider.transform.rotation = x);
+        }
+        
+        
+    }
+}

package/Runtime/scripts/OrientObjectAlongTowardPoint.cs.meta

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

package/Runtime/scripts/SnapObject/SnapObject.cs

@@ -0,0 +1,104 @@
+using System.Collections;
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using jeanf.EventSystem;
+namespace jeanf.vrplayer
+{
+   public class SnapObject : PickableObject
+    {
+        private GameObject nearestSnapPoint;
+        public GameObject NearestSnapPoint { get { return nearestSnapPoint; } set { nearestSnapPoint = value; } }
+        [SerializeField] LayerMask snapTargetLayer;
+        public LayerMask SnapTargetLayer { get { return snapTargetLayer; }}
+        private List<GameObject> snapPoints = new List<GameObject>();
+        public List<GameObject> SnapPoints { get {  return snapPoints; } }
+        private SnapZone attachedSnapZone;
+        public SnapZone AttachedSnapZone {  get { return attachedSnapZone; }}
+        [SerializeField] bool shouldOrientOnSnap;
+        [SerializeField] bool shouldUseOffsetOnSnap;
+        public bool ShouldOrientOnSnap { get { return shouldOrientOnSnap; } }
+        public static event Action<Transform, Vector3> OnSnapMove;
+        public static event Action<Transform, Quaternion> OnSnapRotate;
+        public static event Action<bool> OnSnap;
+        [SerializeField] Quaternion snapOffsetRotation;
+        [SerializeField] VoidEventChannelSO snapBegun;
+        [SerializeField] VoidEventChannelSO snapEnded;
+
+        //On assigne
+        private void OnTriggerEnter(Collider other)
+        {
+            if (other.gameObject.GetComponent<SnapZone>())
+            {
+                attachedSnapZone = other.gameObject.GetComponent<SnapZone>();
+                try
+                {
+                    snapBegun.RaiseEvent();
+                }
+                catch { }
+                foreach (GameObject snapPoint in attachedSnapZone.SnapPoints)
+                {
+                    snapPoints.Add(snapPoint);
+                }
+            }
+        }
+
+        //On call le snap
+        private void OnTriggerStay(Collider other)
+        {
+            if (other.gameObject.GetComponent<SnapZone>())
+            {
+                Snap();
+            }
+        }
+
+        //On désassigne
+        private void OnTriggerExit(Collider other)
+        {
+
+            if (other.gameObject.GetComponent<SnapZone>())
+            {
+                attachedSnapZone = null;
+                nearestSnapPoint = null;
+                OnSnap.Invoke(false);
+                snapEnded.RaiseEvent(); 
+            }
+        }
+
+        private void Snap()
+        {
+            RaycastHit hit;
+            if (Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out hit, Mathf.Infinity, layerMask: snapTargetLayer))
+            {
+                OnSnap.Invoke(true);
+                float minDistance = Mathf.Infinity;
+                foreach (GameObject snapPoint in SnapPoints)
+                {
+                    float distance = Vector3.Distance(hit.point, snapPoint.transform.position);
+
+                    if (distance < minDistance)
+                    {
+                        minDistance = distance;
+
+                        nearestSnapPoint = snapPoint;
+                    }
+
+                }
+                if (shouldUseOffsetOnSnap)
+                {
+                    OnSnapRotate.Invoke(transform, nearestSnapPoint.transform.rotation * snapOffsetRotation);
+                }
+                else
+                {
+                    OnSnapRotate.Invoke(transform, nearestSnapPoint.transform.rotation);
+                }
+                OnSnapMove.Invoke(transform, nearestSnapPoint.transform.position);
+
+            }
+            else
+            {
+                OnSnap.Invoke(false);
+            }
+        }
+    }
+}

package/Runtime/scripts/SnapObject/SnapObject.cs.meta

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

package/Runtime/scripts/SnapObject/SnapZone.cs

@@ -0,0 +1,14 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System;
+ 
+namespace jeanf.vrplayer
+{
+    public class SnapZone : MonoBehaviour
+    {     
+        [SerializeField] private List<GameObject> snapPoints = new List<GameObject>();
+        public List<GameObject> SnapPoints { get { return snapPoints; } }
+    }
+
+}

package/Runtime/scripts/SnapObject/SnapZone.cs.meta

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

package/Runtime/scripts/SnapObject.meta

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

package/Runtime/scripts/Teleportation/SendTeleportTarget.cs

@@ -0,0 +1,85 @@
+using jeanf.EventSystem;
+using UnityEngine;
+using UnityEngine.Events;
+#if UNITY_EDITOR
+using System;
+using UnityEditor;
+#endif
+using jeanf.propertyDrawer;
+
+namespace jeanf.vrplayer
+{
+    public class SendTeleportTarget : MonoBehaviour, IDebugBehaviour
+    {
+        public bool isDebug
+        { 
+            get => _isDebug;
+            set => _isDebug = value; 
+        }
+        [SerializeField] private bool _isDebug = false;
+        
+        [Header("Broadcasting on:")] 
+        [SerializeField] private TeleportEventChannelSO _teleportChannel;
+        
+        [Header("Teleportation parameters:")] 
+        public bool isTeleportPlayer = false;
+        [DrawIf("isTeleportPlayer", false, ComparisonType.Equals, DisablingType.DontDraw)]
+        [SerializeField] public Transform objectToTeleport;
+        [SerializeField] public bool isUsingFilter = true;
+        [DrawIf("isUsingFilter", true, ComparisonType.Equals, DisablingType.DontDraw)]
+        public FilterSO _filter;
+        [SerializeField] private bool sendEventOnEnable = false;
+        
+        public Transform ObjectToTeleport
+        {
+            get => objectToTeleport;
+            set
+            {
+                if(_isDebug) Debug.Log($"ObjectToTeleport name : {value.gameObject.name}");
+                objectToTeleport = value;
+            } 
+        }
+
+        private void OnEnable()
+        {
+            if (sendEventOnEnable) Teleport();
+        }
+
+        public void Teleport()
+        {
+            var teleportInformation = new TeleportInformation(objectToTeleport, this.transform, isTeleportPlayer, _filter, isUsingFilter);
+            if(_isDebug) Debug.Log($"[teleportInformation ({gameObject.name})] " +
+                                   $"objectToTeleport : {teleportInformation.objectToTeleport}, " +
+                                   $"targetDestination : {teleportInformation.targetDestination}, " +
+                                   $"isTeleportPlayer : {teleportInformation.objectIsPlayer}, " +
+                                   $"_filter : {teleportInformation.filter.filters[0]}, " +
+                                   $"isUsingFilter : {teleportInformation.isUsingFilter}");
+            _teleportChannel.RaiseEvent(teleportInformation);
+        }
+
+#if UNITY_EDITOR
+        [DrawGizmo(GizmoType.Pickable)]
+        private void OnDrawGizmos()
+        {
+            if (!this.transform) return;
+
+            var thisTransform = transform.position;
+            Gizmos.color = new Color(.2f, .6f, .2f, .5f);
+            Gizmos.DrawSphere(thisTransform, .25f);
+            Gizmos.color = new Color(.2f, .6f, .2f, 1f);
+            Gizmos.DrawWireSphere(thisTransform, .5f);
+
+            // Blue Arrow for teleport direction
+            var a = transform.position + transform.rotation * new Vector3(0, 0, .5f); // tip of the arrow
+            var b = transform.position + transform.rotation * new Vector3(-.05f, 0, .45f); // bottom left of the arrow
+            var c = transform.position + transform.rotation * new Vector3(.05f, 0, .45f); // bottom right of the arrow
+            Gizmos.color = new Color(0, 0, 1, 1f); // using blue color (same as the axis)
+            Gizmos.DrawLine(thisTransform, a);
+            Gizmos.DrawLine(c, b);
+            Gizmos.DrawLine(c, a);
+            Gizmos.DrawLine(b, a);
+        }
+        #endif
+    }
+}
+

package/Runtime/scripts/Teleportation/SendTeleportTarget.cs.meta

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