Virtual Reality: How to Implement Snap Turning in Unity for People with Disabilities

using System.Collections;
using System.Collections.Generic;
using System;
using UnityEngine;

public class SimpleCapsuleWithStickMovement : MonoBehaviour
{
    public bool EnableLinearMovement = true;
    public bool EnableRotation = true;
    public bool HMDRotatesPlayer = true;
    public bool RotationEitherThumbstick = false;
    public float RotationAngle = 45.0f; // The angle is defined here.
    public float Speed = 0.0f;
    public OVRCameraRig CameraRig;

    private bool ReadyToSnapTurn;
    private Rigidbody _rigidbody;

    public event Action CameraUpdated;
    public event Action PreCharacterMove;

    private void Awake()
    {
        _rigidbody = GetComponent <Rigidbody>();
        if (CameraRig == null) CameraRig = GetComponentInChildren <OVRCameraRig>();
    }

    void Start ()
    {

    }

    private void FixedUpdate()
    {
        if (CameraUpdated != null) CameraUpdated();
        if (PreCharacterMove != null) PreCharacterMove();

        if (HMDRotatesPlayer) RotatePlayerToHMD();
        if (EnableLinearMovement) StickMovement();
        if (EnableRotation) SnapTurn();
    }

    void RotatePlayerToHMD()
    {
        Transform root = CameraRig.trackingSpace;
        Transform centerEye = CameraRig.centerEyeAnchor;

        Vector3 prevPos = root.position;
        Quaternion prevRot = root.rotation;

        transform.rotation = Quaternion.Euler(0.0f, centerEye.rotation.eulerAngles.y, 0.0f);

        root.position = prevPos;
        root.rotation = prevRot;
    }

    void StickMovement()
    {
        Quaternion ort = CameraRig.centerEyeAnchor.rotation;
        Vector3 ortEuler = ort.eulerAngles;
        ortEuler.z = ortEuler.x = 0f;
        ort = Quaternion.Euler(ortEuler);

        Vector3 moveDir = Vector3.zero;
        Vector2 primaryAxis = OVRInput.Get(OVRInput.Axis2D.PrimaryThumbstick);
        moveDir += ort * (primaryAxis.x * Vector3.right);
        moveDir += ort * (primaryAxis.y * Vector3.forward);
        //_rigidbody.MovePosition(_rigidbody.transform.position + moveDir * Speed * Time.fixedDeltaTime);
        _rigidbody.MovePosition(_rigidbody.position + moveDir * Speed * Time.fixedDeltaTime);
    }

    void SnapTurn()
    {
        if (OVRInput.Get(OVRInput.Button.SecondaryThumbstickLeft) ||
            (RotationEitherThumbstick && OVRInput.Get(OVRInput.Button.PrimaryThumbstickLeft)))
        {
            if (ReadyToSnapTurn)
            {
                ReadyToSnapTurn = false;
                transform.RotateAround(CameraRig.centerEyeAnchor.position, Vector3.up, -RotationAngle);
            }
        }
        else if (OVRInput.Get(OVRInput.Button.SecondaryThumbstickRight) ||
            (RotationEitherThumbstick && OVRInput.Get(OVRInput.Button.PrimaryThumbstickRight)))
        {
            if (ReadyToSnapTurn)
            {
                ReadyToSnapTurn = false;
                transform.RotateAround(CameraRig.centerEyeAnchor.position, Vector3.up, RotationAngle);
            }
        }
        else
        {
            ReadyToSnapTurn = true;
        }
    }
}

        using UnityEngine.InputSystem;
        using UnityEngine.InputSystem.Controls;
        using UnityEngine.XR.Interaction.Toolkit.Inputs;
        
        namespace UnityEngine.XR.Interaction.Toolkit
        {
            ///  <summary>
            /// A locomotion provider that allows the user to rotate their rig using a 2D axis input
            /// from an input system action.
            ///  </summary>
            [AddComponentMenu("XR/Locomotion/Snap Turn Provider (Action-based)", 11)]
            [HelpURL(XRHelpURLConstants.k_ActionBasedSnapTurnProvider)]
            public class ActionBasedSnapTurnProvider : SnapTurnProviderBase
            {
                [SerializeField]
                [Tooltip("The Input System Action that will be used to read Snap Turn data from the left hand controller. Must be a Value Vector2 Control.")]
                InputActionProperty m_LeftHandSnapTurnAction;
                ///  <summary>
                /// The Input System Action that Unity uses to read Snap Turn data sent from the left hand controller. Must be a  <see cref="InputActionType.Value"/>  <see cref="Vector2Control"/> Control.
                ///  </summary>
                public InputActionProperty leftHandSnapTurnAction
                {
                    get => m_LeftHandSnapTurnAction;
                    set => SetInputActionProperty(ref m_LeftHandSnapTurnAction, value);
                }
        
                [SerializeField]
                [Tooltip("The Input System Action that will be used to read Snap Turn data from the right hand controller. Must be a Value Vector2 Control.")]
                InputActionProperty m_RightHandSnapTurnAction;
                ///  <summary>
                /// The Input System Action that Unity uses to read Snap Turn data sent from the right hand controller. Must be a  <see cref="InputActionType.Value"/>  <see cref="Vector2Control"/> Control.
                ///  </summary>
                public InputActionProperty rightHandSnapTurnAction
                {
                    get => m_RightHandSnapTurnAction;
                    set => SetInputActionProperty(ref m_RightHandSnapTurnAction, value);
                }
        
                ///  <summary>
                /// See  <see cref="MonoBehaviour"/>.
                ///  </summary>
                protected void OnEnable()
                {
                    m_LeftHandSnapTurnAction.EnableDirectAction();
                    m_RightHandSnapTurnAction.EnableDirectAction();
                }
        
                ///  <summary>
                /// See  <see cref="MonoBehaviour"/>.
                ///  </summary>
                protected void OnDisable()
                {
                    m_LeftHandSnapTurnAction.DisableDirectAction();
                    m_RightHandSnapTurnAction.DisableDirectAction();
                }
        
                ///  <inheritdoc />
                protected override Vector2 ReadInput()
                {
                    var leftHandValue = m_LeftHandSnapTurnAction.action?.ReadValue <Vector2>() ?? Vector2.zero;
                    var rightHandValue = m_RightHandSnapTurnAction.action?.ReadValue <Vector2>() ?? Vector2.zero;
        
                    return leftHandValue + rightHandValue;
                }
        
                void SetInputActionProperty(ref InputActionProperty property, InputActionProperty value)
                {
                    if (Application.isPlaying)
                        property.DisableDirectAction();
        
                    property = value;
        
                    if (Application.isPlaying && isActiveAndEnabled)
                        property.EnableDirectAction();
                }
            }
        }