AbstractCameraBackgroundBehaviour.cs

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

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

namespace maxstAR
{
    public class AbstractCameraBackgroundBehaviour : MonoBehaviour
    {
        public Shader RGBBackgroundShader;
        public Shader YuvBackgroundShader;
        public Shader AndroidYuvBackgroundShader;
        public Color32 pauseColor = new Color32(255, 255, 255, 255);
        private static AbstractCameraBackgroundBehaviour instance = null;

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

                return instance;
            }
        }

        private int cameraWidth = 0;
        private int cameraHeight = 0;
        private Texture2D rgbTexture = null;
        private bool keepRendering = false;

        private Texture2D yTexture = null;
        private Texture2D uvTexture = null;

        void Awake()
        {
            Debug.Log("Current graphics device type is " + SystemInfo.graphicsDeviceType + ".");

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

        void OnApplicationPause(bool pause)
        {
            if (pause)
            {
                StopRendering();
            }
            else
            {
                StartRendering();
            }
        }

        void OnEnable()
        {
            StartRendering();
        }

        void OnDisable()
        {
            StopRendering();
        }

        void OnDestroy()
        {
            StopRendering();
        }

        private void StartRendering()
        {
            GetComponent<Renderer>().material.SetFloat("pauseMode", 0.0f);
            Debug.Log("StartRendering");
            keepRendering = true;
        }

        private void StopRendering()
        {
            GetComponent<Renderer>().material.SetFloat("pauseMode", 1.0f);
            Debug.Log("StopRendering");
            keepRendering = false;
        }

        private void CreateCameraTexture(int imageWidth, int imageHeight, ColorFormat imageFormat)
        {
            if(rgbTexture != null || yTexture != null) {
                return;
            }

            if(imageFormat == ColorFormat.RGB888) {
                rgbTexture = new Texture2D(imageWidth, imageHeight, TextureFormat.RGB24, false);
                GetComponent<Renderer>().material = new Material(RGBBackgroundShader);
                GetComponent<Renderer>().material.mainTexture = rgbTexture;
            } else if(imageFormat == ColorFormat.YUV420sp) {
                yTexture = new Texture2D(imageWidth, imageHeight, TextureFormat.R8, false);
                uvTexture = new Texture2D(imageWidth / 2, imageHeight / 2, TextureFormat.RG16, false);

                if (Application.platform == RuntimePlatform.Android) {
                    GetComponent<Renderer>().material = new Material(AndroidYuvBackgroundShader);
                } else {
                    GetComponent<Renderer>().material = new Material(YuvBackgroundShader);
                }

                GetComponent<Renderer>().material.SetTexture("_YTex", yTexture);
                GetComponent<Renderer>().material.SetTexture("_UVTex", uvTexture);
            }

            Mesh mesh = GetComponent<MeshFilter>().mesh;
            Vector3[] vertices = mesh.vertices;
            Vector2[] uvs = new Vector2[vertices.Length];

            uvs[0].x = 0;   uvs[0].y = 1;
            uvs[1].x = 1;   uvs[1].y = 0;
            uvs[2].x = 1;   uvs[2].y = 1;
            uvs[3].x = 0;   uvs[3].y = 0;
            mesh.uv = uvs;

            GetComponent<Renderer>().material.SetColor("_PauseColor", pauseColor);
            GetComponent<Renderer>().material.renderQueue = 1500;
            Debug.Log("Create background texture");
        }

        private void Update()
        {
            TrackingState state = TrackerManager.GetInstance().GetTrackingState();
            TrackedImage image = state.GetImagePtr();

            if (image != null && image.GetWidth() > 0 && image.GetHeight() > 0)
            {
                CreateCameraTexture(image.GetWidth(), image.GetHeight(), image.GetFormat());

                if (keepRendering)
                {
                    UpdateInternal(image);
                }
            }
        }

        void UpdateInternal(TrackedImage image)
        {
            IntPtr cameraFrameBuffer = image.GetDataPtr();

            if (cameraFrameBuffer != IntPtr.Zero)
            {
                switch(image.GetFormat()) {
                    case ColorFormat.RGB888:
                        {
                            if(rgbTexture != null) {
                                rgbTexture.LoadRawTextureData(cameraFrameBuffer, image.GetWidth() * image.GetHeight() * 3);
                                rgbTexture.Apply();
                            }
                        }
                        break;
                    case ColorFormat.YUV420sp:
                        {
                            if(yTexture != null) {
                                IntPtr yPtr;
                                IntPtr uvPtr;
                                unsafe
                                {
                                    byte* pointer = (byte*)cameraFrameBuffer.ToPointer();
                                    yPtr = (IntPtr)pointer;
                                    pointer += image.GetWidth() * image.GetHeight();
                                    uvPtr = (IntPtr)pointer;
                                }

                                yTexture.LoadRawTextureData(yPtr, image.GetWidth() * image.GetHeight());
                                yTexture.Apply();
                                uvTexture.LoadRawTextureData(uvPtr, image.GetWidth() * image.GetHeight() / 2);
                                uvTexture.Apply();
                            }
                        }
                        break;
                }

            }
        }

        internal bool RenderingEnabled()
        {
            return keepRendering;
        }
    }
}