AbstractWearableManager.cs

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

using UnityEngine;
using System.Collections;
using System.Runtime.InteropServices;
using System;

namespace maxstAR
{
    public abstract class AbstractWearableManager : MonoBehaviour
    {
        private GameObject eyeLeft = null;
        private GameObject eyeRight = null;
        private WearableDeviceController wearableDeviceController;
        private WearableCalibration wearableCalibration;

        void Start()
        {
            if (Application.platform == RuntimePlatform.Android)
            {
                if (AbstractConfigurationScriptableObject.GetInstance().WearableType ==
                        WearableCalibration.WearableType.OpticalSeeThrough)
                {
                    wearableDeviceController = new WearableDeviceController();
                    wearableCalibration = WearableCalibration.GetInstance();

                    bool res = wearableDeviceController.IsSupportedWearableDevice();
                    Debug.Log("wearableDeviceController.IsSupportedWearableDevice()" + res.ToString());
                    if (wearableDeviceController.IsSupportedWearableDevice())
                    {
                        string modelName = wearableDeviceController.GetModelName();

                        Debug.Log(modelName.ToString());
                        if (wearableCalibration.Init(modelName, Screen.width, Screen.height))
                        {
                            Debug.Log("wearableCalibration.Init suc");
                            wearableDeviceController.SetStereoMode(true);

                            AbstractCameraBackgroundBehaviour cameraBackground = GetComponentInChildren<AbstractCameraBackgroundBehaviour>();
                            cameraBackground.gameObject.SetActive(false);

                            CreateWearableEye();
                        }
                    }
                }
            }
        }

        void OnDestroy()
        {
            if (Application.platform == RuntimePlatform.Android)
            {
                if (AbstractConfigurationScriptableObject.GetInstance().WearableType ==
                        WearableCalibration.WearableType.OpticalSeeThrough)
                {
                    //if (wearableCalibration.IsActivated())
                    {
                        wearableDeviceController.SetStereoMode(false);
                        wearableCalibration.Deinit();
                        DestroyWearableEye();
                    }
                }
            }
        }

        private void CreateWearableEye()
        {
            if (eyeLeft == null)
            {
                eyeLeft = new GameObject("EyeLeft");
                eyeLeft.AddComponent<Camera>();
            }

            if (eyeRight == null)
            {
                eyeRight = new GameObject("EyeRight");
                eyeRight.AddComponent<Camera>();
            }

            eyeLeft.transform.parent = transform;
            eyeRight.transform.parent = transform;

            eyeLeft.transform.localPosition = Vector3.zero;
            eyeLeft.transform.localRotation = Quaternion.identity;
            eyeLeft.transform.localScale = Vector3.one;

            eyeRight.transform.localPosition = Vector3.zero;
            eyeRight.transform.localRotation = Quaternion.identity;
            eyeRight.transform.localScale = Vector3.one;

            Camera mainCamera = transform.GetComponent<Camera>();
            Camera leftCamera = eyeLeft.GetComponent<Camera>();
            Camera rightCamera = eyeRight.GetComponent<Camera>();

            CameraClearFlags clearFlags = mainCamera.clearFlags;
            Color backgroundColor = mainCamera.backgroundColor;
            float depth = mainCamera.depth + 1;
            float nearClipPlane = mainCamera.nearClipPlane;
            float farClipPlane = mainCamera.farClipPlane;

            float[] projectionMatrixEyeLeftPtr = wearableCalibration.GetProjectionMatrix(WearableCalibration.EyeType.EYE_LEFT);
            float[] projectionMatrixEyeRightPtr = wearableCalibration.GetProjectionMatrix(WearableCalibration.EyeType.EYE_RIGHT);

            Matrix4x4 projectionEyeLeft = MatrixUtils.ConvertGLProjectionToUnityProjection(projectionMatrixEyeLeftPtr);
            Matrix4x4 projectionEyeRight = MatrixUtils.ConvertGLProjectionToUnityProjection(projectionMatrixEyeRightPtr);

            leftCamera.clearFlags = clearFlags;
            leftCamera.backgroundColor = backgroundColor;
            leftCamera.depth = depth;
            leftCamera.nearClipPlane = nearClipPlane;
            leftCamera.farClipPlane = farClipPlane;
            leftCamera.rect = new Rect(0.0f, 0.0f, 0.5f, 1.0f);
            leftCamera.projectionMatrix = projectionEyeLeft;

            rightCamera.clearFlags = clearFlags;
            rightCamera.backgroundColor = backgroundColor;
            rightCamera.depth = depth;
            rightCamera.nearClipPlane = nearClipPlane;
            rightCamera.farClipPlane = farClipPlane;
            rightCamera.rect = new Rect(0.5f, 0.0f, 0.5f, 1.0f);
            rightCamera.projectionMatrix = projectionEyeRight;
        }

        private void DestroyWearableEye()
        {
            if (eyeLeft != null)
            {
                DestroyImmediate(eyeLeft);
            }

            if (eyeRight != null)
            {
                DestroyImmediate(eyeRight);
            }
        }
    }
}