////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (C) 2007-2020 , Inc.  All Rights Reserved.
//
////////////////////////////////////////////////////////////////////////////////

using System;
using System.Runtime.InteropServices;
using System.Text;

using UnityEngine;

using GCSeries.Core.Sdk;

namespace GCSeries.Core.Interop
{
    public static class ZPlugin
    {
        ////////////////////////////////////////////////////////////////////////
        // Public Methods
        ////////////////////////////////////////////////////////////////////////

        public static void ThrowOnError(ZPluginError pluginError)
        {
            if (pluginError != ZPluginError.Ok)
            {
                throw new Exception();
            }
        }

        public static void LogOnError(ZPluginError pluginError, string functionName)
        {
#if ZCORE_LOGGING_ENABLED
            if (pluginError != ZPluginError.Ok)
            {
#if UNITY_EDITOR
                Debug.LogErrorFormat("ZPlugin.{0} returned ZPluginError: {1}",
                    functionName, pluginError);
#else
                Debug.LogErrorFormat("ZPlugin.{0} returned ZPluginError: {1}\n\n{2}",
                    functionName, pluginError, new System.Diagnostics.StackTrace());
#endif
            }
#endif
        }

        public static void IssueEvent(ZPluginEvent pluginEvent)
        {
            IntPtr renderEventFunc = GetRenderEventFunc();
            if (renderEventFunc != IntPtr.Zero)
            {
                GL.IssuePluginEvent(renderEventFunc, (int)pluginEvent);
            }
            else
            {
                Debug.LogError(
                    "Invalid render event function pointer. " +
                    $"Failed to issue plugin event: {pluginEvent}");
            }
        }

        public static void InitializeLogging()
        {
            SetLogger(Marshal.GetFunctionPointerForDelegate(s_loggerCallback));
        }

        public static void ShutDownLogging()
        {
#if UNITY_EDITOR_OSX
            SetLogger(IntPtr.Zero);
#endif
        }

        ////////////////////////////////////////////////////////////////////////
        // DLL Import Declarations
        ////////////////////////////////////////////////////////////////////////

        [DllImport(
            DllName,
            EntryPoint = "GetRenderEventFunc",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern IntPtr GetRenderEventFunc();

        [DllImport(
            DllName,
            EntryPoint = "zcuSetLogger",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern void SetLogger(
            IntPtr logger);

        [DllImport(
            DllName,
            EntryPoint = "zcuGetPluginVersion",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern void GetPluginVersion(
            out int major,
            out int minor,
            out int patch);

        [DllImport(
            DllName,
            EntryPoint = "zcuGetWindowPosition",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern void GetWindowPosition(
            out int x,
            out int y);

        /// <summary>
        /// Loads the  SDK runtime library and detects connected 
        /// peripherals. For the detected peripherals, <see cref="Initialize"/> 
        /// creates instances of all underlying Displays, TrackerDevices, 
        /// and TrackerTargets.
        /// </summary>
        /// 
        /// <param name="context">
        /// A handle to the internal state of the  SDK. 
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuInitialize",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError Initialize(out IntPtr context);

        /// <summary>
        /// Updates the underlying state of the SDK. This includes 
        /// polling and caching tracker target pose information. 
        /// Additionally, any stereo frustums will receive the latest 
        /// pose information from the default head target. Call this 
        /// once per frame.
        /// </summary>
        /// 
        /// <param name="context">
        /// A handle to the internal state of the  SDK.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuUpdate",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError Update(IntPtr context);

        /// <summary>
        /// Frees allocated memory and unloads plugins. Call this 
        /// on application shutdown.
        /// </summary>
        /// 
        /// <param name="context">
        /// A handle to the internal state of the  SDK.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuShutDown",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError ShutDown(IntPtr context);

        /// <summary>
        /// Gets the version of the runtime that has been loaded by 
        /// <see cref="Initialize"/>. The version is in the following 
        /// format: major.minor.patch
        /// </summary>
        /// 
        /// <param name="context">
        /// A handle to the internal state of the  SDK. 
        /// </param>
        /// <param name="major">
        /// The major component of the revision number.
        /// </param>
        /// <param name="minor">
        /// The minor component of the revision number.
        /// </param>
        /// <param name="patch">
        /// The patch component of the revision number.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetRuntimeVersion",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetRuntimeVersion(
            IntPtr context,
            out int major,
            out int minor,
            out int patch);

        /// <summary>
        /// Sets whether or not tracking for all devices is enabled.
        /// </summary>
        /// 
        /// <param name="context">
        /// A handle to the internal state of the  SDK.
        /// </param>
        /// <param name="isEnabled">
        /// True to enable tracking, false to disable it.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuSetTrackingEnabled",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError SetTrackingEnabled(
            IntPtr context,
            [param: MarshalAs(UnmanagedType.Bool)]
            bool isEnabled);

        /// <summary>
        /// Checks whether tracking for all devices is enabled.
        /// </summary>
        /// 
        /// <param name="context">
        /// A handle to the internal state of the  SDK.
        /// </param>
        /// <param name="isEnabled">
        /// True if enabled, false otherwise.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuIsTrackingEnabled",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError IsTrackingEnabled(
            IntPtr context,
            [param: MarshalAs(UnmanagedType.Bool), Out()]
            out bool isEnabled);

        /// <summary>
        /// Refreshes all of the underlying display information.
        /// </summary>
        /// 
        /// <param name="context">
        /// A handle to the internal state of the  SDK.
        /// </param>
        /// 
        /// <remarks>
        /// This invalidates any cached display data that has been returned 
        /// in prior queries. You must query for these display handles again.
        /// </remarks>
        [DllImport(
            DllName,
            EntryPoint = "zcuRefreshDisplays",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError RefreshDisplays(IntPtr context);

        /// <summary>
        /// Gets the number of connected displays.
        /// </summary>
        /// 
        /// <param name="context">
        /// A handle to the internal state of the  SDK.
        /// </param>
        /// <param name="numDisplays">
        /// The number of connected displays.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetNumDisplays",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetNumDisplays(
            IntPtr context,
            out int numDisplays);

        /// <summary>
        /// Gets the number of connected displays based on a specified type.
        /// </summary>
        /// 
        /// <param name="context">
        /// A handle to the internal state of the  SDK.
        /// </param>
        /// <param name="displayType">
        /// The type of display to query.
        /// </param>
        /// <param name="numDisplays">
        /// The number of displays of the specified type.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetNumDisplaysByType",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetNumDisplaysByType(
            IntPtr context,
            ZDisplayType displayType,
            out int numDisplays);

        /// <summary>
        /// Gets the display handle based on the specified 
        /// (<paramref name="x"/>, <paramref name="y"/>) pixel 
        /// coordinates on the virtual desktop.
        /// </summary>
        /// 
        /// <param name="context">
        /// A handle to the internal state of the  SDK. 
        /// </param>
        /// <param name="x">
        /// The x pixel coordinate on the virtual desktop. 
        /// </param>
        /// <param name="y">
        /// The y pixel coordinate on the virtual desktop.
        /// </param>
        /// <param name="displayHandle">
        /// The handle for the display at the specified pixel location. 
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetDisplay",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetDisplay(
            IntPtr context,
            int x,
            int y,
            out IntPtr displayHandle);

        /// <summary>
        /// Gets the display handle at a specified index.
        /// </summary>
        /// 
        /// <param name="context">
        /// A handle to the internal state of the  SDK.
        /// </param>
        /// <param name="index">
        /// The index of the display to query.
        /// </param>
        /// <param name="displayHandle">
        /// The handle for the display at the specified index.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetDisplayByIndex",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetDisplayByIndex(
            IntPtr context,
            int index,
            out IntPtr displayHandle);

        /// <summary>
        /// Gets the display handle for a specified type. Note 
        /// that in this case, the index is per type. Thus if 
        /// you have only one device of a given type, the index is 0.
        /// </summary>
        /// 
        /// <param name="context">
        /// A handle to the internal state of the  SDK.
        /// </param>
        /// <param name="displayType">
        /// The display type to query.
        /// </param>
        /// <param name="index">
        /// The index for the specified device of this type.
        /// </param>
        /// <param name="displayHandle">
        /// The handle for the display of the specified type.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetDisplayByType",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetDisplayByType(
            IntPtr context,
            ZDisplayType displayType,
            int index,
            out IntPtr displayHandle);

        /// <summary>
        /// Gets the display's type.
        /// </summary>
        /// 
        /// <param name="displayHandle">
        /// A handle to the display.
        /// </param>
        /// <param name="displayType">
        /// The display's type.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetDisplayType",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetDisplayType(
            IntPtr displayHandle,
            out ZDisplayType displayType);

        /// <summary>
        /// Gets the display's number. The display number refers 
        /// to the number shown for the display when you set screen 
        /// resolution in the Windows Control Panel.
        /// </summary>
        /// 
        /// <param name="displayHandle">
        /// A handle to the display. 
        /// </param>
        /// <param name="displayNumber">
        /// The display's number.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetDisplayNumber",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetDisplayNumber(
            IntPtr displayHandle,
            out int displayNumber);

        /// <summary>
        /// Gets the index of the GPU that is connected to the 
        /// specified display.
        /// </summary>
        /// 
        /// <param name="displayHandle">
        /// A handle to the display.
        /// </param>
        /// <param name="adapterIndex">
        /// The index of the display's GPU. 
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetDisplayAdapterIndex",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetDisplayAdapterIndex(
            IntPtr displayHandle,
            out int adapterIndex);

        /// <summary>
        /// Gets the index of the monitor attached to the display's GPU.
        /// </summary>
        /// 
        /// <param name="displayHandle">
        /// A handle to the display.
        /// </param>
        /// <param name="monitorIndex">
        /// The index for the attached monitor.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetDisplayMonitorIndex",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetDisplayMonitorIndex(
            IntPtr displayHandle,
            out int monitorIndex);

        /// <summary>
        /// Gets the string value of the specified attribute for 
        /// the display. See <see cref="ZDisplayAttribute"/> for a 
        /// list of the available attributes.
        /// </summary>
        /// 
        /// <param name="displayHandle">
        /// A handle to the display. 
        /// </param>
        /// <param name="attribute">
        /// The attribute to query. 
        /// </param>
        /// <param name="buffer">
        /// The user allocated character buffer to hold the attribute's 
        /// string value.
        /// </param>
        /// <param name="bufferSize">
        /// The size of the user allocated buffer.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetDisplayAttributeStr",
            CallingConvention = CallingConvention.StdCall,
            CharSet = CharSet.Ansi)]
        internal static extern ZPluginError GetDisplayAttributeStr(
            IntPtr displayHandle,
            ZDisplayAttribute attribute,
            [param: MarshalAs(UnmanagedType.LPStr), Out()]
            StringBuilder buffer,
            int bufferSize);

        /// <summary>
        /// Gets the size of the specified attribute's value in bytes.
        /// </summary>
        /// 
        /// <param name="displayHandle">
        /// A handle to the display.
        /// </param>
        /// <param name="attribute">
        /// The attribute to query.
        /// </param>
        /// <param name="size">
        /// The size of the attribute's value.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetDisplayAttributeStrSize",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetDisplayAttributeStrSize(
            IntPtr displayHandle,
            ZDisplayAttribute attribute,
            out int size);

        /// <summary>
        /// Gets the display's size in meters.
        /// </summary>
        /// 
        /// <param name="displayHandle">
        /// A handle to the display.
        /// </param>
        /// <param name="width">
        /// The display's width in meters.
        /// </param>
        /// <param name="height">
        /// The display's height in meters.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetDisplaySize",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetDisplaySize(
            IntPtr displayHandle,
            out float width,
            out float height);

        /// <summary>
        /// Gets the (x, y) pixel location of the specified 
        /// display on the virtual desktop (top-left corner).
        /// </summary>
        /// 
        /// <param name="displayHandle">
        /// A handle to the display.
        /// </param>
        /// <param name="x">
        /// The x pixel location.
        /// </param>
        /// <param name="y">
        /// The y pixel location.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetDisplayPosition",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetDisplayPosition(
            IntPtr displayHandle,
            out int x,
            out int y);

        /// <summary>
        /// Gets the display's preferred native resolution in pixels.
        /// </summary>
        /// 
        /// <param name="displayHandle">
        /// A handle to the display.
        /// </param>
        /// <param name="x">
        /// The width in pixels.
        /// </param>
        /// <param name="y">
        /// The height in pixels.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetDisplayNativeResolution",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetDisplayNativeResolution(
            IntPtr displayHandle,
            out int x,
            out int y);

        /// <summary>
        /// Gets the display's angles about each axis in degrees.
        /// </summary>
        /// 
        /// <param name="displayHandle">
        /// A handle to the display.
        /// </param>
        /// <param name="x">
        /// The angle of the display about the x axis.
        /// </param>
        /// <param name="y">
        /// The angle of the display about the y axis.
        /// </param>
        /// <param name="z">
        /// The angle of the display about the z axis.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetDisplayAngle",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetDisplayAngle(
            IntPtr displayHandle,
            out float x,
            out float y,
            out float z);

        /// <summary>
        /// Gets the display's vertical refresh rate.
        /// </summary>
        /// 
        /// <param name="displayHandle">
        /// A handle to the display.
        /// </param>
        /// <param name="refreshRate">
        /// The vertical refresh rate.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetDisplayVerticalRefreshRate",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetDisplayVerticalRefreshRate(
            IntPtr displayHandle,
            out float refreshRate);

        /// <summary>
        /// Checks if the specified display is connected via 
        /// the USB port. Currently this only applies to  
        /// displays.
        /// </summary>
        /// 
        /// <param name="displayHandle">
        /// A handle to the display.
        /// </param>
        /// <param name="isHardwarePresent">
        /// True if connected, false otherwise.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuIsDisplayHardwarePresent",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError IsDisplayHardwarePresent(
            IntPtr displayHandle,
            [param: MarshalAs(UnmanagedType.Bool), Out()]
            out bool isHardwarePresent);

        /// <summary>
        /// Performs a raycast against the display. The incoming 
        /// pose is assumed to transform the direction of the 
        /// negative Z vector, which is then used for the 
        /// intersection test.
        /// </summary>
        /// 
        /// <param name="displayHandle">
        /// A handle to the display.
        /// </param>
        /// <param name="pose">
        /// A <see cref="ZCTrackerPose"/> in tracker space.
        /// </param>
        /// <param name="intersectionInfo">
        /// Struct containing information about the intersection 
        /// (i.e. hit, screen position, etc.)
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuIntersectDisplay",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError IntersectDisplay(
            IntPtr displayHandle,
            [param: MarshalAs(UnmanagedType.LPStruct)]
            ZPose pose,
            out ZDisplayIntersectionInfo intersectionInfo);

        /// <summary>
        /// Creates a stereo buffer for left/right frame detection.
        /// </summary>
        /// 
        /// <param name="context">
        /// A handle to the internal state of the  SDK.
        /// </param>
        /// <param name="renderer">
        /// The application's graphics API.
        /// </param>
        /// <param name="reserved">
        /// A reserved argument depending on the <paramref name="renderer"/>.
        /// </param>
        /// <param name="bufferHandle">
        /// A handle for the buffer.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuCreateStereoBuffer",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError CreateStereoBuffer(
            IntPtr context,
            int renderer,
            IntPtr reserved,
            out IntPtr bufferHandle);

        /// <summary>
        /// Destroys the stereo buffer.
        /// </summary>
        /// 
        /// <param name="bufferHandle">
        /// A handle to the buffer.
        /// </param>
        /// 
        /// <remarks>
        /// Calling <see cref="ShutDown(IntPtr)"/> will free any stereo 
        /// buffers that have not been explicitly destroyed by calling 
        /// zcDestroyStereoBuffer().
        /// </remarks>
        [DllImport(
            DllName,
            EntryPoint = "zcuDestroyStereoBuffer",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError DestroyStereoBuffer(
            IntPtr bufferHandle);

        [DllImport(
            DllName,
            EntryPoint = "zcuBeginStereoBufferPatternDetection",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError BeginStereoBufferPatternDetection(
            IntPtr bufferHandle,
            [param: MarshalAs(UnmanagedType.Bool), Out()]
            out bool isPatternDetectionEnabled);

        [DllImport(
            DllName,
            EntryPoint = "zcuEndStereoBufferPatternDetection",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError EndStereoBufferPatternDetection(
            IntPtr bufferHandle,
            [param: MarshalAs(UnmanagedType.Bool), Out()]
            out bool isPatternDetected);

        [DllImport(
            DllName,
            EntryPoint = "zcuIsStereoBufferPatternDetected",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError IsStereoBufferPatternDetected(
            IntPtr bufferHandle,
            [param: MarshalAs(UnmanagedType.Bool), Out()]
            out bool isPatternDetected);

        [DllImport(
            DllName,
            EntryPoint = "zcuIsStereoBufferSyncRequested",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError IsStereoBufferSyncRequested(
            IntPtr bufferHandle,
            [param: MarshalAs(UnmanagedType.Bool), Out()]
            out bool isSyncRequested);

        /// <summary>
        /// Creates a stereo viewport.
        /// </summary>
        /// 
        /// <param name="context">
        /// A handle to the internal state of the  SDK.
        /// </param>
        /// <param name="viewportHandle">
        /// A handle to the viewport.
        /// </param>
        /// 
        /// <remarks>
        /// The stereo viewport is abstract and not an actual window 
        /// that is created and registered through the OS. It manages a 
        /// stereo frustum, which is responsible for various stereoscopic 
        /// 3D calculations such as calculating the view and projection 
        /// matrices for each eye.
        /// </remarks>
        [DllImport(
            DllName,
            EntryPoint = "zcuCreateViewport",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError CreateViewport(
            IntPtr context,
            out IntPtr viewportHandle);

        /// <summary>
        /// Destroys a stereo viewport.
        /// </summary>
        /// 
        /// <param name="viewportHandle">
        /// A handle to the viewport.
        /// </param>
        /// 
        /// <remarks>
        /// Calling <see cref="ShutDown(IntPtr)"/> will free any 
        /// viewports that have not been explicitly destroyed by 
        /// calling zcDestroyViewport().
        /// </remarks>
        [DllImport(
            DllName,
            EntryPoint = "zcuDestroyViewport",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError DestroyViewport(
            IntPtr viewportHandle);

        /// <summary>
        /// Sets the viewport's absolute virtual desktop coordinates 
        /// (top-left corner).
        /// </summary>
        /// 
        /// <param name="viewportHandle">
        /// A handle to the viewport.
        /// </param>
        /// <param name="x">
        /// The x coordinate for the upper left corner of the viewport.
        /// </param>
        /// <param name="y">
        /// The y coordinate for the upper left corner of the viewport.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuSetViewportPosition",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError SetViewportPosition(
            IntPtr viewportHandle,
            int x,
            int y);

        /// <summary>
        /// Gets the viewport's absolute virtual desktop coordinates 
        /// (top-left corner).
        /// </summary>
        /// 
        /// <param name="viewportHandle">
        /// A handle to the viewport.
        /// </param>
        /// <param name="x">
        /// The x coordinate for the upper left corner of the viewport.
        /// </param>
        /// <param name="y">
        /// The y coordinate for the upper left corner of the viewport.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetViewportPosition",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetViewportPosition(
            IntPtr viewportHandle,
            out int x,
            out int y);

        /// <summary>
        /// Sets the viewport's size in pixels.
        /// </summary>
        /// 
        /// <param name="viewportHandle">
        /// A handle to the viewport.
        /// </param>
        /// <param name="width">
        /// The width of the viewport in pixels.
        /// </param>
        /// <param name="height">
        /// The height of the viewport in pixels.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuSetViewportSize",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError SetViewportSize(
            IntPtr viewportHandle,
            int width,
            int height);

        /// <summary>
        /// Gets the viewport's size in pixels.
        /// </summary>
        /// 
        /// <param name="viewportHandle">
        /// A handle to the viewport.
        /// </param>
        /// <param name="width">
        /// The width of the viewport in pixels.
        /// </param>
        /// <param name="height">
        /// The height of the viewport in pixels.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetViewportSize",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetViewportSize(
            IntPtr viewportHandle,
            out int width,
            out int height);

        /// <summary>
        /// Gets the coordinate space transformation from 
        /// space <paramref name="a"/> to <paramref name="b"/>.
        /// </summary>
        /// 
        /// <param name="viewportHandle">
        /// A handle to the viewport.
        /// </param>
        /// <param name="a">
        /// The source coordinate space.
        /// </param>
        /// <param name="b">
        /// The destination coordinate space.
        /// </param>
        /// <param name="transform">
        /// The transformation matrix in order to transform from space a to b.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetCoordinateSpaceTransform",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetCoordinateSpaceTransform(
            IntPtr viewportHandle,
            ZCoordinateSpace a,
            ZCoordinateSpace b,
            out ZMatrix4 transform);

        /// <summary>
        /// Transforms a 4x4 transformation matrix from 
        /// space <paramref name="a"/> to <paramref name="b"/>.
        /// </summary>
        /// 
        /// <param name="viewportHandle">
        /// A handle to the viewport.
        /// </param>
        /// <param name="a">
        /// The source coordinate space.
        /// </param>
        /// <param name="b">
        /// The destination coordinate space.
        /// </param>
        /// <param name="matrix">
        /// The input matrix to be transformed.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuTransformMatrix",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError TransformMatrix(
            IntPtr viewportHandle,
            ZCoordinateSpace a,
            ZCoordinateSpace b,
            ref ZMatrix4 matrix);

        /// <summary>
        /// Gets the frustum owned by a specified viewport.
        /// </summary>
        /// 
        /// <param name="viewportHandle">
        /// A handle to the viewport.
        /// </param>
        /// <param name="frustumHandle">
        /// A handle to the frustum.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetFrustum",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetFrustum(
            IntPtr viewportHandle,
            out IntPtr frustumHandle);

        /// <summary>
        /// Sets the specified frustum attribute's value.
        /// </summary>
        /// 
        /// <param name="frustumHandle">
        /// A handle to the frustum.
        /// </param>
        /// <param name="attribute">
        /// The attribute to be modified.
        /// </param>
        /// <param name="value">
        /// The desired value to be applied to the attribute.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuSetFrustumAttributeF32",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError SetFrustumAttributeF32(
            IntPtr frustumHandle,
            ZFrustumAttribute attribute,
            float value);

        /// <summary>
        /// Gets the specified frustum attribute's value.
        /// </summary>
        /// 
        /// <param name="frustumHandle">
        /// A handle to the frustum.
        /// </param>
        /// <param name="attribute">
        /// The attribute to be queried.
        /// </param>
        /// <param name="value">
        /// The specified attribute's current value.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetFrustumAttributeF32",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetFrustumAttributeF32(
            IntPtr frustumHandle,
            ZFrustumAttribute attribute,
            out float value);

        /// <summary>
        /// Sets the specified frustum attribute's value.
        /// </summary>
        /// 
        /// <param name="frustumHandle">
        /// A handle to the frustum.
        /// </param>
        /// <param name="attribute">
        /// The attribute to be modified.
        /// </param>
        /// <param name="value">
        /// The desired value to be applied to the attribute.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuSetFrustumAttributeB",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError SetFrustumAttributeB(
            IntPtr frustumHandle,
            ZFrustumAttribute attribute,
            [param: MarshalAs(UnmanagedType.Bool)]
            bool value);

        /// <summary>
        /// Gets the specified frustum attribute's value.
        /// </summary>
        /// 
        /// <param name="frustumHandle">
        /// A handle to the frustum.
        /// </param>
        /// <param name="attribute">
        /// The attribute to be queried.
        /// </param>
        /// <param name="value">
        /// The specified attribute's current value.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetFrustumAttributeB",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetFrustumAttributeB(
            IntPtr frustumHandle,
            ZFrustumAttribute attribute,
            [param: MarshalAs(UnmanagedType.Bool), Out()]
            out bool value);

        /// <summary>
        /// Sets the frustum's portal mode. In portal mode, 
        /// the scene is fixed relative to the physical world, 
        /// not the viewport. Refer to <see cref="ZPortalMode"/> 
        /// for details on portal modes.
        /// </summary>
        /// 
        /// <param name="frustumHandle">
        /// A handle to the frustum.
        /// </param>
        /// <param name="portalModeFlags">
        /// A bitmask for the portal mode flags.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuSetFrustumPortalMode",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError SetFrustumPortalMode(
            IntPtr frustumHandle,
            ZPortalMode portalModeFlags);

        /// <summary>
        /// Gets the frustum's setting for portal mode. In portal mode, 
        /// the scene is fixed relative to the physical world, not the 
        /// viewport.
        /// </summary>
        /// 
        /// <param name="frustumHandle">
        /// A handle to the frustum.
        /// </param>
        /// <param name="portalModeFlags">
        /// A bitmask representing the current portal mode settings.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetFrustumPortalMode",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetFrustumPortalMode(
            IntPtr frustumHandle,
            out ZPortalMode portalModeFlags);

        /// <summary>
        /// Sets the frustum's camera offset.
        /// </summary>
        /// 
        /// <param name="frustumHandle">
        /// A handle to the frustum
        /// </param>
        /// <param name="cameraOffset">
        /// The desired camera offset in meters
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuSetFrustumCameraOffset",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError SetFrustumCameraOffset(
            IntPtr frustumHandle,
            [param: MarshalAs(UnmanagedType.LPStruct)]
            ZVector3 cameraOffset);

        /// <summary>
        /// Gets the frustum's camera offset.
        /// </summary>
        /// 
        /// <param name="frustumHandle">
        /// A handle to the frustum.
        /// </param>
        /// <param name="cameraOffset">
        /// The current camera offset in meters.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetFrustumCameraOffset",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetFrustumCameraOffset(
            IntPtr frustumHandle,
            out ZVector3 cameraOffset);

        /// <summary>
        /// Sets the frustum's head pose in tracker space.
        /// </summary>
        /// 
        /// <param name="frustumHandle">
        /// A handle to the frustum.
        /// </param>
        /// <param name="headPose">
        /// The desired head pose.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuSetFrustumHeadPose",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError SetFrustumHeadPose(
            IntPtr frustumHandle,
            [param: MarshalAs(UnmanagedType.LPStruct)]
            ZPose headPose);

        /// <summary>
        /// Gets the frustum's current head pose in tracker space.
        /// </summary>
        /// 
        /// <param name="frustumHandle">
        /// A handle to the frustum.
        /// </param>
        /// <param name="headPose">
        /// The current head pose.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetFrustumHeadPose",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetFrustumHeadPose(IntPtr frustumHandle, out ZPose headPose);

        /// <summary>
        /// Gets the frustum's view matrix for a specified eye. 
        /// The view matrix is calculated from the head pose + eye offset.
        /// </summary>
        /// 
        /// <param name="frustumHandle">
        /// A handle to the frustum.
        /// </param>
        /// <param name="eye">
        /// The eye to query.
        /// </param>
        /// <param name="viewMatrix">
        /// The view matrix for the specified eye.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetFrustumViewMatrix",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetFrustumViewMatrix(
            IntPtr frustumHandle,
            ZEye eye,
            out ZMatrix4 viewMatrix);

        /// <summary>
        /// Gets the frustum's projection matrix for a specified eye.
        /// </summary>
        /// 
        /// <param name="frustumHandle">
        /// A handle to the frustum.
        /// </param>
        /// <param name="eye">
        /// The eye to query.
        /// </param>
        /// <param name="projectionMatrix">
        /// The projection matrix for the specified eye.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetFrustumProjectionMatrix",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetFrustumProjectionMatrix(
            IntPtr frustumHandle,
            ZEye eye,
            out ZMatrix4 projectionMatrix);

        /// <summary>
        /// Gets the frustum's boundaries for the specified eye.
        /// </summary>
        /// 
        /// <param name="frustumHandle">
        /// A handle to the frustum.
        /// </param>
        /// <param name="eye">
        /// The eye to query.
        /// </param>
        /// <param name="bounds">
        /// The boundaries for the specified eye.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetFrustumBounds",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetFrustumBounds(
            IntPtr frustumHandle,
            ZEye eye,
            out ZFrustumBounds bounds);

        /// <summary>
        /// Gets the specified eye's position in the specified 
        /// coordinate space.
        /// </summary>
        /// 
        /// <param name="frustumHandle">
        /// A handle to the frustum.
        /// </param>
        /// <param name="eye">
        /// The eye to query.
        /// </param>
        /// <param name="coordinateSpace">
        /// The coordinate space in which to return the eye position.
        /// </param>
        /// <param name="eyePosition">
        /// The eye's position.
        /// </param>
        [DllImport(
            DllName,
            EntryPoint = "zcuGetFrustumEyePosition",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetFrustumEyePosition(
            IntPtr frustumHandle,
            ZEye eye,
            ZCoordinateSpace coordinateSpace,
            out ZVector3 eyePosition);

        [DllImport(
            DllName,
            EntryPoint = "zcuGetNumTrackerDevices",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetNumTrackerDevices(
            IntPtr context,
            out int numDevices);

        [DllImport(
            DllName,
            EntryPoint = "zcuGetTrackerDevice",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetTrackerDevice(
            IntPtr context,
            int index,
            out IntPtr deviceHandle);

        [DllImport(
            DllName,
            EntryPoint = "zcuGetTrackerDeviceByName",
            CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Ansi)]
        internal static extern ZPluginError GetTrackerDeviceByName(
            IntPtr context,
            [param: MarshalAs(UnmanagedType.LPStr)]
            string deviceName,
            out IntPtr deviceHandle);

        [DllImport(
            DllName,
            EntryPoint = "zcuSetTrackerDeviceEnabled",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError SetTrackerDeviceEnabled(
            IntPtr deviceHandle,
            [param: MarshalAs(UnmanagedType.Bool)]
            bool isEnabled);

        [DllImport(
            DllName,
            EntryPoint = "zcuIsTrackerDeviceEnabled",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError IsTrackerDeviceEnabled(
            IntPtr deviceHandle,
            [param: MarshalAs(UnmanagedType.Bool), Out()]
            out bool isEnabled);

        [DllImport(
            DllName,
            EntryPoint = "zcuGetTrackerDeviceName",
            CallingConvention = CallingConvention.StdCall,
            CharSet = CharSet.Ansi)]
        internal static extern ZPluginError GetTrackerDeviceName(
            IntPtr deviceHandle,
            [param: MarshalAs(UnmanagedType.LPStr), Out()]
            StringBuilder buffer, int bufferSize);

        [DllImport(
            DllName,
            EntryPoint = "zcuGetTrackerDeviceNameSize",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetTrackerDeviceNameSize(
            IntPtr deviceHandle,
            out int size);

        [DllImport(
            DllName,
            EntryPoint = "zcuGetNumTargets",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetNumTargets(
            IntPtr deviceHandle,
            out int numTargets);

        [DllImport(
            DllName,
            EntryPoint = "zcuGetNumTargetsByType",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetNumTargetsByType(
            IntPtr context,
            ZTargetType targetType,
            out int numTargets);

        [DllImport(
            DllName,
            EntryPoint = "zcuGetTarget",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetTarget(
            IntPtr deviceHandle,
            int index,
            out IntPtr targetHandle);

        [DllImport(
            DllName,
            EntryPoint = "zcuGetTargetByName",
            CallingConvention = CallingConvention.StdCall,
            CharSet = CharSet.Ansi)]
        internal static extern ZPluginError GetTargetByName(
            IntPtr deviceHandle,
            [param: MarshalAs(UnmanagedType.LPStr)]
            string targetName, out IntPtr targetHandle);

        [DllImport(
            DllName,
            EntryPoint = "zcuGetTargetByType",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetTargetByType(
            IntPtr context,
            ZTargetType targetType,
            int index,
            out IntPtr targetHandle);

        [DllImport(
            DllName,
            EntryPoint = "zcuGetTargetName",
            CallingConvention = CallingConvention.StdCall,
            CharSet = CharSet.Ansi)]
        internal static extern ZPluginError GetTargetName(
            IntPtr targetHandle,
            [param: MarshalAs(UnmanagedType.LPStr), Out()]
            StringBuilder buffer, int bufferSize);

        [DllImport(
            DllName,
            EntryPoint = "zcuGetTargetNameSize",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetTargetNameSize(
            IntPtr targetHandle,
            out int size);

        [DllImport(
            DllName,
            EntryPoint = "zcuSetTargetEnabled",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError SetTargetEnabled(
            IntPtr targetHandle,
            [param: MarshalAs(UnmanagedType.Bool)]
            bool isEnabled);

        [DllImport(
            DllName,
            EntryPoint = "zcuIsTargetEnabled",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError IsTargetEnabled(
            IntPtr targetHandle,
            [param: MarshalAs(UnmanagedType.Bool), Out()]
            out bool isEnabled);

        [DllImport(
            DllName,
            EntryPoint = "zcuIsTargetVisible",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError IsTargetVisible(
            IntPtr targetHandle,
            [param: MarshalAs(UnmanagedType.Bool), Out()]
            out bool isEnabled);

        [DllImport(
            DllName,
            EntryPoint = "zcuSetTargetMoveEventThresholds",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError SetTargetMoveEventThresholds(
            IntPtr targetHandle,
            float time,
            float distance,
            float angle);

        [DllImport(
            DllName,
            EntryPoint = "zcuGetTargetMoveEventThresholds",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetTargetMoveEventThresholds(
            IntPtr targetHandle,
            out float time,
            out float distance,
            out float angle);

        [DllImport(
            DllName,
            EntryPoint = "zcuGetTargetPose",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetTargetPose(
            IntPtr targetHandle,
            out ZPose pose);

        [DllImport(
            DllName,
            EntryPoint = "zcuGetNumTargetButtons",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetNumTargetButtons(
            IntPtr targetHandle,
            out int numButtons);

        [DllImport(
            DllName,
            EntryPoint = "zcuIsTargetButtonPressed",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError IsTargetButtonPressed(
            IntPtr targetHandle,
            int buttonId,
            [param: MarshalAs(UnmanagedType.Bool), Out()]
            out bool isButtonPressed);

        [DllImport(
            DllName,
            EntryPoint = "zcuSetTargetLedEnabled",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError SetTargetLedEnabled(
            IntPtr targetHandle,
            [param: MarshalAs(UnmanagedType.Bool)]
            bool isLedEnabled);

        [DllImport(
            DllName,
            EntryPoint = "zcuIsTargetLedEnabled",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError IsTargetLedEnabled(
            IntPtr targetHandle,
            [param: MarshalAs(UnmanagedType.Bool), Out()]
            out bool isLedEnabled);

        [DllImport(
            DllName,
            EntryPoint = "zcuSetTargetLedColor",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError SetTargetLedColor(
            IntPtr targetHandle,
            float r,
            float g,
            float b);

        [DllImport(
            DllName,
            EntryPoint = "zcuGetTargetLedColor",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetTargetLedColor(
            IntPtr targetHandle,
            out float r,
            out float g,
            out float b);

        [DllImport(
            DllName,
            EntryPoint = "zcuSetTargetVibrationEnabled",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError SetTargetVibrationEnabled(
            IntPtr targetHandle,
            [param: MarshalAs(UnmanagedType.Bool)]
            bool isVibrationEnabled);

        [DllImport(
            DllName,
            EntryPoint = "zcuIsTargetVibrationEnabled",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError IsTargetVibrationEnabled(
            IntPtr targetHandle,
            [param: MarshalAs(UnmanagedType.Bool), Out()]
            out bool isVibrationEnabled);

        [DllImport(
            DllName,
            EntryPoint = "zcuIsTargetVibrating",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError IsTargetVibrating(
            IntPtr targetHandle,
            [param: MarshalAs(UnmanagedType.Bool), Out()]
            out bool isVibrating);

        [DllImport(
            DllName,
            EntryPoint = "zcuStartTargetVibration",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError StartTargetVibration(
            IntPtr targetHandle,
            float onPeriod,
            float offPeriod,
            int numTimes,
            float intensity);

        [DllImport(
            DllName,
            EntryPoint = "zcuStopTargetVibration",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError StopTargetVibration(
            IntPtr targetHandle);

        [DllImport(
            DllName,
            EntryPoint = "zcuIsTargetTapPressed",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError IsTargetTapPressed(
            IntPtr targetHandle,
            [param: MarshalAs(UnmanagedType.Bool), Out()]
            out bool isTapPressed);

        [DllImport(
            DllName,
            EntryPoint = "zcuSetTargetTapThreshold",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError SetTargetTapThreshold(
            IntPtr targetHandle,
            float seconds);

        [DllImport(
            DllName,
            EntryPoint = "zcuGetTargetTapThreshold",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetTargetTapThreshold(
            IntPtr targetHandle,
            out float seconds);

        [DllImport(
            DllName,
            EntryPoint = "zcuSetMouseEmulationEnabled",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError SetMouseEmulationEnabled(
            IntPtr context,
            [param: MarshalAs(UnmanagedType.Bool)]
            bool isEnabled);

        [DllImport(
            DllName,
            EntryPoint = "zcuIsMouseEmulationEnabled",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError IsMouseEmulationEnabled(
            IntPtr context,
            [param: MarshalAs(UnmanagedType.Bool), Out()]
            out bool isEnabled);

        [DllImport(
            DllName,
            EntryPoint = "zcuSetMouseEmulationTarget",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError SetMouseEmulationTarget(
            IntPtr context,
            IntPtr targetHandle);

        [DllImport(
            DllName,
            EntryPoint = "zcuGetMouseEmulationTarget",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetMouseEmulationTarget(
            IntPtr context,
            out IntPtr targetHandle);

        [DllImport(
            DllName,
            EntryPoint = "zcuSetMouseEmulationMaxDistance",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError SetMouseEmulationMaxDistance(
            IntPtr context,
            float maxDistance);

        [DllImport(
            DllName,
            EntryPoint = "zcuGetMouseEmulationMaxDistance",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetMouseEmulationMaxDistance(
            IntPtr context,
            out float maxDistance);

        [DllImport(
            DllName,
            EntryPoint = "zcuSetMouseEmulationButtonMapping",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError SetMouseEmulationButtonMapping(
            IntPtr context,
            int buttonId,
            ZMouseButton mouseButton);

        [DllImport(
            DllName,
            EntryPoint = "zcuGetMouseEmulationButtonMapping",
            CallingConvention = CallingConvention.StdCall)]
        internal static extern ZPluginError GetMouseEmulationButtonMapping(
            IntPtr context,
            int buttonId,
            out ZMouseButton mouseButton);

        [DllImport(
            DllName,
            EntryPoint = "zcuCreateXROverlay",
            CallingConvention = CallingConvention.StdCall)]
        public static extern bool CreateXROverlay();

        [DllImport(
            DllName,
            EntryPoint = "zcuDestroyXROverlay",
            CallingConvention = CallingConvention.StdCall)]
        public static extern bool DestroyXROverlay();

        [DllImport(
            DllName,
            EntryPoint = "zcuSetXROverlayParentWindowHandle",
            CallingConvention = CallingConvention.StdCall)]
        public static extern void SetXROverlayParentWindowHandle(
            IntPtr hWnd);

        [DllImport(
            DllName,
            EntryPoint = "zcuSetXROverlayOnDestroyCallback",
            CallingConvention = CallingConvention.StdCall)]
        public static extern void SetXROverlayOnDestroyCallback(
            IntPtr callback);

        [DllImport(
            DllName,
            EntryPoint = "zcuIsXROverlayActive",
            CallingConvention = CallingConvention.StdCall)]
        public static extern bool IsXROverlayActive();

        [DllImport(
            DllName,
            EntryPoint = "zcuIsXROverlayEnabled",
            CallingConvention = CallingConvention.StdCall)]
        public static extern bool IsXROverlayEnabled();

        [DllImport(
            DllName,
            EntryPoint = "zcuSetXROverlayEnabled",
            CallingConvention = CallingConvention.StdCall)]
        public static extern void SetXROverlayEnabled(
            bool isEnabled);

        [DllImport(
            DllName,
            EntryPoint = "zcuSetXROverlayDimensions",
            CallingConvention = CallingConvention.StdCall)]
        public static extern void SetXROverlayDimensions(
            int x,
            int y,
            int width,
            int height);

        [DllImport(
            DllName,
            EntryPoint = "zcuSetXROverlayPosition",
            CallingConvention = CallingConvention.StdCall)]
        public static extern void SetXROverlayPosition(
            int x,
            int y);

        [DllImport(
            DllName,
            EntryPoint = "zcuSetXROverlaySize",
            CallingConvention = CallingConvention.StdCall)]
        public static extern void SetXROverlaySize(
            int width,
            int height);

        [DllImport(
            DllName,
            EntryPoint = "zcuSetXROverlayTextures",
            CallingConvention = CallingConvention.StdCall)]
        public static extern void SetXROverlayTextures(
            IntPtr leftTexturePtr,
            IntPtr rightTexturePtr);

        ////////////////////////////////////////////////////////////////////////
        // Private Methods
        ////////////////////////////////////////////////////////////////////////

        private static void LoggerCallback(int severity, string message)
        {
            message = $"[{DllName}.dll] {message}";

            switch (severity)
            {
                case 0:
                    Debug.Log(message);
                    break;
                case 1:
                    Debug.LogWarning(message);
                    break;
                case 2:
                    Debug.LogError(message);
                    break;
                default:
                    break;
            }
        }

        ////////////////////////////////////////////////////////////////////////
        // Private Types
        ////////////////////////////////////////////////////////////////////////

        private delegate void LoggerCallbackDelegate(
            int level,
            string message);

        ////////////////////////////////////////////////////////////////////////
        // Private Constants
        ////////////////////////////////////////////////////////////////////////

        private const string DllName = "zCoreUnity";

        ////////////////////////////////////////////////////////////////////////
        // Private Members
        ////////////////////////////////////////////////////////////////////////

        private static LoggerCallbackDelegate s_loggerCallback =
            new LoggerCallbackDelegate(LoggerCallback);
    }
}