Removed TOTU 103

Assets/Common/Scripts/DisplayImage.cs

@@ -0,0 +1,162 @@
+// Copyright 2022-2024 Niantic.
+using System.Text;
+using UnityEngine.XR.ARFoundation;
+using UnityEngine.UI;
+using UnityEngine;
+
+namespace Niantic.Lightship.AR.Samples
+{
+    public abstract class DisplayImage : MonoBehaviour
+    {
+        // Name of the display rotation matrix in the shader.
+        const string k_DisplayMatrixName = "_DisplayMatrix";
+
+        private readonly int k_DisplayMatrix = Shader.PropertyToID(k_DisplayMatrixName);
+
+        protected readonly StringBuilder m_StringBuilder = new();
+
+        protected ScreenOrientation m_CurrentScreenOrientation;
+
+        [SerializeField]
+        [Tooltip("The ARCameraManager which will produce camera frame events.")]
+        ARCameraManager m_CameraManager;
+
+        [SerializeField]
+        [Tooltip("Raw Image UI element for display.")]
+        protected RawImage m_RawImage;
+
+        [SerializeField]
+        [Tooltip("Material using the shader.")]
+        Material m_Material;
+
+        [SerializeField]
+        [Tooltip("UI Text field for image info")]
+        Text m_ImageInfo;
+
+        private Camera m_camera;
+
+        protected virtual void Awake()
+        {
+            // Acquire a reference to the rendering camera
+            m_camera = m_CameraManager.GetComponent<Camera>();
+
+            // Get the current screen orientation, and update the raw image UI
+            m_CurrentScreenOrientation = Screen.orientation;
+        }
+
+        protected virtual void OnEnable()
+        {
+            UpdateRawImage();
+        }
+
+        protected virtual void Update()
+        {
+            Debug.Assert(m_RawImage != null, "no raw image");
+
+            // If the raw image needs to be updated because of a device orientation change or because of a texture
+            // aspect ratio difference, then update the raw image with the new values.
+            if (m_CurrentScreenOrientation != Screen.orientation)
+            {
+                m_CurrentScreenOrientation = Screen.orientation;
+                UpdateRawImage();
+            }
+
+            // Update the image
+            var sizeDelta = m_RawImage.rectTransform.sizeDelta;
+            OnUpdatePresentation(
+                viewportWidth: (int)sizeDelta.x,
+                viewportHeight: (int)sizeDelta.y,
+                orientation: m_CurrentScreenOrientation,
+                renderingMaterial: m_RawImage.material,
+                image: out var texture,
+                displayMatrix: out var displayMatrix);
+
+            m_RawImage.texture = texture;
+            m_RawImage.material.SetMatrix(k_DisplayMatrix, displayMatrix);
+
+            if (m_RawImage.texture != null)
+            {
+                // Display some text information about each of the textures.
+                var displayTexture = m_RawImage.texture as Texture2D;
+                if (displayTexture != null)
+                {
+                    m_StringBuilder.Clear();
+                    BuildTextureInfo(m_StringBuilder, "env", displayTexture);
+                    LogText(m_StringBuilder.ToString());
+                }
+            }
+        }
+
+        /// <summary>
+        /// Invoked when it is time to update the presentation.
+        /// </summary>
+        /// <param name="viewportWidth">The width of the portion of the screen the image will be rendered onto.</param>
+        /// <param name="viewportHeight">The height of the portion of the screen the image will be rendered onto.</param>
+        /// <param name="orientation">The orientation of the screen.</param>
+        /// <param name="renderingMaterial">The material used to render the image.</param>
+        /// <param name="image">The image to render.</param>
+        /// <param name="displayMatrix">A transformation matrix to fit the image onto the viewport.</param>
+        protected abstract void OnUpdatePresentation( int viewportWidth, int viewportHeight, ScreenOrientation orientation,
+            Material renderingMaterial, out Texture image, out Matrix4x4 displayMatrix);
+
+
+        private static void BuildTextureInfo(StringBuilder stringBuilder, string textureName, Texture2D texture)
+        {
+            stringBuilder.AppendLine($"texture : {textureName}");
+            if (texture == null)
+            {
+                stringBuilder.AppendLine("   <null>");
+            }
+            else
+            {
+                stringBuilder.AppendLine($"   format : {texture.format}");
+                stringBuilder.AppendLine($"   width  : {texture.width}");
+                stringBuilder.AppendLine($"   height : {texture.height}");
+                stringBuilder.AppendLine($"   mipmap : {texture.mipmapCount}");
+            }
+        }
+
+        private void LogText(string text)
+        {
+            if (m_ImageInfo != null)
+            {
+                m_ImageInfo.text = text;
+            }
+            else
+            {
+                Debug.Log(text);
+            }
+        }
+
+        private void UpdateRawImage()
+        {
+            Debug.Assert(m_RawImage != null, "no raw image");
+
+            // The aspect ratio of the presentation in landscape orientation
+            var aspect = Mathf.Max(m_camera.pixelWidth, m_camera.pixelHeight) /
+                (float)Mathf.Min(m_camera.pixelWidth, m_camera.pixelHeight);
+
+            // Determine the raw image rectSize preserving the texture aspect ratio, matching the screen orientation,
+            // and keeping a minimum dimension size.
+            float minDimension = 480.0f;
+            float maxDimension = Mathf.Round(minDimension * aspect);
+            Vector2 rectSize;
+            switch (m_CurrentScreenOrientation)
+            {
+                case ScreenOrientation.LandscapeRight:
+                case ScreenOrientation.LandscapeLeft:
+                    rectSize = new Vector2(maxDimension, minDimension);
+                    break;
+                case ScreenOrientation.PortraitUpsideDown:
+                case ScreenOrientation.Portrait:
+                default:
+                    rectSize = new Vector2(minDimension, maxDimension);
+                    break;
+            }
+
+            // Update the raw image dimensions and the raw image material parameters.
+            m_RawImage.rectTransform.sizeDelta = rectSize;
+            m_RawImage.material = m_Material;
+        }
+    }
+}