fr.jeanf.universal.player 0.7.3

package/Runtime/xrToolkit/Scripts/LocomotionConfigurationMenu.cs.meta

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

package/Runtime/xrToolkit/Scripts/LocomotionSchemeManager.cs

@@ -0,0 +1,524 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using UnityEngine.InputSystem;
+
+namespace UnityEngine.XR.Interaction.Toolkit.Examples
+{
+    /// <summary>
+    /// Use this class as a central manager to configure locomotion control schemes and configuration preferences.
+    /// </summary>
+    /// <remarks>
+    /// Input bindings will often overlap between different locomotion methods, and this class can be used to
+    /// set binding masks which are used to determine which bindings of an action to enable and which to ignore.
+    /// 
+    /// <example>
+    /// Teleport  (Input Action)
+    /// (1) Binding &lt;XRController&gt;{LeftHand}/PrimaryButton (Use in control scheme "Generic XR")
+    /// (2) Binding &lt;XRController&gt;{LeftHand}/Primary2DAxis (Use in control scheme "Noncontinuous Move")
+    /// Move (Input Action)
+    /// (3) Binding &lt;XRController&gt;{LeftHand}/Primary2DAxis (Use in control scheme "Continuous Move")
+    ///
+    /// Set <see cref="baseControlScheme"/>="Generic XR"
+    /// Set <see cref="noncontinuousControlScheme"/>="Noncontinuous Move"
+    /// Set <see cref="continuousControlScheme"/>="Continuous Move"
+    /// Set <see cref="actions"/> to be both input actions (Teleport and Move).
+    ///
+    /// When <see cref="moveScheme"/>=<see cref="MoveScheme.Noncontinuous"/>,
+    /// bindings (1) and (2) will be enabled, but binding (3) will be disabled.
+    ///
+    /// When <see cref="moveScheme"/>=<see cref="MoveScheme.Continuous"/>,
+    /// bindings (1) and (3) will be enabled, but binding (2) will be disabled.
+    /// </example>
+    /// </remarks>
+    public class LocomotionSchemeManager : MonoBehaviour
+    {
+        /// <summary>
+        /// Sets which movement control scheme to use.
+        /// </summary>
+        /// <seealso cref="moveScheme"/>
+        public enum MoveScheme
+        {
+            /// <summary>
+            /// Use noncontinuous movement control scheme.
+            /// </summary>
+            Noncontinuous,
+
+            /// <summary>
+            /// Use continuous movement control scheme.
+            /// </summary>
+            Continuous,
+        }
+
+        /// <summary>
+        /// Sets which turn style of locomotion to use.
+        /// </summary>
+        /// <seealso cref="turnStyle"/>
+        public enum TurnStyle
+        {
+            /// <summary>
+            /// Use snap turning to rotate the direction you are facing by snapping by a specified angle.
+            /// </summary>
+            Snap,
+
+            /// <summary>
+            /// Use continuous turning to smoothly rotate the direction you are facing by a specified speed.
+            /// </summary>
+            Continuous,
+        }
+
+        /// <summary>
+        /// Sets which orientation the forward direction of continuous movement is relative to.
+        /// </summary>
+        /// <seealso cref="moveForwardSource"/>
+        /// <seealso cref="ContinuousMoveProviderBase.forwardSource"/>
+        public enum MoveForwardSource
+        {
+            /// <summary>
+            /// Use to continuously move in a direction based on the head orientation.
+            /// </summary>
+            Head,
+
+            /// <summary>
+            /// Use to continuously move in a direction based on the left hand orientation.
+            /// </summary>
+            LeftHand,
+
+            /// <summary>
+            /// Use to continuously move in a direction based on the right hand orientation.
+            /// </summary>
+            RightHand,
+        }
+
+        [SerializeField]
+        [Tooltip("Controls which movement control scheme to use.")]
+        MoveScheme m_MoveScheme;
+        /// <summary>
+        /// Controls which movement control scheme to use.
+        /// </summary>
+        /// <seealso cref="MoveScheme"/>
+        public MoveScheme moveScheme
+        {
+            get => m_MoveScheme;
+            set
+            {
+                SetMoveScheme(value);
+                m_MoveScheme = value;
+            }
+        }
+
+        [SerializeField]
+        [Tooltip("Controls which turn style of locomotion to use.")]
+        TurnStyle m_TurnStyle;
+        /// <summary>
+        /// Controls which turn style of locomotion to use.
+        /// </summary>
+        /// <seealso cref="TurnStyle"/>
+        public TurnStyle turnStyle
+        {
+            get => m_TurnStyle;
+            set
+            {
+                SetTurnStyle(value);
+                m_TurnStyle = value;
+            }
+        }
+
+        [SerializeField]
+        [Tooltip("Controls which orientation the forward direction of continuous movement is relative to.")]
+        MoveForwardSource m_MoveForwardSource;
+        /// <summary>
+        /// Controls which orientation the forward direction of continuous movement is relative to.
+        /// </summary>
+        /// <seealso cref="MoveForwardSource"/>
+        public MoveForwardSource moveForwardSource
+        {
+            get => m_MoveForwardSource;
+            set
+            {
+                SetMoveForwardSource(value);
+                m_MoveForwardSource = value;
+            }
+        }
+
+        [SerializeField]
+        [Tooltip("Input action assets associated with locomotion to affect when the active movement control scheme is set." +
+            " Can use this list by itself or together with the Action Maps list to set control scheme masks by Asset or Map.")]
+        List<InputActionAsset> m_ActionAssets;
+        /// <summary>
+        /// Input action assets associated with locomotion to affect when the active movement control scheme is set.
+        /// Can use this list by itself or together with the Action Maps list to set control scheme masks by Asset or Map.
+        /// </summary>
+        /// <seealso cref="actionMaps"/>
+        public List<InputActionAsset> actionAssets
+        {
+            get => m_ActionAssets;
+            set => m_ActionAssets = value;
+        }
+
+        [SerializeField]
+        [Tooltip("Input action maps associated with locomotion to affect when the active movement control scheme is set." +
+            " Can use this list together with the Action Assets list to set control scheme masks by Map instead of the whole Asset.")]
+        List<string> m_ActionMaps;
+        /// <summary>
+        /// Input action maps associated with locomotion to affect when the active movement control scheme is set.
+        /// Can use this list together with the Action Assets list to set control scheme masks by Map instead of the whole Asset.
+        /// </summary>
+        /// <seealso cref="actionAssets"/>
+        public List<string> actionMaps
+        {
+            get => m_ActionMaps;
+            set => m_ActionMaps = value;
+        }
+
+        [SerializeField]
+        [Tooltip("Input actions associated with locomotion to affect when the active movement control scheme is set." +
+            " Can use this list to select exactly the actions to affect instead of setting control scheme masks by Asset or Map.")]
+        List<InputActionReference> m_Actions;
+        /// <summary>
+        /// Input actions associated with locomotion that are affected by the active movement control scheme.
+        /// Can use this list to select exactly the actions to affect instead of setting control scheme masks by Asset or Map.
+        /// </summary>
+        /// <seealso cref="actionAssets"/>
+        /// <seealso cref="actionMaps"/>
+        public List<InputActionReference> actions
+        {
+            get => m_Actions;
+            set => m_Actions = value;
+        }
+
+        [SerializeField]
+        [Tooltip("Name of an input control scheme that defines the grouping of bindings that should remain enabled when applying any movement control scheme." +
+            " Control schemes are created and named in the Input Actions window. The other movement control schemes are applied additively to this scheme." +
+            " Can be an empty string, which means only bindings that match the specified movement control scheme will be enabled.")]
+        string m_BaseControlScheme;
+        /// <summary>
+        /// Name of an input control scheme that defines the grouping of bindings that should remain enabled when applying any movement control scheme.
+        /// Control schemes are created and named in the Input Actions window. The other movement control schemes are applied additively to this scheme.
+        /// Can be an empty string, which means only bindings that match the specified movement control scheme will be enabled.
+        /// </summary>
+        public string baseControlScheme
+        {
+            get => m_BaseControlScheme;
+            set => m_BaseControlScheme = value;
+        }
+
+        [SerializeField]
+        [Tooltip("Name of an input control scheme that defines the grouping of bindings that should remain enabled when applying the noncontinuous movement control scheme." +
+            " Control schemes are created and named in the Input Actions window. Can be an empty string, which means only bindings that match the" +
+            " base control scheme will be enabled.")]
+        string m_NoncontinuousControlScheme;
+        /// <summary>
+        /// Name of an input control scheme that defines the grouping of bindings that should remain enabled when applying the noncontinuous movement control scheme.
+        /// Control schemes are created and named in the Input Actions window. Can be an empty string, which means only bindings that match the
+        /// base control scheme will be enabled.
+        /// </summary>
+        public string noncontinuousControlScheme
+        {
+            get => m_NoncontinuousControlScheme;
+            set => m_NoncontinuousControlScheme = value;
+        }
+
+        [SerializeField]
+        [Tooltip("Name of an input control scheme that defines the grouping of bindings that should remain enabled when applying the continuous movement control scheme." +
+            " Control schemes are created and named in the Input Actions window. Can be an empty string, which means only bindings that match the" +
+            " base control scheme will be enabled.")]
+        string m_ContinuousControlScheme;
+        /// <summary>
+        /// Name of an input control scheme that defines the grouping of bindings that should remain enabled when applying the continuous movement control scheme.
+        /// Control schemes are created and named in the Input Actions window. Can be an empty string, which means only bindings that match the
+        /// base control scheme will be enabled.
+        /// </summary>
+        public string continuousControlScheme
+        {
+            get => m_ContinuousControlScheme;
+            set => m_ContinuousControlScheme = value;
+        }
+
+        [SerializeField]
+        [Tooltip("Stores the locomotion provider for continuous movement.")]
+        ContinuousMoveProviderBase m_ContinuousMoveProvider;
+        /// <summary>
+        /// Stores the locomotion provider for continuous movement.
+        /// </summary>
+        /// <seealso cref="ContinuousMoveProviderBase"/>
+        public ContinuousMoveProviderBase continuousMoveProvider
+        {
+            get => m_ContinuousMoveProvider;
+            set => m_ContinuousMoveProvider = value;
+        }
+
+        [SerializeField]
+        [Tooltip("Stores the locomotion provider for continuous turning.")]
+        ContinuousTurnProviderBase m_ContinuousTurnProvider;
+        /// <summary>
+        /// Stores the locomotion provider for continuous turning.
+        /// </summary>
+        /// <seealso cref="ContinuousTurnProviderBase"/>
+        public ContinuousTurnProviderBase continuousTurnProvider
+        {
+            get => m_ContinuousTurnProvider;
+            set => m_ContinuousTurnProvider = value;
+        }
+
+        [SerializeField]
+        [Tooltip("Stores the locomotion provider for snap turning.")]
+        SnapTurnProviderBase m_SnapTurnProvider;
+        /// <summary>
+        /// Stores the locomotion provider for snap turning.
+        /// </summary>
+        /// <seealso cref="SnapTurnProviderBase"/>
+        public SnapTurnProviderBase snapTurnProvider
+        {
+            get => m_SnapTurnProvider;
+            set => m_SnapTurnProvider = value;
+        }
+
+        [SerializeField]
+        [Tooltip("Stores the \"Head\" Transform used with continuous movement when inputs should be relative to head orientation (usually the main camera).")]
+        Transform m_HeadForwardSource;
+        /// <summary>
+        /// Stores the "Head" <see cref="Transform"/> used with continuous movement when inputs should be relative to head orientation (usually the main camera).
+        /// </summary>
+        public Transform headForwardSource
+        {
+            get => m_HeadForwardSource;
+            set => m_HeadForwardSource = value;
+        }
+
+        [SerializeField]
+        [Tooltip("Stores the \"Left Hand\" Transform used with continuous movement when inputs should be relative to the left hand's orientation.")]
+        Transform m_LeftHandForwardSource;
+        /// <summary>
+        /// Stores the "Left Hand" <see cref="Transform"/> used with continuous movement when inputs should be relative to the left hand's orientation.
+        /// </summary>
+        public Transform leftHandForwardSource
+        {
+            get => m_LeftHandForwardSource;
+            set => m_LeftHandForwardSource = value;
+        }
+
+        [SerializeField]
+        [Tooltip("Stores the \"Right Hand\" Transform used with continuous movement when inputs should be relative to the right hand's orientation.")]
+        Transform m_RightHandForwardSource;
+        /// <summary>
+        /// Stores the "Right Hand" <see cref="Transform"/> used with continuous movement when inputs should be relative to the right hand's orientation.
+        /// </summary>
+        public Transform rightHandForwardSource
+        {
+            get => m_RightHandForwardSource;
+            set => m_RightHandForwardSource = value;
+        }
+
+        void OnEnable()
+        {
+            SetMoveScheme(m_MoveScheme);
+            SetTurnStyle(m_TurnStyle);
+            SetMoveForwardSource(m_MoveForwardSource);
+        }
+
+        void OnDisable()
+        {
+            ClearBindingMasks();
+        }
+
+        void SetMoveScheme(MoveScheme scheme)
+        {
+            switch (scheme)
+            {
+                case MoveScheme.Noncontinuous:
+                    SetBindingMasks(m_NoncontinuousControlScheme);
+                    if (m_ContinuousMoveProvider != null)
+                    {
+                        m_ContinuousMoveProvider.enabled = false;
+                    }
+
+                    break;
+                case MoveScheme.Continuous:
+                    SetBindingMasks(m_ContinuousControlScheme);
+                    if (m_ContinuousMoveProvider != null)
+                    {
+                        m_ContinuousMoveProvider.enabled = true;
+                    }
+
+                    break;
+                default:
+                    throw new InvalidEnumArgumentException(nameof(scheme), (int)scheme, typeof(MoveScheme));
+            }
+        }
+
+        void SetTurnStyle(TurnStyle style)
+        {
+            switch (style)
+            {
+                case TurnStyle.Snap:
+                    if (m_ContinuousTurnProvider != null)
+                    {
+                        m_ContinuousTurnProvider.enabled = false;
+                    }
+
+                    if (m_SnapTurnProvider != null)
+                    {
+                        // TODO: If the Continuous Turn and Snap Turn providers both use the same
+                        // action, then disabling the first provider will cause the action to be
+                        // disabled, so the action needs to be enabled, which is done by forcing
+                        // the OnEnable() of the second provider to be called.
+                        // ReSharper disable Unity.InefficientPropertyAccess
+                        m_SnapTurnProvider.enabled = false;
+                        m_SnapTurnProvider.enabled = true;
+                        // ReSharper restore Unity.InefficientPropertyAccess
+                        m_SnapTurnProvider.enableTurnLeftRight = true;
+                    }
+                    break;
+                case TurnStyle.Continuous:
+                    if (m_SnapTurnProvider != null)
+                    {
+                        m_SnapTurnProvider.enableTurnLeftRight = false;
+                    }
+
+                    if (m_ContinuousTurnProvider != null)
+                    {
+                        m_ContinuousTurnProvider.enabled = true;
+                    }
+                    break;
+                default:
+                    throw new InvalidEnumArgumentException(nameof(style), (int)style, typeof(TurnStyle));
+            }
+        }
+
+        void SetMoveForwardSource(MoveForwardSource forwardSource)
+        {
+            if (m_ContinuousMoveProvider == null)
+            {
+                Debug.LogError($"Cannot set forward source to {forwardSource}," +
+                    $" the reference to the {nameof(ContinuousMoveProviderBase)} is missing or the object has been destroyed.", this);
+                return;
+            }
+
+            switch (forwardSource)
+            {
+                case MoveForwardSource.Head:
+                    m_ContinuousMoveProvider.forwardSource = m_HeadForwardSource;
+                    break;
+                case MoveForwardSource.LeftHand:
+                    m_ContinuousMoveProvider.forwardSource = m_LeftHandForwardSource;
+                    break;
+                case MoveForwardSource.RightHand:
+                    m_ContinuousMoveProvider.forwardSource = m_RightHandForwardSource;
+                    break;
+                default:
+                    throw new InvalidEnumArgumentException(nameof(forwardSource), (int)forwardSource, typeof(MoveForwardSource));
+            }
+        }
+
+        void SetBindingMasks(string controlSchemeName)
+        {
+            foreach (var actionReference in m_Actions)
+            {
+                if (actionReference == null)
+                    continue;
+
+                var action = actionReference.action;
+                if (action == null)
+                {
+                    Debug.LogError($"Cannot set binding mask on {actionReference} since the action could not be found.", this);
+                    continue;
+                }
+
+                // Get the (optional) base control scheme and the control scheme to apply on top of base
+                var baseInputControlScheme = FindControlScheme(m_BaseControlScheme, actionReference);
+                var inputControlScheme = FindControlScheme(controlSchemeName, actionReference);
+
+                action.bindingMask = GetBindingMask(baseInputControlScheme, inputControlScheme);
+            }
+
+            if (m_ActionMaps.Count > 0 && m_ActionAssets.Count == 0)
+            {
+                Debug.LogError($"Cannot set binding mask on action maps since no input action asset references have been set.", this);
+            }
+
+            foreach (var actionAsset in m_ActionAssets)
+            {
+                if (actionAsset == null)
+                    continue;
+
+                // Get the (optional) base control scheme and the control scheme to apply on top of base
+                var baseInputControlScheme = FindControlScheme(m_BaseControlScheme, actionAsset);
+                var inputControlScheme = FindControlScheme(controlSchemeName, actionAsset);
+
+                if (m_ActionMaps.Count == 0)
+                {
+                    actionAsset.bindingMask = GetBindingMask(baseInputControlScheme, inputControlScheme);
+                    continue;
+                }
+
+                foreach (var mapName in m_ActionMaps)
+                {
+                    var actionMap = actionAsset.FindActionMap(mapName);
+                    if (actionMap == null)
+                    {
+                        Debug.LogError($"Cannot set binding mask on \"{mapName}\" since the action map not be found in '{actionAsset}'.", this);
+                        continue;
+                    }
+
+                    actionMap.bindingMask = GetBindingMask(baseInputControlScheme, inputControlScheme);
+                }
+            }
+        }
+
+        void ClearBindingMasks()
+        {
+            SetBindingMasks(string.Empty);
+        }
+
+        InputControlScheme? FindControlScheme(string controlSchemeName, InputActionReference action)
+        {
+            if (action == null)
+                throw new ArgumentNullException(nameof(action));
+
+            if (string.IsNullOrEmpty(controlSchemeName))
+                return null;
+
+            var asset = action.asset;
+            if (asset == null)
+            {
+                Debug.LogError($"Cannot find control scheme \"{controlSchemeName}\" for '{action}' since it does not belong to an {nameof(InputActionAsset)}.", this);
+                return null;
+            }
+
+            return FindControlScheme(controlSchemeName, asset);
+        }
+
+        InputControlScheme? FindControlScheme(string controlSchemeName, InputActionAsset asset)
+        {
+            if (asset == null)
+                throw new ArgumentNullException(nameof(asset));
+
+            if (string.IsNullOrEmpty(controlSchemeName))
+                return null;
+
+            var scheme = asset.FindControlScheme(controlSchemeName);
+            if (scheme == null)
+            {
+                Debug.LogError($"Cannot find control scheme \"{controlSchemeName}\" in '{asset}'.", this);
+                return null;
+            }
+
+            return scheme;
+        }
+
+        static InputBinding? GetBindingMask(InputControlScheme? baseInputControlScheme, InputControlScheme? inputControlScheme)
+        {
+            if (inputControlScheme.HasValue)
+            {
+                return baseInputControlScheme.HasValue
+                    ? InputBinding.MaskByGroups(baseInputControlScheme.Value.bindingGroup, inputControlScheme.Value.bindingGroup)
+                    : InputBinding.MaskByGroup(inputControlScheme.Value.bindingGroup);
+            }
+
+            return baseInputControlScheme.HasValue
+                ? InputBinding.MaskByGroup(baseInputControlScheme.Value.bindingGroup)
+                : (InputBinding?)null;
+        }
+    }
+}

package/Runtime/xrToolkit/Scripts/LocomotionSchemeManager.cs.meta

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

package/Runtime/xrToolkit/Scripts/UpdateControlText.cs

@@ -0,0 +1,41 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.XR.Interaction.Toolkit;
+
+public class UpdateControlText : MonoBehaviour
+{
+    [SerializeField]
+    TextMesh m_TextMesh = new TextMesh();
+
+    public void OnSliderEvent(float value)
+    {
+        if (m_TextMesh)
+            m_TextMesh.text = string.Format("{0:0.#}", value);
+    }
+
+    public void OnKnobEvent(float value)
+    {
+        if (m_TextMesh)
+            m_TextMesh.text = string.Format("{0:0.#}", value);
+    }
+
+    IEnumerator StartTextMeshFade(TextMesh textMesh)
+    {
+        float duration = 0.5f;
+        float t = 0f;
+        while (t <= duration)
+        {
+            t += Time.deltaTime;
+            textMesh.color = new Color(textMesh.color.r, textMesh.color.g, textMesh.color.b,
+                Mathf.Lerp(1.0f, 0.0f, Mathf.Min(Mathf.SmoothStep(0f, 1f, t / duration), 1.0f)));
+            yield return null;
+        }
+    }
+
+    public void OnButtonEvent()
+    {
+        if (m_TextMesh)
+            StartCoroutine(StartTextMeshFade(m_TextMesh));
+    }
+}

package/Runtime/xrToolkit/Scripts/UpdateControlText.cs.meta

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

package/Runtime/xrToolkit/Scripts/xr.toolkit.asmdef

@@ -0,0 +1,17 @@
+{
+    "name": "xr.toolkit",
+    "rootNamespace": "",
+    "references": [
+        "GUID:fe685ec1767f73d42b749ea8045bfe43",
+        "GUID:75469ad4d38634e559750d17036d5f7c"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/Runtime/xrToolkit/Scripts/xr.toolkit.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 24e442f89618c5d4cad09e3d635b003b
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/xrToolkit/Scripts.meta

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