forked from BilalY/Rasagar
431 lines
16 KiB
C#
431 lines
16 KiB
C#
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;
|
|
}
|
|
}
|
|
}
|