AbstractARManager.cs

/*==============================================================================
Copyright 2017 Maxst, Inc. All Rights Reserved.
==============================================================================*/

using UnityEngine;
using System.Collections;
using UnityEngine.Rendering;

namespace maxstAR
{
    public abstract class AbstractARManager : MonoBehaviour
    {
        private static AbstractARManager instance = null;

        internal static AbstractARManager Instance
        {
            get
            {
                if (instance == null)
                {
                    instance = FindObjectOfType<AbstractARManager>();
                }

                return instance;
            }
        }

        private string licenseKey = null;
        private AndroidEngine androidEngine = null;
        private int screenWidth = 0;
        private int screenHeight = 0;
        private ScreenOrientation orientation = ScreenOrientation.Unknown;
        private float nearClipPlane = 0.0f;
        private float farClipPlane = 0.0f;
        private Camera arCamera = null;
        private int cameraWidth = 0;
        private int cameraHeight = 0;
        //private GameObject watermarkObject = null;

        protected virtual void Awake()
        {
            Init();

            if (Application.platform == RuntimePlatform.Android ||
                Application.platform == RuntimePlatform.IPhonePlayer)
            {
                MaxstAR.SetScreenOrientation((int)Screen.orientation);
            }
            else
            {
                MaxstAR.SetScreenOrientation((int)ScreenOrientation.LandscapeLeft);
            }

            MaxstAR.OnSurfaceChanged(Screen.width, Screen.height);
        }

        protected void Init()
        {
            licenseKey = AbstractConfigurationScriptableObject.GetInstance().LicenseKey;
            if (Application.platform == RuntimePlatform.Android)
            {
                androidEngine = new AndroidEngine(licenseKey);
            }
            else if (Application.platform == RuntimePlatform.IPhonePlayer)
            {
                NativeStaticAPI.init(licenseKey);
            }

            // If CameraBackgroundBehaviour is not activated when start application, projection matrix 
            // can not be made because screen width and height isn't set properly.
            if (screenWidth != Screen.width || screenHeight != Screen.height)
            {
                screenWidth = Screen.width;
                screenHeight = Screen.height;
                MaxstAR.OnSurfaceChanged(screenWidth, screenHeight);
            }

            if (Application.platform == RuntimePlatform.Android ||
                Application.platform == RuntimePlatform.IPhonePlayer)
            {
                MaxstAR.SetScreenOrientation((int)Screen.orientation);
            }
            else
            {
                MaxstAR.SetScreenOrientation((int)ScreenOrientation.LandscapeLeft);
            }

            arCamera = GetComponent<Camera>();
        }

        void Update()
        {
            // If world center is target then tracking pose should be set to main camera's transform
            if (worldCenterMode == WorldCenterMode.TARGET)
            {
                TrackingState trackingState = TrackerManager.GetInstance().GetTrackingState();
                TrackingResult trackingResult = trackingState.GetTrackingResult();
                if (trackingResult.GetCount() > 0)
                {
                    Trackable trackable = trackingResult.GetTrackable(0);
                    Matrix4x4 targetPose = trackable.GetTargetPose().inverse;

                    if (targetPose == Matrix4x4.zero)
                        return;

                    Quaternion rotation = Quaternion.Euler(90, 0, 0);
                    Matrix4x4 m = Matrix4x4.TRS(new Vector3(0, 0, 0), rotation, new Vector3(1, 1, 1));
                    targetPose = m * targetPose;

                    Camera.main.transform.position = MatrixUtils.PositionFromMatrix(targetPose);
                    Camera.main.transform.rotation = MatrixUtils.QuaternionFromMatrix(targetPose);
                    Camera.main.transform.localScale = MatrixUtils.ScaleFromMatrix(targetPose);
                }
            }
        }

        protected virtual void OnDestroy()
        {
            if (Application.platform == RuntimePlatform.Android)
            {
                androidEngine.Dispose();
            }
        }

        public enum WorldCenterMode
        {
            CAMERA = 0,
            TARGET = 1
        }

        [SerializeField]
        private WorldCenterMode worldCenterMode;

        public WorldCenterMode WorldCenterModeSetting
        {
            get
            {
                return worldCenterMode;
            }
        }

        public void SetWorldCenterMode(WorldCenterMode worldCenterMode)
        {
            this.worldCenterMode = worldCenterMode;
        }

        void OnPreRender()
        {
            if (screenWidth != Screen.width || screenHeight != Screen.height)
            {
                screenWidth = Screen.width;
                screenHeight = Screen.height;
                MaxstAR.OnSurfaceChanged(screenWidth, screenHeight);
            }

            if (orientation != Screen.orientation)
            {
                orientation = Screen.orientation;

                if (Application.platform == RuntimePlatform.Android ||
                    Application.platform == RuntimePlatform.IPhonePlayer)
                {
                    MaxstAR.SetScreenOrientation((int)orientation);
                }
            }

            if (nearClipPlane != arCamera.nearClipPlane || farClipPlane != arCamera.farClipPlane)
            {
                nearClipPlane = arCamera.nearClipPlane;
                farClipPlane = arCamera.farClipPlane;
            }

            //if (SystemInfo.graphicsDeviceType == GraphicsDeviceType.Vulkan ||
            //  SystemInfo.graphicsDeviceType == GraphicsDeviceType.Metal)
            //{
            //  Debug.LogError("Current graphics device type is " + SystemInfo.graphicsDeviceType + ". This is not supported");
            //  //return;
            //}

            int tempCameraWidth = CameraDevice.GetInstance().GetWidth();
            int tempCameraHeight = CameraDevice.GetInstance().GetHeight();

            if (tempCameraWidth == 0 || tempCameraHeight == 0)
            {
                return;
            }

            if (cameraWidth != tempCameraWidth || cameraHeight != tempCameraHeight)
            {
                cameraWidth = tempCameraWidth;
                cameraHeight = tempCameraHeight;
            }

            TransformBackgroundPlane(arCamera, AbstractCameraBackgroundBehaviour.Instance.transform);
      
            arCamera.projectionMatrix = MatrixUtils.getProjectionMatrix();
        }

        //private void DrawZombie()
        //{
        //  if (MaxstARUtils.IsDirectXAPI())
        //  {
        //      GL.IssuePluginEvent(BackgroundRenderer.GetInstance().GetNativeRenderEventFunc(), MaxstARUtils.NATIVE_RENDER_EVENT_DRAW_ZOMBIE_DX);
        //  }
        //  else
        //  {
        //      GL.IssuePluginEvent(BackgroundRenderer.GetInstance().GetNativeRenderEventFunc(), MaxstARUtils.NATIVE_RENDER_EVENT_DRAW_ZOMBIE_GL);
        //  }
        //}

        private void TransformBackgroundPlane(Camera camera, Transform planeTransform)
        {
            float widthRatio = (float)Screen.width / cameraWidth;
            float heightRatio = (float)Screen.height / cameraHeight;
            float farClipPlane = camera.farClipPlane * 0.90f;
            float tanFovWidth = (1.0f / (float)Screen.width) * (float)Screen.height;
            float frustumWidth = tanFovWidth * farClipPlane * camera.aspect;
            float viewWidth = (float)frustumWidth / Screen.width;
            float viewHeight = viewWidth * (widthRatio / heightRatio);
            float flipHorizontal = 1.0f;
            float flipVertical = 1.0f;

   //         UnityEngine.VR.VRSettings.enabled = false;
   //         if (UnityEngine.XR.XRSettings.enabled)
            //{
            //  viewWidth = viewWidth * 2.0f;
            //}

            //Debug.Log("UnityEngine.VR.VRSettings.enabled : " + UnityEngine.VR.VRSettings.enabled);
            //Debug.Log("Loaded device name: " + UnityEngine.VR.VRSettings.loadedDeviceName);

            if (CameraDevice.GetInstance().IsFlipHorizontal())
            {
                flipHorizontal = -1.0f;
            }

            if (CameraDevice.GetInstance().IsFlipVertical())
            {
                flipVertical = -1.0f;
            }

            if (MaxstARUtils.IsDirectXAPI())
            {
                flipHorizontal = -flipHorizontal;
            }

            if (widthRatio > heightRatio)
            {
                planeTransform.localScale = new Vector3(widthRatio * cameraWidth * viewWidth * flipVertical,
                    widthRatio * cameraHeight * viewWidth * flipHorizontal, 0.1f);
                planeTransform.localPosition = new Vector3(0.0f, 0.0f, farClipPlane);
            }
            else
            {
                planeTransform.localScale = new Vector3(heightRatio * cameraWidth * viewHeight * flipVertical,
                    heightRatio * cameraHeight * viewHeight * flipHorizontal, 0.1f);
                planeTransform.localPosition = new Vector3(0.0f, 0.0f, farClipPlane);
            }

            if (SystemInfo.graphicsDeviceType == GraphicsDeviceType.Direct3D9 ||
                SystemInfo.graphicsDeviceType == GraphicsDeviceType.Direct3D11 ||
                SystemInfo.graphicsDeviceType == GraphicsDeviceType.Direct3D12)
            {
                planeTransform.localScale = new Vector3(planeTransform.localScale.x, -planeTransform.localScale.y, planeTransform.localScale.z);
            }
        }

        //private void CreateWatermarkIfNeeded()
        //{
        //  int tempCameraWidth = CameraDevice.GetInstance().GetWidth();
        //  int tempCameraHeight = CameraDevice.GetInstance().GetHeight();

        //  if (tempCameraWidth == 0 || tempCameraHeight == 0)
        //  {
        //      return;
        //  }

        //  if (MaxstARUtils.IsDirectXAPI())
        //  {
        //      int signatureType = NativeSharedAPI.Signature_getSignatureType();
        //      if (signatureType != 0 && signatureType != 2)
        //      {
        //          if (watermarkObject == null)
        //          {
        //              watermarkObject = WatermarkUtil.Instance.CreateWartermarkObject(signatureType);
        //              watermarkObject.transform.parent = transform;
        //          }

        //          if (watermarkObject != null)
        //          {
        //              watermarkObject.transform.localScale = new Vector3(0.5f, 1.0f, -0.14f);
        //              watermarkObject.transform.localPosition = new Vector3(-0.8f, -0.6f, 2.5f);
        //              watermarkObject.transform.localRotation = Quaternion.Euler(new Vector3(-90.0f, 0.0f, 0.0f));

        //              if (watermarkObject.GetComponent<MeshRenderer>() == null ||
        //                  watermarkObject.GetComponent<MeshFilter>() == null ||
        //                  watermarkObject.GetComponent<MeshRenderer>().enabled == false)
        //              {
        //                  Destroy(watermarkObject);
        //                  watermarkObject = null;
        //              }
        //          }
        //      }
        //  }
        //}
    }
}