242 lines
9.7 KiB
C#
242 lines
9.7 KiB
C#
//======= Copyright (c) Stereolabs Corporation, All rights reserved. ===============
|
|
|
|
using UnityEngine;
|
|
using UnityEngine.Rendering;
|
|
/// <summary>
|
|
/// Helper functions for the post processing effects applied to the final mixed reality image.
|
|
/// Used by ZEDRenderingPlane when Post-Processing is enabled, and always used by GreenScreenManager.
|
|
/// </summary>
|
|
public class ZEDPostProcessingTools
|
|
{
|
|
/// <summary>
|
|
/// Cached property ID for _horizontal. Use horizontalPropertyID property instead.
|
|
/// </summary>
|
|
private static int? _horizpropID;
|
|
/// <summary>
|
|
/// Cached shader ID for "_horizontal" property, to optimize shader assignment.
|
|
/// We do this since this is a property we may set every frame.
|
|
/// </summary>
|
|
private static int horizontalPropertyID
|
|
{
|
|
get
|
|
{
|
|
if (_horizpropID == null)
|
|
{
|
|
_horizpropID = Shader.PropertyToID("horizontal");
|
|
}
|
|
return (int)_horizpropID;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the gaussian value for f(x) = (1/2*3.14*s)*e(-x*x/(2*s)).
|
|
/// </summary>
|
|
/// <param name="x"></param>
|
|
/// <param name="sigma"></param>
|
|
/// <returns></returns>
|
|
public static float Gaussian(float x, float sigma)
|
|
{
|
|
return (1.0f / (2.0f * Mathf.PI * sigma)) * Mathf.Exp(-((x * x) / (2.0f * sigma)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes weights to be sent to the blur shader.
|
|
/// </summary>
|
|
/// <param name="sigma"></param>
|
|
/// <param name="weights_"></param>
|
|
/// <param name="offsets_"></param>
|
|
public static void ComputeWeights(float sigma, out float[] weights_, out float[] offsets_)
|
|
{
|
|
float[] weights = new float[5];
|
|
float[] offsets = { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f };
|
|
|
|
weights_ = new float[5];
|
|
offsets_ = new float[5] { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f };
|
|
|
|
// Calculate the weights
|
|
weights[0] = Gaussian(0, sigma);
|
|
if (sigma != 0)
|
|
{
|
|
float sum = weights[0];
|
|
for (int i = 1; i < 5; ++i)
|
|
{
|
|
weights[i] = Gaussian(offsets[i], sigma);
|
|
sum += 2.0f * weights[i];
|
|
}
|
|
|
|
for (int i = 0; i < 5; ++i)
|
|
{
|
|
weights[i] /= sum;
|
|
}
|
|
|
|
//Fix for just 3 fetches
|
|
weights_[0] = weights[0];
|
|
weights_[1] = weights[1] + weights[2];
|
|
weights_[2] = weights[3] + weights[4];
|
|
|
|
offsets_[0] = 0.0f;
|
|
offsets_[1] = ((weights[1] * offsets[1]) + (weights[2] * offsets[2])) / weights_[1];
|
|
offsets_[2] = ((weights[3] * offsets[3]) + (weights[4] * offsets[4])) / weights_[2];
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// Blurs a render texture.
|
|
/// </summary>
|
|
/// <param name="source">Source RenderTexture.</param>
|
|
/// <param name="dest">RenderTexture that the blurred version will be rendered into.</param>
|
|
/// <param name="mat">Material used to blur.</param>
|
|
/// <param name="pass">The pass used by the material.</param>
|
|
/// <param name="numberIterations">More iterations means a more prominent blur.</param>
|
|
/// <param name="downscale">The downscale of the source, which increases blur and decreases computation time.</param>
|
|
public static void Blur(RenderTexture source, RenderTexture dest, Material mat, int pass, int numberIterations = -1, int downscale = 2)
|
|
{
|
|
if (numberIterations == -1 || numberIterations == 0)
|
|
{
|
|
Graphics.Blit(source, dest, mat, pass);
|
|
return;
|
|
}
|
|
|
|
RenderTexture buffer = RenderTexture.GetTemporary(source.width / downscale, source.height / downscale, source.depth, source.format, RenderTextureReadWrite.Default);
|
|
|
|
if (mat == null)
|
|
{
|
|
Graphics.Blit(source, buffer);
|
|
Graphics.Blit(buffer, dest);
|
|
}
|
|
else
|
|
{
|
|
bool oddEven = false;
|
|
|
|
//Create two buffers to make a multi-pass blur.
|
|
RenderTexture buffer2 = RenderTexture.GetTemporary(source.width / downscale, source.height / downscale, source.depth, source.format, RenderTextureReadWrite.Default);
|
|
|
|
|
|
Graphics.Blit(source, buffer);
|
|
//To each pass, alternate the buffer, and set the blur direction.
|
|
for (int i = 0; i < numberIterations * 2; i++)
|
|
{
|
|
//mat.SetInt("horizontal", System.Convert.ToInt32(oddEven));
|
|
mat.SetInt(horizontalPropertyID, System.Convert.ToInt32(oddEven));
|
|
if (i < numberIterations * 2 - 1)
|
|
{
|
|
Graphics.Blit(oddEven ? buffer2 : buffer, !oddEven ? buffer2 : buffer, mat, pass);
|
|
oddEven = !oddEven;
|
|
}
|
|
else
|
|
{
|
|
//mat.SetInt("horizontal", System.Convert.ToInt32(oddEven));
|
|
mat.SetInt(horizontalPropertyID, System.Convert.ToInt32(oddEven));
|
|
|
|
//Copy the buffer to the final texture.
|
|
if (oddEven)
|
|
{
|
|
Graphics.Blit(buffer2, dest, mat, pass);
|
|
}
|
|
else
|
|
{
|
|
Graphics.Blit(buffer, dest, mat, pass);
|
|
}
|
|
}
|
|
}
|
|
//Destroy all the temporary buffers.
|
|
RenderTexture.ReleaseTemporary(buffer2);
|
|
}
|
|
RenderTexture.ReleaseTemporary(buffer);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Holds IDs of shader properties. Used because setting a property by ID is faster than
|
|
/// setting it by a property name.
|
|
/// </summary>
|
|
static class Uniforms
|
|
{
|
|
internal static readonly int _MainTex = Shader.PropertyToID("_MainTex");
|
|
internal static readonly int _TempRT = Shader.PropertyToID("_TempRT");
|
|
internal static readonly int _TempRT2 = Shader.PropertyToID("_TempRT2");
|
|
internal static readonly int _TempRT3 = Shader.PropertyToID("_TempRT3");
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Blurs a render texture.
|
|
/// </summary>
|
|
/// <param name="cb">CommandBuffer from where the rendertexture is taken.</param>
|
|
/// <param name="dest">RenderTexture to be blurred.</param>
|
|
/// <param name="mat">Material used to blur</param>
|
|
/// <param name="pass">The pass used by the material</param>
|
|
/// <param name="numberIterations">More iterations means a more prominent blur</param>
|
|
/// <param name="downscale">The downscale of the source, which increases blur and decreases computation time.</param>
|
|
public static void Blur(CommandBuffer cb, RenderTexture texture, Material mat, int pass, int numberIterations = -1, int downscale = 2)
|
|
{
|
|
|
|
if (numberIterations == -1 || numberIterations == 0)
|
|
{
|
|
cb.GetTemporaryRT(Uniforms._TempRT, texture.width, texture.height, texture.depth);
|
|
cb.Blit(texture, Uniforms._TempRT, mat, pass);
|
|
cb.Blit(Uniforms._TempRT, texture);
|
|
cb.ReleaseTemporaryRT(Uniforms._TempRT);
|
|
return;
|
|
}
|
|
|
|
cb.GetTemporaryRT(Uniforms._TempRT, texture.width / downscale, texture.height / downscale, texture.depth, FilterMode.Bilinear, texture.format, RenderTextureReadWrite.Default);
|
|
cb.GetTemporaryRT(Uniforms._TempRT2, texture.width / downscale, texture.height / downscale, texture.depth, FilterMode.Bilinear, texture.format, RenderTextureReadWrite.Default);
|
|
|
|
bool oddEven = false;
|
|
|
|
//Create two buffers to make a multi-pass blur
|
|
cb.Blit(texture, Uniforms._TempRT);
|
|
//To each pass alternate the buffer, and set the blur direction
|
|
for (int i = 0; i < numberIterations * 2; i++)
|
|
{
|
|
//mat.SetInt("horizontal", System.Convert.ToInt32(oddEven));
|
|
mat.SetInt(horizontalPropertyID, System.Convert.ToInt32(oddEven));
|
|
if (i < numberIterations * 2 - 1)
|
|
{
|
|
cb.Blit(oddEven ? Uniforms._TempRT2 : Uniforms._TempRT, !oddEven ? Uniforms._TempRT2 : Uniforms._TempRT, mat, pass);
|
|
oddEven = !oddEven;
|
|
}
|
|
else
|
|
{
|
|
//mat.SetInt("horizontal", System.Convert.ToInt32(oddEven));
|
|
mat.SetInt(horizontalPropertyID, System.Convert.ToInt32(oddEven));
|
|
|
|
//Copy the buffer to the final texture
|
|
if (oddEven)
|
|
{
|
|
cb.Blit(Uniforms._TempRT2, texture, mat, pass);
|
|
}
|
|
else
|
|
{
|
|
cb.Blit(Uniforms._TempRT, texture, mat, pass);
|
|
}
|
|
}
|
|
}
|
|
//Destroy all the temporary buffers
|
|
cb.ReleaseTemporaryRT(Uniforms._TempRT);
|
|
cb.ReleaseTemporaryRT(Uniforms._TempRT2);
|
|
}
|
|
|
|
public static void ComposeMask(CommandBuffer cb, RenderTexture mask, Material matStencilToMask, Material matComposeMask)
|
|
{
|
|
cb.GetTemporaryRT(Uniforms._TempRT, mask.width, mask.height, mask.depth, mask.filterMode, mask.format, RenderTextureReadWrite.Default);
|
|
cb.GetTemporaryRT(Uniforms._TempRT2, -1, -1, 24);
|
|
cb.Blit(mask, Uniforms._TempRT);
|
|
|
|
//This is fine, set up the target and clear.
|
|
cb.SetRenderTarget(Uniforms._TempRT2);
|
|
cb.ClearRenderTarget(false, true, Color.black);
|
|
|
|
//To keep the stencil in post process.
|
|
cb.SetRenderTarget(Uniforms._TempRT2, BuiltinRenderTextureType.CurrentActive);
|
|
cb.Blit(BuiltinRenderTextureType.CameraTarget, Uniforms._TempRT2, matStencilToMask);
|
|
|
|
//Compose the second mask retrieved in the forward pass. The shader should set the stencil to 148.
|
|
//cb.Blit(mask, Uniforms._TempRT);
|
|
cb.SetGlobalTexture("_Mask", Uniforms._TempRT);
|
|
// matComposeMask.set("_Mask", Uniforms._TempRT);
|
|
cb.Blit(Uniforms._TempRT2, mask, matComposeMask);
|
|
}
|
|
}
|