GameBoard.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.Collections.Generic;
using UnityEngine;
using TiltFive.Logging;
 
namespace TiltFive
{
    [ExecuteInEditMode]
    public class GameBoard : UniformScaleTransform
    {
        #region Public Fields

        [Tooltip("Show/Hide the Board Gizmo in the Editor.")]
        public bool ShowGizmo;
 
        [Tooltip("Show/Hide the Unit Grid on the Board Gizmo in the Editor.")]
        public bool ShowGrid;
 
        public float GridHeightOffset = 0f;
        public bool StickyHeightOffset = true;
 

        [Tooltip("Sets the Alpha transparency of the Board Gizmo in the Editor.")]
        [Range(0f, 1f)]
        public float GizmoOpacity = 0.75f;

        [HideInInspector]
        [Obsolete("Please use Gameboard.TryGetGameboardType() instead.", true)]
        public GameboardType GameboardType;
 
        #endregion Public Fields
 
 
        #region Private Fields
 
#if UNITY_EDITOR

        private TableTopGizmo boardGizmo = new TableTopGizmo();

        private float gridOffsetY => StickyHeightOffset ? Mathf.RoundToInt(GridHeightOffset) : GridHeightOffset;

        private LengthUnit currentContentScaleUnit;

        private float currentContentScaleRatio;

        private Vector3 currentScale;
 
        private const float MIN_SCALE = 0.00001f;
 
#endif // UNITY_EDITOR
 
        private static Dictionary<PlayerIndex, GameboardType> playerGameboards = new Dictionary<PlayerIndex, GameboardType>();
        private static Dictionary<GlassesHandle, PrimaryGameboardCore> gameboardCores
            = new Dictionary<GlassesHandle, PrimaryGameboardCore>();
 
        private static HashSet<PrimaryGameboardCore> lostGameboards = new HashSet<PrimaryGameboardCore>();
        private static HashSet<GlassesHandle> incomingGlassesHandles = new HashSet<GlassesHandle>();
        private static HashSet<GlassesHandle> lostGlassesHandles = new HashSet<GlassesHandle>();
 
        private const UInt16 MAX_SUPPORTED_GAMEBOARD_POSES = 1;
        #endregion Private Fields
 
 
        #region Public Enums

        public enum Edge
        {
            Near,
            Far,
            Left,
            Right
        }

        public enum Corner
        {
            FarLeft,
            FarRight,
            NearLeft,
            NearRight
        }
 
        #endregion Public Enums
 
 
        #region Public Structs
 
        [Obsolete("GameboardDimensions is obsolete, please use GameboardExtents instead.", true)]
        public struct GameboardDimensions
        {
            public Length playableSpaceX;
            public Length playableSpaceY;
            public Length borderWidth;
            public Length totalSpaceX => playableSpaceX + (borderWidth * 2);
            public Length totalSpaceY => playableSpaceY + (borderWidth * 2);
 
            public GameboardDimensions(T5_GameboardSize gameboardSize)
            {
                var gameboardExtents = new GameboardExtents(gameboardSize);
                playableSpaceX = gameboardExtents.ViewableSpanX;
                playableSpaceY = gameboardExtents.ViewableSpanZ;
                borderWidth = new Length(GameboardExtents.BORDER_WIDTH_IN_METERS, LengthUnit.Meters);
            }
        }

        public struct GameboardExtents
        {
            public Length ViewableExtentPositiveX;

            public Length ViewableExtentNegativeX;

            public Length ViewableExtentPositiveZ;

            public Length ViewableExtentNegativeZ;

            public Length ViewableExtentPositiveY;

            public Length ViewableSpanX => ViewableExtentPositiveX + ViewableExtentNegativeX;
            public Length ViewableSpanY => ViewableExtentPositiveY;
            public Length ViewableSpanZ => ViewableExtentPositiveZ + ViewableExtentNegativeZ;

            public Length OriginOffsetZ => new Length(ViewableSpanZ.ToMeters / 2f - ViewableExtentNegativeZ.ToMeters, LengthUnit.Meters);
 
            internal const float BORDER_WIDTH_IN_METERS = 0.05f;
            internal static readonly T5_GameboardSize GAMEBOARD_SIZE_LE;
            internal static readonly T5_GameboardSize GAMEBOARD_SIZE_XE;
            internal static readonly T5_GameboardSize GAMEBOARD_SIZE_XE_RAISED;
 
            static GameboardExtents()
            {
                GAMEBOARD_SIZE_LE = new T5_GameboardSize(0.35f, 0.35f, 0.35f, 0.35f, 0f);
                GAMEBOARD_SIZE_XE = new T5_GameboardSize(0.35f, 0.35f, 0.61667f, 0.35f, 0.0f);
                GAMEBOARD_SIZE_XE_RAISED = new T5_GameboardSize(0.35f, 0.35f, 0.55944f, 0.35f, 0.20944f);
            }
 
            public GameboardExtents(T5_GameboardSize gameboardSize)
            {
                ViewableExtentPositiveX = new Length(gameboardSize.ViewableExtentPositiveX, LengthUnit.Meters);
                ViewableExtentNegativeX = new Length(gameboardSize.ViewableExtentNegativeX, LengthUnit.Meters);
                ViewableExtentPositiveZ = new Length(gameboardSize.ViewableExtentPositiveZ, LengthUnit.Meters);
                ViewableExtentNegativeZ = new Length(gameboardSize.ViewableExtentNegativeZ, LengthUnit.Meters);
                ViewableExtentPositiveY = new Length(gameboardSize.ViewableExtentPositiveY, LengthUnit.Meters);
            }

            public Vector3 GetCornerPositionInGameboardSpace(Corner corner)
            {
                switch (corner)
                {
                    case Corner.FarLeft:
                        return Vector3.forward * ViewableExtentPositiveZ.ToMeters
                            + Vector3.left * ViewableExtentNegativeX.ToMeters;
                    case Corner.FarRight:
                        return Vector3.forward * ViewableExtentPositiveZ.ToMeters
                            + Vector3.right * ViewableExtentPositiveX.ToMeters;
                    case Corner.NearLeft:
                        return Vector3.back * ViewableExtentNegativeZ.ToMeters
                            + Vector3.left * ViewableExtentNegativeX.ToMeters;
                    case Corner.NearRight:
                        return Vector3.back * ViewableExtentNegativeZ.ToMeters
                            + Vector3.right * ViewableExtentPositiveX.ToMeters;
                    default:
                        throw new System.ArgumentException("Cannot get corner positions for invalid Corner enum values.");
                }
            }

            public Vector3 GetEdgeCenterPositionInGameboardSpace(Edge edge)
            {
                switch (edge)
                {
                    case Edge.Left:
                        return Vector3.left * ViewableExtentNegativeX.ToMeters
                            + Vector3.forward * OriginOffsetZ.ToMeters;
                    case Edge.Right:
                        return Vector3.right * ViewableExtentPositiveX.ToMeters
                            + Vector3.forward * OriginOffsetZ.ToMeters;
                    case Edge.Near:
                        return Vector3.back * ViewableExtentNegativeZ.ToMeters;
                    case Edge.Far:
                        return Vector3.forward * ViewableExtentPositiveZ.ToMeters;
                    default:
                        throw new System.ArgumentException("Cannot get edge center positions for invalid Edge enum values.");
                }
            }

            [Obsolete("GameboardExtents.GetPhysicalCenterPositionInGameboardSpace is deprecated. Please use GameboardExtents.GetGeometricCenterPositionInGameboardSpace instead.")]
            public Vector3 GetPhysicalCenterPositionInGameboardSpace() { return GetGeometricCenterPositionInGameboardSpace(); }

            public Vector3 GetGeometricCenterPositionInGameboardSpace()
            {
                // If we ever have some funky gameboard in the future with a double-eccentric tracking origin,
                // we'd just need to add another vector along the X axis (e.g. Vector3.right * OriginOffsetX.ToMeters)
                return Vector3.forward * OriginOffsetZ.ToMeters;
            }
        }
 
        #endregion Private Structs
 
 
        #region Public Functions

        public static bool TryGetGameboardType(out GameboardType gameboardType)
        {
            return TryGetGameboardType(PlayerIndex.One, out gameboardType);
        }
 
        public static bool TryGetGameboardType(PlayerIndex playerIndex, out GameboardType gameboardType)
        {
            // Return false and a default gameboard if the player is nonexistent or disconnected.
            if(!Player.TryGetGlassesHandle(playerIndex, out var glassesHandle)
                || !playerGameboards.TryGetValue(playerIndex, out var currentGameboardType))
            {
                gameboardType = GameboardType.GameboardType_None;
                return false;
            }
 
            gameboardType = currentGameboardType;
            return true;
        }

        [Obsolete("TryGetGameboardDimensions is obsolete. Please use TryGetGameboardExtents instead.", true)]
        public static bool TryGetGameboardDimensions(GameboardType gameboardType, out GameboardDimensions gameboardDimensions)
        {
            if(gameboardType == GameboardType.GameboardType_None)
            {
                gameboardDimensions = new GameboardDimensions();
                return false;
            }
 
            // Default to the LE gameboard dimensions in meters.
            T5_GameboardSize gameboardSize = GameboardExtents.GAMEBOARD_SIZE_LE;
            int result = NativePlugin.T5_RESULT_UNKNOWN_ERROR;
 
            try
            {
                result = NativePlugin.GetGameboardDimensions(gameboardType, ref gameboardSize);
            }
            catch (Exception e)
            {
                Log.Error(e.Message);
            }
 
            gameboardDimensions = new GameboardDimensions(gameboardSize);
 
            return result == NativePlugin.T5_RESULT_SUCCESS;
        }

        public static bool TryGetGameboardExtents(GameboardType gameboardType, out GameboardExtents gameboardExtents)
        {
            if(gameboardType == GameboardType.GameboardType_None)
            {
                gameboardExtents = new GameboardExtents();
                return false;
            }
 
            T5_GameboardSize gameboardSize = new T5_GameboardSize();
            int result = NativePlugin.T5_RESULT_UNKNOWN_ERROR;
 
            try
            {
                result = NativePlugin.GetGameboardDimensions(gameboardType, ref gameboardSize);
            }
            catch (Exception e)
            {
                Log.Error(e.Message);
            }
 
            gameboardExtents = new GameboardExtents(gameboardSize);
 
            return result == NativePlugin.T5_RESULT_SUCCESS;
        }

        public bool TransformPose(Vector3 positionInGameboardSpace, Quaternion rotationToGameboardSpace, PlayerIndex playerIndex,
            out Vector3 positionInWorldSpace, out Quaternion rotationToWorldSpace)
        {
            if (!Player.TryGetSettings(playerIndex, out var playerSettings))
            {
                positionInWorldSpace = Vector3.zero;
                rotationToWorldSpace = Quaternion.identity;
                return false;
            }
 
            TransformPose(positionInGameboardSpace, rotationToGameboardSpace, playerSettings.scaleSettings,
                out positionInWorldSpace, out rotationToWorldSpace);
            return true;
        }

        public bool TransformPose(Pose poseInGameboardSpace, PlayerIndex playerIndex, out Pose poseInWorldSpace)
        {
            if (!Player.TryGetSettings(playerIndex, out var playerSettings))
            {
                poseInWorldSpace = new Pose();
                return false;
            }
 
            poseInWorldSpace = TransformPose(poseInGameboardSpace, playerSettings.scaleSettings);
            return true;
        }

        public bool TransformPoint(Vector3 pointInGameboardSpace, PlayerIndex playerIndex, out Vector3 pointInWorldSpace)
        {
            if (!Player.TryGetSettings(playerIndex, out var playerSettings))
            {
                pointInWorldSpace = Vector3.zero;
                return false;
            }
 
            pointInWorldSpace = TransformPoint(pointInGameboardSpace, playerSettings.scaleSettings);
            return true;
        }

        public bool InverseTransformPose(Vector3 positionInWorldSpace, Quaternion rotationToWorldSpace, PlayerIndex playerIndex,
            out Vector3 positionInGameboardSpace, out Quaternion rotationToGameboardSpace)
        {
            if (!Player.TryGetSettings(playerIndex, out var playerSettings))
            {
                positionInGameboardSpace = Vector3.zero;
                rotationToGameboardSpace = Quaternion.identity;
                return false;
            }
 
            InverseTransformPose(positionInWorldSpace, rotationToWorldSpace, playerSettings.scaleSettings,
                out positionInGameboardSpace, out rotationToGameboardSpace);
            return true;
        }

        public bool InverseTransformPose(Pose poseInWorldSpace, PlayerIndex playerIndex, out Pose poseInGameboardSpace)
        {
            if (!Player.TryGetSettings(playerIndex, out var playerSettings))
            {
                poseInGameboardSpace = new Pose();
                return false;
            }
 
            poseInGameboardSpace = InverseTransformPose(poseInWorldSpace, playerSettings.scaleSettings);
            return true;
        }

        public bool InverseTransformPoint(Vector3 pointInWorldSpace, PlayerIndex playerIndex, out Vector3 pointInGameboardSpace)
        {
            if (!Player.TryGetSettings(playerIndex, out var playerSettings))
            {
                pointInGameboardSpace = Vector3.zero;
                return false;
            }
 
            pointInGameboardSpace = InverseTransformPoint(pointInWorldSpace, playerSettings.scaleSettings);
            return true;
        }
 
#if UNITY_EDITOR
 
        new public void Awake()
        {
            base.Awake();
            currentScale = transform.localScale;
        }

        public void DrawGizmo(ScaleSettings scaleSettings, GameBoardSettings gameBoardSettings)
        {
            UnifyScale();
 
            if (ShowGizmo)
            {
                boardGizmo.Draw(scaleSettings, gameBoardSettings, GizmoOpacity, ShowGrid, gridOffsetY);
            }
 
            var sceneViewRepaintNecessary = ScaleCompensate(scaleSettings);
            sceneViewRepaintNecessary |= ContentScaleCompensate(scaleSettings);
 
            if(sceneViewRepaintNecessary)
            {
                boardGizmo.ResetGrid(scaleSettings, gameBoardSettings);     // This may need to change once separate game board configs are in.
                UnityEditor.SceneView.lastActiveSceneView.Repaint();
            }
        }

        public GameboardType GetDisplayedGameboardType(GameBoardSettings gameBoardSettings)
        {
            return GetDisplayedGameboardType(PlayerIndex.One, gameBoardSettings);
        }
 
        public static GameboardType GetDisplayedGameboardType(PlayerIndex playerIndex, GameBoardSettings gameBoardSettings)
        {
            if(playerIndex == PlayerIndex.None)
            {
                return GameboardType.GameboardType_None;
            }
 
            var displayedGameboardType = playerGameboards.TryGetValue(playerIndex, out var gameboardType)
                ? gameboardType
                : GameboardType.GameboardType_LE;
 
            displayedGameboardType = gameBoardSettings.gameboardTypeOverride != GameboardType.GameboardType_None
                ? gameBoardSettings.gameboardTypeOverride
                : displayedGameboardType;
 
            return displayedGameboardType;
        }
 
#endif  // UNITY_EDITOR
 
        #endregion Public Functions
 
 
        #region Internal Functions
 
        internal static void Scan()
        {
            incomingGlassesHandles.Clear();
            lostGlassesHandles.Clear();
            lostGameboards.Clear();
            var glassesHandles = Glasses.GetAllConnectedGlassesHandles();
 
            // Incoming gameboard cores
            for(int i = 0; i < glassesHandles.Length; i++)
            {
                var glassesHandle = glassesHandles[i];
                incomingGlassesHandles.Add(glassesHandle);
 
                if (Glasses.IsTracked(glassesHandle))
                {
                    if(!gameboardCores.ContainsKey(glassesHandle)
                        && Player.TryGetPlayerIndex(glassesHandle, out var playerIndex)
                        && Player.TryGetSettings(playerIndex, out var playerSettings)
                        && playerSettings.gameboardSettings.physicalGameboardOrigin != null)
                    {
                        gameboardCores.Add(glassesHandle, new PrimaryGameboardCore(
                                glassesHandle, playerSettings.gameboardSettings.physicalGameboardOrigin.transform));
                    }
                }
            }
 
            // Outgoing gameboard cores
            foreach (var glassesHandle in gameboardCores.Keys)
            {
                if(!incomingGlassesHandles.Contains(glassesHandle))
                {
                    lostGlassesHandles.Add(glassesHandle);
                }
                // Ensure the gameboard is still tracked
                else if(!Glasses.IsTracked(glassesHandle)
                        || !Player.TryGetPlayerIndex(glassesHandle, out var playerIndex)
                        || !Player.TryGetSettings(playerIndex, out var playerSettings)
                        || playerSettings.gameboardSettings.physicalGameboardOrigin == null)
                {
                    lostGameboards.Add(gameboardCores[glassesHandle]);
                }
            }
 
            // Bookkeeping for outgoing gameboard cores
            foreach(var lostGlassesHandle in lostGlassesHandles)
            {
                lostGameboards.Add(gameboardCores[lostGlassesHandle]);
                gameboardCores.Remove(lostGlassesHandle);
            }
 
            foreach(var lostGameboard in lostGameboards)
            {
                lostGameboard.Dispose();
            }
        }
 
        internal static void Update(GlassesHandle glassesHandle, GameBoardSettings gameboardSettings, ScaleSettings scaleSettings)
        {
            if(gameboardCores.TryGetValue(glassesHandle, out var gameboardCore))
            {
                gameboardCore.Update(gameboardSettings, scaleSettings);
            }
        }
 
        internal static void SetGameboardType(PlayerIndex playerIndex, GameboardType gameboardType)
        {
            if(playerIndex == PlayerIndex.None)
            {
                return;
            }
 
            playerGameboards[playerIndex] = gameboardType;
        }
 
        internal static void SetGameboardType(GlassesHandle glassesHandle, GameboardType gameboardType)
        {
            if (Player.TryGetPlayerIndex(glassesHandle, out var playerIndex))
            {
                SetGameboardType(playerIndex, gameboardType);
            }
        }

        internal Pose TransformPose(Pose poseInGameboardSpace, ScaleSettings scaleSettings)
        {
            TransformPose(poseInGameboardSpace.position, poseInGameboardSpace.rotation, scaleSettings,
                out var posUWRLD, out var rotToUWRLD_OBJ);
            return new Pose(posUWRLD, rotToUWRLD_OBJ);
        }

        internal void TransformPose(Vector3 positionInGameboardSpace, Quaternion rotationToGameboardSpace, ScaleSettings scaleSettings,
            out Vector3 positionInWorldSpace, out Quaternion rotationToWorldSpace)
        {
            positionInWorldSpace = TransformPoint(positionInGameboardSpace, scaleSettings);
 
            // The rotation from gameboard space to world space
            var rotToUWRLD_USTAGE = transform.rotation;
 
            // The rotation from the object's local space to gameboard space
            var rotToUSTAGE_OBJ = rotationToGameboardSpace;
 
            // The rotation from the object's local space to world space
            var rotToUWRLD_OBJ = rotToUWRLD_USTAGE * rotToUSTAGE_OBJ;
 
            rotationToWorldSpace = rotToUWRLD_OBJ;
        }

        internal Vector3 TransformPoint(Vector3 pointInGameboardSpace, ScaleSettings scaleSettings)
        {
            var pos_USTAGE = pointInGameboardSpace;
 
            var scaleToUWRLD_USTAGE = scaleSettings.GetScaleToWorldSpaceFromGameboardSpace(localScale);
            var rotToUWRLD_USTAGE = transform.rotation;
            var pos_UWRLD = rotToUWRLD_USTAGE * (scaleToUWRLD_USTAGE * pos_USTAGE) + transform.position;
 
            return pos_UWRLD;
        }

        internal Pose InverseTransformPose(Pose poseInWorldSpace, ScaleSettings scaleSettings)
        {
            InverseTransformPose(poseInWorldSpace.position, poseInWorldSpace.rotation, scaleSettings,
                out var posUSTAGE, out var rotToUSTAGE_OBJ);
            return new Pose(posUSTAGE, rotToUSTAGE_OBJ);
        }

        internal void InverseTransformPose(Vector3 positionInWorldSpace, Quaternion rotationToWorldSpace, ScaleSettings scaleSettings,
            out Vector3 positionInGameboardSpace, out Quaternion rotationToGameboardSpace)
        {
            positionInGameboardSpace = InverseTransformPoint(positionInWorldSpace, scaleSettings);
 
            // The rotation from gameboard space to world space
            var rotToUWRLD_USTAGE = transform.rotation;
 
            // The rotation from world space to gameboard space
            var rotToUSTAGE_UWRLD = Quaternion.Inverse(rotToUWRLD_USTAGE);
 
            // The rotation from the object's local space to world space
            var rotToUWRLD_OBJ = rotationToWorldSpace;
 
            // The rotation from the object's local space to gameboard space
            var rotToUSTAGE_OBJ = rotToUSTAGE_UWRLD * rotToUWRLD_OBJ;
 
            rotationToGameboardSpace = rotToUSTAGE_OBJ;
        }

        internal Vector3 InverseTransformPoint(Vector3 pointInWorldSpace, ScaleSettings scaleSettings)
        {
            var pos_UWRLD = pointInWorldSpace;
 
            var scaleToUSTAGE_UWRLD = 1f / scaleSettings.GetScaleToWorldSpaceFromGameboardSpace(localScale);
            var rotToUSTAGE_UWRLD = Quaternion.Inverse(transform.rotation);
            var pos_USTAGE = pos_UWRLD - transform.position;
            pos_USTAGE = rotToUSTAGE_UWRLD * pos_USTAGE;
            pos_USTAGE *= scaleToUSTAGE_UWRLD;
 
            return pos_USTAGE;
        }
 
        internal static void OnDisable()
        {
            foreach (var gameboardCore in gameboardCores.Values)
            {
                gameboardCore.Dispose();
            }
            gameboardCores.Clear();
        }
 
        #endregion
 
 
        #region Private Functions
 
#if UNITY_EDITOR

        private bool ScaleCompensate(ScaleSettings scaleSettings)
        {
            if(currentScale == transform.localScale) { return false; }
 
            // Prevent negative scale values for the game board.
            if( transform.localScale.x < MIN_SCALE)
            {
                transform.localScale = Vector3.one * MIN_SCALE;
            }
 
            //var sceneView = UnityEditor.SceneView.lastActiveSceneView;
 
            //sceneView.Frame(new Bounds(transform.position, (1/5f) * Vector3.one * scaleSettings.worldSpaceUnitsPerPhysicalMeter / localScale ), true);
 
            currentScale = transform.localScale;
            return true;
        }

        private bool ContentScaleCompensate(ScaleSettings scaleSettings)
        {
            if(currentContentScaleRatio == scaleSettings.contentScaleRatio
            && currentContentScaleUnit == scaleSettings.contentScaleUnit) { return false; }
 
            //var sceneView = UnityEditor.SceneView.lastActiveSceneView;
 
            currentContentScaleUnit = scaleSettings.contentScaleUnit;
            currentContentScaleRatio = scaleSettings.contentScaleRatio;
 
            //sceneView.Frame(new Bounds(transform.position, (1/5f) * Vector3.one * scaleSettings.worldSpaceUnitsPerPhysicalMeter / localScale ), true);
 
            return true;
        }
 
 
#endif  // UNITY_EDITOR
 
        #endregion Private Functions
 
 
        #region Private Classes
 
        private abstract class BaseGameboardCore : TrackableCore<GameBoardSettings, T5_GameboardPose>, IDisposable
        {
            #region Protected Fields
 
            protected GlassesHandle glassesHandle;
            protected Transform gameboardTransform;
 
            protected Pose DEFAULT_GAMEBOARD_POSE_USTAGE = new Pose(Vector3.zero, Quaternion.identity);
 
            #endregion Protected Fields
 
 
            #region Public Functions
 
            public BaseGameboardCore(GlassesHandle glassesHandle, Transform gameboardTransform)
            {
                this.glassesHandle = glassesHandle;
                this.gameboardTransform = gameboardTransform;
            }
 
            public void Dispose()
            {
                // Perform any necessary cleanup here.
            }
 
            #endregion Public Functions
 
 
            #region Protected Functions
 
            protected override void Update(GameBoardSettings settings, ScaleSettings scaleSettings, GameBoardSettings gameBoardSettings)
            {
                // Obtain the latest gameboard pose.
                base.Update(settings, scaleSettings, settings);
            }
 
            #endregion Protected Functions
 
 
            #region TrackableCore Overrides
 
            protected override void SetDefaultPoseGameboardSpace(GameBoardSettings settings)
            {
                pose_USTAGE = DEFAULT_GAMEBOARD_POSE_USTAGE;
            }
 
            protected override void SetDrivenObjectTransform(GameBoardSettings settings, ScaleSettings scaleSettings, GameBoardSettings gameboardSettings)
            {
                gameboardTransform?.SetPositionAndRotation(pose_UWRLD.position, pose_UWRLD.rotation);
            }
 
            protected override void SetInvalidPoseGameboardSpace(in T5_GameboardPose state, GameBoardSettings settings, ScaleSettings scaleSettings, GameBoardSettings gameboardSettings)
            {
                SetPoseGameboardSpace(state, settings, scaleSettings, settings);
            }
 
            protected override void SetPoseGameboardSpace(in T5_GameboardPose state, GameBoardSettings settings, ScaleSettings scaleSettings, GameBoardSettings gameboardSettings)
            {
                var gameboardPos_USTAGE = ConvertPosSTAGEToUSTAGE(state.PosOfBOARD_STAGE);
                Quaternion rotToSTAGE_BOARD = Quaternion.Inverse(state.RotationToBOARD_STAGE);
                Quaternion rotToUSTAGE_UBOARD = ChangeHandednessRightToLeft(rotToSTAGE_BOARD);
 
                pose_USTAGE = new Pose(gameboardPos_USTAGE, rotToUSTAGE_UBOARD);
            }
 
            protected override void SetPoseUnityWorldSpace(ScaleSettings scaleSettings, GameBoardSettings gameboardSettings)
            {
                pose_UWRLD = gameboardSettings.currentGameBoard.TransformPose(pose_USTAGE, scaleSettings);
            }
 
            protected override bool TryCheckConnected(out bool connected)
            {
                // Trackable gameboards depend on glasses that are connected and tracking.
                connected = Glasses.IsTracked(glassesHandle);
                return true;
            }
 
            #endregion TrackableCore Overrides
 
 
            #region Private Helper Functions
 
            private Quaternion ChangeHandednessRightToLeft(Quaternion rotToB_A)
            {
                return new Quaternion(-rotToB_A.x, -rotToB_A.z, -rotToB_A.y, rotToB_A.w);
            }
 
            #endregion Private Helper Functions
        }
 
 
        private class PrimaryGameboardCore : BaseGameboardCore
        {
            public PrimaryGameboardCore(GlassesHandle glassesHandle, Transform gameboardTransform)
                : base(glassesHandle, gameboardTransform) { }
 
            public void Update(GameBoardSettings gameboardSettings, ScaleSettings scaleSettings)
            {
                base.Update(gameboardSettings, scaleSettings, gameboardSettings);
                // If the gameboard settings' physical gameboard was reassigned, update this gameboard core.
                gameboardTransform = gameboardSettings.physicalGameboardOrigin.transform;
            }
 
            protected override bool TryGetStateFromPlugin(out T5_GameboardPose state, out bool poseIsValid)
            {
                var succeeded = false;
                T5_GameboardPose[] resultingPoses = new T5_GameboardPose[MAX_SUPPORTED_GAMEBOARD_POSES];
                UInt16 count = MAX_SUPPORTED_GAMEBOARD_POSES;
 
                try
                {
                    succeeded = NativePlugin.GetGameboardPoses(glassesHandle, resultingPoses, ref count) == NativePlugin.T5_RESULT_SUCCESS;
                }
                catch (Exception e)
                {
                    Log.Error(e.Message);
                }
 
                if (!succeeded || count < 1 || resultingPoses.Length < 1)
                {
                    state = new T5_GameboardPose();     // Default values
                    poseIsValid = false;
                    GameBoard.SetGameboardType(glassesHandle, GameboardType.GameboardType_None);
                    return succeeded;
                }
 
                state = resultingPoses[0];
                poseIsValid = true;
                GameBoard.SetGameboardType(glassesHandle, state.GameboardType);
                return true;
            }
        }
 
        #endregion Private Classes
    }
}