NativePlugin.cs

/*
 * Copyright (C) 2020-2023 Tilt Five, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
using System;
using System.Runtime.InteropServices;
using UnityEngine;
 
namespace TiltFive
{
    public class NativePlugin
    {
 
#if (UNITY_IPHONE || UNITY_WEBGL) && !UNITY_EDITOR
        public const string PLUGIN_LIBRARY = @"__Internal";
#else
        public const string PLUGIN_LIBRARY = @"TiltFiveUnity";
#endif
 
        internal const int T5_RESULT_SUCCESS = 0;
        internal const int T5_RESULT_UNKNOWN_ERROR = 1;
 
        #region Native Functions
 
        // Init
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern int SetApplicationInfo(
            T5_StringUTF8 appName,
            T5_StringUTF8 appId,
            T5_StringUTF8 appVersion);
 
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern int SetPlatformContext(
            IntPtr platformContext);
 
        [DllImport(PLUGIN_LIBRARY)]
        [return: MarshalAs(UnmanagedType.I4)]
        internal static extern ServiceCompatibility GetServiceCompatibility();
 
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern int IsTiltFiveUIRequestingAttention(ref T5_Bool attentionRequested);
 
        // Glasses Acquisition
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern int RefreshGlassesAvailable();
 
        // Set Maximum Desired Glasses.  Count starts at 0.
        //
        // Note that using this to reduce the count will result in glasses being released back to
        // the set of available glasses, which can invalidate handles currently in use.  Generally,
        // this should only be called once on load to indicate how many glasses your application
        // wants.
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern void SetMaxDesiredGlasses(byte maxCount);
 
        // Glasses Availability
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern int GetGlassesHandles(
            ref byte handleCount,
            [MarshalAs(UnmanagedType.LPArray, SizeParamIndex=0)] UInt64[] glassesHandle);
 
        // Glasses Friendly Name
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern int GetGlassesFriendlyName(UInt64 glassesHandle, ref T5_StringUTF8 glassesFriendlyName);
 
        // Head Pose
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern int GetGlassesPose(
            UInt64 glassesHandle,
            ref T5_GlassesPose glassesPose,
            [MarshalAs(UnmanagedType.I4)] T5_GlassesPoseUsage glassesPoseUsage);
 
        // Gameboard Poses
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern int GetGameboardPoses(UInt64 glassesHandle,
            [MarshalAs(UnmanagedType.LPArray, SizeConst = 1)] T5_GameboardPose[] gameboardPoses,
            ref UInt16 count);
 
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern int ConfigureCameraStream(UInt64 glassesHandle, T5_CameraStreamConfig cameraConfig);
 
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern int GetFilledCamImageBuffer(UInt64 glassesHandle, ref T5_CamImage camImageBuffer);
 
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern int SubmitEmptyCamImageBuffer(UInt64 glassesHandle, IntPtr camImageBuffer, UInt32 bufferSize);
 
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern int CancelCamImageBuffer(UInt64 glassesHandle, IntPtr buffer);
 
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern int GetDewarpedPixelCoordinate(UInt64 glassesHandle, ref T5_PixelDewarp pixelDewarp);
 
#if TILT_FIVE_ENABLE_PROJECTOR_EXTRINSICS_ADJUSTMENTS
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern int SetProjectorExtrinsicsAdjustment(UInt64 glassesHandle,
            [MarshalAs(UnmanagedType.LPArray, SizeConst = 14)] float[] args);
#endif
 
        // Gameboard dimensions
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern int GetGameboardDimensions(
            [MarshalAs(UnmanagedType.I4)] GameboardType gameboardType,
            ref T5_GameboardSize playableSpaceInMeters);
 
        // Wand Availability
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern int GetWandAvailability(
            UInt64 glassesHandle,
            ref T5_Bool wandAvailable,
            [MarshalAs(UnmanagedType.I4)] ControllerIndex wandTarget);
 
        // Scan for Wands
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern int ScanForWands();
 
        // Wand Controls State
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern int GetControllerState(
            UInt64 glassesHandle,
            [MarshalAs(UnmanagedType.I4)] ControllerIndex controllerIndex,
            ref T5_ControllerState controllerState);
 
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern int SendImpulse(UInt64 glassesHandle,
            [MarshalAs(UnmanagedType.I4)] ControllerIndex controllerIndex, float amplitude, ushort duration);
 
        // Submit Render Textures
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern int QueueStereoImages(UInt64 glassesHandle, T5_FrameInfo frameInfo);
 
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern IntPtr GetSendFrameCallback();
 
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern int GetMaxDisplayDimensions(
            UInt64 glassesHandle,
            out UInt16 framebufferWidth,
            out UInt16 framebufferHeight);
 
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern int GetGlassesIPD(UInt64 glassesHandle, ref float glassesIPD);
 
        [DllImport(PLUGIN_LIBRARY)]
        internal static extern void UnloadWorkaround();
 
#if UNITY_WEBGL && !UNITY_EDITOR
        [DllImport ("__Internal")]
        internal static extern void RegisterPlugin();
#endif
 
        #endregion Native Functions
    }

    internal struct T5_Bool
    {
        private readonly byte booleanByte;
 
        public T5_Bool(bool boolean)
        {
            booleanByte = Convert.ToByte(boolean);
        }
 
        public static implicit operator bool(T5_Bool t5_boolean)
            => Convert.ToBoolean(t5_boolean.booleanByte);
        public static implicit operator T5_Bool(bool boolean) => new T5_Bool(boolean);
    }

    [StructLayout(LayoutKind.Sequential)]
    internal struct T5_Position
    {
        public float X, Y, Z;
 
        public T5_Position(Vector3 position)
        {
            X = position.x;
            Y = position.y;
            Z = position.z;
        }
 
        public static implicit operator Vector3(T5_Position t5_position)
            => new Vector3(t5_position.X, t5_position.Y, t5_position.Z);
        public static implicit operator T5_Position(Vector3 position) => new T5_Position(position);
    }

    [StructLayout(LayoutKind.Sequential)]
    internal struct T5_Rotation
    {
        public float W, X, Y, Z;
 
        public T5_Rotation(Quaternion rotation)
        {
            W = rotation.w;
            X = rotation.x;
            Y = rotation.y;
            Z = rotation.z;
        }
 
        public static implicit operator Quaternion(T5_Rotation t5_rotation)
            => new Quaternion(t5_rotation.X, t5_rotation.Y, t5_rotation.Z, t5_rotation.W);
        public static implicit operator T5_Rotation(Quaternion rotation) => new T5_Rotation(rotation);
    }
 
    internal struct GlassesHandle : IEquatable<GlassesHandle>
    {
        private UInt64 glassesHandle;
        public static implicit operator UInt64(GlassesHandle handle) => handle.glassesHandle;
        public static implicit operator GlassesHandle(UInt64 handle) => new GlassesHandle() { glassesHandle = handle };
        public override int GetHashCode() => glassesHandle.GetHashCode();
        public bool Equals(GlassesHandle other) => glassesHandle == other.glassesHandle;
        public override string ToString()
        {
            return glassesHandle.ToString();
        }
    }

    [StructLayout(LayoutKind.Sequential)]
    internal struct T5_GlassesPose
    {
        public UInt64 TimestampNanos;
 
        private T5_Position posOfGLS_STAGE;
        private T5_Rotation rotationToGLS_STAGE;
 
        public GameboardType GameboardType;
 
        public Vector3 PosOfGLS_STAGE { get => posOfGLS_STAGE; set => posOfGLS_STAGE = value; }
        public Quaternion RotationToGLS_STAGE { get => rotationToGLS_STAGE; set => rotationToGLS_STAGE = value; }
    }

    [StructLayout(LayoutKind.Sequential)]
    internal struct T5_GameboardPose
    {
        public UInt64 TimestampNanos;
 
        private T5_Position posOfBOARD_STAGE;
        private T5_Rotation rotationToBOARD_STAGE;
 
        public GameboardType GameboardType;
        public UInt64 id;
 
        public Vector3 PosOfBOARD_STAGE { get => posOfBOARD_STAGE; set => posOfBOARD_STAGE = value; }
        public Quaternion RotationToBOARD_STAGE { get => rotationToBOARD_STAGE; set => rotationToBOARD_STAGE = value; }
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct T5_CamImage
    {
        public UInt16 ImageBufferWidth_PIX;
        public UInt16 ImageBufferHeight_PIX;
        public UInt16 ImageBufferStride_PIX;
        public UInt32 ImageBufferSize_PIX;
        public IntPtr ImageBuffer;
        private T5_Position posOfCAM_STAGE;
        private T5_Rotation rotToCAM_STAGE;
        public Vector3 PosOfCAM_STAGE { get => posOfCAM_STAGE; set => posOfCAM_STAGE = value; }
        public Quaternion RotToCAM_STAGE { get => rotToCAM_STAGE; set => rotToCAM_STAGE = value; }
 
        [Obsolete("T5_CamImage.PosOfCAM_GBD is deprecated. Please use T5_CamImage.PosOfCAM_STAGE instead.")]
        public Vector3 PosOfCAM_GBD => PosOfCAM_STAGE;
        [Obsolete("T5_CamImage.RotToCAM_GBD is deprecated. Please use T5_CamImage.RotToCAM_STAGE instead.")]
        public Quaternion RotToCAM_GBD => RotToCAM_STAGE;
 
        public T5_CamImage(UInt16 bufferWidth, UInt16 bufferHeight, UInt16 bufferStride, UInt32 bufferSize)
        {
            ImageBuffer = IntPtr.Zero;
            ImageBufferWidth_PIX = bufferWidth;
            ImageBufferHeight_PIX = bufferHeight;
            ImageBufferStride_PIX = bufferStride;
            ImageBufferSize_PIX = bufferSize;
            posOfCAM_STAGE = Vector3.zero;
            rotToCAM_STAGE = Quaternion.identity;
        }
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct T5_CameraStreamConfig
    {
        public byte cameraIndex;
        private T5_Bool streamEnabled;
        public bool enabled { get => streamEnabled; set => streamEnabled = value; }
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct T5_PixelDewarp
    {
        public Vector2 pixelCoord_PIX { get => pixelCoord_PIX; set => pixelCoord_PIX = value; }
        public Vector2 pixelCoord_IMG { get => pixelCoord_IMG; set => pixelCoord_IMG = value; }
        public byte cameraIndex;
    }

    [StructLayout(LayoutKind.Sequential)]
    internal struct T5_ControllerState
    {
        [StructLayout(LayoutKind.Sequential)]
        public struct Joystick
        {
            public float X, Y;
 
            public static implicit operator Vector2(Joystick joystick) => new Vector2(joystick.X, joystick.Y);
        }
 
        [StructLayout(LayoutKind.Sequential)]
        public struct Buttons
        {
            private T5_Bool t5,
                one,
                two,
                three,
                a,
                b,
                x,
                y;
 
            public bool T5 { get => t5; set => t5 = value; }
            public bool One { get => one; set => one = value; }
            public bool Two { get => two; set => two = value; }
            public bool Three { get => three; set => three = value; }
            public bool A { get => a; set => a = value; }
            public bool B { get => b; set => b = value; }
            public bool X { get => x; set => x = value; }
            public bool Y { get => y; set => y = value; }
            [Obsolete("Buttons.System is deprecated, please use Wandbutton.T5 instead.", true)]
            public bool System => T5;
            [Obsolete("Buttons.Z is deprecated, please use Wandbutton.Three instead.", true)]
            public bool Z => Three;
        }
 
        public UInt64 TimestampNanos;
 
        private T5_Bool analogValid;
        private T5_Bool batteryValid;
        private T5_Bool buttonsValid;
        private T5_Bool poseValid;
 
        public float Trigger;
        public Joystick Stick;
        public byte Battery;
        public Buttons ButtonsState;
 
        private T5_Rotation rotToWND_STAGE;
        private T5_Position aimPos_STAGE;
        private T5_Position fingertipsPos_STAGE;
        private T5_Position gripPos_STAGE;
 
        public T5_Hand Hand;
 
        public bool AnalogValid { get => analogValid; set => analogValid = value; }
        public bool BatteryValid { get => batteryValid; set => batteryValid = value; }
        public bool ButtonsValid { get => buttonsValid; set => buttonsValid = value; }
        public bool PoseValid { get => poseValid; set => poseValid = value; }
 
        public Quaternion RotToWND_STAGE { get => rotToWND_STAGE; set => rotToWND_STAGE = value; }
        public Vector3 AimPos_STAGE { get => aimPos_STAGE; set => aimPos_STAGE = value; }
        public Vector3 FingertipsPos_STAGE { get => fingertipsPos_STAGE; set => fingertipsPos_STAGE = value; }
        public Vector3 GripPos_STAGE { get => gripPos_STAGE; set => gripPos_STAGE = value; }
    }

    [StructLayout(LayoutKind.Sequential)]
    internal struct T5_VCI
    {
        public float StartX_VCI;
        public float StartY_VCI;
        public float Width_VCI;
        public float Height_VCI;
 
        public T5_VCI(Rect rect)
        {
            StartX_VCI = rect.x;
            StartY_VCI = rect.y;
            Width_VCI = rect.width;
            Height_VCI = rect.height;
        }
 
        public static implicit operator Rect(T5_VCI vci)
            => new Rect(vci.StartX_VCI, vci.StartY_VCI, vci.Width_VCI, vci.Height_VCI);
        public static implicit operator T5_VCI(Rect rect) => new T5_VCI(rect);
    }

    [StructLayout(LayoutKind.Sequential)]
    internal struct T5_FrameInfo
    {
        public IntPtr LeftTexHandle;
        public IntPtr RightTexHandle;
        public UInt16 TexWidth_PIX;
        public UInt16 TexHeight_PIX;
 
        private T5_Bool isSrgb;
        private T5_Bool isUpsideDown;
 
        private T5_VCI vci;
 
        private T5_Rotation rotToLVC_STAGE;
        private T5_Position posOfLVC_STAGE;
 
        private T5_Rotation rotToRVC_STAGE;
        private T5_Position posOfRVC_STAGE;
 
        public bool IsSrgb { get => isSrgb; set => isSrgb = value; }
        public bool IsUpsideDown { get => isUpsideDown; set => isUpsideDown = value; }
        public Rect VCI { get => vci; set => vci = value; }
        public Quaternion RotToLVC_STAGE { get => rotToLVC_STAGE; set => rotToLVC_STAGE = value; }
        public Vector3 PosOfLVC_STAGE { get => posOfLVC_STAGE; set => posOfLVC_STAGE = value; }
        public Quaternion RotToRVC_STAGE { get => rotToRVC_STAGE; set => rotToRVC_STAGE = value; }
        public Vector3 PosOfRVC_STAGE { get => posOfRVC_STAGE; set => posOfRVC_STAGE = value; }
    }

    [StructLayout(LayoutKind.Explicit, Pack = 4)]
    internal struct T5_StringUTF8 : IDisposable
    {
        [FieldOffset(0)] private UInt32 maxBufferSize;
        [FieldOffset(4)] private UInt32 length;
        [FieldOffset(8)] private IntPtr pStringBytesUTF8;
 
        public T5_StringUTF8(string text)
        {
            pStringBytesUTF8 = IntPtr.Zero;
            length = 0;
            maxBufferSize = 16 * 1024;
 
            if (text != null)
            {
                // Allocate enough unmanaged memory to store the string
                byte[] textBytesUTF8 = System.Text.Encoding.UTF8.GetBytes(text);
 
                // If the string is too long to fit in the unmanaged buffer, truncate it.
                length = (UInt32)Math.Min(textBytesUTF8.Length, maxBufferSize);
                pStringBytesUTF8 = Marshal.AllocHGlobal((int)maxBufferSize);
 
                // Store the string data
                Marshal.Copy(textBytesUTF8, 0, pStringBytesUTF8, (int)length);
            }
        }
 
        public static implicit operator string(T5_StringUTF8 t5_StringUTF8)
            => ToString(t5_StringUTF8);
 
        public static implicit operator T5_StringUTF8(string text) => new T5_StringUTF8(text);
 
        private static string ToString(T5_StringUTF8 t5_StringUTF8)
        {
            if (t5_StringUTF8.pStringBytesUTF8 == IntPtr.Zero)
            {
                return null;
            }
 
            var managedBytes = new byte[t5_StringUTF8.length];
            try
            {
                Marshal.Copy(t5_StringUTF8.pStringBytesUTF8, managedBytes, 0, (int)t5_StringUTF8.length);
                return System.Text.Encoding.UTF8.GetString(managedBytes);
            }
            catch (Exception e)
            {
                Debug.LogError($"Failed to copy string from unmanaged memory: {e}");
                return null;
            }
        }

        public void Dispose()
        {
            // Don't forget to free that unmanaged memory we allocated.
            // Marshal.FreeHGlobal() will safely do nothing if IntPtr.Zero is passed in.
            Marshal.FreeHGlobal(pStringBytesUTF8);
            pStringBytesUTF8 = IntPtr.Zero;
        }
    }

    public enum ServiceCompatibility : Int32
    {
        // <summary>
        // The running service is incompatible with this client.
        // </summary>
        Incompatible = 0,
 
        // <summary>
        // The running service is compatible with this client.
        // </summary>
        Compatible = 1,
 
        // <summary>
        // Don't know yet whether the running service is compatible with this client.
        // </summary>
        Unknown = 2,
    }

    public enum PlayerIndex
    {
        [HideInInspector]
        None = 0,
        One = 1,
        Two = 2,
        Three = 3,
        Four = 4
    }

    public enum ControllerIndex : Int32
    {
        Right = 0,

        Left = 1
    }

    public enum GameboardType : Int32
    {
        GameboardType_None = 1,

        GameboardType_LE = 2,

        GameboardType_XE = 3,

        GameboardType_XE_Raised = 4,
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct T5_GameboardSize
    {
        public float ViewableExtentPositiveX;

        public float ViewableExtentNegativeX;

        public float ViewableExtentPositiveZ;

        public float ViewableExtentNegativeZ;

        public float ViewableExtentPositiveY;
 
        public T5_GameboardSize(float viewableExtentPositiveX, float viewableExtentNegativeX,
            float viewableExtentPositiveZ, float viewableExtentNegativeZ,
            float viewableExtentPositiveY)
        {
            ViewableExtentPositiveX = viewableExtentPositiveX;
            ViewableExtentNegativeX = viewableExtentNegativeX;
            ViewableExtentPositiveZ = viewableExtentPositiveZ;
            ViewableExtentNegativeZ = viewableExtentNegativeZ;
            ViewableExtentPositiveY = viewableExtentPositiveY;
        }
 
        [Obsolete("This version of the T5_GameboardSize constructor is obsolete. " +
            "Please use T5_GameboardSize(float viewableExtentPositiveX, float viewableExtentNegativeX, " +
            "float viewableExtentPositiveZ, float viewableExtentNegativeZ, float viewableExtentPositiveY) instead.", true)]
        public T5_GameboardSize(float playableSpaceX, float playableSpaceZ, float borderWidth)
        {
            ViewableExtentPositiveX = playableSpaceX / 2f;
            ViewableExtentNegativeX = playableSpaceX / 2f;
            ViewableExtentPositiveZ = playableSpaceZ / 2f;
            ViewableExtentNegativeZ = playableSpaceZ / 2f;
            ViewableExtentPositiveY = 0f;
        }
    }

    public enum ControllerPosition : Int32
    {
        Grip = 0,

        Fingertips = 1,

        Aim = 2
    }

    public enum T5_Hand : byte
    {
        Unknown = 0,

        Left = 1,

        Right = 2,
    }

    internal enum T5_GlassesPoseUsage : Int32
    {
        GlassesPresentation = 1,

        SpectatorPresentation = 2,
    }
}