//======= 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);
}
}