using System.Collections.Generic;
|
using UnityEngine.Rendering;
|
|
namespace UnityEngine.PostProcessing
|
{
|
using Mode = BuiltinDebugViewsModel.Mode;
|
|
public sealed class BuiltinDebugViewsComponent : PostProcessingComponentCommandBuffer<BuiltinDebugViewsModel>
|
{
|
static class Uniforms
|
{
|
internal static readonly int _DepthScale = Shader.PropertyToID("_DepthScale");
|
internal static readonly int _TempRT = Shader.PropertyToID("_TempRT");
|
internal static readonly int _Opacity = Shader.PropertyToID("_Opacity");
|
internal static readonly int _MainTex = Shader.PropertyToID("_MainTex");
|
internal static readonly int _TempRT2 = Shader.PropertyToID("_TempRT2");
|
internal static readonly int _Amplitude = Shader.PropertyToID("_Amplitude");
|
internal static readonly int _Scale = Shader.PropertyToID("_Scale");
|
}
|
|
const string k_ShaderString = "Hidden/Post FX/Builtin Debug Views";
|
|
enum Pass
|
{
|
Depth,
|
Normals,
|
MovecOpacity,
|
MovecImaging,
|
MovecArrows
|
}
|
|
ArrowArray m_Arrows;
|
|
class ArrowArray
|
{
|
public Mesh mesh { get; private set; }
|
|
public int columnCount { get; private set; }
|
public int rowCount { get; private set; }
|
|
public void BuildMesh(int columns, int rows)
|
{
|
// Base shape
|
var arrow = new Vector3[6]
|
{
|
new Vector3(0f, 0f, 0f),
|
new Vector3(0f, 1f, 0f),
|
new Vector3(0f, 1f, 0f),
|
new Vector3(-1f, 1f, 0f),
|
new Vector3(0f, 1f, 0f),
|
new Vector3(1f, 1f, 0f)
|
};
|
|
// make the vertex array
|
int vcount = 6 * columns * rows;
|
var vertices = new List<Vector3>(vcount);
|
var uvs = new List<Vector2>(vcount);
|
|
for (int iy = 0; iy < rows; iy++)
|
{
|
for (int ix = 0; ix < columns; ix++)
|
{
|
var uv = new Vector2(
|
(0.5f + ix) / columns,
|
(0.5f + iy) / rows
|
);
|
|
for (int i = 0; i < 6; i++)
|
{
|
vertices.Add(arrow[i]);
|
uvs.Add(uv);
|
}
|
}
|
}
|
|
// make the index array
|
var indices = new int[vcount];
|
|
for (int i = 0; i < vcount; i++)
|
indices[i] = i;
|
|
// initialize the mesh object
|
mesh = new Mesh { hideFlags = HideFlags.DontSave };
|
mesh.SetVertices(vertices);
|
mesh.SetUVs(0, uvs);
|
mesh.SetIndices(indices, MeshTopology.Lines, 0);
|
mesh.UploadMeshData(true);
|
|
// update the properties
|
columnCount = columns;
|
rowCount = rows;
|
}
|
|
public void Release()
|
{
|
GraphicsUtils.Destroy(mesh);
|
mesh = null;
|
}
|
}
|
|
public override bool active
|
{
|
get
|
{
|
return model.IsModeActive(Mode.Depth)
|
|| model.IsModeActive(Mode.Normals)
|
|| model.IsModeActive(Mode.MotionVectors);
|
}
|
}
|
|
public override DepthTextureMode GetCameraFlags()
|
{
|
var mode = model.settings.mode;
|
var flags = DepthTextureMode.None;
|
|
switch (mode)
|
{
|
case Mode.Normals:
|
flags |= DepthTextureMode.DepthNormals;
|
break;
|
case Mode.MotionVectors:
|
flags |= DepthTextureMode.MotionVectors | DepthTextureMode.Depth;
|
break;
|
case Mode.Depth:
|
flags |= DepthTextureMode.Depth;
|
break;
|
}
|
|
return flags;
|
}
|
|
public override CameraEvent GetCameraEvent()
|
{
|
return model.settings.mode == Mode.MotionVectors
|
? CameraEvent.BeforeImageEffects
|
: CameraEvent.BeforeImageEffectsOpaque;
|
}
|
|
public override string GetName()
|
{
|
return "Builtin Debug Views";
|
}
|
|
public override void PopulateCommandBuffer(CommandBuffer cb)
|
{
|
var settings = model.settings;
|
var material = context.materialFactory.Get(k_ShaderString);
|
material.shaderKeywords = null;
|
|
if (context.isGBufferAvailable)
|
material.EnableKeyword("SOURCE_GBUFFER");
|
|
switch (settings.mode)
|
{
|
case Mode.Depth:
|
DepthPass(cb);
|
break;
|
case Mode.Normals:
|
DepthNormalsPass(cb);
|
break;
|
case Mode.MotionVectors:
|
MotionVectorsPass(cb);
|
break;
|
}
|
|
context.Interrupt();
|
}
|
|
void DepthPass(CommandBuffer cb)
|
{
|
var material = context.materialFactory.Get(k_ShaderString);
|
var settings = model.settings.depth;
|
|
cb.SetGlobalFloat(Uniforms._DepthScale, 1f / settings.scale);
|
cb.Blit((Texture)null, BuiltinRenderTextureType.CameraTarget, material, (int)Pass.Depth);
|
}
|
|
void DepthNormalsPass(CommandBuffer cb)
|
{
|
var material = context.materialFactory.Get(k_ShaderString);
|
cb.Blit((Texture)null, BuiltinRenderTextureType.CameraTarget, material, (int)Pass.Normals);
|
}
|
|
void MotionVectorsPass(CommandBuffer cb)
|
{
|
#if UNITY_EDITOR
|
// Don't render motion vectors preview when the editor is not playing as it can in some
|
// cases results in ugly artifacts (i.e. when resizing the game view).
|
if (!Application.isPlaying)
|
return;
|
#endif
|
|
var material = context.materialFactory.Get(k_ShaderString);
|
var settings = model.settings.motionVectors;
|
|
// Blit the original source image
|
int tempRT = Uniforms._TempRT;
|
cb.GetTemporaryRT(tempRT, context.width, context.height, 0, FilterMode.Bilinear);
|
cb.SetGlobalFloat(Uniforms._Opacity, settings.sourceOpacity);
|
cb.SetGlobalTexture(Uniforms._MainTex, BuiltinRenderTextureType.CameraTarget);
|
cb.Blit(BuiltinRenderTextureType.CameraTarget, tempRT, material, (int)Pass.MovecOpacity);
|
|
// Motion vectors (imaging)
|
if (settings.motionImageOpacity > 0f && settings.motionImageAmplitude > 0f)
|
{
|
int tempRT2 = Uniforms._TempRT2;
|
cb.GetTemporaryRT(tempRT2, context.width, context.height, 0, FilterMode.Bilinear);
|
cb.SetGlobalFloat(Uniforms._Opacity, settings.motionImageOpacity);
|
cb.SetGlobalFloat(Uniforms._Amplitude, settings.motionImageAmplitude);
|
cb.SetGlobalTexture(Uniforms._MainTex, tempRT);
|
cb.Blit(tempRT, tempRT2, material, (int)Pass.MovecImaging);
|
cb.ReleaseTemporaryRT(tempRT);
|
tempRT = tempRT2;
|
}
|
|
// Motion vectors (arrows)
|
if (settings.motionVectorsOpacity > 0f && settings.motionVectorsAmplitude > 0f)
|
{
|
PrepareArrows();
|
|
float sy = 1f / settings.motionVectorsResolution;
|
float sx = sy * context.height / context.width;
|
|
cb.SetGlobalVector(Uniforms._Scale, new Vector2(sx, sy));
|
cb.SetGlobalFloat(Uniforms._Opacity, settings.motionVectorsOpacity);
|
cb.SetGlobalFloat(Uniforms._Amplitude, settings.motionVectorsAmplitude);
|
cb.DrawMesh(m_Arrows.mesh, Matrix4x4.identity, material, 0, (int)Pass.MovecArrows);
|
}
|
|
cb.SetGlobalTexture(Uniforms._MainTex, tempRT);
|
cb.Blit(tempRT, BuiltinRenderTextureType.CameraTarget);
|
cb.ReleaseTemporaryRT(tempRT);
|
}
|
|
void PrepareArrows()
|
{
|
int row = model.settings.motionVectors.motionVectorsResolution;
|
int col = row * Screen.width / Screen.height;
|
|
if (m_Arrows == null)
|
m_Arrows = new ArrowArray();
|
|
if (m_Arrows.columnCount != col || m_Arrows.rowCount != row)
|
{
|
m_Arrows.Release();
|
m_Arrows.BuildMesh(col, row);
|
}
|
}
|
|
public override void OnDisable()
|
{
|
if (m_Arrows != null)
|
m_Arrows.Release();
|
|
m_Arrows = null;
|
}
|
}
|
}
|
