HX-PGS-AIM-Android/Library/PackageCache/com.unity.render-pipelines..../Runtime/Debugging/ShaderDebugPrintManager.cs

using System;
using System.Collections.Generic;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using UnityEngine.Assertions;

namespace UnityEngine.Rendering
{
    /// <summary>
    /// Internal development tool.
    /// Manages gpu-buffers for shader debug printing.
    /// </summary>

    public sealed class ShaderDebugPrintManager
    {
        private static readonly ShaderDebugPrintManager s_Instance = new ShaderDebugPrintManager();

        private const int k_FramesInFlight = 4;
        private const int k_MaxBufferElements = 1024 * 16; // Must match the shader size definition

        private List<GraphicsBuffer> m_OutputBuffers = new List<GraphicsBuffer>();

        private List<Rendering.AsyncGPUReadbackRequest> m_ReadbackRequests =
            new List<Rendering.AsyncGPUReadbackRequest>();

        // Cache Action to avoid delegate allocation
        private Action<AsyncGPUReadbackRequest> m_BufferReadCompleteAction;

        private int m_FrameCounter = 0;
        private bool m_FrameCleared = false;

        private string m_OutputLine = "";
        private Action<string> m_OutputAction;

        private static readonly int m_ShaderPropertyIDInputMouse = Shader.PropertyToID("_ShaderDebugPrintInputMouse");
        private static readonly int m_ShaderPropertyIDInputFrame = Shader.PropertyToID("_ShaderDebugPrintInputFrame");
        private static readonly int m_shaderDebugOutputData = Shader.PropertyToID("shaderDebugOutputData");

        // A static "container" for all profiler markers.
        private static class Profiling
        {
            // Uses nameof to avoid aliasing
            public static readonly ProfilingSampler BufferReadComplete = new ProfilingSampler($"{nameof(ShaderDebugPrintManager)}.{nameof(BufferReadComplete)}");
        }

        // Should match: com.unity.render-pipelines.core/ShaderLibrary/ShaderDebugPrint.hlsl
        enum DebugValueType
        {
            TypeUint = 1,
            TypeInt = 2,
            TypeFloat = 3,
            TypeUint2 = 4,
            TypeInt2 = 5,
            TypeFloat2 = 6,
            TypeUint3 = 7,
            TypeInt3 = 8,
            TypeFloat3 = 9,
            TypeUint4 = 10,
            TypeInt4 = 11,
            TypeFloat4 = 12,
            TypeBool = 13,
        };
        private const uint k_TypeHasTag = 128;

        private int DebugValueTypeToElemSize(DebugValueType type)
        {
            switch (type)
            {
                case DebugValueType.TypeUint:
                case DebugValueType.TypeInt:
                case DebugValueType.TypeFloat:
                case DebugValueType.TypeBool:
                    return 1;
                case DebugValueType.TypeUint2:
                case DebugValueType.TypeInt2:
                case DebugValueType.TypeFloat2:
                    return 2;
                case DebugValueType.TypeUint3:
                case DebugValueType.TypeInt3:
                case DebugValueType.TypeFloat3:
                    return 3;
                case DebugValueType.TypeUint4:
                case DebugValueType.TypeInt4:
                case DebugValueType.TypeFloat4:
                    return 4;
                default:
                    return 0;
            }
        }

        private ShaderDebugPrintManager()
        {
            for (int i = 0; i < k_FramesInFlight; i++)
            {
                m_OutputBuffers.Add(new GraphicsBuffer(GraphicsBuffer.Target.Structured, k_MaxBufferElements, 4));
                m_ReadbackRequests.Add(new Rendering.AsyncGPUReadbackRequest());
            }

            m_BufferReadCompleteAction = BufferReadComplete;
            m_OutputAction = DefaultOutput;
        }

        /// <summary>
        /// Get the current instance.
        /// </summary>
        public static ShaderDebugPrintManager instance => s_Instance;

        /// <summary>
        /// Set shader input constants.
        /// </summary>
        /// <param name="cmd">CommandBuffer to store the commands.</param>
        /// <param name="input">Input parameters for the constants.</param>
        public void SetShaderDebugPrintInputConstants(CommandBuffer cmd, ShaderDebugPrintInput input)
        {
            var mouse = new Vector4(input.pos.x, input.pos.y, input.leftDown ? 1 : 0, input.rightDown ? 1 : 0);
            cmd.SetGlobalVector(m_ShaderPropertyIDInputMouse, mouse);
            cmd.SetGlobalInt(m_ShaderPropertyIDInputFrame, m_FrameCounter);
        }

        /// <summary>
        /// Binds the gpu-buffers for current frame.
        /// </summary>
        /// <param name="cmd">CommandBuffer to store the commands.</param>
        public void SetShaderDebugPrintBindings(CommandBuffer cmd)
        {
            int index = m_FrameCounter % k_FramesInFlight;
            if (!m_ReadbackRequests[index].done)
            {
                // We shouldn't end up here too often
                m_ReadbackRequests[index].WaitForCompletion();
            }

            cmd.SetGlobalBuffer(m_shaderDebugOutputData, m_OutputBuffers[index]);

            ClearShaderDebugPrintBuffer();
        }

        private void ClearShaderDebugPrintBuffer()
        {
            // Only clear the buffer the first time this is called in each frame
            if (!m_FrameCleared)
            {
                int index = m_FrameCounter % k_FramesInFlight;
                NativeArray<uint> data = new NativeArray<uint>(1, Allocator.Temp);
                data[0] = 0;
                m_OutputBuffers[index].SetData(data, 0, 0, 1);
                m_FrameCleared = true;
            }
        }

        private void BufferReadComplete(Rendering.AsyncGPUReadbackRequest request)
        {
            using var profScope = new ProfilingScope(Profiling.BufferReadComplete);

            Assert.IsTrue(request.done);

            if (!request.hasError)
            {
                NativeArray<uint> data = request.GetData<uint>(0);

                uint count = data[0];

                if (count >= k_MaxBufferElements)
                {
                    count = k_MaxBufferElements;
                    // Shader print buffer is full, some data is lost!
                    Debug.LogWarning("Debug Shader Print Buffer Full!");
                }

                string newOutputLine = "";
                if (count > 0)
                    newOutputLine += "Frame #" + m_FrameCounter + ": ";

                unsafe // Need to do ugly casts via pointers
                {
                    uint* ptr = (uint*)data.GetUnsafePtr();
                    for (int i = 1; i < count;)
                    {
                        DebugValueType type = (DebugValueType)(data[i] & 0x0f);
                        bool hasTag = (data[i] & k_TypeHasTag) == k_TypeHasTag;

                        // ensure elem for tag after the header
                        if (hasTag && i + 1 < count)
                        {
                            uint tagEncoded = data[i + 1];
                            i++;

                            for (int j = 0; j < 4; j++)
                            {
                                char c = (char)(tagEncoded & 255);
                                // skip '\0', for low-level output (avoid string termination)
                                if (c == 0)
                                    continue;
                                newOutputLine += c;
                                tagEncoded >>= 8;
                            }

                            newOutputLine += " ";
                        }

                        // ensure elem for payload after the header/tag
                        int elemSize = DebugValueTypeToElemSize(type);
                        if (i + elemSize > count)
                            break;

                        i++; // [i] == payload

                        switch (type)
                        {
                            case DebugValueType.TypeUint:
                            {
                                newOutputLine += $"{data[i]}u";
                                break;
                            }
                            case DebugValueType.TypeInt:
                            {
                                int valueInt = *(int*)&ptr[i];
                                newOutputLine += valueInt;
                                break;
                            }
                            case DebugValueType.TypeFloat:
                            {
                                float valueFloat = *(float*)&ptr[i];
                                newOutputLine += $"{valueFloat}f";
                                break;
                            }
                            case DebugValueType.TypeUint2:
                            {
                                uint* valueUint2 = &ptr[i];
                                newOutputLine += $"uint2({valueUint2[0]}, {valueUint2[1]})";
                                break;
                            }
                            case DebugValueType.TypeInt2:
                            {
                                int* valueInt2 = (int*)&ptr[i];
                                newOutputLine += $"int2({valueInt2[0]}, {valueInt2[1]})";
                                break;
                            }
                            case DebugValueType.TypeFloat2:
                            {
                                float* valueFloat2 = (float*)&ptr[i];
                                newOutputLine += $"float2({valueFloat2[0]}, {valueFloat2[1]})";
                                break;
                            }
                            case DebugValueType.TypeUint3:
                            {
                                uint* valueUint3 = &ptr[i];
                                newOutputLine += $"uint3({valueUint3[0]}, {valueUint3[1]}, {valueUint3[2]})";
                                break;
                            }
                            case DebugValueType.TypeInt3:
                            {
                                int* valueInt3 = (int*)&ptr[i];
                                newOutputLine += $"int3({valueInt3[0]}, {valueInt3[1]}, {valueInt3[2]})";
                                break;
                            }
                            case DebugValueType.TypeFloat3:
                            {
                                float* valueFloat3 = (float*)&ptr[i];
                                newOutputLine += $"float3({valueFloat3[0]}, {valueFloat3[1]}, {valueFloat3[2]})";
                                break;
                            }
                            case DebugValueType.TypeUint4:
                            {
                                uint* valueUint4 = &ptr[i];
                                newOutputLine += $"uint4({valueUint4[0]}, {valueUint4[1]}, {valueUint4[2]}, {valueUint4[3]})";
                                break;
                            }
                            case DebugValueType.TypeInt4:
                            {
                                int* valueInt4 = (int*)&ptr[i];
                                newOutputLine += $"int4({valueInt4[0]}, {valueInt4[1]}, {valueInt4[2]}, {valueInt4[3]})";
                                break;
                            }
                            case DebugValueType.TypeFloat4:
                            {
                                float* valueFloat4 = (float*)&ptr[i];
                                newOutputLine += $"float4({valueFloat4[0]}, {valueFloat4[1]}, {valueFloat4[2]}, {valueFloat4[3]})";
                                break;
                            }
                            case DebugValueType.TypeBool:
                            {
                                newOutputLine += ((data[i] == 0) ? "False" : "True");
                                break;
                            }
                            default:
                                i = (int)count;  // Cannot handle the rest if there is an unknown type
                                break;
                        }

                        i += elemSize;

                        newOutputLine += " ";
                    }
                }

                if (count > 0)
                {
                    m_OutputLine = newOutputLine;
                    m_OutputAction(newOutputLine);
                }
            }
            else
            {
                const string errorMsg = "Error at read back!";
                m_OutputLine = errorMsg;
                m_OutputAction(errorMsg);
            }
        }

        /// <summary>
        /// Initiate async read-back of the GPU buffer to the CPU.
        /// Prepare a new GPU buffer for the next frame.
        /// </summary>
        public void EndFrame()
        {
            int index = m_FrameCounter % k_FramesInFlight;
            m_ReadbackRequests[index] = Rendering.AsyncGPUReadback.Request(m_OutputBuffers[index], m_BufferReadCompleteAction);

            m_FrameCounter++;
            m_FrameCleared = false;
        }

        /// <summary>
        /// Initiate synchronous read-back of the GPU buffer to the CPU and executes output action. By default prints to the debug log.
        /// </summary>
        public void PrintImmediate()
        {
            int index = m_FrameCounter % k_FramesInFlight;
            var request = Rendering.AsyncGPUReadback.Request(m_OutputBuffers[index]);
            request.WaitForCompletion();
            m_BufferReadCompleteAction(request);

            m_FrameCounter++;
            m_FrameCleared = false;
        }

        // Custom output API

        /// <summary>
        /// Get current print line.
        /// </summary>
        public string outputLine { get => m_OutputLine; }

        /// <summary>
        /// Action taken for each print line. By default prints to the debug log.
        /// </summary>
        public Action<string> outputAction { set => m_OutputAction = value; }

        /// <summary>
        /// The default output action. Print to the debug log.
        /// </summary>
        /// <param name="line">Line to be printed.</param>
        public void DefaultOutput(string line)
        {
            Debug.Log(line);
        }
    }

    /// <summary>
    /// Shader constant input parameters.
    /// </summary>
    public struct ShaderDebugPrintInput
    {
        // Mouse input for the shader

        /// <summary>
        /// Mouse position.
        /// GameView bottom-left == (0,0) top-right == (surface.width, surface.height) where surface == game display surface/rendertarget
        /// For screen pixel coordinates, game-view should be set to "Free Aspect".
        /// Works only in PlayMode.
        /// </summary>
        public Vector2 pos { get; set; }

        /// <summary>
        /// Left mouse button is pressed.
        /// </summary>
        public bool leftDown { get; set; }

        /// <summary>
        /// Right mouse button is pressed.
        /// </summary>
        public bool rightDown { get; set; }

        /// <summary>
        /// Middle mouse button is pressed.
        /// </summary>
        public bool middleDown { get; set; }

        /// <summary>
        /// Pretty print parameters for debug purposes.
        /// </summary>
        /// <returns>A string containing debug information</returns>
        // NOTE: Separate from ToString on purpose.
        public string String()
        {
            return $"Mouse: {pos.x}x{pos.y}  Btns: Left:{leftDown} Right:{rightDown} Middle:{middleDown} ";
        }
    }

    /// <summary>
    /// Reads system input to produce ShaderDebugPrintInput parameters.
    /// </summary>
    public static class ShaderDebugPrintInputProducer
    {
        /// <summary>
        /// Read system input.
        /// </summary>
        /// <returns>Input parameters for ShaderDebugPrintManager.</returns>
        static public ShaderDebugPrintInput Get()
        {
            var r = new ShaderDebugPrintInput();
#if ENABLE_LEGACY_INPUT_MANAGER
            r.pos = Input.mousePosition;
            r.leftDown = Input.GetMouseButton(0);
            r.rightDown = Input.GetMouseButton(1);
            r.middleDown = Input.GetMouseButton(2);
#endif
#if ENABLE_INPUT_SYSTEM && ENABLE_INPUT_SYSTEM_PACKAGE
            // NOTE: needs Unity.InputSystem asmdef reference.
            var mouse = InputSystem.Mouse.current;
            r.pos = mouse.position.ReadValue();
            r.leftDown = mouse.leftButton.isPressed;
            r.rightDown = mouse.rightButton.isPressed;
            r.middleDown = mouse.middleButton.isPressed;
#endif
            return r;
        }
    }
}