PICO_VR/PICOSDK/Runtime/Scripts/Features/PXR_Input.cs

/*******************************************************************************
Copyright © 2015-2022 PICO Technology Co., Ltd.All rights reserved.  

NOTICE：All information contained herein is, and remains the property of 
PICO Technology Co., Ltd. The intellectual and technical concepts 
contained herein are proprietary to PICO Technology Co., Ltd. and may be 
covered by patents, patents in process, and are protected by trade secret or 
copyright law. Dissemination of this information or reproduction of this 
material is strictly forbidden unless prior written permission is obtained from
PICO Technology Co., Ltd. 
*******************************************************************************/

using LitJson;
using System;
using UnityEngine;
using UnityEngine.XR;

namespace Unity.XR.PXR
{
    public static class PXR_Input
    {
        public enum ControllerDevice
        {
            G2 = 3,
            Neo2,
            Neo3,
            PICO_4,
            G3,
            NewController = 10
        }

        public enum Controller
        {
            LeftController,
            RightController,
        }

        public enum VibrateController
        {
            No = 0,
            Left = 1,
            Right = 2,
            LeftAndRight = 3,
        }

        public enum VibrateType
        {
            None = 0,
            LeftController = 1,
            RightController = 2,
            BothController = 3,
        }

        public enum CacheType
        {
            DontCache = 0,
            CacheAndVibrate = 1,
            CacheNoVibrate = 2,
        }

        public enum ChannelFlip
        {
            No,
            Yes,
        }

        public enum CacheConfig {
            CacheAndVibrate = 1,
            CacheNoVibrate = 2,
        }

        /// <summary>
        /// Gets the current dominant controller.
        /// </summary>
        /// <returns>The current dominant controller: `LeftController`; `RightController`.</returns>
        public static Controller GetDominantHand()
        {
            return (Controller)PXR_Plugin.Controller.UPxr_GetControllerMainInputHandle();
        }

        /// <summary>
        /// Sets a controller as the dominant controller.
        /// </summary>
        /// <param name="controller">The controller to be set as the dominant controller: `0`-left controller; `1`-right controller.</param>
        public static void SetDominantHand(Controller controller)
        {
            PXR_Plugin.Controller.UPxr_SetControllerMainInputHandle((UInt32)controller);
        }

        /// <summary>
        /// Sets controller vibration, including vibration amplitude and duration.
        /// @note The `SendHapticImpulse` method offered by UnityXR is also supported. Click [here](https://docs.unity3d.com/ScriptReference/XR.InputDevice.SendHapticImpulse.html) for more information.
        /// </summary>
        /// <param name="strength">Vibration amplitude. The valid value ranges from `0` to `1`. The greater the value, the stronger the vibration amplitude. To stop controller vibration, call this function again and set this parameter to `0`.</param>
        /// <param name="time">Vibration duration. The valid value ranges from `0` to `65535` ms.</param>
        /// <param name="controller">The controller to set vibration for:
        /// * `0`: left controller
        /// * `1`: right controller
        /// </param>
        [Obsolete("Please use SendHapticImpulse instead")]
        public static void SetControllerVibration(float strength, int time, Controller controller)
        {
            PXR_Plugin.Controller.UPxr_SetControllerVibration((UInt32)controller, strength, time);
        }

        /// <summary>
        /// Gets the device model.
        /// </summary>
        /// <returns>The device model. Enumerations: `G2`, `Neo2`, `Neo3`, `NewController`, `PICO_4`.</returns> 
        public static ControllerDevice GetControllerDeviceType()
        {
            return (ControllerDevice)PXR_Plugin.Controller.UPxr_GetControllerType();
        }

        /// <summary>
        /// Gets the connection status for a specified controller.
        /// </summary>
        /// <param name="controller">The controller to get connection status for:
        /// * `0`: left controller
        /// * `1`: right controller
        /// </param>
        /// <returns>The connection status of the specified controller:
        /// * `true`: connected
        /// * `false`: not connected
        /// </returns>
        public static bool IsControllerConnected(Controller controller)
        {
            var state = false;
            switch (controller)
            {
                case Controller.LeftController:
                    InputDevices.GetDeviceAtXRNode(XRNode.LeftHand).TryGetFeatureValue(PXR_Usages.controllerStatus, out state);
                    return state;
                case Controller.RightController:
                    InputDevices.GetDeviceAtXRNode(XRNode.RightHand).TryGetFeatureValue(PXR_Usages.controllerStatus, out state);
                    return state;
            }
            return state;
        }

        /// <summary>
        /// Sets the offset of the controller's display position to its real position.
        /// </summary>
        /// <param name="hand">The controller to set an offset for:
        /// * `0`: left controller
        /// * `1`: right controller
        /// </param>
        /// <param name="offset">The offset (in meters).</param>
        public static void SetControllerOriginOffset(Controller controller, Vector3 offset)
        {
            PXR_Plugin.Controller.UPxr_SetControllerOriginOffset((int)controller, offset);
        }

        /// <summary>
        /// Gets the predicted orientation of a specified controller after a specified time.
        /// </summary>
        /// <param name="hand">The controller to get the predicted rotation for:
        /// * `0`: left controller
        /// * `1`: right controller
        /// </param>
        /// <param name="predictTime">The time for prediction (in milliseconds).</param>
        /// <returns>The predicted orientation.</returns>
        public static Quaternion GetControllerPredictRotation(Controller controller, double predictTime)
        {
            PxrControllerTracking pxrControllerTracking = new PxrControllerTracking();
            float[] headData = new float[7] { 0, 0, 0, 0, 0, 0, 0 };

            PXR_Plugin.Controller.UPxr_GetControllerTrackingState((uint)controller, predictTime, headData, ref pxrControllerTracking);

            return new Quaternion(
                pxrControllerTracking.localControllerPose.pose.orientation.x,
                pxrControllerTracking.localControllerPose.pose.orientation.y,
                pxrControllerTracking.localControllerPose.pose.orientation.z,
                pxrControllerTracking.localControllerPose.pose.orientation.w);
        }

        /// <summary>
        /// Gets the predicted position of a specified controller after a specified time.
        /// </summary>
        /// <param name="hand">The controller to get the predicted position for:
        /// * `0`: left controller
        /// * `1`: right controller
        /// </param>
        /// <param name="predictTime">The time for prediction (in milliseconds).</param>
        /// <returns>The predicted position.</returns>
        public static Vector3 GetControllerPredictPosition(Controller controller, double predictTime)
        {
            PxrControllerTracking pxrControllerTracking = new PxrControllerTracking();
            float[] headData = new float[7] { 0, 0, 0, 0, 0, 0, 0 };

            PXR_Plugin.Controller.UPxr_GetControllerTrackingState((uint)controller, predictTime, headData, ref pxrControllerTracking);

            return new Vector3(
                pxrControllerTracking.localControllerPose.pose.position.x,
                pxrControllerTracking.localControllerPose.pose.position.y,
                pxrControllerTracking.localControllerPose.pose.position.z);
        }

        /// @deprecated Use \ref SendHapticImpulse instead.
        /// <summary>
        /// Sets event-triggered vibration for a specified controller.
        /// </summary>
        /// <param name="hand">The controller to enable vibration for:
        /// * `0`: left controller
        /// * `1`: right controller
        /// </param>
        /// <param name="frequency">Vibration frequency, which ranges from `50` to `500` Hz.</param>
        /// <param name="strength">Vibration amplitude. Its valid value ranges from `0` to `1`. The higher the value, the stronger the vibration amplitude.</param>
        /// <param name="time">Vibration duration, which ranges from `0` to `65535` ms.</param>
        [Obsolete("Please use SendHapticImpulse instead")]
        public static int SetControllerVibrationEvent(UInt32 hand, int frequency, float strength, int time)
        {
            return PXR_Plugin.Controller.UPxr_SetControllerVibrationEvent(hand, frequency, strength, time);
        }

        /// @deprecated Use \ref StopHapticBuffer(int sourceId, bool clearCache) instead.
        /// <summary>
        /// Stops audio-triggered vibration.
        /// </summary>
        /// <param name="id">A reserved parameter, set it to the source ID returned by `StartVibrateBySharem` or `SaveVibrateByCache` to stop the corresponding vibration,
        /// or set it to `0` to stop all vibrations.</param>
        [Obsolete("Please use StopHapticBuffer instead")]
        public static int StopControllerVCMotor(int sourceId)
        {
            return PXR_Plugin.Controller.UPxr_StopControllerVCMotor(sourceId);
        }

        /// @deprecated Deprecated.
        /// <summary>
        /// Starts audio-triggered vibration for specified controller(s). The audio data come from an audio file.
        /// </summary>
        /// <param name="file">The path to the audio file.</param>
        /// <param name="vibrateController">The controller(s) to enable vibration for:
        /// * `0`: none
        /// * `1`: left controller
        /// * `2`: right controller
        /// * `3`: left and right controllers
        /// </param>
        [Obsolete("Deprecated")]
        public static int StartControllerVCMotor(string file, VibrateController vibrateController)
        {
            return PXR_Plugin.Controller.UPxr_StartControllerVCMotor(file, (int)vibrateController);
        }

        /// @deprecated Deprecated.
        /// <summary>
        /// Sets the amplitude for audio-triggered vibration. Support changing the vibration amplitude during audio playback.
        /// </summary>
        /// <param name="mode">Vibration amplitude level:
        /// * `0`: no vibration
        /// * `1`: standard amplitude
        /// * `2`: 2×standard amplitude
        /// * `3`: 3×standard amplitude
        /// * `4`: 4×standard amplitude
        /// @note "3×standard amplitude" and "4×standard amplitude" are NOT recommended as they will cause serious loss of vibration details.
        /// </param>
        [Obsolete("Deprecated")]
        public static int SetControllerAmp(float mode)
        {
            return PXR_Plugin.Controller.UPxr_SetControllerAmp(mode);
        }

        /// @deprecated Use \ref SendHapticBuffer(VibrateType vibrateType, AudioClip audioClip, ChannelFlip channelFlip, ref int sourceId, CacheType cacheType) instead.
        /// <summary>
        /// Starts audio-triggered vibration for specified controller(s). The audio data come from an audio clip passed to the Unity Engine.
        /// </summary>
        /// <param name="audioClip">The path to the audio clip.</param>
        /// <param name="vibrateController">The controller(s) to enable vibration for:
        /// * `0`: none
        /// * `1`: left controller
        /// * `2`: right controller
        /// * `3`: left and right controllers
        /// </param>
        /// <param nname="channelFlip">Whether to enable audio channel inversion:
        /// * `Yes`: enable
        /// * `No`: disable
        /// Once audio channel inversion is enabled, the left controller vibrates with the audio data from the right channel, and vice versa.
        /// </param>
        /// <param nname="sourceId">Returns the unique ID for controlling the corresponding vibration,
        /// which will be used in `StartVibrateByCache`, `ClearVibrateByCache` or `StopControllerVCMotor`.</param>
        [Obsolete("Please use SendHapticBuffer instead")]
        public static int StartVibrateBySharem(AudioClip audioClip, VibrateController vibrateController, ChannelFlip channelFlip, ref int sourceId)
        {
            if (audioClip == null)
            {
                return 0;
            }
            float[] data = new float[audioClip.samples * audioClip.channels];
            int buffersize = audioClip.samples * audioClip.channels;
            audioClip.GetData(data, 0);
            int sampleRate = audioClip.frequency;
            int channelMask = audioClip.channels;
            return PXR_Plugin.Controller.UPxr_StartVibrateBySharem(data, (int)vibrateController, buffersize, sampleRate, channelMask, 32, (int)channelFlip, ref sourceId);
        }

        /**
         * @deprecated Use \ref SendHapticBuffer(VibrateType vibrateType, float[] pcmData, int buffersize, int frequency, int channelMask, ChannelFlip channelFlip, ref int sourceId, CacheType cacheType) instead.
         */
        /// <summary>
        /// Starts audio-triggered vibration for specified controller(s). This function is the overloaded version.
        /// </summary>
        /// <param name="data">The PCM data.</param>
        /// <param name="vibrateController">The controller(s) to enable vibration for:
        /// * `0`: none
        /// * `1`: left controller
        /// * `2`: right controller
        /// * `3`: left and right controllers
        /// </param>
        /// <param name="buffersize">The length of PCM data. Formula: (audioClip.samples)×(audioClip.channels).</param>
        /// <param name="frequency">Audio sampling rate.</param>
        /// <param name="channelMask">The number of channels.</param>
        /// <param name="channelFlip">Whether to enable audio channel inversion:
        /// * `Yes`: enable
        /// * `No`: disable
        ///  Once audio channel inversion is enabled, the left controller vibrates with the audio data from the right channel, and vice versa.
        /// </param>
        /// <param name="sourceId">Returns the unique ID for controlling the corresponding vibration,
        /// which will be used in `StartVibrateByCache`, `ClearVibrateByCache` or `StopControllerVCMotor`.</param>
        [Obsolete("Please use SendHapticBuffer instead")]
        public static int StartVibrateBySharem(float[] data, VibrateController vibrateController, int buffersize, int frequency, int channelMask, ChannelFlip channelFlip, ref int sourceId)
        {
            return PXR_Plugin.Controller.UPxr_StartVibrateBySharem(data, (int)vibrateController, buffersize, frequency, channelMask, 32, (int)channelFlip, ref sourceId);
        }

        /// @deprecated Use \ref SendHapticBuffer(VibrateType vibrateType, AudioClip audioClip, ChannelFlip channelFlip, ref int sourceId, CacheType cacheType) instead.
        /// <summary>
        /// Caches audio-triggered vibration data for specified controller(s).
        /// @note The cached data can be extracted from the cache directory and then transmitted, which reduces resource consumption and improves service performance.
        /// </summary>
        /// <param name="audioClip">The path to the audio clip.</param>
        /// <param name="vibrateController">The controller(s) to cache data for:
        /// * `0`: none
        /// * `1`: left controller
        /// * `2`: right controller
        /// * `3`: left and right controllers</param>
        /// <param name="channelFlip">Whether to enable audio channel inversion:
        /// * `Yes`: enable
        /// * `No`: disable
        /// Once audio channel inversion is enabled, the left controller vibrates with the audio data from the right channel, and vice versa.
        /// </param>
        /// <param name="cacheConfig">Whether to keep the controller vibrating while caching audio-based vibration data:
        /// * `CacheAndVibrate`: cache and keep vibrating
        /// * `CacheNoVibrate`: cache and stop vibrating
        /// </param>
        /// <param name="sourceId">Returns the unique ID for controlling the corresponding vibration,
        /// which will be used in `StartVibrateByCache`, `ClearVibrateByCache` or `StopControllerVCMotor`.</param>
        /// <returns>
        /// * `0`: success
        /// * `-1`: failure
        /// </returns>
        [Obsolete("Please use SendHapticBuffer instead")]
        public static int SaveVibrateByCache(AudioClip audioClip, VibrateController vibrateController, ChannelFlip channelFlip, CacheConfig cacheConfig, ref int sourceId)
        {
            if (audioClip == null)
            {
                return 0;
            }
            float[] data = new float[audioClip.samples * audioClip.channels];
            int buffersize = audioClip.samples * audioClip.channels;
            audioClip.GetData(data, 0);
            int sampleRate = audioClip.frequency;
            int channelMask = audioClip.channels;
            return PXR_Plugin.Controller.UPxr_SaveVibrateByCache(data, (int)vibrateController, buffersize, sampleRate, channelMask, 32, (int)channelFlip, (int)cacheConfig, ref sourceId);
        }

        /// @deprecated Use \ref SendHapticBuffer(VibrateType vibrateType, float[] pcmData, int buffersize, int frequency, int channelMask, ChannelFlip channelFlip, ref int sourceId, CacheType cacheType)
        /// <summary>
        /// Caches audio-triggered vibration data for specified controller(s). This function is the overloaded version.
        /// @note The cached data can be extracted from the cache directory and then transmitted, which reduces resource consumption and improves service performance.
        /// </summary>
        /// <param name="data">The PCM data.</param>
        /// <param name="vibrateController">The controller(s) to cache data for:
        /// * `0`: none
        /// * `1`: left controller
        /// * `2`: right controller
        /// * `3`: left and right controllers
        /// </param>
        /// <param name="buffersize">The length of PCM data. Formula: (audioClip.samples)×(audioClip.channels)</param>
        /// <param name="frequency">Audio sampling rate.</param>
        /// <param name="channelMask">The number of channels.</param>
        /// <param name="channelFlip">Whether to enable audio channel inversion:
        /// * `Yes`: enable
        /// * `No`: disable
        /// Once audio channel inversion is enabled, the left controller vibrates with the audio data from the right channel, and vice versa.
        /// </param>
        /// <param name="cacheConfig">Whether to keep the controller vibrating while caching audio-based vibration data:
        /// * `CacheAndVibrate`: cache and keep vibrating
        /// * `CacheNoVibrate`: cache and stop vibrating
        /// </param>
        /// <param name="sourceId">Returns the unique ID for controlling the corresponding vibration,
        /// which will be used in `StartVibrateByCache`, `ClearVibrateByCache` or `StopControllerVCMotor`.</param>
        /// <returns>
        /// * `0`: success
        /// * `-1`: failure
        /// </returns>
        [Obsolete("Please use SendHapticBuffer instead")]
        public static int SaveVibrateByCache(float[] data, VibrateController vibrateController, int buffersize, int frequency, int channelMask, ChannelFlip channelFlip, CacheConfig cacheConfig, ref int sourceId)
        {
            return PXR_Plugin.Controller.UPxr_SaveVibrateByCache(data, (int)vibrateController, buffersize, frequency, channelMask, 32, (int)channelFlip, (int)cacheConfig, ref sourceId);
        }

        /// @deprecated Use \ref StartHapticBuffer instead.
        /// <summary>
        /// Plays cached audio-triggered vibration data.
        /// </summary>
        /// <param name="sourceId">The source ID returned by `StartVibrateBySharem` or `SaveVibrateByCache`.</param>
        /// <returns>
        /// * `0`: success
        /// * `-1`: failure
        /// </returns>
        [Obsolete("Please use StartHapticBuffer instead")]
        public static int StartVibrateByCache(int sourceId)
        {
            return PXR_Plugin.Controller.UPxr_StartVibrateByCache(sourceId);
        }

        /// @deprecated Use \ref StopHapticBuffer(clearCache) instead.
        /// <summary>
        /// Clears cached audio-triggered vibration data.
        /// </summary>
        /// <param name="sourceId">The source ID returned by `StartVibrateBySharem` or `SaveVibrateByCache`.</param>
        /// <returns>
        /// * `0`: success
        /// * `-1`: failure
        /// </returns>
        [Obsolete("Please use StopHapticBuffer(clearCache) instead")]
        public static int ClearVibrateByCache(int sourceId)
        {
            return PXR_Plugin.Controller.UPxr_ClearVibrateByCache(sourceId);
        }

        public static int SetControllerEnableKey(bool isEnable, PxrControllerKeyMap Key)
        {
            return PXR_Plugin.Controller.UPxr_SetControllerEnableKey(isEnable, Key);
        }

        /// @deprecated Use \ref SendHapticBuffer(VibrateType vibrateType, TextAsset phfText, ChannelFlip channelFlip, float amplitudeScale, ref int sourceId) instead.
        /// <summary>
        /// Starts PHF-triggered vibration for specified controller(s). PHF stands for PICO haptic file.
        /// </summary>
        /// <param name="phfText">The path to the PHF file.</param>
        /// <param name="sourceId">The source ID returned by `StartVibrateBySharem` or `SaveVibrateByCache`.</param>
        /// <param name="vibrateController">The controller(s) to enable vibration for:
        /// * `0`: none
        /// * `1`: left controller
        /// * `2`: right controller
        /// * `3`: left and right controllers
        /// </param>
        /// <param name="channelFlip">Whether to enable audio channel inversion:
        /// * `Yes`: enable
        /// * `No`: disable
        /// Once audio channel inversion is enabled, the left controller vibrates with the audio data from the right channel, and vice versa.</param>
        /// <param name="amp">The vibration gain, the valid value range from `0` to `2`:
        /// * `0`: no vibration
        /// * `1`: standard amplitude
        /// * `2`: 2×standard amplitude</param>
        /// <returns>
        /// * `0`: success
        /// * `-1`: failure
        /// </returns>
        [Obsolete("Please use SendHapticBuffer instead")]
        public static int StartVibrateByPHF(TextAsset phfText, ref int sourceId, VibrateController vibrateController, ChannelFlip channelFlip, float amp)
        {
            return PXR_Plugin.Controller.UPxr_StartVibrateByPHF(phfText.text, phfText.text.Length, ref sourceId, (int)vibrateController, (int)channelFlip, amp);
        }

        /// @deprecated Use \ref PauseHapticBuffer instead.
        /// <summary>
        /// Pauses PHF-triggered vibration.
        /// </summary>
        /// <param name="sourceId">The source ID returned by `StartVibrateBySharem` or `SaveVibrateByCache`.</param>
        /// <returns>
        /// * `0`: success
        /// * `-1`: failure
        /// </returns>
        [Obsolete("Please use PauseHapticBuffer instead")]
        public static int PauseVibrate(int sourceId)
        {
            return PXR_Plugin.Controller.UPxr_PauseVibrate(sourceId);
        }

        /// @deprecated Use \ref ResumeHapticBuffer instead.
        /// <summary>
        /// Resumes PHF-triggered vibration.
        /// </summary>
        /// <param name="sourceId">The source ID returned by `StartVibrateBySharem` or `SaveVibrateByCache`.</param>
        /// <returns>
        /// * `0`: success
        /// * `-1`: failure
        /// </returns>
        [Obsolete("Please use ResumeHapticBuffer instead")]
        public static int ResumeVibrate(int sourceId)
        {
            return PXR_Plugin.Controller.UPxr_ResumeVibrate(sourceId);
        }

        /// @deprecated Use \ref UpdateHapticBuffer instead.
        /// <summary>
        /// Dynamically updates PHF and AudioClip vibration data.
        /// </summary>
        /// <param name="sourceId">The source ID returned by `StartVibrateBySharem` or `SaveVibrateByCache`.</param>
        /// <param name="vibrateController">The controller(s) to update PHF and AudioClip vibration data for:
        /// * `0`: none
        /// * `1`: left controller
        /// * `2`: right controller
        /// * `3`: left and right controllers
        /// </param>
        /// <param name="channelFlip">Whether to enable audio channel inversion:
        /// * `Yes`: enable
        /// * `No`: disable
        /// Once audio channel inversion is enabled, the left controller vibrates with the audio data from the right channel, and vice versa.</param>
        /// <param name="amp">The vibration gain, the valid value range from `0` to `2`:
        /// * `0`: no vibration
        /// * `1`: standard amplitude
        /// * `2`: 2×standard amplitude</param>
        /// <returns>
        /// * `0`: success
        /// * `-1`: failure
        /// </returns>
        [Obsolete("Please use UpdateHapticBuffer instead")]
        public static int UpdateVibrateParams(int sourceId, VibrateController vibrateController, ChannelFlip channelFlip, float amp)
        {
            return PXR_Plugin.Controller.UPxr_UpdateVibrateParams(sourceId, (int)vibrateController, (int)channelFlip, amp);
        }
        
        /// <summary>
        /// Gets the data about the poses of body joints.
        /// </summary>
        /// <param name="predictTime">Reserved parameter, pass `0`.</param>
        /// <param name="bodyTrackerResult">Contains the data about the poses of body joints, including position, action, and more.</param>
        public static int GetBodyTrackingPose(double predictTime, ref BodyTrackerResult bodyTrackerResult)
        {
            return PXR_Plugin.Controller.UPxr_GetBodyTrackingPose(predictTime, ref bodyTrackerResult);
        }
        
        /// <summary>
        /// Gets the number of PICO Motion Trackers currently connected and their IDs.
        /// </summary>
        /// <param name="state">The number and IDs of connected PICO Motion Trackers.</param>
        public static int GetFitnessBandConnectState(ref PxrFitnessBandConnectState state)
        {
            return PXR_Plugin.Controller.UPxr_GetFitnessBandConnectState(ref state);
        }

        /// <summary>
        /// Gets the battery of a specified PICO Motion Traker.
        /// </summary>
        /// <param name="trackerId">The ID of the motion tracker to get battery for.</param>
        /// <param name="battery">The motion tracker's battery. Value range: [0,5]. The smaller the value, the lower the battery level.</param>
        public static int GetFitnessBandBattery(int trackerId, ref int battery)
        {
            return PXR_Plugin.Controller.UPxr_GetFitnessBandBattery(trackerId, ref battery);
        }

        /// <summary>
        /// Gets whether the PICO Motion Tracker has completed calibration.
        /// </summary>
        /// <param name="calibrated">Indicates the calibration status:
        /// `0`: calibration uncompleted
        /// `1`: calibration completed
        /// </param>
        public static int GetFitnessBandCalibState(ref int calibrated) {
            return PXR_Plugin.Controller.UPxr_GetFitnessBandCalibState(ref calibrated);
        }

        /// <summary>
        /// Sets a body tracking mode for PICO Motion Tracker. If this API is not called, the mode defaults to leg tracking.
        /// @note If you want to set the mode to full-body tracking, you must call this API before calling `OpenFitnessBandCalibrationAPP`.
        /// </summary>
        /// <param name="mode">Selects a body tracking mode from the following:
        /// * `0`: leg tracking, nodes numbered 0 to 15 in `BodyTrackerRole` enum will return data.
        /// * `1`: full-body tracking, nodes numbered 0 to 23 in `BodyTrackerRole` enum will return data.
        /// </param>
        /// <returns>
        /// * `0`: success
        /// * `1`: failure
        /// </returns>
        public static int SetSwiftMode(int mode)
        {
            return PXR_Plugin.Controller.UPxr_SetSwiftMode(mode);
        }

        /// <summary>
        /// Sets bone lengths for different parts of the avatar. The data will be sent to PICO'S algorithm to make the avatar's poses more accurate. 
        /// </summary>
        /// <param name="boneLength">Sets the bone lengths for different parts of the avatar. See the `BodyTrackingBoneLength` for details.</param>
        /// <returns>
        /// * `0`: success
        /// * `1`: failure
        /// </returns>
        public static int SetBodyTrackingBoneLength(BodyTrackingBoneLength boneLength)
        {
            return PXR_Plugin.Controller.UPxr_SetBodyTrackingBoneLength(boneLength);
        }

        /// <summary>
        /// Launches the calibration app if the PICO Motion Tracker hasn't completed calibration.
        /// </summary>
        public static void OpenFitnessBandCalibrationAPP() {
            PXR_Plugin.System.UPxr_OpenFitnessBandCalibrationAPP();
        }

        /// <summary>
        /// Sends a haptic impulse to specified controller(s) to trigger vibration.
        /// @note To stop vibration, call this API again and set both `amplitude` and `duration` to `0`.
        /// </summary>
        /// <param name="vibrateType">The controller(s) to send the haptic impulse to:
        /// * `None`
        /// * `LeftController`
        /// * `RightController`
        /// * `BothController`
        /// </param>
        /// <param name="amplitude">Vibration amplitude, which ranges from `0` to `1`. The higher the value, the stronger the vibration amplitude.</param>
        /// <param name="duration">Vibration duration, which ranges from `0` to `65535` ms.</param>
        /// <param name="frequency">Vibration frequency, which ranges from `50` to `500` Hz.</param>
        public static void SendHapticImpulse(VibrateType vibrateType, float amplitude, int duration, int frequency = 150)
        {
            switch (vibrateType)
            {
                case VibrateType.None:
                    break;
                case VibrateType.LeftController:
                    PXR_Plugin.Controller.UPxr_SetControllerVibrationEvent(0, frequency, amplitude, duration);
                    break;
                case VibrateType.RightController:
                    PXR_Plugin.Controller.UPxr_SetControllerVibrationEvent(1, frequency, amplitude, duration);
                    break;
                case VibrateType.BothController:
                    PXR_Plugin.Controller.UPxr_SetControllerVibrationEvent(0, frequency, amplitude, duration);
                    PXR_Plugin.Controller.UPxr_SetControllerVibrationEvent(1, frequency, amplitude, duration);
                    break;
                default:
                    break;
            }
        }

        /// <summary>
        /// Sends a buffer of haptic data to specified controller(s) to trigger vibration.
        /// </summary>
        /// <param name="vibrateType">The controller(s) to send the haptic data to:
        /// * `None`
        /// * `LeftController`
        /// * `RightController`
        /// * `BothController`
        /// </param>
        /// <param name="audioClip">The audio data pulled from the audio file stored in the AudioClip component is used as the haptic data.</param>
        /// <param name="channelFlip">Determines whether to enable audio channel inversion. Once enabled, the left controller vibrates with the audio data from the right channel, and vice versa.
        /// * `Yes`: enable
        /// * `No`: disable
        /// </param>
        /// <param name="sourceId">Returns the unique ID for controlling the corresponding buffered haptic,
        /// which will be used in `PauseHapticBuffer`, `ResumeHapticBuffer`, `UpdateHapticBuffer`, or `StopHapticBuffer`.</param>
        /// <param name="cacheType">Whether to keep the controller vibrating while caching haptic data:
        /// * `DontCache`: don't cache.
        /// * `CacheAndVibrate`: cache and keep vibrating.
        /// * `CacheNoVibrate`: cache and stop vibrating. Call `StartHapticBuffer` to start haptic after caching the data.
        /// @note If not defined, `DontCache` will be passed by default.
        /// </param>
        /// <returns>
        /// * `0`: success
        /// * `1`: failure
        /// </returns>
        /**
         * \overload int SendHapticBuffer(VibrateType vibrateType, AudioClip audioClip, ChannelFlip channelFlip, ref int sourceId, CacheType cacheType)
         */
        public static int SendHapticBuffer(VibrateType vibrateType, AudioClip audioClip, ChannelFlip channelFlip, ref int sourceId, CacheType cacheType = CacheType.DontCache)
        {
            if (audioClip == null)
            {
                return 0;
            }
            float[] data = new float[audioClip.samples * audioClip.channels];
            int buffersize = audioClip.samples * audioClip.channels;
            audioClip.GetData(data, 0);
            int sampleRate = audioClip.frequency;
            int channelMask = audioClip.channels;
            if (cacheType == CacheType.DontCache)
            {
                return PXR_Plugin.Controller.UPxr_StartVibrateBySharem(data, (int)vibrateType, buffersize, sampleRate, channelMask, 32, (int)channelFlip, ref sourceId);
            }
            else
            {
                return PXR_Plugin.Controller.UPxr_SaveVibrateByCache(data, (int)vibrateType, buffersize, sampleRate, channelMask, 32, (int)channelFlip, (int)cacheType, ref sourceId);
            }
        }

        /// <summary>
        /// Sends a buffer of haptic data to specified controller(s) to trigger vibration.
        /// </summary>
        /// <param name="vibrateType">The controller(s) to send the haptic data to:
        /// * `None`
        /// * `LeftController`
        /// * `RightController`
        /// * `BothController`
        /// </param>
        /// <param name="pcmData">The PCM data is converted from the audio file stored in the AudioClip component in the Unity Engine.</param>
        /// <param name="buffersize">The length of PCM data. Calculation formula: (audioClip.samples)×(audioClip.channels). Sample refers to the data in each channel.</param>
        /// <param name="frequency">Sample rate. The higher the sample rate, the closer the recorded signal is to the original.</param>
        /// <param name="channelMask">The number of channels that play the haptic data.</param>
        /// <param name="channelFlip">Determines whether to enable audio channel inversion. Once enabled, the left controller vibrates with the audio data from the right channel, and vice versa.
        /// * `Yes`: enable
        /// * `No`: disable
        /// </param>
        /// <param name="sourceId">Returns the unique ID for controlling the corresponding buffered haptic,
        /// which will be used in `PauseHapticBuffer`, `ResumeHapticBuffer`, `UpdateHapticBuffer`, or `StopHapticBuffer`.</param>
        /// <param name="cacheType">Whether to keep the controller vibrating while caching haptic data:
        /// * `DontCache`: don't cache.
        /// * `CacheAndVibrate`: cache and keep vibrating.
        /// * `CacheNoVibrate`: cache and stop vibrating. Call `StartHapticBuffer` to start vibration after caching the data.
        /// @note If not defined, `DontCache` will be passed by default.
        /// </param>
        /// <returns>
        /// * `0`: success
        /// * `-1`: failure
        /// </returns>
        /**
         * \overload int SendHapticBuffer(VibrateType vibrateType, float[] pcmData, int buffersize, int frequency, int channelMask, ChannelFlip channelFlip, ref int sourceId, CacheType cacheType)
         */
        public static int SendHapticBuffer(VibrateType vibrateType, float[] pcmData, int buffersize, int frequency, int channelMask, ChannelFlip channelFlip, ref int sourceId, CacheType cacheType = CacheType.DontCache)
        {
            if (cacheType == CacheType.DontCache)
            {
                return PXR_Plugin.Controller.UPxr_StartVibrateBySharem(pcmData, (int)vibrateType, buffersize, frequency, channelMask, 32, (int)channelFlip, ref sourceId);
            }
            else
            {
                return PXR_Plugin.Controller.UPxr_SaveVibrateByCache(pcmData, (int)vibrateType, buffersize, frequency, channelMask, 32, (int)channelFlip, (int)cacheType, ref sourceId);
            }
        }

        /// <summary>
        /// Sends a buffer of haptic data to specified controller(s) to trigger vibration.
        /// </summary>
        /// <param name="vibrateType">The controller(s) to send the haptic data to:
        /// * `None`
        /// * `LeftController`
        /// * `RightController`
        /// * `BothController`
        /// </param>
        /// <param name="phfText">The PHF file (.json) that contains haptic data.</param>
        /// <param name="channelFlip">Determines whether to enable audio channel inversion. Once enabled, the left controller vibrates with the audio data from the right channel, and vice versa.
        /// * `Yes`: enable
        /// * `No`: disable
        /// <param name="amplitudeScale">Vibration amplitude, the higher the amplitude, the stronger the haptic effect. The valid value range from `0` to `2`:
        /// * `0`: no vibration
        /// * `1`: standard amplitude
        /// * `2`: 2×standard amplitude
        /// </param>
        /// <param name="sourceId">Returns the unique ID for controlling the corresponding buffered haptic,
        /// which will be used in `PauseHapticBuffer`, `ResumeHapticBuffer`, `UpdateHapticBuffer`, or `StopHapticBuffer`.</param>
        /// <returns>
        /// * `0`: success
        /// * `-1`: failure
        /// </returns>
        public static int SendHapticBuffer(VibrateType vibrateType, TextAsset phfText, ChannelFlip channelFlip, float amplitudeScale, ref int sourceId)
        {
            return PXR_Plugin.Controller.UPxr_StartVibrateByPHF(phfText.text, phfText.text.Length, ref sourceId, (int)vibrateType, (int)channelFlip, amplitudeScale);
        }

        /// <summary>
        /// Stops a specified buffered haptic.
        /// </summary>
        /// <param name="sourceId">The source ID returned by `SendHapticBuffer`. Set it to the target source ID to stop a specific buffered haptic,
        /// or set it to `0` to stop all buffered haptics. If not defined, `0` will be passed to stop all buffered haptics by default.</param>
        /// <param name="clearCache">Determines whether to clear the cached data of the specified haptic.
        /// If not defined, `false` will be passed to keep the cached data by default.</param>
        /// <returns>
        /// * `0`: success
        /// * `1`: failure
        /// </returns>
        public static int StopHapticBuffer(int sourceId = 0, bool clearCache = false)
        {
            if (clearCache)
            {
                PXR_Plugin.Controller.UPxr_ClearVibrateByCache(sourceId);
            }
            return PXR_Plugin.Controller.UPxr_StopControllerVCMotor(sourceId);
        }

        /// <summary>
        /// Pauses a specified buffered haptic.
        /// </summary>
        /// <param name="sourceId">The source ID returned by `SendHapticBuffer`.
        /// Set it to the target source ID to stop a specific buffered haptic.</param>
        /// <returns>
        /// * `0`: success
        /// * `-1`: failure
        /// </returns>
        public static int PauseHapticBuffer(int sourceId)
        {
            return PXR_Plugin.Controller.UPxr_PauseVibrate(sourceId);
        }

        /// <summary>
        /// Resumes a paused buffered haptic.
        /// </summary>
        /// <param name="sourceId">The source ID returned by `SendHapticBuffer`.
        /// Set it to the target source ID to resume a specific buffered haptic.</param>
        /// <returns>
        /// * `0`: success
        /// * `-1`: failure
        /// </returns>
        public static int ResumeHapticBuffer(int sourceId)
        {
            return PXR_Plugin.Controller.UPxr_ResumeVibrate(sourceId);
        }

        /// <summary>
        /// Starts a specified buffered haptic.
        /// @note If you pass `CacheNoVibrate` in `SendHapticBuffer`, call this API if you want to start haptic after caching the data.
        /// </summary>
        /// <param name="sourceId">The source ID returned by `SendHapticBuffer` when there is cached data for the haptic.</param>
        /// <returns>
        /// * `0`: success
        /// * `-1`: failure
        /// </returns>
        public static int StartHapticBuffer(int sourceId)
        {
            return PXR_Plugin.Controller.UPxr_StartVibrateByCache(sourceId);
        }

        /// <summary>
        /// Updates the settings for a specified buffered haptic.
        /// </summary>
        /// <param name="sourceId">The source ID returned by `SendHapticBuffer`.
        /// Set it to the target source ID to update a specific buffered haptic.</param>
        /// <param name="vibrateType">The controller(s) that the vibration is applied to:
        /// * `None`
        /// * `LeftController`
        /// * `RightController`
        /// * `BothController`
        /// </param>
        /// <param name="channelFlip">Determines whether to enable audio channel inversion. Once enabled, the left controller vibrates with the audio data from the right channel, and vice versa.
        /// * `Yes`: enable
        /// * `No`: disable
        /// <param name="amplitudeScale">Vibration amplitude, the higher the amplitude, the stronger the haptic effect. The valid value range from `0` to `2`:
        /// * `0`: no vibration
        /// * `1`: standard amplitude
        /// * `2`: 2×standard amplitude
        /// </param>
        /// <returns>
        /// * `0`: success
        /// * `-1`: failure
        /// </returns>
        public static int UpdateHapticBuffer(int sourceId, VibrateType vibrateType, ChannelFlip channelFlip, float amplitudeScale)
        {
            return PXR_Plugin.Controller.UPxr_UpdateVibrateParams(sourceId, (int)vibrateType, (int)channelFlip, amplitudeScale);
        }

        /// <summary>Creates a haptic stream.</summary>
        /// <param name="phfVersion">The version of the PICO haptic file (PHF) that the stream uses.</param>
        /// <param name="frameDurationMs">Interframe space, which is the amount of time in milliseconds existing between the transmissions of frames.</param>
        /// <param name="hapticInfo">The information about this haptic stream you create.</param>
        /// <param name="speed">The streaming speed.</param>
        /// <param name="id">Returns the ID of the stream.</param>
        /// <returns>
        /// * `0`: success
        /// * `1`: failure
        /// </returns>
        public static int CreateHapticStream(string phfVersion, UInt32 frameDurationMs, ref VibrateInfo hapticInfo, float speed, ref int id)
        {
            return PXR_Plugin.Controller.UPxr_CreateHapticStream(phfVersion, frameDurationMs, ref hapticInfo, speed, ref id);
        }

        /// <summary>
        /// Writes haptic data to a specified stream.
        /// </summary>
        /// <param name="id">The ID of the target stream.</param>
        /// <param name="frames">The data contained in the PICO haptic file (PHF).</param>
        /// <param name="numFrames">The number of frames.</param>
        /// <returns>
        /// * `0`: success
        /// * `1`: failure
        /// </returns>
        public static int WriteHapticStream(int id, ref PxrPhfParamsNum frames, UInt32 numFrames)
        {
            return PXR_Plugin.Controller.UPxr_WriteHapticStream(id, ref frames, numFrames);
        }

        /// <summary>
        /// Sets a transmission speed for a specified haptic stream.
        /// </summary>
        /// <param name="id">The ID of the stream.</param>
        /// <param name="speed">The transmission speed to set for the stream.</param>
        /// <returns>
        /// * `0`: success
        /// * `1`: failure
        /// </returns>
        public static int SetHapticStreamSpeed(int id, float speed)
        {
            return PXR_Plugin.Controller.UPxr_SetPHFHapticSpeed(id, speed);
        }

        /// <summary>
        /// Gets the transmission speed of a specified haptic stream.
        /// </summary>
        /// <param name="id">The ID of the stream.</param>
        /// <param name="speed">Returns the stream's transmission speed.</param>
        /// <returns>
        /// * `0`: success
        /// * `1`: failure
        /// </returns>
        public static int GetHapticStreamSpeed(int id, ref float speed)
        {
            return PXR_Plugin.Controller.UPxr_GetPHFHapticSpeed(id, ref speed);
        }

        /// <summary>
        /// Gets the No. of the frame that the controller currently plays.
        /// </summary>
        /// <param name="id">The ID of the haptic stream that triggers the vibration.</param>
        /// <param name="frameSequence">Returns the current frame's sequence No.</param>
        /// <returns>
        /// * `0`: success
        /// * `1`: failure
        /// </returns>
        public static int GetHapticStreamCurrentFrameSequence(int id, ref UInt64 frameSequence)
        {
            return PXR_Plugin.Controller.UPxr_GetCurrentFrameSequence(id, ref frameSequence);
        }

        /// <summary>
        /// Starts the transmission of a specified haptic stream.
        /// </summary>
        /// <param name="source_id">The ID of the haptic stream.</param>
        /// <returns>
        /// * `0`: success
        /// * `1`: failure
        /// </returns>
        public static int StartHapticStream(int source_id)
        {
            return PXR_Plugin.Controller.UPxr_StartPHFHaptic(source_id);
        }

        /// <summary>
        /// Stops the transmission of a specified haptic stream.
        /// </summary>
        /// <param name="source_id">The ID of the haptic stream.</param>
        /// <returns>
        /// * `0`: success
        /// * `1`: failure
        /// </returns>
        public static int StopHapticStream(int source_id)
        {
            return PXR_Plugin.Controller.UPxr_StopPHFHaptic(source_id);
        }

        /// <summary>
        /// Removes a specified haptic stream.
        /// </summary>
        /// <param name="source_id">The ID of the stream.</param>
        /// <returns>
        /// * `0`: success
        /// * `1`: failure
        /// </returns>
        public static int RemoveHapticStream(int source_id)
        {
            return PXR_Plugin.Controller.UPxr_RemovePHFHaptic(source_id);
        }

        /// <summary>
        /// Parses the haptic data in a specified PICO haptic file (PHF).
        /// </summary>
        /// <param name="phfText">The PICO haptic file (.json) to parse.</param>
        public static PxrPhfFile AnalysisHapticStreamPHF(TextAsset phfText)
        {
            String str = phfText.text;
            return JsonMapper.ToObject<PxrPhfFile>(str);
        }

        /// <summary>
        /// Recenters the controller on PICO G3.
        /// </summary>
        public static void ResetController()
        {
            PXR_Plugin.Controller.UPxr_ResetController();
        }

        /// <summary>
        /// Sets arm model parameters on PICO G3.
        /// </summary>
        /// <param name="gazetype">Gaze type, which is used to define the way of getting the HMD data.</param>
        /// <param name="armmodeltype">Arm model type</param>
        /// <param name="elbowHeight">The elbow's height, which changes the arm's length.Value range: (0.0f, 0.2f). The default value is 0.0f.</param>
        /// <param name="elbowDepth">The elbow's depth, which changes the arm's position.Value range: (0.0f, 0.2f). The default value is 0.0f.</param>
        /// <param name="pointerTiltAngle">The ray's tilt angle. Value range: (0.0f, 30.0f). The default value is 0.0f.</param>
        public static void SetArmModelParameters(PxrGazeType gazetype, PxrArmModelType armmodeltype, float elbowHeight, float elbowDepth, float pointerTiltAngle)
        {
            PXR_Plugin.Controller.UPxr_SetArmModelParameters(gazetype, armmodeltype, elbowHeight, elbowDepth, pointerTiltAngle);
        }

        /// <summary>
        /// Gets the current user's dominant hand in the system on PICO G3.
        /// </summary>
        /// <param name="deviceID">Specifies the ID of the PICO device.</param>
        public static void GetControllerHandness(ref int deviceID)
        {
            PXR_Plugin.Controller.UPxr_GetControllerHandness(ref deviceID);
        }

    }
}