using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine.TerrainTools;
using UnityEngine;
using UObject = UnityEngine.Object;
using UnityEngine.Experimental.Rendering;

namespace UnityEditor.TerrainTools
{
    /// <summary>
    /// Provides methods for changing and restoring active <see cref="RenderTexture"/>s.
    /// </summary>
    public struct ActiveRenderTextureScope : IDisposable
    {
        RenderTexture m_Prev;

        /// <summary>
        /// Initializes and returns an instance of <see cref="ActiveRenderTextureScope"/>. 
        /// </summary>
        /// <remarks>Call this constructor to swap the previous active <see cref="RenderTexture"/> with the RenderTexture that is passed in.</remarks>
        /// <param name="rt">The RenderTexture to set as active.</param>
        public ActiveRenderTextureScope(RenderTexture rt)
        {
            m_Prev = RenderTexture.active;
            RenderTexture.active = rt;
        }

        /// <summary>
        /// Restores the previous <see cref="RenderTexture"/>.
        /// </summary>
        public void Dispose()
        {
            // restore prev active RT
            RenderTexture.active = m_Prev;
        }
    }


    /// <summary>
    /// Provides a utility class for safely managing the lifetime of a <see cref="RenderTexture"/>.
    /// </summary>
    public class RTHandle
    {
        private RenderTexture   m_RT;
        private bool           m_IsTemp;

        /// <summary>
        /// The RenderTexture for this RTHandle.
        /// </summary>
        public RenderTexture RT => m_RT;

        /// <summary>
        /// The descriptor for the RTHandle and RenderTexture.
        /// </summary>
        public RenderTextureDescriptor Desc => m_RT?.descriptor ?? default;

        internal bool IsTemp => m_IsTemp;

        /// <summary>
        /// The name for the RTHandle and RenderTexture.
        /// </summary>
        public string Name {
            get => m_RT?.name ?? default;
            set => m_RT.name = value;
            }

        internal RTHandle()
        {

        }

        /// <summary>
        /// Sets the name of the <see cref="RenderTexture"/>, and returns a reference to this <see cref="RTHandle"/>.
        /// </summary>
        /// <param name="name">The name of the underlying RenderTexture.</param>
        /// <returns>Returns a reference to this RTHandle.</returns>
        public RTHandle WithName(string name)
        {
            Name = name;
            return this;
        }

        /// <summary>
        /// Converts the <see cref="RTHandle"/> to a <see cref="RenderTexture"/> type.
        /// </summary>
        /// <param name="handle">The RTHandle to convert.</param>
        /// <returns>Returns a RenderTexture handle.</returns>
        public static implicit operator RenderTexture(RTHandle handle)
        {
            return handle.RT;
        }

        /// <summary>
        /// Converts the <see cref="RTHandle"/> to a <see cref="Texture"/> type.
        /// </summary>
        /// <param name="handle">The RTHandle to convert.</param>
        /// <returns>Returns a RenderTexture handle.</returns>
        public static implicit operator Texture(RTHandle handle)
        {
            return handle.RT;
        }

        internal void SetRenderTexture(RenderTexture rt, bool isTemp)
        {
            m_RT = rt;
            m_IsTemp = isTemp;
        }

        /// <summary>
        /// Represents a <c>struct</c> for handling the lifetime of an <see cref="RTHandle"/> within a <c>using</c> block.
        /// </summary>
        /// <remarks>Releases the <see cref="RenderTexture"/> when this <c>struct</c> is disposed.</remarks>
        public struct RTHandleScope : System.IDisposable
        {
            RTHandle m_Handle;

            internal RTHandleScope(RTHandle handle)
            {
                m_Handle = handle;
            }

            /// <summary>
            /// Releases the handled RenderTexture.
            /// </summary>
            public void Dispose()
            {
                RTUtils.Release(m_Handle);
            }
        }

        /// <summary>
        /// Gets a new disposable <see cref="RTHandleScope"/> instance to use within <c>using</c> blocks.
        /// </summary>
        /// <returns>Returns a new RTHandleScope instance.</returns>
        public RTHandleScope Scoped() => new RTHandleScope(this);
    }

    /// <summary>
    /// Provides a utility class for getting and releasing <see cref="RenderTexture"/>s handles.
    /// </summary>
    /// <remarks>
    /// Tracks the lifetimes of these RenderTextures. Any RenderTextures that aren't released within several frames are regarded as leaked RenderTexture resources, which generate warnings in the Console.
    /// </remarks>
    public static class RTUtils
    {
        class Log
        {
            public int Frames;
            public string StackTrace;
        }

        internal static bool s_EnableStackTrace = false;
        private static Stack<Log> s_LogPool = new Stack<Log>();
        private static Dictionary<RTHandle, Log> s_Logs = new Dictionary<RTHandle, Log>();

        internal static int s_CreatedHandleCount;
        internal static int s_TempHandleCount;

        private static bool m_AgeCheckAdded;

        private static void AgeCheck()
        {
            if (!m_AgeCheckAdded)
            {
                Debug.LogError("Checking lifetime of RenderTextures but m_AgeCheckAdded = false");
            }

            foreach (var kvp in s_Logs)
            {
                var log = kvp.Value;

                if (log.Frames >= 4)
                {
                    var trace = !s_EnableStackTrace ? string.Empty : "\n" + log.StackTrace;
                    Debug.LogWarning($"RTHandle \"{kvp.Key.Name}\" has existed for more than 4 frames. Possible memory leak.{trace}");
                }

                log.Frames++;
            }
        }

        private static void CheckAgeCheck()
        {
            if (s_TempHandleCount != 0 || s_CreatedHandleCount != 0)
                return;

            Debug.Assert(s_Logs.Count == 0, "Internal RTHandle type counts for temporary and non-temporary RTHandles are both 0 but the containers for tracking leaked RTHandles have counts that are not 0");

            if (!m_AgeCheckAdded)
            {
                EditorApplication.update += AgeCheck;
                m_AgeCheckAdded = true;
            }
            else
            {
                EditorApplication.update -= AgeCheck;
                m_AgeCheckAdded = false;
            }
        }

        private static void AddLogForHandle(RTHandle handle)
        {
            var log = s_LogPool.Any() ? s_LogPool.Pop() : new Log();
            if (s_EnableStackTrace)
                log.StackTrace = System.Environment.StackTrace;
            s_Logs.Add(handle, log);
        }

        /// <summary>
        /// Gets a RenderTextureDescriptor for <see cref="RenderTexture"/> operations on GPU.
        /// </summary>
        /// <param name="width">The width of the RenderTexture.</param>
        /// <param name="height">The height of the RenderTexture.</param>
        /// <param name="format">The <see cref="RenderTextureFormat"/> of the RenderTexture.</param>
        /// <param name="depth">The depth of the RenderTexture.</param>
        /// <param name="mipCount">The mip count of the RenderTexture. Default is <c>0</c>.</param>
        /// <param name="srgb">The flag that determines whether RenderTextures created using this descriptor are in sRGB or Linear space.</param>
        /// <returns>Returns a RenderTextureDescriptor object.</returns>
        /// <seealso cref="GetDescriptor"/>
        public static RenderTextureDescriptor GetDescriptor(int width, int height, int depth, RenderTextureFormat format, int mipCount = 0, bool srgb = false)
        {
            return GetDescriptor(width, height, depth, GraphicsFormatUtility.GetGraphicsFormat(format, srgb), mipCount, srgb);
        }

        /// <summary>
        /// Gets a RenderTextureDescriptor for <see cref="RenderTexture"/> operations on GPU with the <c>enableRandomWrite</c> flag set to <c>true</c>.
        /// </summary>
        /// <param name="width">The width of the RenderTexture.</param>
        /// <param name="height">The height of the RenderTexture.</param>
        /// <param name="format">The <see cref="RenderTextureFormat"/> of the RenderTexture.</param>
        /// <param name="depth">The depth of the RenderTexture.</param>
        /// <param name="mipCount">The mip count of the RenderTexture. Default is <c>0</c>.</param>
        /// <param name="srgb">The flag that determines whether RenderTextures created using this descriptor are in sRGB or Linear space.</param>
        /// <returns>Returns a RenderTextureDescriptor object.</returns>
        /// <seealso cref="GetDescriptor"/>
        public static RenderTextureDescriptor GetDescriptorRW(int width, int height, int depth, RenderTextureFormat format, int mipCount = 0, bool srgb = false)
        {
            return GetDescriptorRW(width, height, depth, GraphicsFormatUtility.GetGraphicsFormat(format, srgb), mipCount, srgb);
        }

        /// <summary>
        /// Gets a RenderTextureDescriptor for <see cref="RenderTexture"/> operations on GPU with the <c>enableRandomWrite</c> flag set to <c>true</c>.
        /// </summary>
        /// <param name="width">The width of the RenderTexture.</param>
        /// <param name="height">The height of the RenderTexture.</param>
        /// <param name="format">The <see cref="RenderTextureFormat"/> of the RenderTexture.</param>
        /// <param name="depth">The depth of the RenderTexture.</param>
        /// <param name="mipCount">The mip count of the RenderTexture. Default is <c>0</c>.</param>
        /// <param name="srgb">The flag that determines whether RenderTextures created using this descriptor are in sRGB or Linear space.</param>
        /// <returns>Returns a RenderTextureDescriptor object.</returns>
        /// <seealso cref="GetDescriptor"/>
        public static RenderTextureDescriptor GetDescriptorRW(int width, int height, int depth, GraphicsFormat format, int mipCount = 0, bool srgb = false)
        {
            var desc = GetDescriptor(width, height, depth, format, mipCount, srgb);
            desc.enableRandomWrite = true;
            return desc;
        }

        /// <summary>Gets a RenderTextureDescriptor set up for <see cref="RenderTexture"/> operations on GPU.</summary>
        /// <param name="width">The width of the RenderTexture.</param>
        /// <param name="height">The height of the RenderTexture.</param>
        /// <param name="format">The <see cref="RenderTextureFormat"/> of the RenderTexture.</param>
        /// <param name="depth">The depth of the RenderTexture.</param>
        /// <param name="mipCount">The mip count of the RenderTexture. Default is <c>0</c>.</param>
        /// <param name="srgb">The flag that determines whether RenderTextures created using this descriptor are in sRGB or Linear space.</param>
        /// <returns>Returns a RenderTextureDescriptor object.</returns>
        public static RenderTextureDescriptor GetDescriptor(int width, int height, int depth, GraphicsFormat format, int mipCount = 0, bool srgb = false)
        {
            var desc = new RenderTextureDescriptor(width, height, format, depth)
            {
                sRGB = srgb,
                mipCount = mipCount,
                useMipMap = mipCount != 0,
            };

            return desc;
        }

        private static RTHandle GetHandle(RenderTextureDescriptor desc, bool isTemp)
        {
            CheckAgeCheck();

            if (isTemp)
                s_TempHandleCount++;
            else
                s_CreatedHandleCount++;

            var handle = new RTHandle();
            handle.SetRenderTexture(isTemp ? RenderTexture.GetTemporary(desc) : new RenderTexture(desc), isTemp);
            AddLogForHandle(handle);

            return handle;
        }

        /// <summary>
        /// Gets an <see cref="RTHandle"/> for a <see cref="RenderTexture"/> acquired with <see cref="RenderTexture.GetTemporary"/>.
        /// </summary>
        /// <remarks>Use <see cref="RTUtils.Release"/> to release the RTHandle.</remarks>
        /// <param name="desc">RenderTextureDescriptor for the RenderTexture.</param>
        /// <returns>Returns a temporary RTHandle.</returns>
        /// <seealso cref="RenderTextureDescriptor"/>
        public static RTHandle GetTempHandle(RenderTextureDescriptor desc)
        {
            return GetHandle(desc, true);
        }

        /// <summary>
        /// Gets an <see cref="RTHandle"/> for a <see cref="RenderTexture"/> acquired with <see cref="RenderTexture.GetTemporary"/>.
        /// </summary>
        /// <remarks>Use <see cref="RTUtils.Release"/> to release the RTHandle.</remarks>
        /// <param name="width">The width of the RenderTexture.</param>
        /// <param name="height">The height of the RenderTexture.</param>
        /// <param name="depth">The depth of the RenderTexture.</param>
        /// <param name="format">The format of the RenderTexture.</param>
        /// <returns>Returns a temporary RTHandle.</returns>
        public static RTHandle GetTempHandle(int width, int height, int depth, GraphicsFormat format)
        {
            return GetHandle(GetDescriptor(width, height, depth, format), true);
        }

        /// <summary>
        /// Gets an <see cref="RTHandle"/> for a <see cref="RenderTexture"/> acquired with <c>new RenderTexture(desc)</c>.
        /// </summary>
        /// <param name="desc">The <c>RenderTextureDescriptor</c> for the RenderTexture.</param>
        /// <returns>Returns an RTHandle.</returns>
        /// <seealso cref="RenderTextureDescriptor"/>
        public static RTHandle GetNewHandle(RenderTextureDescriptor desc)
        {
            return GetHandle(desc, false);
        }

        /// <summary>
        /// Gets an <see cref="RTHandle"/> for a <see cref="RenderTexture"/> acquired with <c>new RenderTexture(desc)</c>.
        /// </summary>
        /// <remarks>Use <see cref="RTUtils.Release"/> to release the RTHandle.</remarks>
        /// <param name="width">The width of the RenderTexture.</param>
        /// <param name="height">The height of the RenderTexture.</param>
        /// <param name="depth">The depth of the RenderTexture.</param>
        /// <param name="format">The format of the RenderTexture.</param>
        /// <returns>Returns an RTHandle.</returns>
        public static RTHandle GetNewHandle(int width, int height, int depth, GraphicsFormat format)
        {
            return GetHandle(GetDescriptor(width, height, depth, format), false);
        }

        /// <summary>
        /// Releases the <see cref="RenderTexture"/> resource associated with the specified <see cref="RTHandle"/>.
        /// </summary>
        /// <param name="handle">The RTHandle from which to release RenderTexture resources.</param>
        /// <seealso cref="RenderTexture.ReleaseTemporary"/>
        public static void Release(RTHandle handle)
        {
            if (handle.RT == null)
                return;

            if (!s_Logs.ContainsKey(handle))
                throw new InvalidOperationException("Attemping to release a RTHandle that is not currently tracked by the system. This should never happen");

            var log = s_Logs[handle];
            s_Logs.Remove(handle);
            log.Frames = 0;
            log.StackTrace = null;

            s_LogPool.Push(log);

            if (handle.IsTemp)
            {
                --s_TempHandleCount;
                RenderTexture.ReleaseTemporary(handle.RT);
            }
            else
            {
                --s_CreatedHandleCount;
                handle.RT.Release();
                Destroy(handle.RT);
            }

            CheckAgeCheck();
        }

        /// <summary>
        /// Destroys a <see cref="RenderTexture"/> created using <c>new RenderTexture()</c>.
        /// </summary>
        /// <param name="rt">The RenderTexture to destroy.</param>
        /// <seealso cref="UObject.Destroy"/>
        /// <seealso cref="UObject.DestroyImmediate"/>
        public static void Destroy(RenderTexture rt)
        {
            if (rt == null)
                return;

#if UNITY_EDITOR
            if (Application.isPlaying)
                UObject.Destroy(rt);
            else
                UObject.DestroyImmediate(rt);
#else
            UObject.Destroy(rt);
#endif
        }

        /// <summary>
        /// Gets the number of <see cref="RTHandle"/>s that have been requested and not released yet.
        /// </summary>
        /// <returns>Returns the number of RTHandles that have been requested and not released.</returns>
        public static int GetHandleCount() => s_Logs.Count;
    }

    /// <summary>
    /// Provides utility methods for Terrain.
    /// </summary>
    public static class Utility
    {
        static Material m_DefaultPreviewMat = null;


        /// <summary>
        /// Retrieves the default preview <see cref="Material"/> for painting on Terrains.
        /// </summary>
        /// <param name="filtersPreviewEnabled">Whether the filter preview is enabled.</param>
        /// <returns>Returns Terrain painting's default preview <see cref="Material"/>.</returns>
        public static Material GetDefaultPreviewMaterial(bool filtersPreviewEnabled = false)
        {
            if (m_DefaultPreviewMat == null)
            {
                m_DefaultPreviewMat = new Material(Shader.Find("Hidden/TerrainTools/BrushPreview"));
            }

            SetMaterialKeyword(m_DefaultPreviewMat, FilterUtility.filterPreviewKeyword, filtersPreviewEnabled);

            //set defaults for uniforms in the shader
            m_DefaultPreviewMat.SetFloat("_HoleStripeThreshold", 1.0f/255.0f);
            m_DefaultPreviewMat.SetFloat("_UseAltColor", 0.0f);
            m_DefaultPreviewMat.SetFloat("_IsPaintHolesTool", 0.0f);
            
            return m_DefaultPreviewMat;
        }

        static Material m_PaintHeightMat;
        /// <summary>
        /// Gets the paint height material to render builtin brush passes. 
        /// </summary>
        /// <remarks>
        /// This material overrides the Builtin PaintHeight shader with Terrain Tools version of PaintHeight.
        /// See <see cref="TerrainBuiltinPaintMaterialPasses"/> for the available passes to choose from.
        /// See "/com.unity.terrain-tools/Shaders/PaintHeight.shader" for the override PaintHeight shader.
        /// </remarks>
        /// <returns>Material with the Paint Height shader </returns>
        public static Material GetPaintHeightMaterial()
        {
            if (m_PaintHeightMat == null)
            {
                m_PaintHeightMat = new Material(Shader.Find("Hidden/TerrainEngine/PaintHeightTool"));
            }
            return m_PaintHeightMat;
        }

        private static Material m_TexelValidityMaterial;
        private static Material GetTexelValidityMaterial()
        {
            if (m_TexelValidityMaterial == null)
            {
                m_TexelValidityMaterial = new Material(Shader.Find("Hidden/TerrainTools/TexelValidityBlit"));
            }

            return m_TexelValidityMaterial;
        }

        /// <summary>
        /// Prepares the passed in <see cref="Material"/> for painting on Terrains.
        /// </summary>
        /// <param name="paintContext">The painting context data.</param>
        /// <param name="brushTransform">The brush's transformation data.</param>
        /// <param name="material">The material being used for painting on Terrains.</param>
        /// <seealso cref="PaintContext"/>
        /// <seealso cref="BrushTransform"/>
        public static void SetupMaterialForPainting(PaintContext paintContext, BrushTransform brushTransform, Material material)
        {
            TerrainPaintUtility.SetupTerrainToolMaterialProperties(paintContext, brushTransform, material);

            material.SetVector("_Heightmap_Tex",
                new Vector4(
                    1f / paintContext.targetTextureWidth,
                    1f / paintContext.targetTextureHeight,
                    paintContext.targetTextureWidth,
                    paintContext.targetTextureHeight)
            );

            material.SetVector("_PcPixelRect",
                new Vector4(paintContext.pixelRect.x,
                    paintContext.pixelRect.y,
                    paintContext.pixelRect.width,
                    paintContext.pixelRect.height)
            );

            material.SetVector("_PcUvVectors",
                new Vector4(paintContext.pixelRect.x / (float)paintContext.targetTextureWidth,
                            paintContext.pixelRect.y / (float)paintContext.targetTextureHeight,
                            paintContext.pixelRect.width / (float)paintContext.targetTextureWidth,
                            paintContext.pixelRect.height / (float)paintContext.targetTextureHeight)
            );
        }

        /// <summary>
        /// Prepares the passed in <see cref="Material"/> for painting on Terrains while checking for Texel Validity.
        /// </summary>
        /// <param name="paintContext">The painting context data.</param>
        /// <param name="texelCtx">The texel context data.</param>
        /// <param name="brushTransform">The brush's transformation data.</param>
        /// <param name="material">The material being used for painting on Terrains.</param>
        /// <seealso cref="PaintContext"/>
        /// <seealso cref="BrushTransform"/>
        public static void SetupMaterialForPaintingWithTexelValidityContext(PaintContext paintContext, PaintContext texelCtx, BrushTransform brushTransform, Material material)
        {
            SetupMaterialForPainting(paintContext, brushTransform, material);
            material.SetTexture("_PCValidityTex", texelCtx.sourceRenderTexture);
        }

        /// <summary>
        /// Retrieves texel context data used for checking texel validity.
        /// </summary>
        /// <param name="terrain"></param>
        /// <param name="boundsInTerrainSpace"></param>
        /// <param name="extraBorderPixels"></param>
        /// <returns>Returns the <see cref="PaintContext"/> object used for checking texel validity.</returns>
        public static PaintContext CollectTexelValidity(Terrain terrain, Rect boundsInTerrainSpace, int extraBorderPixels = 0)
        {
            var res = terrain.terrainData.heightmapResolution;
            // use holes format because we really only need to know if the texel value is 0 or 1
            var ctx = PaintContext.CreateFromBounds(terrain, boundsInTerrainSpace, res, res, extraBorderPixels);
            ctx.CreateRenderTargets(Terrain.holesRenderTextureFormat);
            ctx.Gather(
                t => t.terrain.terrainData.heightmapTexture, // just provide heightmap texture. no need to create a temp one
                new Color(0, 0, 0, 0),
                blitMaterial: GetTexelValidityMaterial()
            );

            return ctx;
        }

        /// <summary>
        /// Converts data from a <see cref="AnimationCurve"/> into a <see cref="Texture2D"/>
        /// </summary>
        /// <param name="curve">The <see cref="AnimationCurve"/> to convert from.</param>
        /// <param name="tex">The <see cref="Texture2D"/> to convert data into.</param>
        /// <returns>Returns the range of the <see cref="AnimationCurve"/>.</returns>
        public static Vector2 AnimationCurveToRenderTexture(AnimationCurve curve, ref Texture2D tex)
        {
            //assume this a 1D texture that has already been created
            tex.wrapMode = TextureWrapMode.Clamp;
            tex.filterMode = FilterMode.Bilinear;

            float val = curve.Evaluate(0.0f);
            Vector2 range = new Vector2(val, val);

            Color[] pixels = new Color[tex.width * tex.height];
            pixels[0].r = val;
            for (int i = 1; i < tex.width; i++)
            {
                float pct = (float)i / (float)tex.width;
                pixels[i].r = curve.Evaluate(pct);
                range[0] = Mathf.Min(range[0], pixels[i].r);
                range[1] = Mathf.Max(range[1], pixels[i].r);
            }
            tex.SetPixels(pixels);
            tex.Apply();

            return range;
        }

        /// <summary>
        /// Sets and Generates the filter <see cref="RenderTexture"/> for transformation brushes and bind the texture to the provided Material.
        /// </summary>
        /// <param name="commonUI">The brush's commonUI group.</param>
        /// <param name="sourceRenderTexture">The <see cref="RenderTexture"/> designated as the source.</param>
        /// <param name="destinationRenderTexture">The <see cref="RenderTexture"/> designated as the destination.</param>
        /// <param name="mat">The <see cref="Material"/> to update.</param>
        /// <seealso cref="FilterStack"/>
        /// <seealso cref="FilterContext"/>
        public static void GenerateAndSetFilterRT(IBrushUIGroup commonUI, RenderTexture sourceRenderTexture, RenderTexture destinationRenderTexture, Material mat)
        {
            commonUI.GenerateBrushMask(sourceRenderTexture, destinationRenderTexture);
            mat.SetTexture("_FilterTex", destinationRenderTexture);
        }

        /// <summary>
        /// Enable or disable the keyword for the provided Material instance
        /// </summary>
        /// <param name="mat">The material to set.</param>
        /// <param name="keyword">The keyword to enable and disable.</param>
        /// <param name="enabled">Whether to enable or disable the keyword of the material.</param>
        public static void SetMaterialKeyword(Material mat, string keyword, bool enabled)
        {
            if(enabled)
            {
                mat.EnableKeyword(keyword);
            }
            else
            {
                mat.DisableKeyword(keyword);
            }
        }
    }

    /// <summary>
    /// Provides mesh utility methods for Terrain.
    /// </summary>
    public static class MeshUtils
    {
        /// <summary>
        /// Sets which shader pass to use when rendering the <see cref="RenderTopdownProjection"/>.
        /// </summary>
        public enum ShaderPass
        {
            /// <summary>
            /// Height shader pass.
            /// </summary>
            Height = 0,
            /// <summary>
            /// Mask shader pass.
            /// </summary>
            Mask = 1,
        }

        private static Material m_defaultProjectionMaterial;
        /// <summary>
        /// Gets the default projection <see cref="Material"/>.
        /// </summary>
        public static Material defaultProjectionMaterial {
            get
            {
                if (m_defaultProjectionMaterial == null)
                {
                    m_defaultProjectionMaterial = new Material(Shader.Find("Hidden/TerrainTools/MeshUtility"));
                }

                return m_defaultProjectionMaterial;
            }
        }
        
        /// <summary>
        /// Converts a <see cref="Matrix4x4"/> into a <see cref="Quaternion"/>.
        /// </summary>
        /// <param name="m">The <see cref="Matrix4x4"/> to convert from.</param>
        /// <returns>Returns a converted <see cref="Quaternion"/>.</returns>
        public static Quaternion QuaternionFromMatrix(Matrix4x4 m)
        {
            // Adapted from: http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
            Quaternion q = new Quaternion();
            q.w = Mathf.Sqrt(Mathf.Max(0, 1 + m[0, 0] + m[1, 1] + m[2, 2])) / 2;
            q.x = Mathf.Sqrt(Mathf.Max(0, 1 + m[0, 0] - m[1, 1] - m[2, 2])) / 2;
            q.y = Mathf.Sqrt(Mathf.Max(0, 1 - m[0, 0] + m[1, 1] - m[2, 2])) / 2;
            q.z = Mathf.Sqrt(Mathf.Max(0, 1 - m[0, 0] - m[1, 1] + m[2, 2])) / 2;
            q.x *= Mathf.Sign(q.x * (m[2, 1] - m[1, 2]));
            q.y *= Mathf.Sign(q.y * (m[0, 2] - m[2, 0]));
            q.z *= Mathf.Sign(q.z * (m[1, 0] - m[0, 1]));
            return q;
        }

        /// <summary>
        /// Transforms a <see cref="Bounds"/>.
        /// </summary>
        /// <param name="m">The transformation <see cref="Matrix4x4"/>.</param>
        /// <param name="bounds">The <see cref="Bounds"/> to transform.</param>
        /// <returns>Returns the transformed <see cref="Bounds"/>.</returns>
        public static Bounds TransformBounds(Matrix4x4 m, Bounds bounds)
        {
            Vector3[] points = new Vector3[8];

            // get points for each corner of the bounding box
            points[0] = new Vector3(bounds.max.x, bounds.max.y, bounds.max.z);
            points[1] = new Vector3(bounds.min.x, bounds.max.y, bounds.max.z);
            points[2] = new Vector3(bounds.max.x, bounds.min.y, bounds.max.z);
            points[3] = new Vector3(bounds.max.x, bounds.max.y, bounds.min.z);
            points[4] = new Vector3(bounds.min.x, bounds.min.y, bounds.max.z);
            points[5] = new Vector3(bounds.min.x, bounds.min.y, bounds.min.z);
            points[6] = new Vector3(bounds.max.x, bounds.min.y, bounds.min.z);
            points[7] = new Vector3(bounds.min.x, bounds.max.y, bounds.min.z);

            Vector3 min = Vector3.one * float.PositiveInfinity;
            Vector3 max = Vector3.one * float.NegativeInfinity;

            for (int i = 0; i < points.Length; ++i)
            {
                Vector3 p = m.MultiplyPoint(points[i]);

                // update min values
                if (p.x < min.x)
                {
                    min.x = p.x;
                }

                if (p.y < min.y)
                {
                    min.y = p.y;
                }

                if (p.z < min.z)
                {
                    min.z = p.z;
                }

                // update max values
                if (p.x > max.x)
                {
                    max.x = p.x;
                }

                if (p.y > max.y)
                {
                    max.y = p.y;
                }

                if (p.z > max.z)
                {
                    max.z = p.z;
                }
            }

            return new Bounds() { max = max, min = min };
        }

        private static string GetPrettyVectorString(Vector3 v)
        {
            return string.Format("( {0}, {1}, {2} )", v.x, v.y, v.z);
        }

        /// <summary>
        /// Renders the top down projection of a <see cref="Mesh"/> into a <see cref="RenderTexture"/>.
        /// </summary>
        /// <param name="mesh">The <see cref="Mesh"/> to render.</param>
        /// <param name="model">The transformation <see cref="Matrix4x4"/>.</param>
        /// <param name="destination">The <see cref="RenderTexture"/> designated as the destination.</param>
        /// <param name="mat">The <see cref="Material"/> to update.</param>
        /// <param name="pass">The <see cref="ShaderPass"/> to use.</param>
        public static void RenderTopdownProjection(Mesh mesh, Matrix4x4 model, RenderTexture destination, Material mat, ShaderPass pass)
        {
            RenderTexture prev = RenderTexture.active;
            RenderTexture.active = destination;

            Bounds modelBounds = TransformBounds(model, mesh.bounds);

            float nearPlane = (modelBounds.max.y - modelBounds.center.y) * 4;
            float farPlane = (modelBounds.min.y - modelBounds.center.y);

            Vector3 viewFrom = new Vector3(modelBounds.center.x, modelBounds.center.z, -modelBounds.center.y);
            Vector3 viewTo = viewFrom + Vector3.down;
            Vector3 viewUp = Vector3.forward;

            //             Debug.Log(
            // $@"Bounds =
            // [
            //     center: { modelBounds.center }
            //     max: { modelBounds.max }
            //     extents: { modelBounds.extents }
            // ]
            // nearPlane: { nearPlane }
            // farPlane: { farPlane }
            // diff: { nearPlane - farPlane }
            // view: [ from = { GetPrettyVectorString( viewFrom ) }, to = { GetPrettyVectorString( viewTo ) }, up = { GetPrettyVectorString( viewUp ) } ]"
            //             );

            // reset the view to accomodate for the transformed bounds
            Matrix4x4 view = Matrix4x4.LookAt(viewFrom, viewTo, viewUp);
            Matrix4x4 proj = Matrix4x4.Ortho(-1, 1, -1, 1, nearPlane, farPlane);
            Matrix4x4 mvp = proj * view * model;

            GL.Clear(true, true, Color.black);

            mat.SetMatrix("_Matrix_M", model);
            mat.SetMatrix("_Matrix_MV", view * model);
            mat.SetMatrix("_Matrix_MVP", mvp);

            mat.SetPass((int)pass);
            GL.PushMatrix();
            {
                Graphics.DrawMeshNow(mesh, Matrix4x4.identity);
            }
            GL.PopMatrix();

            RenderTexture.active = prev;
        }
    }
}