public void InitData(RenderPipelineResources renderPipelineResources)
{
m_DebugLightVolumeMaterial = CoreUtils.CreateEngineMaterial(renderPipelineResources.shaders.debugLightVolumePS);
m_DebugLightVolumeCompute = renderPipelineResources.shaders.debugLightVolumeCS;
m_DebugLightVolumeGradientKernel = m_DebugLightVolumeCompute.FindKernel("LightVolumeGradient");
m_DebugLightVolumeColorsKernel = m_DebugLightVolumeCompute.FindKernel("LightVolumeColors");
m_ColorGradientTexture = renderPipelineResources.textures.colorGradient;
m_Blit = CoreUtils.CreateEngineMaterial(renderPipelineResources.shaders.blitPS);
m_LightCountBuffer = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: GraphicsFormat.R32_SFloat, enableRandomWrite: false, useMipMap: false, name: "LightVolumeCount");
m_ColorAccumulationBuffer = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, enableRandomWrite: false, useMipMap: false, name: "LightVolumeColorAccumulation");
m_DebugLightVolumesTexture = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, enableRandomWrite: true, useMipMap: false, name: "LightVolumeDebugLightVolumesTexture");
m_DepthBuffer = RTHandles.Alloc(Vector2.one, depthBufferBits: DepthBits.None, colorFormat: GraphicsFormat.R8_UNorm, filterMode: FilterMode.Point, name: "LightVolumeDepth");
// Fill the render target array
m_RTIDs[0] = m_LightCountBuffer;
m_RTIDs[1] = m_ColorAccumulationBuffer;
}
public void Initialize(RenderPipelineResources resources, HDRaytracingManager raytracingManager, SharedRTManager sharedRTManager, LightLoop lightLoop)
{
// Keep track of the external buffers
m_RenderPipelineResources = resources;
m_RaytracingManager = raytracingManager;
// Keep track of the lightloop
m_LightLoop = lightLoop;
// Keep track of the shader rt manager
m_SharedRTManager = sharedRTManager;
// Texture used to output debug information
m_DebugLightClusterTexture = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: UnityEngine.Experimental.Rendering.HDPipeline.HDRenderPipeline.OverrideRTGraphicsFormat(GraphicsFormat.R16G16B16A16_SFloat), enableRandomWrite: true, useDynamicScale: true, useMipMap: false, name: "DebugLightClusterTexture");
// Pre allocate the cluster with a dummy size
m_LightCluster = new ComputeBuffer(1, sizeof(uint));
}
void CheckIntermediateTexturesSize(int texWidth, int texHeight)
{
// If the first texture is not the right size
if (m_PlanarReflectionFilterTex0 == null || m_PlanarReflectionFilterTex0.rt.width < texWidth)
{
var hdPipeline = (HDRenderPipeline)RenderPipelineManager.currentPipeline;
var probeFormat = (GraphicsFormat)hdPipeline.currentPlatformRenderPipelineSettings.lightLoopSettings.reflectionProbeFormat;
// We re-allocate them all
RTHandles.Release(m_PlanarReflectionFilterTex0);
RTHandles.Release(m_PlanarReflectionFilterTex1);
RTHandles.Release(m_PlanarReflectionFilterDepthTex0);
RTHandles.Release(m_PlanarReflectionFilterDepthTex1);
m_PlanarReflectionFilterTex0 = RTHandles.Alloc(texWidth, texHeight, TextureXR.slices, colorFormat: probeFormat, enableRandomWrite: true, useDynamicScale: false, useMipMap: true, name: "PlanarReflectionTextureIntermediate0");
m_PlanarReflectionFilterTex1 = RTHandles.Alloc(texWidth, texHeight, TextureXR.slices, colorFormat: probeFormat, enableRandomWrite: true, useDynamicScale: false, useMipMap: false, name: "PlanarReflectionTextureIntermediate1");
m_PlanarReflectionFilterDepthTex0 = RTHandles.Alloc(texWidth, texHeight, TextureXR.slices, colorFormat: GraphicsFormat.R32_SFloat, enableRandomWrite: true, useDynamicScale: false, useMipMap: true, name: "PlanarReflectionTextureIntermediateDepth0");
m_PlanarReflectionFilterDepthTex1 = RTHandles.Alloc(texWidth, texHeight, TextureXR.slices, colorFormat: GraphicsFormat.R32_SFloat, enableRandomWrite: true, useDynamicScale: false, useMipMap: false, name: "PlanarReflectionTextureIntermediateDepth1");
}
}
// It can be used to configure render targets and their clear state. Also to create temporary render target textures.
// When empty this render pass will render to the active camera render target.
// You should never call CommandBuffer.SetRenderTarget. Instead call <c>ConfigureTarget</c> and <c>ConfigureClear</c>.
// The render pipeline will ensure target setup and clearing happens in an performance manner.
protected override void Setup(ScriptableRenderContext renderContext, CommandBuffer cmd)
{
blurMaterial = CoreUtils.CreateEngineMaterial(Shader.Find("Hidden/FullScreen/BlurPasses"));
compositingMaterial = CoreUtils.CreateEngineMaterial(Shader.Find("Hidden/FullScreen/LiquidCompositing"));
shaderTags = new ShaderTagId[4]
{
new ShaderTagId("Forward"),
new ShaderTagId("ForwardOnly"),
new ShaderTagId("SRPDefaultUnlit"),
new ShaderTagId("FirstPass"),
};
// Allocate the buffers used for the blur in half resolution to save some memory
downSampleBuffer = RTHandles.Alloc(
Vector2.one * 0.5f, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16G16B16A16_SNorm,
useDynamicScale: true, name: "DownSampleBuffer"
);
blurBuffer = RTHandles.Alloc(
Vector2.one * 0.5f, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16G16B16A16_SNorm,
useDynamicScale: true, name: "BlurBuffer"
);
targetColorBuffer = TargetBuffer.Custom;
targetDepthBuffer = TargetBuffer.Custom;
clearFlags = ClearFlag.All;
quad = new Mesh();
quad.SetVertices(new List <Vector3> {
new Vector3(-1, -1, 0),
new Vector3(1, -1, 0),
new Vector3(-1, 1, 0),
new Vector3(1, 1, 0),
});
quad.SetTriangles(new List <int> {
0, 3, 1, 0, 2, 3
}, 0);
quad.RecalculateBounds();
quad.UploadMeshData(false);
}
protected override void DoSetup()
{
if (Shader.Find(ShaderName) != null)
{
material = new Material(Shader.Find(ShaderName));
}
else
{
Debug.LogError($"Unable to find shader {ShaderName}. Post Process Volume {nameof(SunFlareFX)} is unable to load.");
}
computeShader = Resources.Load("PostProcessShaders/SunFlareOcclusion") as ComputeShader;
if (computeShader == null)
{
Debug.LogError($"Unable to find shader SunFlareOcclusion in Resources. Post Process Volume {nameof(SunFlareFX)} is unable to load.");
}
else
{
textureOcclusionKernel = computeShader.FindKernel("TextureOcclusion");
blurTextureOcclusionKernel = computeShader.FindKernel("BlurTextureOcclusion");
reduceTextureOcclusionKernel = computeShader.FindKernel("ReduceTextureOcclusion");
angleOcclusionKernel = computeShader.FindKernel("AngleOcclusion");
}
occlusionTextureA = RTHandles.Alloc(
OcclusionRes, OcclusionRes,
colorFormat: GraphicsFormat.R32_SFloat,
name: "SunFlareOcclusionA",
enableRandomWrite: true,
useMipMap: false,
autoGenerateMips: false,
wrapMode: TextureWrapMode.Clamp);
occlusionTextureB = RTHandles.Alloc(
OcclusionRes, OcclusionRes,
colorFormat: GraphicsFormat.R32_SFloat,
name: "SunFlareOcclusionB",
enableRandomWrite: true,
useMipMap: false,
autoGenerateMips: false,
wrapMode: TextureWrapMode.Clamp);
angleOcclusion = new ComputeBuffer(AngleSamples, sizeof(float));
}
public void RebuildTextures(int resolution)
{
bool updateNeeded = m_SkyboxCubemapRT == null || (m_SkyboxCubemapRT.rt.width != resolution);
// Cleanup first if needed
if (updateNeeded)
{
RTHandles.Release(m_SkyboxCubemapRT);
m_SkyboxCubemapRT = null;
RTHandles.Release(m_SkyboxBSDFCubemapIntermediate);
m_SkyboxBSDFCubemapIntermediate = null;
CoreUtils.Destroy(m_SkyboxBSDFCubemapArray);
m_SkyboxBSDFCubemapArray = null;
}
// Reallocate everything
if (m_SkyboxCubemapRT == null)
{
m_SkyboxCubemapRT = RTHandles.Alloc(resolution, resolution, colorFormat: HDRenderPipeline.OverrideRTGraphicsFormat(GraphicsFormat.R16G16B16A16_SFloat), dimension: TextureDimension.Cube, useMipMap: true, autoGenerateMips: false, filterMode: FilterMode.Trilinear, name: "SkyboxCubemap");
if (m_SupportsConvolution)
{
m_SkyboxBSDFCubemapIntermediate = RTHandles.Alloc(resolution, resolution, colorFormat: UnityEngine.Experimental.Rendering.HDPipeline.HDRenderPipeline.OverrideRTGraphicsFormat(GraphicsFormat.R16G16B16A16_SFloat), dimension: TextureDimension.Cube, useMipMap: true, autoGenerateMips: false, filterMode: FilterMode.Trilinear, name: "SkyboxBSDFIntermediate");
m_SkyboxBSDFCubemapArray = new CubemapArray(resolution, m_IBLFilterArray.Length, TextureFormat.RGBAHalf, true)
{
hideFlags = HideFlags.HideAndDontSave,
wrapMode = TextureWrapMode.Repeat,
wrapModeV = TextureWrapMode.Clamp,
filterMode = FilterMode.Trilinear,
anisoLevel = 0,
name = "SkyboxCubemapConvolution"
};
}
}
m_CubemapScreenSize = new Vector4((float)resolution, (float)resolution, 1.0f / (float)resolution, 1.0f / (float)resolution);
if (updateNeeded)
{
m_NeedUpdate = true; // Special case. Even if update mode is set to OnDemand, we need to regenerate the environment after destroying the texture.
RebuildSkyMatrices(resolution);
}
}
void InitializeScreenSpaceShadows()
{
if (!m_Asset.currentPlatformRenderPipelineSettings.hdShadowInitParams.supportScreenSpaceShadows)
{
return;
}
// Fetch the shaders
#if ENABLE_RAYTRACING
m_ScreenSpaceShadowsCS = m_Asset.renderPipelineRayTracingResources.shadowRaytracingCS;
m_ScreenSpaceShadowsFilterCS = m_Asset.renderPipelineRayTracingResources.shadowFilterCS;
m_ScreenSpaceShadowsRT = m_Asset.renderPipelineRayTracingResources.shadowRaytracingRT;
// Directional shadow kernels
m_ClearShadowTexture = m_ScreenSpaceShadowsCS.FindKernel("ClearShadowTexture");
m_OutputShadowTextureKernel = m_ScreenSpaceShadowsCS.FindKernel("OutputShadowTexture");
m_RaytracingDirectionalShadowSample = m_ScreenSpaceShadowsCS.FindKernel("RaytracingDirectionalShadowSample");
m_RaytracingPointShadowSample = m_ScreenSpaceShadowsCS.FindKernel("RaytracingPointShadowSample");
// Area shadow kernels
m_AreaRaytracingAreaShadowPrepassKernel = m_ScreenSpaceShadowsCS.FindKernel("RaytracingAreaShadowPrepass");
m_AreaRaytracingAreaShadowNewSampleKernel = m_ScreenSpaceShadowsCS.FindKernel("RaytracingAreaShadowNewSample");
m_AreaShadowApplyTAAKernel = m_ScreenSpaceShadowsFilterCS.FindKernel("AreaShadowApplyTAA");
m_AreaUpdateAnalyticHistoryKernel = m_ScreenSpaceShadowsFilterCS.FindKernel("AreaAnalyticHistoryCopy");
m_AreaUpdateShadowHistoryKernel = m_ScreenSpaceShadowsFilterCS.FindKernel("AreaShadowHistoryCopy");
m_AreaEstimateNoiseKernel = m_ScreenSpaceShadowsFilterCS.FindKernel("AreaShadowEstimateNoise");
m_AreaFirstDenoiseKernel = m_ScreenSpaceShadowsFilterCS.FindKernel("AreaShadowDenoiseFirstPass");
m_AreaSecondDenoiseKernel = m_ScreenSpaceShadowsFilterCS.FindKernel("AreaShadowDenoiseSecondPass");
m_AreaShadowNoDenoiseKernel = m_ScreenSpaceShadowsFilterCS.FindKernel("AreaShadowNoDenoise");
// Allocate the intermediate buffers
m_ShadowIntermediateBufferRG0 = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R16G16_SFloat, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, name: "ShadowIntermediateBufferRG0");
m_ShadowIntermediateBufferRGBA0 = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, name: "ShadowIntermediateBufferRGBA0");
m_ShadowIntermediateBufferRGBA1 = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, name: "ShadowIntermediateBufferRGBA1");
#endif
// Directional shadow material
s_ScreenSpaceShadowsMat = CoreUtils.CreateEngineMaterial(screenSpaceShadowsShader);
// Allocate the final result texture
int numMaxShadows = Math.Max(m_Asset.currentPlatformRenderPipelineSettings.hdShadowInitParams.maxScreenSpaceShadows, 1);
m_ScreenSpaceShadowTextureArray = RTHandles.Alloc(Vector2.one, slices: numMaxShadows * TextureXR.slices, dimension: TextureDimension.Tex2DArray, filterMode: FilterMode.Point, colorFormat: GraphicsFormat.R16_SFloat, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, name: "AreaShadowArrayBuffer");
}
void InitializeScreenSpaceShadows()
{
if (!m_Asset.currentPlatformRenderPipelineSettings.hdShadowInitParams.supportScreenSpaceShadows)
{
return;
}
#if ENABLE_RAYTRACING
// Allocate the intermediate buffers
m_AnalyticProbBuffer = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R16G16_SFloat, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, name: "AnalyticProbBuffer");
m_DenoiseBuffer0 = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, name: "DenoiseBuffer0");
m_DenoiseBuffer1 = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, name: "DenoiseBuffer1");
#endif
s_ScreenSpaceShadowsMat = CoreUtils.CreateEngineMaterial(screenSpaceShadowsShader);
// Allocate the final result texture
int numMaxShadows = Math.Max(m_Asset.currentPlatformRenderPipelineSettings.hdShadowInitParams.maxScreenSpaceShadows, 1);
m_ScreenSpaceShadowTextureArray = RTHandles.Alloc(Vector2.one, slices: numMaxShadows * TextureXR.slices, dimension: TextureDimension.Tex2DArray, filterMode: FilterMode.Point, colorFormat: GraphicsFormat.R16_SFloat, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, name: "AreaShadowArrayBuffer");
}
public void Init(HDRenderPipelineRayTracingResources rayTracingResources, DebugDisplaySettings currentDebugDisplaySettings)
{
// Keep track of the external resources
m_DebugDisplaySettings = currentDebugDisplaySettings;
m_PipelineResources = rayTracingResources;
m_RayCountTexture = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: GraphicsFormat.R32G32B32A32_UInt, enableRandomWrite: true, useMipMap: false, name: "RayCountTexture");
// We only require 3 buffers (this supports a maximal size of 8192x8192)
m_ReducedRayCountBuffer0 = new ComputeBuffer(4 * 256 * 256, sizeof(uint));
m_ReducedRayCountBuffer1 = new ComputeBuffer(4 * 32 * 32, sizeof(uint));
m_ReducedRayCountBuffer2 = new ComputeBuffer(4, sizeof(uint));
// Initialize the cpu ray count (Optional)
for (int i = 0; i < 4; ++i)
{
m_ReducedRayCountValues[i] = 0;
}
}
public void Init(RenderPipelineResources rpResources, HDRenderPipelineRayTracingResources rpRTResources, RenderPipelineSettings pipelineSettings, HDRaytracingManager raytracingManager, SharedRTManager sharedRTManager)
{
// Keep track of the pipeline asset
m_PipelineSettings = pipelineSettings;
m_PipelineResources = rpResources;
m_PipelineRayTracingResources = rpRTResources;
// keep track of the ray tracing manager
m_RaytracingManager = raytracingManager;
// Keep track of the shared rt manager
m_SharedRTManager = sharedRTManager;
// Intermediate buffer that holds the pre-denoised texture
m_IntermediateBuffer = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, autoGenerateMips: false, name: "IntermediateAOBuffer");
// Buffer that holds the uncompressed normal buffer
m_ViewSpaceNormalBuffer = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, autoGenerateMips: false, name: "ViewSpaceNormalBuffer");
}
public override void OnEnable()
{
base.OnEnable();
m_EnableLuxIntensityMode = true;
// HDRI sky does not have control over sun display.
m_CommonUIElementsMask = 0xFFFFFFFF & ~(uint)(SkySettingsUIElement.IncludeSunInBaking);
var o = new PropertyFetcher <HDRISky>(serializedObject);
m_hdriSky = Unpack(o.Find(x => x.hdriSky));
m_UpperHemisphereLuxValue = Unpack(o.Find(x => x.upperHemisphereLuxValue));
m_UpperHemisphereLuxColor = Unpack(o.Find(x => x.upperHemisphereLuxColor));
m_EnableCloudMotion = Unpack(o.Find(x => x.enableDistortion));
m_Procedural = Unpack(o.Find(x => x.procedural));
m_Flowmap = Unpack(o.Find(x => x.flowmap));
m_UpperHemisphereOnly = Unpack(o.Find(x => x.upperHemisphereOnly));
m_ScrollDirection = Unpack(o.Find(x => x.scrollDirection));
m_ScrollSpeed = Unpack(o.Find(x => x.scrollSpeed));
m_EnableBackplate = Unpack(o.Find(x => x.enableBackplate));
m_BackplateType = Unpack(o.Find(x => x.backplateType));
m_GroundLevel = Unpack(o.Find(x => x.groundLevel));
m_Scale = Unpack(o.Find(x => x.scale));
m_ProjectionDistance = Unpack(o.Find(x => x.projectionDistance));
m_PlateRotation = Unpack(o.Find(x => x.plateRotation));
m_PlateTexRotation = Unpack(o.Find(x => x.plateTexRotation));
m_PlateTexOffset = Unpack(o.Find(x => x.plateTexOffset));
m_BlendAmount = Unpack(o.Find(x => x.blendAmount));
m_PointLightShadow = Unpack(o.Find(x => x.pointLightShadow));
m_DirLightShadow = Unpack(o.Find(x => x.dirLightShadow));
m_RectLightShadow = Unpack(o.Find(x => x.rectLightShadow));
m_ShadowTint = Unpack(o.Find(x => x.shadowTint));
m_IntensityTexture = RTHandles.Alloc(1, 1, colorFormat: GraphicsFormat.R32G32B32A32_SFloat);
if (HDRenderPipelineGlobalSettings.instance?.renderPipelineResources != null)
{
m_IntegrateHDRISkyMaterial = CoreUtils.CreateEngineMaterial(HDRenderPipelineGlobalSettings.instance.renderPipelineResources.shaders.integrateHdriSkyPS);
}
m_ReadBackTexture = new Texture2D(1, 1, GraphicsFormat.R32G32B32A32_SFloat, TextureCreationFlags.None);
}
void AllocateRenderTexture()
{
if (m_Atlas != null)
{
m_Atlas.Release();
}
m_Atlas = RTHandles.Alloc(width, height, filterMode: m_FilterMode, depthBufferBits: m_DepthBufferBits, sRGB: false, colorFormat: m_Format, name: m_Name);
if (m_SupportMomentShadows)
{
string momentShadowMapName = m_Name + "Moment";
m_AtlasMoments = RTHandles.Alloc(width, height, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.ARGBFloat, sRGB: false, enableRandomWrite: true, name: momentShadowMapName);
string intermediateSummedAreaName = m_Name + "IntermediateSummedArea";
m_IntermediateSummedAreaTexture = RTHandles.Alloc(width, height, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.ARGBInt, sRGB: false, enableRandomWrite: true, name: intermediateSummedAreaName);
string summedAreaName = m_Name + "SummedAreaFinal";
m_SummedAreaTexture = RTHandles.Alloc(width, height, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.ARGBInt, sRGB: false, enableRandomWrite: true, name: summedAreaName);
}
identifier = new RenderTargetIdentifier(m_Atlas);
}
AOVRequestDataCollection BuildAovRequest()
{
var aovRequest = AOVRequest.NewDefault();
CustomPassAOVBuffers[] customPassAovBuffers = null;
customPassAovBuffers = new[] { new CustomPassAOVBuffers(CustomPassInjectionPoint.BeforePostProcess, CustomPassAOVBuffers.OutputType.CustomPassBuffer) };
var bufAlloc = _rt ?? (_rt = RTHandles.Alloc(_outputTexture.width, _outputTexture.height));
return(new AOVRequestBuilder().Add(
aovRequest,
RTAllocator,
null, // lightFilter
null,
customPassAovBuffers,
bufferId => bufAlloc,
AovCallbackEx
).Build());
}
public Texture2DAtlas(int width, int height, GraphicsFormat format, FilterMode filterMode = FilterMode.Point, bool powerOfTwoPadding = false, string name = "", bool useMipMap = true)
{
m_Width = width;
m_Height = height;
m_Format = format;
m_UseMipMaps = useMipMap;
m_AtlasTexture = RTHandles.Alloc(
width: m_Width,
height: m_Height,
filterMode: filterMode,
colorFormat: m_Format,
wrapMode: TextureWrapMode.Clamp,
useMipMap: useMipMap,
autoGenerateMips: false,
name: name
);
m_AtlasAllocator = new AtlasAllocator(width, height, powerOfTwoPadding);
}
public void Init(HDRenderPipelineAsset asset, SkyManager skyManager, HDRaytracingManager raytracingManager, SharedRTManager sharedRTManager, GBufferManager gbufferManager)
{
// Keep track of the pipeline asset
m_PipelineAsset = asset;
m_PipelineResources = asset.renderPipelineResources;
// Keep track of the sky manager
m_SkyManager = skyManager;
// keep track of the ray tracing manager
m_RaytracingManager = raytracingManager;
// Keep track of the shared rt manager
m_SharedRTManager = sharedRTManager;
m_GBufferManager = gbufferManager;
m_IndirectDiffuseTexture = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, enableRandomWrite: true, xrInstancing: true, useDynamicScale: true, useMipMap: false, autoGenerateMips: false, name: "IndirectDiffuseBuffer");
m_DenoiseBuffer0 = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, enableRandomWrite: true, xrInstancing: true, useDynamicScale: true, useMipMap: false, autoGenerateMips: false, name: "IndirectDiffuseDenoiseBuffer");
}
void InitSSSBuffers()
{
RenderPipelineSettings settings = asset.currentPlatformRenderPipelineSettings;
if (settings.supportedLitShaderMode == RenderPipelineSettings.SupportedLitShaderMode.ForwardOnly) //forward only
{
// In case of full forward we must allocate the render target for forward SSS (or reuse one already existing)
// TODO: Provide a way to reuse a render target
m_SSSColor = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R8G8B8A8_SRGB, dimension: TextureXR.dimension, useDynamicScale: true, name: "SSSBuffer");
m_SSSReuseGBufferMemory = false;
}
// We need to allocate the texture if we are in forward or both in case one of the cameras is in enable forward only mode
if (settings.supportMSAA && settings.supportedLitShaderMode != RenderPipelineSettings.SupportedLitShaderMode.DeferredOnly)
{
m_SSSColorMSAA = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R8G8B8A8_SRGB, dimension: TextureXR.dimension, enableMSAA: true, bindTextureMS: true, useDynamicScale: true, name: "SSSBufferMSAA");
}
if ((settings.supportedLitShaderMode & RenderPipelineSettings.SupportedLitShaderMode.DeferredOnly) != 0) //deferred or both
{
// In case of deferred, we must be in sync with SubsurfaceScattering.hlsl and lit.hlsl files and setup the correct buffers
m_SSSColor = m_GbufferManager.GetSubsurfaceScatteringBuffer(0); // Note: This buffer must be sRGB (which is the case with Lit.shader)
m_SSSReuseGBufferMemory = true;
}
if (NeedTemporarySubsurfaceBuffer() || settings.supportMSAA)
{
// Caution: must be same format as m_CameraSssDiffuseLightingBuffer
m_SSSCameraFilteringBuffer = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.B10G11R11_UFloatPack32, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, name: "SSSCameraFiltering"); // Enable UAV
}
// fill the list with the max number of diffusion profile so we dont have
// the error: exceeds previous array size (5 vs 3). Cap to previous size.
m_SSSThicknessRemaps = new Vector4[DiffusionProfileConstants.DIFFUSION_PROFILE_COUNT];
m_SSSShapeParams = new Vector4[DiffusionProfileConstants.DIFFUSION_PROFILE_COUNT];
m_SSSTransmissionTintsAndFresnel0 = new Vector4[DiffusionProfileConstants.DIFFUSION_PROFILE_COUNT];
m_SSSDisabledTransmissionTintsAndFresnel0 = new Vector4[DiffusionProfileConstants.DIFFUSION_PROFILE_COUNT];
m_SSSWorldScales = new Vector4[DiffusionProfileConstants.DIFFUSION_PROFILE_COUNT];
m_SSSFilterKernels = new Vector4[DiffusionProfileConstants.DIFFUSION_PROFILE_COUNT * DiffusionProfileConstants.SSS_N_SAMPLES_NEAR_FIELD];
m_SSSDiffusionProfileHashes = new float[DiffusionProfileConstants.DIFFUSION_PROFILE_COUNT];
m_SSSDiffusionProfileUpdate = new int[DiffusionProfileConstants.DIFFUSION_PROFILE_COUNT];
m_SSSSetDiffusionProfiles = new DiffusionProfileSettings[DiffusionProfileConstants.DIFFUSION_PROFILE_COUNT];
}
public void Initialize(RenderPipelineResources rpResources, HDRenderPipelineRayTracingResources rpRTResources, HDRaytracingManager raytracingManager, SharedRTManager sharedRTManager, HDRenderPipeline renderPipeline)
{
// Keep track of the external buffers
m_RenderPipelineResources = rpResources;
m_RenderPipelineRayTracingResources = rpRTResources;
m_RaytracingManager = raytracingManager;
// Keep track of the render pipeline
m_RenderPipeline = renderPipeline;
// Keep track of the shader rt manager
m_SharedRTManager = sharedRTManager;
// Texture used to output debug information
m_DebugLightClusterTexture = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, name: "DebugLightClusterTexture");
// Pre allocate the cluster with a dummy size
m_LightCluster = new ComputeBuffer(1, sizeof(uint));
}
internal void CreateProbeVolumeBuffers()
{
m_VisibleProbeVolumeBounds = new List <OrientedBBox>();
m_VisibleProbeVolumeData = new List <ProbeVolumeEngineData>();
s_VisibleProbeVolumeBoundsBuffer = new ComputeBuffer(k_MaxVisibleProbeVolumeCount, Marshal.SizeOf(typeof(OrientedBBox)));
s_VisibleProbeVolumeDataBuffer = new ComputeBuffer(k_MaxVisibleProbeVolumeCount, Marshal.SizeOf(typeof(ProbeVolumeEngineData)));
s_ProbeVolumeAtlasBlitDataBuffer = new ComputeBuffer(s_MaxProbeVolumeProbeCount, Marshal.SizeOf(typeof(SphericalHarmonicsL1)));
s_ProbeVolumeAtlasBlitDataValidityBuffer = new ComputeBuffer(s_MaxProbeVolumeProbeCount, Marshal.SizeOf(typeof(float)));
s_ProbeVolumeAtlasOctahedralDepthBuffer = new ComputeBuffer(s_MaxProbeVolumeProbeCount, Marshal.SizeOf(typeof(float)));
m_ProbeVolumeAtlasSHRTHandle = RTHandles.Alloc(
width: s_ProbeVolumeAtlasWidth,
height: s_ProbeVolumeAtlasHeight,
slices: s_ProbeVolumeAtlasDepth * m_ProbeVolumeAtlasSHRTDepthSliceCount,
dimension: TextureDimension.Tex3D,
colorFormat: UnityEngine.Experimental.Rendering.GraphicsFormat.R16G16B16A16_SFloat,//GraphicsFormat.B10G11R11_UFloatPack32,
enableRandomWrite: true,
useMipMap: false,
name: "ProbeVolumeAtlasSH"
);
probeVolumeAtlas = new Texture3DAtlasDynamic(s_ProbeVolumeAtlasWidth, s_ProbeVolumeAtlasHeight, s_ProbeVolumeAtlasDepth, k_MaxVisibleProbeVolumeCount, m_ProbeVolumeAtlasSHRTHandle);
// TODO: (Nick): Might be able drop precision down to half-floats, since we only need to encode depth data up to one probe spacing distance away. Could rescale depth data to this range before encoding.
m_ProbeVolumeAtlasOctahedralDepthRTHandle = RTHandles.Alloc(
width: s_ProbeVolumeAtlasOctahedralDepthWidth,
height: s_ProbeVolumeAtlasOctahedralDepthHeight,
slices: 1,
dimension: TextureDimension.Tex2D,
colorFormat: UnityEngine.Experimental.Rendering.GraphicsFormat.R32G32_SFloat, // float2(mean, variance)
enableRandomWrite: true,
useMipMap: false,
name: "ProbeVolumeAtlasOctahedralDepthMeanAndVariance"
);
probeVolumeAtlasOctahedralDepth = new Texture2DAtlasDynamic(
s_ProbeVolumeAtlasOctahedralDepthWidth,
s_ProbeVolumeAtlasOctahedralDepthHeight,
k_MaxVisibleProbeVolumeCount,
m_ProbeVolumeAtlasOctahedralDepthRTHandle
);
}
void InitScreenSpaceGlobalIllumination()
{
if (m_Asset.currentPlatformRenderPipelineSettings.supportSSGI)
{
m_IndirectDiffuseBuffer0 = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, autoGenerateMips: false, name: "IndirectDiffuseBuffer0");
m_IndirectDiffuseBuffer1 = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, autoGenerateMips: false, name: "IndirectDiffuseBuffer1");
m_IndirectDiffuseHitPointBuffer = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R16G16_SFloat, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, autoGenerateMips: false, name: "IndirectDiffuseHitBuffer");
// Grab the sets of shaders that we'll be using
ComputeShader ssGICS = m_Asset.renderPipelineResources.shaders.screenSpaceGlobalIlluminationCS;
ComputeShader bilateralUpsampleCS = m_Asset.renderPipelineResources.shaders.bilateralUpsampleCS;
// Grab the set of kernels that we shall be using
m_TraceGlobalIlluminationKernel = ssGICS.FindKernel("TraceGlobalIllumination");
m_TraceGlobalIlluminationHalfKernel = ssGICS.FindKernel("TraceGlobalIlluminationHalf");
m_ReprojectGlobalIlluminationKernel = ssGICS.FindKernel("ReprojectGlobalIllumination");
m_ReprojectGlobalIlluminationHalfKernel = ssGICS.FindKernel("ReprojectGlobalIlluminationHalf");
m_BilateralUpSampleColorTMKernel = bilateralUpsampleCS.FindKernel("BilateralUpSampleColorTM");
}
}
public void Initialize(HDRenderPipeline renderPipeline)
{
// Keep track of the external buffers
m_RenderPipelineResources = renderPipeline.asset.renderPipelineResources;
m_RenderPipelineRayTracingResources = renderPipeline.asset.renderPipelineRayTracingResources;
// Keep track of the render pipeline
m_RenderPipeline = renderPipeline;
// Texture used to output debug information
m_DebugLightClusterTexture = RTHandles.Alloc(Vector2.one, TextureXR.slices, dimension: TextureXR.dimension, filterMode: FilterMode.Point, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, name: "DebugLightClusterTexture");
// Pre allocate the cluster with a dummy size
m_LightCluster = new ComputeBuffer(1, sizeof(uint));
m_LightDataGPUArray = new ComputeBuffer(1, System.Runtime.InteropServices.Marshal.SizeOf(typeof(LightData)));
m_EnvLightDataGPUArray = new ComputeBuffer(1, System.Runtime.InteropServices.Marshal.SizeOf(typeof(EnvLightData)));
// Create the material required for debug
m_DebugMaterial = CoreUtils.CreateEngineMaterial(m_RenderPipelineRayTracingResources.lightClusterDebugS);
}
public static void InitializeBudget(uint maxTextureCount)
{
if (m_RenderTargets == null || m_RenderTargets.Length != maxTextureCount)
{
m_RenderTargets = new RTHandle[maxTextureCount];
m_RenderTargetIds = new int[maxTextureCount];
ShadowRendering.maxTextureCount = maxTextureCount;
for (int i = 0; i < maxTextureCount; i++)
{
m_RenderTargetIds[i] = Shader.PropertyToID($"ShadowTex_{i}");
m_RenderTargets[i] = RTHandles.Alloc(m_RenderTargetIds[i], $"ShadowTex_{i}");
}
}
if (m_LightInputTextures == null || m_LightInputTextures.Length != maxTextureCount)
{
m_LightInputTextures = new RenderTargetIdentifier[maxTextureCount];
}
}
internal void ReleaseRayTracingManager()
{
RTHandles.Release(m_RayTracingDistanceBuffer);
RTHandles.Release(m_RayTracingDirectionBuffer);
RTHandles.Release(m_RayTracingIntermediateBufferR0);
RTHandles.Release(m_RayTracingIntermediateBufferR1);
RTHandles.Release(m_RayTracingIntermediateBufferRG0);
RTHandles.Release(m_RayTracingIntermediateBufferRGBA0);
RTHandles.Release(m_RayTracingIntermediateBufferRGBA1);
RTHandles.Release(m_RayTracingIntermediateBufferRGBA2);
RTHandles.Release(m_RayTracingIntermediateBufferRGBA3);
m_RayTracingLightCluster.ReleaseResources();
m_ReflectionDenoiser.Release();
m_TemporalFilter.Release();
m_SimpleDenoiser.Release();
m_DiffuseDenoiser.Release();
m_RayCountManager.Release();
}
/// <summary>
/// Releases all native resources allocated by this instance.
/// </summary>
public void Release()
{
if (colorRt != null)
{
RTHandles.Release(colorRt);
colorRt = null;
}
if (depthRt != null)
{
RTHandles.Release(depthRt);
depthRt = null;
}
if (uiRt != null)
{
RTHandles.Release(uiRt);
uiRt = null;
}
}
public void Cleanup()
{
CoreUtils.Destroy(m_CombineLightingPass);
CoreUtils.Destroy(m_CopyStencilForSplitLighting);
for (int i = 0; i < k_MaxSSSBuffer; ++i)
{
if (!m_ReuseGBufferMemory [i])
{
RTHandles.Release(m_ColorMRTs[i]);
if (m_MSAASupport)
{
RTHandles.Release(m_ColorMSAAMRTs[i]);
}
}
}
RTHandles.Release(m_CameraFilteringBuffer);
RTHandles.Release(m_HTile);
}
protected override void Setup(ScriptableRenderContext renderContext, CommandBuffer cmd)
{
// Hidden foreground camera:
var cam = GameObject.Find(kCameraTag);
if (cam == null)
{
cam = new GameObject(kCameraTag);
// cam = new GameObject(kCameraTag) { hideFlags = HideFlags.HideAndDontSave };
cam.AddComponent <Camera>();
}
depthClearMaterial = new Material(Shader.Find("Hidden/Renderers/ForegroundDepthClear"));
var trueDethBuffer = new RenderTargetIdentifier(BuiltinRenderTextureType.Depth);
trueDepthBuffer = RTHandles.Alloc(trueDethBuffer);
foregroundCamera = cam.GetComponent <Camera>();
}
public Texture2DAtlas(int width, int height, RenderTextureFormat format)
{
m_Width = width;
m_Height = height;
m_Format = format;
m_AtlasTexture = RTHandles.Alloc(m_Width,
m_Height,
1,
DepthBits.None,
m_Format,
FilterMode.Point,
TextureWrapMode.Clamp,
TextureDimension.Tex2D,
false,
false,
true,
false);
m_AtlasAllocator = new AtlasAllocator(width, height);
}
public override void OnEnable()
{
base.OnEnable();
// HDRI sky does not have control over sun display.
m_CommonUIElementsMask = 0xFFFFFFFF & ~(uint)(SkySettingsUIElement.IncludeSunInBaking);
var o = new PropertyFetcher <HDRISky>(serializedObject);
m_hdriSky = Unpack(o.Find(x => x.hdriSky));
m_DesiredLuxValue = Unpack(o.Find(x => x.desiredLuxValue));
m_IntensityMode = Unpack(o.Find(x => x.skyIntensityMode));
m_UpperHemisphereLuxValue = Unpack(o.Find(x => x.upperHemisphereLuxValue));
m_IntensityTexture = RTHandles.Alloc(1, 1, colorFormat: GraphicsFormat.R32G32B32A32_SFloat);
var hdrp = HDRenderPipeline.defaultAsset;
m_IntegrateHDRISkyMaterial = CoreUtils.CreateEngineMaterial(hdrp.renderPipelineResources.shaders.integrateHdriSkyPS);
readBackTexture = new Texture2D(1, 1, TextureFormat.RGBAFloat, false, false);
}
protected override void Setup(ScriptableRenderContext renderContext, CommandBuffer cmd)
{
outlineShader = Shader.Find("Hidden/Outline");
fullscreenOutline = CoreUtils.CreateEngineMaterial(outlineShader);
outlineProperties = new MaterialPropertyBlock();
// List all the materials that will be replaced in the frame
shaderTags = new ShaderTagId[3]
{
new ShaderTagId("Forward"),
new ShaderTagId("ForwardOnly"),
new ShaderTagId("SRPDefaultUnlit"),
};
outlineBuffer = RTHandles.Alloc(
Vector2.one, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.B10G11R11_UFloatPack32,
useDynamicScale: true, name: "Outline Buffer"
);
}
public void Cleanup()
{
CoreUtils.Destroy(m_StandardSkyboxMaterial);
CoreUtils.Destroy(m_BlitCubemapMaterial);
CoreUtils.Destroy(m_OpaqueAtmScatteringMaterial);
RTHandles.Release(m_SkyboxBSDFCubemapIntermediate);
CoreUtils.Destroy(m_BlackCubemapArray);
for (int i = 0; i < m_CachedSkyContexts.size; ++i)
{
m_CachedSkyContexts[i].Cleanup();
}
m_StaticLightingSky.Cleanup();
#if UNITY_EDITOR
CoreUtils.Destroy(m_DefaultPreviewSky);
#endif
}
private void InitializeBuffers()
{
m_ColorBuffer = RTHandles.Alloc(Vector2.one,
colorFormat: SystemInfo.GetGraphicsFormat(UnityEngine.Experimental.Rendering.DefaultFormat.HDR),
enableMSAA: true,
bindTextureMS: false,
name: "ColorBuffer");
m_BackgroundBuffer = RTHandles.Alloc(Vector2.one,
colorFormat: SystemInfo.GetGraphicsFormat(UnityEngine.Experimental.Rendering.DefaultFormat.HDR),
enableMSAA: true,
bindTextureMS: true, //NOTE: We resolve on final pass
name: "BackgroundBuffer");
m_StochasticColorBuffer = RTHandles.Alloc(Vector2.one,
colorFormat: SystemInfo.GetGraphicsFormat(UnityEngine.Experimental.Rendering.DefaultFormat.HDR),
enableMSAA: true,
bindTextureMS: false, //NOTE: We want to resolve before final pass
name: "StochasticColorBuffer");
m_DepthStencilBuffer = RTHandles.Alloc(Vector2.one,
depthBufferBits: DepthBits.Depth32,
enableMSAA: true,
name: "DepthStencilBuffer");
m_TransmissionBuffer = RTHandles.Alloc(Vector2.one,
colorFormat: UnityEngine.Experimental.Rendering.GraphicsFormat.R16_SFloat,
enableMSAA: true,
bindTextureMS: true, // NOTE: We resolve on final pass
name: "TransmissionBuffer"); // NOTE: No MSAA on opacity for now.
// Alloc History Buffers
m_HistoryBuffers = new RTHandle[2];
for (int i = 0; i < m_HistoryBuffers.Length; ++i)
{
m_HistoryBuffers[i] = RTHandles.Alloc(Vector2.one,
colorFormat: SystemInfo.GetGraphicsFormat(UnityEngine.Experimental.Rendering.DefaultFormat.HDR),
enableMSAA: false,
name: "HistoryBuffer" + i);
}
}
