659 lines
30 KiB
C#
659 lines
30 KiB
C#
|
using System;
|
||
|
|
using UnityEngine.Rendering.RenderGraphModule;
|
||
|
|
using System.Runtime.CompilerServices; // AggressiveInlining
|
||
|
|
|
||
|
|
namespace UnityEngine.Rendering.Universal
|
||
|
|
{
|
||
|
|
internal sealed class UberPostProcessPass : PostProcessPass
|
||
|
|
{
|
||
|
|
Material m_Material;
|
||
|
|
Texture2D[] m_FilmGrainTextures;
|
||
|
|
|
||
|
|
public enum FilteringOperation
|
||
|
|
{
|
||
|
|
Linear,
|
||
|
|
Point
|
||
|
|
}
|
||
|
|
|
||
|
|
Texture m_DitherTexture;
|
||
|
|
RTHandle m_UserLut;
|
||
|
|
FilteringOperation m_FilteringOperation;
|
||
|
|
HDROutputUtils.Operation m_HdrOperations;
|
||
|
|
bool m_IsValid;
|
||
|
|
bool m_IsFinalPass;
|
||
|
|
bool m_RequireSRGBConversionBlit;
|
||
|
|
bool m_UseFastSRGBLinearConversion;
|
||
|
|
bool m_RenderOverlayUI;
|
||
|
|
|
||
|
|
public UberPostProcessPass(Shader shader, Texture2D[] filmGrainTextures)
|
||
|
|
{
|
||
|
|
this.renderPassEvent = RenderPassEvent.AfterRenderingPostProcessing - 1;
|
||
|
|
this.profilingSampler = new ProfilingSampler("Blit Post Processing");
|
||
|
|
|
||
|
|
m_Material = PostProcessUtils.LoadShader(shader, passName);
|
||
|
|
m_IsValid = m_Material != null;
|
||
|
|
m_FilmGrainTextures = filmGrainTextures;
|
||
|
|
}
|
||
|
|
|
||
|
|
public override void Dispose()
|
||
|
|
{
|
||
|
|
m_UserLut?.Release();
|
||
|
|
CoreUtils.Destroy(m_Material);
|
||
|
|
m_IsValid = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
public void Setup(Texture ditherTexture,
|
||
|
|
FilteringOperation filteringOperation,
|
||
|
|
HDROutputUtils.Operation hdrOperations,
|
||
|
|
bool requireSRGBConversionBlit,
|
||
|
|
bool useFastSRGBLinearConversion,
|
||
|
|
bool isFinalPass,
|
||
|
|
bool renderOverlayUI)
|
||
|
|
{
|
||
|
|
m_DitherTexture = ditherTexture;
|
||
|
|
m_FilteringOperation = filteringOperation;
|
||
|
|
m_HdrOperations = hdrOperations;
|
||
|
|
m_RequireSRGBConversionBlit = requireSRGBConversionBlit;
|
||
|
|
m_UseFastSRGBLinearConversion = useFastSRGBLinearConversion;
|
||
|
|
m_IsFinalPass = isFinalPass;
|
||
|
|
m_RenderOverlayUI = renderOverlayUI;
|
||
|
|
}
|
||
|
|
|
||
|
|
private class UberPostPassData
|
||
|
|
{
|
||
|
|
internal TextureHandle destinationTexture;
|
||
|
|
internal TextureHandle sourceTexture;
|
||
|
|
internal TextureHandle internalLutTexture;
|
||
|
|
|
||
|
|
internal Material material; // NOTE: material is a ref, pass instance is not re-entrant within a frame!
|
||
|
|
internal UniversalCameraData cameraData;
|
||
|
|
|
||
|
|
internal Tonemapping tonemapping;
|
||
|
|
internal FilteringOperation filteringOperation;
|
||
|
|
internal HDROutputUtils.Operation hdrOperations;
|
||
|
|
internal bool isHdrGrading;
|
||
|
|
|
||
|
|
internal LutParams lut;
|
||
|
|
internal BloomParams bloom;
|
||
|
|
internal LensDistortionParams lensDistortion;
|
||
|
|
internal ChromaticAberrationParams chromaticAberration;
|
||
|
|
internal VignetteParams vignette;
|
||
|
|
internal FilmGrainParams filmGrain;
|
||
|
|
internal DitheringParams dither;
|
||
|
|
|
||
|
|
internal bool isFinalPass;
|
||
|
|
internal bool useFastSRGBLinearConversion;
|
||
|
|
internal bool requireSRGBConversionBlit;
|
||
|
|
}
|
||
|
|
|
||
|
|
const string _CameraColorAfterPostProcessingName = "_CameraColorAfterPostProcessing";
|
||
|
|
|
||
|
|
/// <inheritdoc />
|
||
|
|
public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
|
||
|
|
{
|
||
|
|
if(!m_IsValid)
|
||
|
|
return;
|
||
|
|
|
||
|
|
var colorLookup = volumeStack.GetComponent<ColorLookup>();
|
||
|
|
var colorAdjustments = volumeStack.GetComponent<ColorAdjustments>();
|
||
|
|
var tonemapping = volumeStack.GetComponent<Tonemapping>();
|
||
|
|
var bloom = volumeStack.GetComponent<Bloom>();
|
||
|
|
var lensDistortion = volumeStack.GetComponent<LensDistortion>();
|
||
|
|
var chromaticAberration = volumeStack.GetComponent<ChromaticAberration>();
|
||
|
|
var vignette = volumeStack.GetComponent<Vignette>();
|
||
|
|
var filmGrain = volumeStack.GetComponent<FilmGrain>();
|
||
|
|
|
||
|
|
var cameraData = frameData.Get<UniversalCameraData>();
|
||
|
|
var postProcessingData = frameData.Get<UniversalPostProcessingData>();
|
||
|
|
var resourceData = frameData.Get<UniversalResourceData>();
|
||
|
|
|
||
|
|
var sourceTexture = resourceData.cameraColor;
|
||
|
|
var overlayUITexture = resourceData.overlayUITexture;
|
||
|
|
var internalColorLut = resourceData.internalColorLut;
|
||
|
|
var userColorLut = TryGetCachedUserLutTextureHandle(renderGraph, colorLookup);
|
||
|
|
var bloomTexture = resourceData.bloom;
|
||
|
|
|
||
|
|
TextureHandle destinationTexture;
|
||
|
|
if (resourceData.isActiveTargetBackBuffer)
|
||
|
|
{
|
||
|
|
destinationTexture = resourceData.backBufferColor;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
//Due to camera stacking we could be rendering to a persistent texture that is not the backbuffer
|
||
|
|
destinationTexture = resourceData.destinationCameraColor.IsValid() ?
|
||
|
|
resourceData.destinationCameraColor
|
||
|
|
//TODO here we don't seem to apply PostProcessUtils.CreateCompatibleTexture. This seems completely out of sync with the other post process passes.
|
||
|
|
//However, changing it, breaks some tests because rendering with the color and depth after this pass when MSAA is on leads to mismatch.
|
||
|
|
//It seems completely arbitrary that we continue to write out color with MSAA if no other pp pass has been applied earlier.
|
||
|
|
: renderGraph.CreateTexture(sourceTexture, _CameraColorAfterPostProcessingName);
|
||
|
|
resourceData.destinationCameraColor = TextureHandle.nullHandle;
|
||
|
|
}
|
||
|
|
|
||
|
|
using (var builder = renderGraph.AddRasterRenderPass<UberPostPassData>(passName, out var passData, profilingSampler))
|
||
|
|
{
|
||
|
|
var srcDesc = sourceTexture.GetDescriptor(renderGraph);
|
||
|
|
|
||
|
|
#if ENABLE_VR && ENABLE_XR_MODULE
|
||
|
|
if (cameraData.xr.enabled)
|
||
|
|
{
|
||
|
|
bool passSupportsFoveation = cameraData.xrUniversal.canFoveateIntermediatePasses || resourceData.isActiveTargetBackBuffer;
|
||
|
|
// This is a screen-space pass, make sure foveated rendering is disabled for non-uniform renders
|
||
|
|
passSupportsFoveation &= !Experimental.Rendering.XRSystem.foveatedRenderingCaps.HasFlag(FoveatedRenderingCaps.NonUniformRaster);
|
||
|
|
builder.EnableFoveatedRasterization(cameraData.xr.supportsFoveatedRendering && passSupportsFoveation);
|
||
|
|
|
||
|
|
// Apply MultiviewRenderRegionsCompatible flag only to the peripheral view in Quad Views
|
||
|
|
if (cameraData.xr.multipassId == 0)
|
||
|
|
{
|
||
|
|
builder.SetExtendedFeatureFlags(ExtendedFeatureFlags.MultiviewRenderRegionsCompatible);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
builder.AllowGlobalStateModification(true);
|
||
|
|
passData.destinationTexture = destinationTexture;
|
||
|
|
builder.SetRenderAttachment(destinationTexture, 0, AccessFlags.Write);
|
||
|
|
passData.sourceTexture = sourceTexture;
|
||
|
|
builder.UseTexture(sourceTexture, AccessFlags.Read);
|
||
|
|
|
||
|
|
if(m_RenderOverlayUI)
|
||
|
|
builder.UseTexture(overlayUITexture, AccessFlags.Read);
|
||
|
|
|
||
|
|
builder.UseTexture(internalColorLut, AccessFlags.Read);
|
||
|
|
if(userColorLut.IsValid())
|
||
|
|
builder.UseTexture(userColorLut, AccessFlags.Read);
|
||
|
|
|
||
|
|
if(bloomTexture.IsValid())
|
||
|
|
builder.UseTexture(bloomTexture, AccessFlags.Read);
|
||
|
|
|
||
|
|
passData.material = m_Material;
|
||
|
|
passData.cameraData = cameraData;
|
||
|
|
passData.useFastSRGBLinearConversion = m_UseFastSRGBLinearConversion;
|
||
|
|
passData.requireSRGBConversionBlit = m_RequireSRGBConversionBlit;
|
||
|
|
|
||
|
|
// HDR
|
||
|
|
passData.tonemapping = tonemapping;
|
||
|
|
passData.filteringOperation = m_FilteringOperation;
|
||
|
|
passData.hdrOperations = m_HdrOperations;
|
||
|
|
passData.isHdrGrading = postProcessingData.gradingMode == ColorGradingMode.HighDynamicRange;
|
||
|
|
|
||
|
|
passData.lut.Setup(colorAdjustments, colorLookup, postProcessingData.lutSize, internalColorLut, userColorLut);
|
||
|
|
passData.bloom.Setup(bloom, in srcDesc, bloomTexture);
|
||
|
|
passData.lensDistortion.Setup(lensDistortion, cameraData.isSceneViewCamera);
|
||
|
|
passData.chromaticAberration.Setup(chromaticAberration);
|
||
|
|
passData.vignette.Setup(vignette, srcDesc.width, srcDesc.height, cameraData.xr);
|
||
|
|
|
||
|
|
// Final pass effects
|
||
|
|
if (m_IsFinalPass)
|
||
|
|
{
|
||
|
|
passData.filmGrain.Setup(filmGrain, m_FilmGrainTextures, cameraData.pixelWidth, cameraData.pixelHeight);
|
||
|
|
passData.dither.Setup(m_DitherTexture, cameraData.pixelWidth, cameraData.pixelHeight);
|
||
|
|
}
|
||
|
|
passData.isFinalPass = m_IsFinalPass;
|
||
|
|
|
||
|
|
builder.SetRenderFunc(static (UberPostPassData data, RasterGraphContext context) =>
|
||
|
|
{
|
||
|
|
var cmd = context.cmd;
|
||
|
|
var cameraData = data.cameraData;
|
||
|
|
var material = data.material;
|
||
|
|
var filteringOperation = data.filteringOperation;
|
||
|
|
RTHandle sourceTextureHdl = data.sourceTexture;
|
||
|
|
|
||
|
|
// Reset keywords
|
||
|
|
material.shaderKeywords = null;
|
||
|
|
|
||
|
|
switch (filteringOperation)
|
||
|
|
{
|
||
|
|
case FilteringOperation.Point:
|
||
|
|
material.EnableKeyword(ShaderKeywordStrings.PointSampling);
|
||
|
|
break;
|
||
|
|
case FilteringOperation.Linear: goto default;
|
||
|
|
default:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
data.lut.Apply(material);
|
||
|
|
|
||
|
|
if (data.bloom.IsActive())
|
||
|
|
data.bloom.Apply(material);
|
||
|
|
|
||
|
|
if(data.lensDistortion.IsActive())
|
||
|
|
data.lensDistortion.Apply(material);
|
||
|
|
|
||
|
|
if(data.chromaticAberration.IsActive())
|
||
|
|
data.chromaticAberration.Apply(material);
|
||
|
|
|
||
|
|
data.vignette.Apply(material, cameraData.xr);
|
||
|
|
|
||
|
|
if(data.filmGrain.IsActive())
|
||
|
|
data.filmGrain.Apply(material);
|
||
|
|
|
||
|
|
if(data.dither.IsActive())
|
||
|
|
data.dither.Apply(material);
|
||
|
|
|
||
|
|
if (data.requireSRGBConversionBlit)
|
||
|
|
material.EnableKeyword(ShaderKeywordStrings.LinearToSRGBConversion);
|
||
|
|
|
||
|
|
if (data.useFastSRGBLinearConversion)
|
||
|
|
material.EnableKeyword(ShaderKeywordStrings.UseFastSRGBLinearConversion);
|
||
|
|
|
||
|
|
if (cameraData.isAlphaOutputEnabled)
|
||
|
|
material.EnableKeyword(ShaderKeywordStrings._ENABLE_ALPHA_OUTPUT);
|
||
|
|
|
||
|
|
if (data.isHdrGrading)
|
||
|
|
{
|
||
|
|
material.EnableKeyword(ShaderKeywordStrings.HDRGrading);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
switch (data.tonemapping.mode.value)
|
||
|
|
{
|
||
|
|
case TonemappingMode.Neutral: material.EnableKeyword(ShaderKeywordStrings.TonemapNeutral); break;
|
||
|
|
case TonemappingMode.ACES: material.EnableKeyword(ShaderKeywordStrings.TonemapACES); break;
|
||
|
|
default: break; // None
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(PostProcessUtils.RequireHDROutput(cameraData))
|
||
|
|
{
|
||
|
|
PostProcessUtils.SetupHDROutput(material, cameraData.hdrDisplayInformation, cameraData.hdrDisplayColorGamut, data.tonemapping, data.hdrOperations, cameraData.rendersOverlayUI);
|
||
|
|
RenderingUtils.SetupOffscreenUIViewportParams(material, ref cameraData.pixelRect, data.isFinalPass && cameraData.resolveFinalTarget);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Done with Uber, blit it
|
||
|
|
#if ENABLE_VR && ENABLE_XR_MODULE
|
||
|
|
if (cameraData.xr.enabled && cameraData.xr.hasValidVisibleMesh)
|
||
|
|
PostProcessUtils.ScaleViewportAndDrawVisibilityMesh(context, data.sourceTexture, data.destinationTexture, data.cameraData, material, data.isFinalPass);
|
||
|
|
else
|
||
|
|
#endif
|
||
|
|
PostProcessUtils.ScaleViewportAndBlit(context, data.sourceTexture, data.destinationTexture, data.cameraData, material, data.isFinalPass);
|
||
|
|
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!resourceData.isActiveTargetBackBuffer)
|
||
|
|
{
|
||
|
|
resourceData.cameraColor = destinationTexture;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#region ColorLut
|
||
|
|
TextureHandle TryGetCachedUserLutTextureHandle(RenderGraph renderGraph, ColorLookup colorLookup)
|
||
|
|
{
|
||
|
|
if (colorLookup.texture.value == null)
|
||
|
|
{
|
||
|
|
if (m_UserLut != null)
|
||
|
|
{
|
||
|
|
m_UserLut.Release();
|
||
|
|
m_UserLut = null;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (m_UserLut == null || m_UserLut.externalTexture != colorLookup.texture.value)
|
||
|
|
{
|
||
|
|
m_UserLut?.Release();
|
||
|
|
m_UserLut = RTHandles.Alloc(colorLookup.texture.value);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return m_UserLut != null ? renderGraph.ImportTexture(m_UserLut) : TextureHandle.nullHandle;
|
||
|
|
}
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
|
|
public static void CalcColorLutParams(ColorAdjustments colorAdjustments, ColorLookup colorLookup, int lutHeight, out Vector4 internalLutParams, out Vector4 userLutParams)
|
||
|
|
{
|
||
|
|
Assertions.Assert.IsNotNull(colorAdjustments, "SetupColorLut colorAdjustments cannot be null.");
|
||
|
|
Assertions.Assert.IsNotNull(colorLookup, "SetupColorLut colorLookup cannot be null.");
|
||
|
|
|
||
|
|
int lutWidth = lutHeight * lutHeight;
|
||
|
|
|
||
|
|
float postExposureLinear = Mathf.Pow(2f, colorAdjustments.postExposure.value);
|
||
|
|
internalLutParams = new Vector4(1f / lutWidth, 1f / lutHeight, lutHeight - 1f, postExposureLinear);
|
||
|
|
|
||
|
|
userLutParams = !colorLookup.IsActive()
|
||
|
|
? Vector4.zero
|
||
|
|
: new Vector4(1f / colorLookup.texture.value.width,
|
||
|
|
1f / colorLookup.texture.value.height,
|
||
|
|
colorLookup.texture.value.height - 1f,
|
||
|
|
colorLookup.contribution.value);
|
||
|
|
}
|
||
|
|
|
||
|
|
public struct LutParams
|
||
|
|
{
|
||
|
|
public TextureHandle internalLutTexture;
|
||
|
|
public TextureHandle activeUserLutTexture;
|
||
|
|
public Vector4 internalLutParams;
|
||
|
|
public Vector4 userLutParams;
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
|
|
public void Setup(ColorAdjustments colorAdjustments, ColorLookup colorLookup, int lutHeight, TextureHandle internalLutTexture, TextureHandle activeUserLutTexture)
|
||
|
|
{
|
||
|
|
this.internalLutTexture = internalLutTexture;
|
||
|
|
this.activeUserLutTexture = activeUserLutTexture;
|
||
|
|
CalcColorLutParams(colorAdjustments, colorLookup, lutHeight, out internalLutParams, out userLutParams);
|
||
|
|
}
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
|
|
public void Apply(Material material)
|
||
|
|
{
|
||
|
|
material.SetTexture(ShaderConstants._InternalLut, internalLutTexture);
|
||
|
|
material.SetTexture(ShaderConstants._UserLut, activeUserLutTexture);
|
||
|
|
material.SetVector(ShaderConstants._Lut_Params, internalLutParams);
|
||
|
|
material.SetVector(ShaderConstants._UserLut_Params, userLutParams);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
#endregion
|
||
|
|
|
||
|
|
#region Bloom
|
||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
|
|
public static void CalcBloomParams(Bloom bloom, in TextureDesc srcDesc, out Vector4 bloomParams, out bool highQualityFiltering, out Texture dirtTexture, out Vector4 dirtScaleOffset, out float dirtIntensity)
|
||
|
|
{
|
||
|
|
using (new ProfilingScope(ProfilingSampler.Get(URPProfileId.RG_UberPostSetupBloomPass)))
|
||
|
|
{
|
||
|
|
// Setup bloom on uber
|
||
|
|
var tint = bloom.tint.value.linear;
|
||
|
|
var luma = ColorUtils.Luminance(tint);
|
||
|
|
tint = luma > 0f ? tint * (1f / luma) : Color.white;
|
||
|
|
bloomParams = new Vector4(bloom.intensity.value, tint.r, tint.g, tint.b);
|
||
|
|
|
||
|
|
highQualityFiltering = bloom.highQualityFiltering.value;
|
||
|
|
|
||
|
|
// Setup lens dirtiness on uber
|
||
|
|
// Keep the aspect ratio correct & center the dirt texture, we don't want it to be
|
||
|
|
// stretched or squashed
|
||
|
|
dirtTexture = bloom.dirtTexture.value == null ? Texture2D.blackTexture : bloom.dirtTexture.value;
|
||
|
|
float dirtRatio = dirtTexture.width / (float)dirtTexture.height;
|
||
|
|
float screenRatio = srcDesc.width / (float)srcDesc.height;
|
||
|
|
dirtScaleOffset = new Vector4(1f, 1f, 0f, 0f);
|
||
|
|
dirtIntensity = bloom.dirtIntensity.value;
|
||
|
|
|
||
|
|
if (dirtRatio > screenRatio)
|
||
|
|
{
|
||
|
|
dirtScaleOffset.x = screenRatio / dirtRatio;
|
||
|
|
dirtScaleOffset.z = (1f - dirtScaleOffset.x) * 0.5f;
|
||
|
|
}
|
||
|
|
else if (screenRatio > dirtRatio)
|
||
|
|
{
|
||
|
|
dirtScaleOffset.y = dirtRatio / screenRatio;
|
||
|
|
dirtScaleOffset.w = (1f - dirtScaleOffset.y) * 0.5f;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public struct BloomParams
|
||
|
|
{
|
||
|
|
public TextureHandle activeBloomTexture;
|
||
|
|
public Vector4 bloomParams;
|
||
|
|
public Texture dirtTexture;
|
||
|
|
public Vector4 dirtScaleOffset;
|
||
|
|
public float dirtIntensity;
|
||
|
|
public bool highQualityFiltering;
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
|
|
public bool IsActive()
|
||
|
|
{
|
||
|
|
return activeBloomTexture.IsValid();
|
||
|
|
}
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
|
|
public void Setup(Bloom bloom, in TextureDesc srcDesc, TextureHandle activeBloomTexture)
|
||
|
|
{
|
||
|
|
this.activeBloomTexture = activeBloomTexture;
|
||
|
|
CalcBloomParams(bloom, in srcDesc, out bloomParams, out highQualityFiltering, out dirtTexture, out dirtScaleOffset, out dirtIntensity);
|
||
|
|
}
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
|
|
public void Apply(Material material)
|
||
|
|
{
|
||
|
|
material.SetTexture(ShaderConstants._Bloom_Texture, activeBloomTexture);
|
||
|
|
material.SetVector(ShaderConstants._Bloom_Params, bloomParams);
|
||
|
|
|
||
|
|
material.SetTexture(ShaderConstants._LensDirt_Texture, dirtTexture);
|
||
|
|
material.SetVector(ShaderConstants._LensDirt_Params, dirtScaleOffset);
|
||
|
|
material.SetFloat(ShaderConstants._LensDirt_Intensity, dirtIntensity);
|
||
|
|
|
||
|
|
// Keyword setup - a bit convoluted as we're trying to save some variants in Uber...
|
||
|
|
if (highQualityFiltering)
|
||
|
|
material.EnableKeyword(dirtIntensity > 0f ? ShaderKeywordStrings.BloomHQDirt : ShaderKeywordStrings.BloomHQ);
|
||
|
|
else
|
||
|
|
material.EnableKeyword(dirtIntensity > 0f ? ShaderKeywordStrings.BloomLQDirt : ShaderKeywordStrings.BloomLQ);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endregion
|
||
|
|
|
||
|
|
#region Lens Distortion
|
||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
|
|
static public void CalcLensDistortionParams(LensDistortion lensDistortion, out Vector4 lensDistortionParams1, out Vector4 lensDistortionParams2)
|
||
|
|
{
|
||
|
|
float amount = 1.6f * Mathf.Max(Mathf.Abs(lensDistortion.intensity.value * 100f), 1f);
|
||
|
|
float theta = Mathf.Deg2Rad * Mathf.Min(160f, amount);
|
||
|
|
float sigma = 2f * Mathf.Tan(theta * 0.5f);
|
||
|
|
var center = lensDistortion.center.value * 2f - Vector2.one;
|
||
|
|
lensDistortionParams1 = new Vector4(
|
||
|
|
center.x,
|
||
|
|
center.y,
|
||
|
|
Mathf.Max(lensDistortion.xMultiplier.value, 1e-4f),
|
||
|
|
Mathf.Max(lensDistortion.yMultiplier.value, 1e-4f)
|
||
|
|
);
|
||
|
|
lensDistortionParams2 = new Vector4(
|
||
|
|
lensDistortion.intensity.value >= 0f ? theta : 1f / theta,
|
||
|
|
sigma,
|
||
|
|
1f / lensDistortion.scale.value,
|
||
|
|
lensDistortion.intensity.value * 100f
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
public struct LensDistortionParams
|
||
|
|
{
|
||
|
|
public Vector4 lensDistortionParams1;
|
||
|
|
public Vector4 lensDistortionParams2;
|
||
|
|
public bool lensDistortionActive;
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
|
|
public bool IsActive()
|
||
|
|
{
|
||
|
|
return lensDistortionActive;
|
||
|
|
}
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
|
|
public void Setup(LensDistortion lensDistortion, bool isSceneViewCamera)
|
||
|
|
{
|
||
|
|
lensDistortionActive = lensDistortion.IsActive() && !isSceneViewCamera;
|
||
|
|
CalcLensDistortionParams(lensDistortion, out lensDistortionParams1, out lensDistortionParams2);
|
||
|
|
}
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
|
|
public void Apply(Material material)
|
||
|
|
{
|
||
|
|
material.SetVector(ShaderConstants._Distortion_Params1, lensDistortionParams1);
|
||
|
|
material.SetVector(ShaderConstants._Distortion_Params2, lensDistortionParams2);
|
||
|
|
|
||
|
|
material.EnableKeyword(ShaderKeywordStrings.Distortion);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endregion
|
||
|
|
|
||
|
|
#region Chromatic Aberration
|
||
|
|
|
||
|
|
public struct ChromaticAberrationParams
|
||
|
|
{
|
||
|
|
public float chromaticAberrationIntensity;
|
||
|
|
public bool chromaticAberrationActive;
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
|
|
public bool IsActive()
|
||
|
|
{
|
||
|
|
return chromaticAberrationActive;
|
||
|
|
}
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
|
|
public void Setup(ChromaticAberration chromaticAberration)
|
||
|
|
{
|
||
|
|
chromaticAberrationActive = chromaticAberration.IsActive();
|
||
|
|
chromaticAberrationIntensity = chromaticAberration.intensity.value;
|
||
|
|
}
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
|
|
public void Apply(Material material)
|
||
|
|
{
|
||
|
|
material.SetFloat(ShaderConstants._Chroma_Params, chromaticAberrationIntensity * 0.05f);
|
||
|
|
|
||
|
|
material.EnableKeyword(ShaderKeywordStrings.ChromaticAberration);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endregion
|
||
|
|
|
||
|
|
#region Vignette
|
||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
|
|
static public void CalcVignetteParams(Vignette vignette, int width, int height, Experimental.Rendering.XRPass xrPass, out Vector4 vignetteParams1, out Vector4 vignetteParams2)
|
||
|
|
{
|
||
|
|
var color = vignette.color.value;
|
||
|
|
var center = vignette.center.value;
|
||
|
|
var aspectRatio = width / (float)height;
|
||
|
|
|
||
|
|
#if ENABLE_VR && ENABLE_XR_MODULE
|
||
|
|
if (xrPass != null && xrPass.enabled && !xrPass.singlePassEnabled)
|
||
|
|
{
|
||
|
|
// In multi-pass mode we need to modify the eye center with the values from .xy of the corrected
|
||
|
|
// center since the version of the shader that is not single-pass will use the value in _Vignette_Params2
|
||
|
|
center = xrPass.ApplyXRViewCenterOffset(center);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
vignetteParams1 = new Vector4(
|
||
|
|
color.r, color.g, color.b,
|
||
|
|
vignette.rounded.value ? aspectRatio : 1f
|
||
|
|
);
|
||
|
|
vignetteParams2 = new Vector4(
|
||
|
|
center.x, center.y,
|
||
|
|
vignette.intensity.value * 3f,
|
||
|
|
vignette.smoothness.value * 5f
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
public struct VignetteParams
|
||
|
|
{
|
||
|
|
public Vector4 vignetteParams1;
|
||
|
|
public Vector4 vignetteParams2;
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
|
|
public void Setup(Vignette vignette, int width, int height, Experimental.Rendering.XRPass xrPass)
|
||
|
|
{
|
||
|
|
CalcVignetteParams(vignette, width, height, xrPass, out vignetteParams1, out vignetteParams2);
|
||
|
|
}
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
|
|
public void Apply(Material material, Experimental.Rendering.XRPass xrPass)
|
||
|
|
{
|
||
|
|
material.SetVector(ShaderConstants._Vignette_Params1, vignetteParams1);
|
||
|
|
material.SetVector(ShaderConstants._Vignette_Params2, vignetteParams2);
|
||
|
|
|
||
|
|
#if ENABLE_VR && ENABLE_XR_MODULE
|
||
|
|
if (xrPass != null && xrPass.enabled && xrPass.singlePassEnabled)
|
||
|
|
{
|
||
|
|
Vector2 center = vignetteParams2;
|
||
|
|
material.SetVector(ShaderConstants._Vignette_ParamsXR, xrPass.ApplyXRViewCenterOffset(center));
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endregion
|
||
|
|
|
||
|
|
#region Film Grain
|
||
|
|
// NOTE: Procedural FilmGrain can be done using the custom texture with RenderTexture. No need to import it into the RenderGraph.
|
||
|
|
const float k_FilmGrainIntensityScale = 4f;
|
||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
|
|
static public void CalcFilmGrainParams(FilmGrain filmGrain, Texture2D[] filmGrainTextures, out Texture grainTexture, out Vector2 grainParams)
|
||
|
|
{
|
||
|
|
grainTexture = (filmGrain.type.value == FilmGrainLookup.Custom) ? filmGrain.texture.value : filmGrainTextures[(int)filmGrain.type.value];
|
||
|
|
grainParams = new Vector2(filmGrain.intensity.value * k_FilmGrainIntensityScale, filmGrain.response.value);
|
||
|
|
}
|
||
|
|
|
||
|
|
public struct FilmGrainParams
|
||
|
|
{
|
||
|
|
public Texture activeGrainTexture;
|
||
|
|
public Vector4 tilingParams;
|
||
|
|
public Vector2 grainParams;
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
|
|
public bool IsActive()
|
||
|
|
{
|
||
|
|
return activeGrainTexture != null;
|
||
|
|
}
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
|
|
public void Setup(FilmGrain filmGrain, Texture2D[] filmGrainTextures, int pixelWidth, int pixelHeight)
|
||
|
|
{
|
||
|
|
activeGrainTexture = null; // Disable by default
|
||
|
|
if (filmGrain.IsActive())
|
||
|
|
{
|
||
|
|
CalcFilmGrainParams(filmGrain, filmGrainTextures, out activeGrainTexture, out grainParams);
|
||
|
|
tilingParams = PostProcessUtils.CalcNoiseTextureTilingParams(activeGrainTexture, pixelWidth, pixelHeight, PostProcessUtils.GetRandomOffset2D());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
|
|
public void Apply(Material material)
|
||
|
|
{
|
||
|
|
PostProcessUtils.ConfigureFilmGrainMaterial(material, activeGrainTexture, grainParams, tilingParams);
|
||
|
|
material.EnableKeyword(ShaderKeywordStrings.FilmGrain);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endregion
|
||
|
|
|
||
|
|
#region 8-bit Dithering
|
||
|
|
|
||
|
|
public struct DitheringParams
|
||
|
|
{
|
||
|
|
public Texture activeDitherTexture;
|
||
|
|
public Vector4 tilingParams;
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
|
|
public bool IsActive()
|
||
|
|
{
|
||
|
|
return activeDitherTexture != null;
|
||
|
|
}
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
|
|
public void Setup(Texture ditherTexture, int pixelWidth, int pixelHeight)
|
||
|
|
{
|
||
|
|
activeDitherTexture = ditherTexture;
|
||
|
|
tilingParams = PostProcessUtils.CalcNoiseTextureTilingParams(ditherTexture, pixelWidth, pixelHeight, PostProcessUtils.GetRandomOffset2D());
|
||
|
|
}
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
|
|
public void Apply(Material material)
|
||
|
|
{
|
||
|
|
PostProcessUtils.ConfigureDitheringMaterial(material, activeDitherTexture, tilingParams);
|
||
|
|
material.EnableKeyword(ShaderKeywordStrings.Dithering);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endregion
|
||
|
|
|
||
|
|
// Precomputed shader ids to same some CPU cycles (mostly affects mobile)
|
||
|
|
internal static class ShaderConstants
|
||
|
|
{
|
||
|
|
// Uber
|
||
|
|
public static readonly int _Distortion_Params1 = Shader.PropertyToID("_Distortion_Params1");
|
||
|
|
public static readonly int _Distortion_Params2 = Shader.PropertyToID("_Distortion_Params2");
|
||
|
|
public static readonly int _Chroma_Params = Shader.PropertyToID("_Chroma_Params");
|
||
|
|
public static readonly int _Vignette_Params1 = Shader.PropertyToID("_Vignette_Params1");
|
||
|
|
public static readonly int _Vignette_Params2 = Shader.PropertyToID("_Vignette_Params2");
|
||
|
|
public static readonly int _Vignette_ParamsXR = Shader.PropertyToID("_Vignette_ParamsXR");
|
||
|
|
|
||
|
|
// Uber Lut
|
||
|
|
public static readonly int _InternalLut = Shader.PropertyToID("_InternalLut");
|
||
|
|
public static readonly int _Lut_Params = Shader.PropertyToID("_Lut_Params");
|
||
|
|
public static readonly int _UserLut = Shader.PropertyToID("_UserLut");
|
||
|
|
public static readonly int _UserLut_Params = Shader.PropertyToID("_UserLut_Params");
|
||
|
|
|
||
|
|
// Uber Bloom
|
||
|
|
public static readonly int _Bloom_Texture = Shader.PropertyToID("_Bloom_Texture");
|
||
|
|
public static readonly int _Bloom_Params = Shader.PropertyToID("_Bloom_Params");
|
||
|
|
public static readonly int _LensDirt_Texture = Shader.PropertyToID("_LensDirt_Texture");
|
||
|
|
public static readonly int _LensDirt_Params = Shader.PropertyToID("_LensDirt_Params");
|
||
|
|
public static readonly int _LensDirt_Intensity = Shader.PropertyToID("_LensDirt_Intensity");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|