TrackableCore.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 UnityEngine;
using TiltFive.Logging;
 
namespace TiltFive
{
    public abstract class TrackableCore<TSettings, TState> where TSettings : TrackableSettings
    {
        #region Properties

        public Pose Pose_GameboardSpace { get => pose_USTAGE; }
        protected Pose pose_USTAGE;

        public Pose Pose_UnityWorldSpace { get => pose_UWRLD; }
        protected Pose pose_UWRLD;

        public bool IsTracked { get => isTracked; }
        protected bool isTracked = false;

        public bool IsConnected { get => isConnected; }
        protected bool isConnected = false;

        protected Pose gameboardPose_UWRLD;
 
        #endregion Properties
 
 
        #region Protected Functions
 
        protected void Reset(TSettings settings)
        {
            SetDefaultPoseGameboardSpace(settings);
            isTracked = false;
        }
 
        // Update is called once per frame
        protected virtual void Update(TSettings settings, ScaleSettings scaleSettings, GameBoardSettings gameboardSettings)
        {
            if(settings == null)
            {
                Log.Error("TrackableSettings configuration required for tracking updates.");
                return;
            }
 
            // Get the game board pose.
            gameboardPose_UWRLD = new Pose(gameboardSettings.gameBoardCenter,
                Quaternion.Inverse(gameboardSettings.currentGameBoard.rotation));
 
            var successfullyConnected = TryCheckConnected(out isConnected) && isConnected;
            var successfullyGotState = TryGetStateFromPlugin(out var state, out bool poseIsValid);
 
            if (successfullyConnected && successfullyGotState && poseIsValid)
            {
                isTracked = true;
                SetPoseGameboardSpace(state, settings, scaleSettings, gameboardSettings);
            }
            else
            {
                isTracked = false;
                SetInvalidPoseGameboardSpace(state, settings, scaleSettings, gameboardSettings);
            }
 
            SetPoseUnityWorldSpace(scaleSettings, gameboardSettings);
 
            SetDrivenObjectTransform(settings, scaleSettings, gameboardSettings);
        }
 
        protected static Vector3 ConvertPosSTAGEToUSTAGE(Vector3 pos_STAGE)
        {
            // Swap Y and Z to change between STAGE and USTAGE
            return new Vector3(pos_STAGE.x, pos_STAGE.z, pos_STAGE.y);
        }
 
        protected static Pose GameboardToWorldSpace(Pose pose_GameboardSpace,
            ScaleSettings scaleSettings, GameBoardSettings gameboardSettings)
        {
            float scaleToUWRLD_USTAGE = scaleSettings.GetScaleToWorldSpaceFromGameboardSpace(gameboardSettings.gameBoardScale);
 
            Vector3 pos_UWRLD = gameboardSettings.currentGameBoard.rotation *
                (scaleToUWRLD_USTAGE * pose_GameboardSpace.position) + gameboardSettings.gameBoardCenter;
 
            Quaternion rotToUWRLD_OBJ = GameboardToWorldSpace(pose_GameboardSpace.rotation, gameboardSettings);
 
            return new Pose(pos_UWRLD, rotToUWRLD_OBJ);
        }
 
        protected static Vector3 GameboardToWorldSpace(Vector3 pos_USTAGE,
            ScaleSettings scaleSettings, GameBoardSettings gameboardSettings)
        {
            float scaleToUWRLD_USTAGE = scaleSettings.GetScaleToWorldSpaceFromGameboardSpace(gameboardSettings.gameBoardScale);
 
            return gameboardSettings.currentGameBoard.rotation *
                (scaleToUWRLD_USTAGE * pos_USTAGE) + gameboardSettings.gameBoardCenter;
        }
 
        protected static Vector3 WorldToGameboardSpace(Vector3 pos_UWRLD,
            ScaleSettings scaleSettings, GameBoardSettings gameboardSettings)
        {
            float scaleToUWRLD_USTAGE = scaleSettings.GetScaleToWorldSpaceFromGameboardSpace(gameboardSettings.gameBoardScale);
            var rotToUWRLD_USTAGE = gameboardSettings.currentGameBoard.rotation;
            var pos_USTAGE = pos_UWRLD - gameboardSettings.gameBoardCenter;
            pos_USTAGE = Quaternion.Inverse(rotToUWRLD_USTAGE) * pos_USTAGE;
            pos_USTAGE /= scaleToUWRLD_USTAGE;
 
            return pos_USTAGE;
        }
 
        protected static Quaternion GameboardToWorldSpace(Quaternion rotToUSTAGE_OBJ, GameBoardSettings gameboardSettings)
        {
            var rotToUWRLD_USTAGE = gameboardSettings.currentGameBoard.rotation;
            var rotToUWRLD_OBJ = rotToUWRLD_USTAGE * rotToUSTAGE_OBJ;
 
            return rotToUWRLD_OBJ;
        }
 
        protected static Quaternion WorldToGameboardSpace(Quaternion rotToUWRLD_OBJ, GameBoardSettings gameboardSettings)
        {
            var rotToUWRLD_USTAGE = gameboardSettings.currentGameBoard.rotation;
            var rotToUSTAGE_UWRLD = Quaternion.Inverse(rotToUWRLD_USTAGE);
            var rotToUSTAGE_OBJ = rotToUSTAGE_UWRLD * rotToUWRLD_OBJ;
 
            return rotToUSTAGE_OBJ;
 
        }
 
        #endregion Protected Functions
 
 
        #region Abstract Functions

        protected abstract void SetDefaultPoseGameboardSpace(TSettings settings);

        protected abstract void SetPoseGameboardSpace(in TState state, TSettings settings, ScaleSettings scaleSettings, GameBoardSettings gameboardSettings);

        protected abstract void SetInvalidPoseGameboardSpace(in TState state, TSettings settings, ScaleSettings scaleSettings, GameBoardSettings gameboardSettings);

        protected abstract void SetPoseUnityWorldSpace(ScaleSettings scaleSettings, GameBoardSettings gameboardSettings);

        protected abstract bool TryCheckConnected(out bool connected);

        protected abstract bool TryGetStateFromPlugin(out TState state, out bool poseIsValid);

        protected abstract void SetDrivenObjectTransform(TSettings settings, ScaleSettings scaleSettings, GameBoardSettings gameboardSettings);
 
        #endregion Abstract Functions
    }
}