void RenderReflectionsPerformance(HDCamera hdCamera, CommandBuffer cmd, RTHandle outputTexture, ScriptableRenderContext renderContext, int frameCount, bool transparent)
{
// Fetch the required resources
BlueNoise blueNoise = GetBlueNoiseManager();
RayTracingShader reflectionShaderRT = m_Asset.renderPipelineRayTracingResources.reflectionRaytracingRT;
ComputeShader reflectionShaderCS = m_Asset.renderPipelineRayTracingResources.reflectionRaytracingCS;
ComputeShader reflectionFilter = m_Asset.renderPipelineRayTracingResources.reflectionBilateralFilterCS;
RTHandle intermediateBuffer0 = GetRayTracingBuffer(InternalRayTracingBuffers.RGBA0);
RTHandle intermediateBuffer1 = GetRayTracingBuffer(InternalRayTracingBuffers.RGBA1);
CoreUtils.SetRenderTarget(cmd, intermediateBuffer1, m_SharedRTManager.GetDepthStencilBuffer(), ClearFlag.Color, clearColor: Color.black);
// Fetch all the settings
var settings = hdCamera.volumeStack.GetComponent <ScreenSpaceReflection>();
LightCluster lightClusterSettings = hdCamera.volumeStack.GetComponent <LightCluster>();
RayTracingSettings rtSettings = hdCamera.volumeStack.GetComponent <RayTracingSettings>();
// Texture dimensions
int texWidth = hdCamera.actualWidth;
int texHeight = hdCamera.actualHeight;
// Evaluate the dispatch parameters
int areaTileSize = 8;
int numTilesXHR = 0, numTilesYHR = 0;
int currentKernel = 0;
RenderTargetIdentifier clearCoatMaskTexture;
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.RaytracingIntegrateReflection)))
{
// Fetch the new sample kernel
if (settings.fullResolution.value)
{
currentKernel = transparent ? m_RaytracingReflectionsTransparentFullResKernel : m_RaytracingReflectionsFullResKernel;
}
else
{
currentKernel = transparent ? m_RaytracingReflectionsTransparentHalfResKernel : m_RaytracingReflectionsHalfResKernel;
}
// Inject the ray-tracing sampling data
blueNoise.BindDitheredRNGData8SPP(cmd);
// Bind all the required textures
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
clearCoatMaskTexture = hdCamera.frameSettings.litShaderMode == LitShaderMode.Deferred ? m_GbufferManager.GetBuffersRTI()[2] : TextureXR.GetBlackTexture();
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._SsrClearCoatMaskTexture, clearCoatMaskTexture);
cmd.SetComputeIntParam(reflectionShaderCS, HDShaderIDs._SsrStencilBit, (int)StencilUsage.TraceReflectionRay);
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._StencilTexture, m_SharedRTManager.GetDepthStencilBuffer(), 0, RenderTextureSubElement.Stencil);
// Bind all the required scalars
m_ShaderVariablesRayTracingCB._RaytracingIntensityClamp = settings.clampValue.value;
m_ShaderVariablesRayTracingCB._RaytracingIncludeSky = settings.reflectSky.value ? 1 : 0;
ConstantBuffer.PushGlobal(cmd, m_ShaderVariablesRayTracingCB, HDShaderIDs._ShaderVariablesRaytracing);
// Bind the output buffers
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._RaytracingDirectionBuffer, intermediateBuffer1);
if (settings.fullResolution.value)
{
// Evaluate the dispatch parameters
numTilesXHR = (texWidth + (areaTileSize - 1)) / areaTileSize;
numTilesYHR = (texHeight + (areaTileSize - 1)) / areaTileSize;
}
else
{
// Evaluate the dispatch parameters
numTilesXHR = (texWidth / 2 + (areaTileSize - 1)) / areaTileSize;
numTilesYHR = (texHeight / 2 + (areaTileSize - 1)) / areaTileSize;
}
// Compute the directions
cmd.DispatchCompute(reflectionShaderCS, currentKernel, numTilesXHR, numTilesYHR, hdCamera.viewCount);
// Prepare the components for the deferred lighting
DeferredLightingRTParameters deferredParamters = PrepareReflectionDeferredLightingRTParameters(hdCamera);
DeferredLightingRTResources deferredResources = PrepareDeferredLightingRTResources(hdCamera, intermediateBuffer1, intermediateBuffer0);
// Evaluate the deferred lighting
RenderRaytracingDeferredLighting(cmd, deferredParamters, deferredResources);
// Fetch the right filter to use
if (settings.fullResolution.value)
{
currentKernel = reflectionFilter.FindKernel("ReflectionIntegrationUpscaleFullRes");
}
else
{
currentKernel = reflectionFilter.FindKernel("ReflectionIntegrationUpscaleHalfRes");
}
// Inject all the parameters for the compute
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._SsrLightingTextureRW, intermediateBuffer0);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._SsrHitPointTexture, intermediateBuffer1);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._BlueNoiseTexture, blueNoise.textureArray16RGB);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, "_RaytracingReflectionTexture", outputTexture);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._ScramblingTexture, m_Asset.renderPipelineResources.textures.scramblingTex);
cmd.SetComputeIntParam(reflectionFilter, HDShaderIDs._SpatialFilterRadius, settings.upscaleRadius.value);
cmd.SetComputeIntParam(reflectionFilter, HDShaderIDs._RaytracingDenoiseRadius, settings.denoise.value ? settings.denoiserRadius.value : 0);
numTilesXHR = (texWidth + (areaTileSize - 1)) / areaTileSize;
numTilesYHR = (texHeight + (areaTileSize - 1)) / areaTileSize;
// Bind the right texture for clear coat support
clearCoatMaskTexture = hdCamera.frameSettings.litShaderMode == LitShaderMode.Deferred ? m_GbufferManager.GetBuffersRTI()[2] : TextureXR.GetBlackTexture();
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._SsrClearCoatMaskTexture, clearCoatMaskTexture);
// Compute the texture
cmd.DispatchCompute(reflectionFilter, currentKernel, numTilesXHR, numTilesYHR, hdCamera.viewCount);
}
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.RaytracingFilterReflection)))
{
if (settings.denoise.value && !transparent)
{
// Grab the history buffer
RTHandle reflectionHistory = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection)
?? hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection, ReflectionHistoryBufferAllocatorFunction, 1);
float historyValidity = 1.0f;
#if UNITY_HDRP_DXR_TESTS_DEFINE
if (Application.isPlaying)
{
historyValidity = 0.0f;
}
else
#endif
// We need to check if something invalidated the history buffers
historyValidity *= ValidRayTracingHistory(hdCamera) ? 1.0f : 0.0f;
HDReflectionDenoiser reflectionDenoiser = GetReflectionDenoiser();
reflectionDenoiser.DenoiseBuffer(cmd, hdCamera, settings.denoiserRadius.value, outputTexture, reflectionHistory, intermediateBuffer0, historyValidity: historyValidity);
HDUtils.BlitCameraTexture(cmd, intermediateBuffer0, outputTexture);
}
}
}
private void CameraEndRendering(ScriptableRenderContext context, Camera camera)
{
CameraPostRender(camera);
}
private void CameraEndFrameRendering(ScriptableRenderContext ctx, Camera[] cameras)
{
}
public void RenderReflections(HDCamera hdCamera, CommandBuffer cmd, RTHandleSystem.RTHandle outputTexture, ScriptableRenderContext renderContext, uint frameCount)
{
// First thing to check is: Do we have a valid ray-tracing environment?
HDRaytracingEnvironment rtEnvironement = m_RaytracingManager.CurrentEnvironment();
BlueNoise blueNoise = m_RaytracingManager.GetBlueNoiseManager();
ComputeShader bilateralFilter = m_PipelineAsset.renderPipelineResources.shaders.reflectionBilateralFilterCS;
RaytracingShader reflectionShader = m_PipelineAsset.renderPipelineResources.shaders.reflectionRaytracing;
bool missingResources = rtEnvironement == null || blueNoise == null || bilateralFilter == null || reflectionShader == null ||
m_PipelineResources.textures.owenScrambledTex == null || m_PipelineResources.textures.scramblingTex == null;
// Try to grab the acceleration structure and the list of HD lights for the target camera
RaytracingAccelerationStructure accelerationStructure = m_RaytracingManager.RequestAccelerationStructure(hdCamera);
HDRaytracingLightCluster lightCluster = m_RaytracingManager.RequestLightCluster(hdCamera);
// If no acceleration structure available, end it now
if (accelerationStructure == null || lightCluster == null || missingResources)
{
return;
}
// Compute the actual resolution that is needed base on the quality
string targetRayGen = "";
switch (rtEnvironement.reflQualityMode)
{
case HDRaytracingEnvironment.ReflectionsQuality.QuarterRes:
{
targetRayGen = m_RayGenHalfResName;
};
break;
case HDRaytracingEnvironment.ReflectionsQuality.Integration:
{
targetRayGen = m_RayGenIntegrationName;
};
break;
}
// Define the shader pass to use for the reflection pass
cmd.SetRaytracingShaderPass(reflectionShader, "ReflectionDXR");
// Set the acceleration structure for the pass
cmd.SetRaytracingAccelerationStructure(reflectionShader, HDShaderIDs._RaytracingAccelerationStructureName, accelerationStructure);
// Inject the ray-tracing sampling data
cmd.SetRaytracingTextureParam(reflectionShader, targetRayGen, HDShaderIDs._OwenScrambledTexture, m_PipelineResources.textures.owenScrambledTex);
cmd.SetRaytracingTextureParam(reflectionShader, targetRayGen, HDShaderIDs._ScramblingTexture, m_PipelineResources.textures.scramblingTex);
// Global reflection parameters
cmd.SetRaytracingFloatParams(reflectionShader, HDShaderIDs._RaytracingIntensityClamp, rtEnvironement.reflClampValue);
cmd.SetRaytracingFloatParams(reflectionShader, HDShaderIDs._RaytracingReflectionMinSmoothness, rtEnvironement.reflMinSmoothness);
cmd.SetRaytracingFloatParams(reflectionShader, HDShaderIDs._RaytracingReflectionMaxDistance, rtEnvironement.reflBlendDistance);
// Inject the ray generation data
cmd.SetGlobalFloat(HDShaderIDs._RaytracingRayBias, rtEnvironement.rayBias);
cmd.SetGlobalFloat(HDShaderIDs._RaytracingRayMaxLength, rtEnvironement.reflRayLength);
cmd.SetRaytracingIntParams(reflectionShader, HDShaderIDs._RaytracingNumSamples, rtEnvironement.reflNumMaxSamples);
int frameIndex = hdCamera.IsTAAEnabled() ? hdCamera.taaFrameIndex : (int)frameCount % 8;
cmd.SetGlobalInt(HDShaderIDs._RaytracingFrameIndex, frameIndex);
// Set the data for the ray generation
cmd.SetRaytracingTextureParam(reflectionShader, targetRayGen, HDShaderIDs._SsrLightingTextureRW, m_LightingTexture);
cmd.SetRaytracingTextureParam(reflectionShader, targetRayGen, HDShaderIDs._SsrHitPointTexture, m_HitPdfTexture);
cmd.SetRaytracingTextureParam(reflectionShader, targetRayGen, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetRaytracingTextureParam(reflectionShader, targetRayGen, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
// Set ray count tex
cmd.SetRaytracingIntParam(reflectionShader, HDShaderIDs._RayCountEnabled, m_RaytracingManager.rayCountManager.rayCountEnabled);
cmd.SetRaytracingTextureParam(reflectionShader, targetRayGen, HDShaderIDs._RayCountTexture, m_RaytracingManager.rayCountManager.rayCountTex);
// Compute the pixel spread value
float pixelSpreadAngle = Mathf.Atan(2.0f * Mathf.Tan(hdCamera.camera.fieldOfView * Mathf.PI / 360.0f) / Mathf.Min(hdCamera.actualWidth, hdCamera.actualHeight));
cmd.SetRaytracingFloatParam(reflectionShader, HDShaderIDs._RaytracingPixelSpreadAngle, pixelSpreadAngle);
// LightLoop data
cmd.SetGlobalBuffer(HDShaderIDs._RaytracingLightCluster, lightCluster.GetCluster());
cmd.SetGlobalBuffer(HDShaderIDs._LightDatasRT, lightCluster.GetLightDatas());
cmd.SetGlobalVector(HDShaderIDs._MinClusterPos, lightCluster.GetMinClusterPos());
cmd.SetGlobalVector(HDShaderIDs._MaxClusterPos, lightCluster.GetMaxClusterPos());
cmd.SetGlobalInt(HDShaderIDs._LightPerCellCount, rtEnvironement.maxNumLightsPercell);
cmd.SetGlobalInt(HDShaderIDs._PunctualLightCountRT, lightCluster.GetPunctualLightCount());
cmd.SetGlobalInt(HDShaderIDs._AreaLightCountRT, lightCluster.GetAreaLightCount());
// Evaluate the clear coat mask texture based on the lit shader mode
RenderTargetIdentifier clearCoatMaskTexture = hdCamera.frameSettings.litShaderMode == LitShaderMode.Deferred ? m_GbufferManager.GetBuffersRTI()[2] : Texture2D.blackTexture;
cmd.SetRaytracingTextureParam(reflectionShader, targetRayGen, HDShaderIDs._SsrClearCoatMaskTexture, clearCoatMaskTexture);
// Set the data for the ray miss
cmd.SetRaytracingTextureParam(reflectionShader, m_MissShaderName, HDShaderIDs._SkyTexture, m_SkyManager.skyReflection);
// Compute the actual resolution that is needed base on the quality
uint widthResolution = 1, heightResolution = 1;
switch (rtEnvironement.reflQualityMode)
{
case HDRaytracingEnvironment.ReflectionsQuality.QuarterRes:
{
widthResolution = (uint)hdCamera.actualWidth / 2;
heightResolution = (uint)hdCamera.actualHeight / 2;
};
break;
case HDRaytracingEnvironment.ReflectionsQuality.Integration:
{
widthResolution = (uint)hdCamera.actualWidth;
heightResolution = (uint)hdCamera.actualHeight;
};
break;
}
// Run the calculus
cmd.DispatchRays(reflectionShader, targetRayGen, widthResolution, heightResolution, 1);
using (new ProfilingSample(cmd, "Filter Reflection", CustomSamplerId.RaytracingFilterReflection.GetSampler()))
{
switch (rtEnvironement.reflQualityMode)
{
case HDRaytracingEnvironment.ReflectionsQuality.QuarterRes:
{
// Fetch the right filter to use
int currentKernel = bilateralFilter.FindKernel("RaytracingReflectionFilter");
// Inject all the parameters for the compute
cmd.SetComputeTextureParam(bilateralFilter, currentKernel, HDShaderIDs._SsrLightingTextureRW, m_LightingTexture);
cmd.SetComputeTextureParam(bilateralFilter, currentKernel, HDShaderIDs._SsrHitPointTexture, m_HitPdfTexture);
cmd.SetComputeTextureParam(bilateralFilter, currentKernel, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetComputeTextureParam(bilateralFilter, currentKernel, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
cmd.SetComputeTextureParam(bilateralFilter, currentKernel, "_NoiseTexture", blueNoise.textureArray16RGB);
cmd.SetComputeTextureParam(bilateralFilter, currentKernel, "_VarianceTexture", m_VarianceBuffer);
cmd.SetComputeTextureParam(bilateralFilter, currentKernel, "_MinColorRangeTexture", m_MinBoundBuffer);
cmd.SetComputeTextureParam(bilateralFilter, currentKernel, "_MaxColorRangeTexture", m_MaxBoundBuffer);
cmd.SetComputeTextureParam(bilateralFilter, currentKernel, "_RaytracingReflectionTexture", outputTexture);
cmd.SetComputeTextureParam(bilateralFilter, currentKernel, HDShaderIDs._ScramblingTexture, m_PipelineResources.textures.scramblingTex);
cmd.SetComputeIntParam(bilateralFilter, HDShaderIDs._SpatialFilterRadius, rtEnvironement.reflSpatialFilterRadius);
// Texture dimensions
int texWidth = outputTexture.rt.width;
int texHeight = outputTexture.rt.width;
// Evaluate the dispatch parameters
int areaTileSize = 8;
int numTilesXHR = (texWidth / 2 + (areaTileSize - 1)) / areaTileSize;
int numTilesYHR = (texHeight / 2 + (areaTileSize - 1)) / areaTileSize;
// Bind the right texture for clear coat support
cmd.SetComputeTextureParam(bilateralFilter, currentKernel, HDShaderIDs._SsrClearCoatMaskTexture, clearCoatMaskTexture);
// Compute the texture
cmd.DispatchCompute(bilateralFilter, currentKernel, numTilesXHR, numTilesYHR, 1);
int numTilesXFR = (texWidth + (areaTileSize - 1)) / areaTileSize;
int numTilesYFR = (texHeight + (areaTileSize - 1)) / areaTileSize;
RTHandleSystem.RTHandle history = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection)
?? hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection, ReflectionHistoryBufferAllocatorFunction, 1);
// Fetch the right filter to use
currentKernel = bilateralFilter.FindKernel("TemporalAccumulationFilter");
cmd.SetComputeFloatParam(bilateralFilter, HDShaderIDs._TemporalAccumuationWeight, rtEnvironement.reflTemporalAccumulationWeight);
cmd.SetComputeTextureParam(bilateralFilter, currentKernel, HDShaderIDs._AccumulatedFrameTexture, history);
cmd.SetComputeTextureParam(bilateralFilter, currentKernel, HDShaderIDs._CurrentFrameTexture, outputTexture);
cmd.SetComputeTextureParam(bilateralFilter, currentKernel, "_MinColorRangeTexture", m_MinBoundBuffer);
cmd.SetComputeTextureParam(bilateralFilter, currentKernel, "_MaxColorRangeTexture", m_MaxBoundBuffer);
cmd.DispatchCompute(bilateralFilter, currentKernel, numTilesXFR, numTilesYFR, 1);
}
break;
case HDRaytracingEnvironment.ReflectionsQuality.Integration:
{
HDUtils.BlitCameraTexture(cmd, hdCamera, m_LightingTexture, outputTexture);
}
break;
}
}
}
public void Render(ScriptableRenderContext IN_context,
Camera IN_camera, CameraBufferSettings cameraBufferSettings, bool useDynameicBatching,
bool useGPUInstancing, bool useLightPerObject,
ShadowSettings shadowSetting, PostFXSettings postFXSettings, int colorLUTResolution)
{
this.context = IN_context;
this.camera = IN_camera;
//setup custom camera settings
//for per camera blend, PostFX settings
var crpCamera = camera.GetComponent<CustomRenderPipelineCamera>();
CameraSettings cameraSettings = crpCamera ? crpCamera.Settings : defaultCameraSettings;
//use depthtexture so shader can access the current buffer depth
if (camera.cameraType == CameraType.Reflection)
{
useDepthTexture = cameraBufferSettings.copyDepthReflection;
useColorTexture = cameraBufferSettings.copyColorReflection;
}
else
{
useDepthTexture = cameraBufferSettings.copyDepth && cameraSettings.copyDepth;
useColorTexture = cameraBufferSettings.copyColor && cameraSettings.copyColor;
}
if (cameraSettings.overridePostFX)
{
//override PostFX option for each cam
postFXSettings = cameraSettings.postFXSettings;
}
//set render scale, scale should atleast move a bit to take effect
float renderScale = cameraSettings.GetRenderScale(cameraBufferSettings.renderScale);
useScaledRendering = renderScale < 0.99f || renderScale > 1.01f;
//change buffer name to the camera name
PrepareBuffer();
//add UI (WorldGeometry) to the scene camera, so we can see UI in editor view
PrepareForSceneView();
if (!Cull(shadowSetting.maxDistance))
{
return;
}
this.useHDR = cameraBufferSettings.allowHDR && camera.allowHDR;
//calculate and store buffersize
if (useScaledRendering)
{
renderScale = Mathf.Clamp(renderScale, renderScaleMin, renderScaleMax);
bufferSize.x = (int)(camera.pixelWidth * renderScale);
bufferSize.y = (int)(camera.pixelHeight * renderScale);
}
else
{
bufferSize.x = camera.pixelWidth;
bufferSize.y = camera.pixelHeight;
}
buffer.BeginSample(SampleName);//Include lights and shadow rendering in main cam profile
//pass the buffer size to GPU so the when sample color and depthe texture,
//we can refer to correct buffer size
buffer.SetGlobalVector(bufferSizeId, new Vector4(
(float)1/bufferSize.x, (float)1 /bufferSize.y, bufferSize.x, bufferSize.y
));
ExecuteBuffer();
//get transfer DirLight data to GPU
//Setup shadow RT and shadow rendering
lighting.Setup(context, cullingResults, shadowSetting, useLightPerObject,
cameraSettings.maskLights ? cameraSettings.RenderingLayerMask : -1);
//FXAA is enable per camera
cameraBufferSettings.fxaa.enabled = cameraSettings.allowFXAA;
//setup postFX
postFXStack.Setup(context, camera,
bufferSize, postFXSettings, cameraSettings.keepAlpha, useHDR,
colorLUTResolution, cameraSettings.finalBlendMode,
cameraBufferSettings.bicubicResampling,
cameraBufferSettings.fxaa);
buffer.EndSample(SampleName);
//Setup rendertarget for normal oject rendering
Setup();
DrawVisibleGeometry(useDynameicBatching, useGPUInstancing, useLightPerObject, cameraSettings.RenderingLayerMask);
//this makes the Legacy shader draw upon the tranparent object
//makes it wired, but they are not supported who cares~
DrawUnsupportedShaders();
DrawGizmosBeforeFX();
if (postFXStack.IsActive)
{
postFXStack.Render(colorAttachmentId);
}
else if (useIntermediateBuffer)
{
// we need to copy the image from intermediate to final
//otherwise nothing goes to camera target, Since PFX is not active
//Draw(colorAttachmentId, BuiltinRenderTextureType.CameraTarget);
DrawFinal(cameraSettings.finalBlendMode);
ExecuteBuffer();
}
DrawGizmosAfterFX();
Cleanup();
//all action will be buffered and render action only begin after submit!
Submit();
}
public override void Setup(ScriptableRenderContext context, ref RenderingData renderingData)
{
Camera camera = renderingData.cameraData.camera;
RenderTextureDescriptor cameraTargetDescriptor = renderingData.cameraData.cameraTargetDescriptor;
// Special path for depth only offscreen cameras. Only write opaques + transparents.
bool isOffscreenDepthTexture = camera.targetTexture != null && camera.targetTexture.format == RenderTextureFormat.Depth;
if (isOffscreenDepthTexture)
{
ConfigureCameraTarget(BuiltinRenderTextureType.CameraTarget, BuiltinRenderTextureType.CameraTarget);
for (int i = 0; i < rendererFeatures.Count; ++i)
{
rendererFeatures[i].AddRenderPasses(this, ref renderingData);
}
EnqueuePass(m_RenderOpaqueForwardPass);
EnqueuePass(m_DrawSkyboxPass);
EnqueuePass(m_RenderTransparentForwardPass);
return;
}
bool mainLightShadows = m_MainLightShadowCasterPass.Setup(ref renderingData);
bool additionalLightShadows = m_AdditionalLightsShadowCasterPass.Setup(ref renderingData);
bool resolveShadowsInScreenSpace = mainLightShadows && renderingData.shadowData.requiresScreenSpaceShadowResolve;
// Depth prepass is generated in the following cases:
// - We resolve shadows in screen space
// - Scene view camera always requires a depth texture. We do a depth pre-pass to simplify it and it shouldn't matter much for editor.
// - If game or offscreen camera requires it we check if we can copy the depth from the rendering opaques pass and use that instead.
bool requiresDepthPrepass = renderingData.cameraData.isSceneViewCamera ||
(renderingData.cameraData.requiresDepthTexture && (!CanCopyDepth(ref renderingData.cameraData)));
requiresDepthPrepass |= resolveShadowsInScreenSpace;
// TODO: There's an issue in multiview and depth copy pass. Atm forcing a depth prepass on XR until
// we have a proper fix.
if (renderingData.cameraData.isStereoEnabled && renderingData.cameraData.requiresDepthTexture)
{
requiresDepthPrepass = true;
}
bool createColorTexture = RequiresIntermediateColorTexture(ref renderingData, cameraTargetDescriptor) ||
rendererFeatures.Count != 0;
// If camera requires depth and there's no depth pre-pass we create a depth texture that can be read
// later by effect requiring it.
bool createDepthTexture = renderingData.cameraData.requiresDepthTexture && !requiresDepthPrepass;
bool postProcessEnabled = renderingData.cameraData.postProcessEnabled;
bool hasOpaquePostProcess = postProcessEnabled &&
renderingData.cameraData.postProcessLayer.HasOpaqueOnlyEffects(RenderingUtils.postProcessRenderContext);
m_ActiveCameraColorAttachment = (createColorTexture) ? m_CameraColorAttachment : RenderTargetHandle.CameraTarget;
m_ActiveCameraDepthAttachment = (createDepthTexture) ? m_CameraDepthAttachment : RenderTargetHandle.CameraTarget;
if (createColorTexture || createDepthTexture)
{
CreateCameraRenderTarget(context, ref renderingData.cameraData);
}
ConfigureCameraTarget(m_ActiveCameraColorAttachment.Identifier(), m_ActiveCameraDepthAttachment.Identifier());
for (int i = 0; i < rendererFeatures.Count; ++i)
{
rendererFeatures[i].AddRenderPasses(this, ref renderingData);
}
int count = activeRenderPassQueue.Count;
for (int i = count - 1; i >= 0; i--)
{
if (activeRenderPassQueue[i] == null)
{
activeRenderPassQueue.RemoveAt(i);
}
}
bool hasAfterRendering = activeRenderPassQueue.Find(x => x.renderPassEvent == RenderPassEvent.AfterRendering) != null;
if (mainLightShadows)
{
EnqueuePass(m_MainLightShadowCasterPass);
}
if (additionalLightShadows)
{
EnqueuePass(m_AdditionalLightsShadowCasterPass);
}
if (requiresDepthPrepass)
{
m_DepthPrepass.Setup(cameraTargetDescriptor, m_DepthTexture);
EnqueuePass(m_DepthPrepass);
}
if (resolveShadowsInScreenSpace)
{
m_ScreenSpaceShadowResolvePass.Setup(cameraTargetDescriptor);
EnqueuePass(m_ScreenSpaceShadowResolvePass);
}
EnqueuePass(m_RenderOpaqueForwardPass);
if (hasOpaquePostProcess)
{
m_OpaquePostProcessPass.Setup(cameraTargetDescriptor, m_ActiveCameraColorAttachment, m_ActiveCameraColorAttachment);
}
if (camera.clearFlags == CameraClearFlags.Skybox && RenderSettings.skybox != null)
{
EnqueuePass(m_DrawSkyboxPass);
}
// If a depth texture was created we necessarily need to copy it, otherwise we could have render it to a renderbuffer
if (createDepthTexture)
{
m_CopyDepthPass.Setup(m_ActiveCameraDepthAttachment, m_DepthTexture);
EnqueuePass(m_CopyDepthPass);
}
if (renderingData.cameraData.requiresOpaqueTexture)
{
// TODO: Downsampling method should be store in the renderer isntead of in the asset.
// We need to migrate this data to renderer. For now, we query the method in the active asset.
Downsampling downsamplingMethod = LightweightRenderPipeline.asset.opaqueDownsampling;
m_CopyColorPass.Setup(m_ActiveCameraColorAttachment.Identifier(), m_OpaqueColor, downsamplingMethod);
EnqueuePass(m_CopyColorPass);
}
EnqueuePass(m_RenderTransparentForwardPass);
bool afterRenderExists = renderingData.cameraData.captureActions != null ||
hasAfterRendering;
// if we have additional filters
// we need to stay in a RT
if (afterRenderExists)
{
// perform post with src / dest the same
if (postProcessEnabled)
{
m_PostProcessPass.Setup(cameraTargetDescriptor, m_ActiveCameraColorAttachment, m_ActiveCameraColorAttachment);
EnqueuePass(m_PostProcessPass);
}
//now blit into the final target
if (m_ActiveCameraColorAttachment != RenderTargetHandle.CameraTarget)
{
if (renderingData.cameraData.captureActions != null)
{
m_CapturePass.Setup(m_ActiveCameraColorAttachment);
EnqueuePass(m_CapturePass);
}
m_FinalBlitPass.Setup(cameraTargetDescriptor, m_ActiveCameraColorAttachment);
EnqueuePass(m_FinalBlitPass);
}
}
else
{
if (postProcessEnabled)
{
m_PostProcessPass.Setup(cameraTargetDescriptor, m_ActiveCameraColorAttachment, RenderTargetHandle.CameraTarget);
EnqueuePass(m_PostProcessPass);
}
else if (m_ActiveCameraColorAttachment != RenderTargetHandle.CameraTarget)
{
m_FinalBlitPass.Setup(cameraTargetDescriptor, m_ActiveCameraColorAttachment);
EnqueuePass(m_FinalBlitPass);
}
}
#if UNITY_EDITOR
if (renderingData.cameraData.isSceneViewCamera)
{
m_SceneViewDepthCopyPass.Setup(m_DepthTexture);
EnqueuePass(m_SceneViewDepthCopyPass);
}
#endif
}
public void RenderReflectionsT2(HDCamera hdCamera, CommandBuffer cmd, RTHandleSystem.RTHandle outputTexture, ScriptableRenderContext renderContext, int frameCount)
{
// First thing to check is: Do we have a valid ray-tracing environment?
HDRaytracingEnvironment rtEnvironment = m_RayTracingManager.CurrentEnvironment();
// If no acceleration structure available, end it now
if (rtEnvironment == null)
{
return;
}
// Fetch the shaders that we will be using
ComputeShader reflectionFilter = m_Asset.renderPipelineRayTracingResources.reflectionBilateralFilterCS;
RayTracingShader reflectionShader = m_Asset.renderPipelineRayTracingResources.reflectionRaytracingRT;
var settings = VolumeManager.instance.stack.GetComponent <ScreenSpaceReflection>();
LightCluster lightClusterSettings = VolumeManager.instance.stack.GetComponent <LightCluster>();
// Bind all the required data for ray tracing
BindRayTracedReflectionData(cmd, hdCamera, rtEnvironment, reflectionShader, settings, lightClusterSettings);
// Force to disable specular lighting
cmd.SetGlobalInt(HDShaderIDs._EnableSpecularLighting, 0);
// Run the computation
cmd.DispatchRays(reflectionShader, m_RayGenIntegrationName, (uint)hdCamera.actualWidth, (uint)hdCamera.actualHeight, 1);
// Restore the previous state of specular lighting
cmd.SetGlobalInt(HDShaderIDs._EnableSpecularLighting, hdCamera.frameSettings.IsEnabled(FrameSettingsField.SpecularLighting) ? 1 : 0);
using (new ProfilingSample(cmd, "Filter Reflection", CustomSamplerId.RaytracingFilterReflection.GetSampler()))
{
if (settings.enableFilter.value)
{
// Grab the history buffer
RTHandleSystem.RTHandle reflectionHistory = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection)
?? hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection, ReflectionHistoryBufferAllocatorFunction, 1);
HDSimpleDenoiser simpleDenoiser = m_RayTracingManager.GetSimpleDenoiser();
simpleDenoiser.DenoiseBuffer(cmd, hdCamera, m_ReflIntermediateTexture0, reflectionHistory, outputTexture, settings.filterRadius.value, singleChannel: false);
}
else
{
HDUtils.BlitCameraTexture(cmd, m_ReflIntermediateTexture0, outputTexture);
}
}
}
public static void BloomPost(ScriptableRenderContext context, int screenWidth, int screenHeight, MobileBaseSRPAsset pipeLineAsset)
{
Material dualFilterMat = pipeLineAsset.DualFiltering;
int blurOffsetDown = Shader.PropertyToID("_BlurOffsetDown");
int blurOffsetUp = Shader.PropertyToID("_BlurOffsetUp");
int brightId = Shader.PropertyToID("_BrightID");
int bloomResult = Shader.PropertyToID("_BloomResult");
int passes = pipeLineAsset.BloomPasses;
int[] downId = new int[passes];
int[] upId = new int[passes];
//Set Offset to the shader
bloomBuffer.SetGlobalFloat(blurOffsetDown, pipeLineAsset.BlurOffsetDown);
bloomBuffer.SetGlobalFloat(blurOffsetUp, pipeLineAsset.BlurOffsetUp);
//IDs Loop
for (int i = 0; i < passes; i++)
{
downId[i] = Shader.PropertyToID("_DownID" + i);
upId[i] = Shader.PropertyToID("_UpID" + i);
}
//Bright Pass
bloomBuffer.GetTemporaryRT(brightId, screenWidth, screenHeight, 0, FilterMode.Bilinear, RenderTextureFormat.ARGBHalf);
bloomBuffer.SetGlobalTexture("_BrightPassTex", MobileBaseSRPCommonValues.RenderTexture.FrameBufferId);
bloomBuffer.Blit(null, brightId, dualFilterMat, 2);
//DownScale Pass
for (int i = 0; i < passes; i++)
{
bloomBuffer.GetTemporaryRT(downId[i], screenWidth >> i, screenHeight >> i, 0, FilterMode.Bilinear, RenderTextureFormat.ARGBHalf);
if (i == 0)
{
bloomBuffer.SetGlobalTexture("_DownScalePassTex", brightId);
bloomBuffer.Blit(null, downId[i], dualFilterMat, 0);
}
else
{
bloomBuffer.SetGlobalTexture("_DownScalePassTex", downId[i - 1]);
bloomBuffer.Blit(null, downId[i], dualFilterMat, 0);
}
}
//UpScale Pass
for (int i = passes - 1; i > 0; i--)
{
bloomBuffer.GetTemporaryRT(upId[i], screenWidth >> i, screenHeight >> i, 0, FilterMode.Bilinear, RenderTextureFormat.ARGBHalf);
if (i == passes - 1)
{
bloomBuffer.SetGlobalTexture("_UpscalePassTex", downId[i]);
bloomBuffer.SetGlobalTexture("_DownPass", downId[i]);
bloomBuffer.Blit(null, upId[i], dualFilterMat, 1);
}
else
{
bloomBuffer.SetGlobalTexture("_UpscalePassTex", upId[i + 1]);
bloomBuffer.SetGlobalTexture("_DownPass", downId[i]);
bloomBuffer.Blit(null, upId[i], dualFilterMat, 1);
}
}
bloomBuffer.GetTemporaryRT(bloomResult, screenWidth * 2, screenHeight * 2, 0, FilterMode.Bilinear, RenderTextureFormat.ARGBHalf);
bloomBuffer.Blit(upId[1], bloomResult, dualFilterMat, 1);
bloomBuffer.SetGlobalTexture("_BloomResult", bloomResult);
//CleanUp Chain
for (int i = 0; i < passes; i++)
{
bloomBuffer.ReleaseTemporaryRT(downId[i]);
}
for (int i = passes - 1; i > 0; i--)
{
bloomBuffer.ReleaseTemporaryRT(upId[i]);
}
context.ExecuteCommandBuffer(bloomBuffer);
bloomBuffer.Clear();
}
protected virtual void OnSrpCameraPreRender(ScriptableRenderContext context, Camera givenCamera)
{
Process();
}
public void RenderDeferred(ScriptableRenderContext renderContext, Camera camera, VXGI vxgi)
{
if (!camera.TryGetCullingParameters(camera, out var cullingParams))
{
return;
}
_cullResults = renderContext.Cull(ref cullingParams);
renderContext.SetupCameraProperties(camera);
int width = camera.pixelWidth;
int height = camera.pixelHeight;
_command.BeginSample(_command.name);
if (camera.cameraType != CameraType.SceneView)
{
_command.EnableShaderKeyword("PROJECTION_PARAMS_X");
}
else
{
_command.DisableShaderKeyword("PROJECTION_PARAMS_X");
}
_command.GetTemporaryRT(ShaderIDs._CameraDepthTexture, width, height, 24, FilterMode.Point, RenderTextureFormat.Depth, RenderTextureReadWrite.Linear);
_command.GetTemporaryRT(ShaderIDs._CameraGBufferTexture0, width, height, 0, FilterMode.Point, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear);
_command.GetTemporaryRT(ShaderIDs._CameraGBufferTexture1, width, height, 0, FilterMode.Point, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear);
_command.GetTemporaryRT(ShaderIDs._CameraGBufferTexture2, width, height, 0, FilterMode.Point, RenderTextureFormat.ARGB2101010, RenderTextureReadWrite.Linear);
_command.GetTemporaryRT(ShaderIDs._CameraGBufferTexture3, width, height, 0, FilterMode.Point, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
_command.GetTemporaryRT(ShaderIDs.FrameBuffer, width, height, 0, FilterMode.Point, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
_command.SetRenderTarget(_gBufferBinding);
_command.ClearRenderTarget(true, true, Color.clear);
renderContext.ExecuteCommandBuffer(_command);
_command.Clear();
TriggerCameraEvent(renderContext, camera, CameraEvent.BeforeGBuffer, vxgi);
RenderGBuffers(renderContext, camera);
TriggerCameraEvent(renderContext, camera, CameraEvent.AfterGBuffer, vxgi);
CopyCameraTargetToFrameBuffer(renderContext, camera);
bool depthNormalsNeeded = (camera.depthTextureMode & DepthTextureMode.DepthNormals) != DepthTextureMode.None;
if (depthNormalsNeeded)
{
TriggerCameraEvent(renderContext, camera, CameraEvent.BeforeDepthNormalsTexture, vxgi);
RenderCameraDepthNormalsTexture(renderContext, camera);
TriggerCameraEvent(renderContext, camera, CameraEvent.AfterDepthNormalsTexture, vxgi);
}
TriggerCameraEvent(renderContext, camera, CameraEvent.BeforeLighting, vxgi);
RenderLighting(renderContext, camera, vxgi);
TriggerCameraEvent(renderContext, camera, CameraEvent.AfterLighting, vxgi);
if (camera.clearFlags == CameraClearFlags.Skybox)
{
TriggerCameraEvent(renderContext, camera, CameraEvent.BeforeSkybox, vxgi);
RenderSkyBox(renderContext, camera);
TriggerCameraEvent(renderContext, camera, CameraEvent.AfterSkybox, vxgi);
}
UpdatePostProcessingLayer(renderContext, camera, vxgi);
TriggerCameraEvent(renderContext, camera, CameraEvent.BeforeImageEffectsOpaque, vxgi);
RenderPostProcessingOpaqueOnly(renderContext, camera);
TriggerCameraEvent(renderContext, camera, CameraEvent.AfterImageEffectsOpaque, vxgi);
TriggerCameraEvent(renderContext, camera, CameraEvent.BeforeForwardAlpha, vxgi);
RenderTransparent(renderContext, camera);
TriggerCameraEvent(renderContext, camera, CameraEvent.AfterForwardAlpha, vxgi);
TriggerCameraEvent(renderContext, camera, CameraEvent.BeforeImageEffects, vxgi);
RenderPostProcessing(renderContext, camera);
_command.Blit(ShaderIDs.FrameBuffer, BuiltinRenderTextureType.CameraTarget);
renderContext.ExecuteCommandBuffer(_command);
_command.Clear();
TriggerCameraEvent(renderContext, camera, CameraEvent.AfterImageEffects, vxgi);
TriggerCameraEvent(renderContext, camera, CameraEvent.AfterEverything, vxgi);
if (depthNormalsNeeded)
{
_command.ReleaseTemporaryRT(ShaderIDs._CameraDepthNormalsTexture);
}
_command.ReleaseTemporaryRT(ShaderIDs._CameraDepthTexture);
_command.ReleaseTemporaryRT(ShaderIDs._CameraGBufferTexture0);
_command.ReleaseTemporaryRT(ShaderIDs._CameraGBufferTexture1);
_command.ReleaseTemporaryRT(ShaderIDs._CameraGBufferTexture2);
_command.ReleaseTemporaryRT(ShaderIDs._CameraGBufferTexture3);
_command.ReleaseTemporaryRT(ShaderIDs.FrameBuffer);
_command.EndSample(_command.name);
renderContext.ExecuteCommandBuffer(_command);
_command.Clear();
}
/// <summary>
/// The camera has stopped rendering.
/// </summary>
/// <param name="context">The context of the SRP.</param>
/// <param name="camera">The camera that stopped rendering.</param>
#if UNIVERSAL_RENDER_PIPELINE
private void EndCameraRendering(ScriptableRenderContext context, Camera camera)
private static void BeginCameraRendering(ScriptableRenderContext context, Camera camera)
{
_currentCamera = camera;
}
void RenderRayTracedReflections(HDCamera hdCamera, CommandBuffer cmd, RTHandle outputTexture, ScriptableRenderContext renderContext, int frameCount, bool transparent = false)
{
ScreenSpaceReflection reflectionSettings = hdCamera.volumeStack.GetComponent <ScreenSpaceReflection>();
// Based on what the asset supports, follow the volume or force the right mode.
if (m_Asset.currentPlatformRenderPipelineSettings.supportedRayTracingMode == RenderPipelineSettings.SupportedRayTracingMode.Both)
{
switch (reflectionSettings.mode.value)
{
case RayTracingMode.Performance:
{
RenderReflectionsPerformance(hdCamera, cmd, outputTexture, renderContext, frameCount, transparent);
}
break;
case RayTracingMode.Quality:
{
RenderReflectionsQuality(hdCamera, cmd, outputTexture, renderContext, frameCount, transparent);
}
break;
}
}
else if (m_Asset.currentPlatformRenderPipelineSettings.supportedRayTracingMode == RenderPipelineSettings.SupportedRayTracingMode.Quality)
{
RenderReflectionsQuality(hdCamera, cmd, outputTexture, renderContext, frameCount, transparent);
}
else
{
RenderReflectionsPerformance(hdCamera, cmd, outputTexture, renderContext, frameCount, transparent);
}
}
void RenderReflectionsQuality(HDCamera hdCamera, CommandBuffer cmd, RTHandle outputTexture, ScriptableRenderContext renderContext, int frameCount, bool transparent)
{
// Fetch the shaders that we will be using
ComputeShader reflectionFilter = m_Asset.renderPipelineRayTracingResources.reflectionBilateralFilterCS;
RayTracingShader reflectionShader = m_Asset.renderPipelineRayTracingResources.reflectionRaytracingRT;
// Request the buffers we shall be using
RTHandle intermediateBuffer0 = GetRayTracingBuffer(InternalRayTracingBuffers.RGBA0);
RTHandle intermediateBuffer1 = GetRayTracingBuffer(InternalRayTracingBuffers.RGBA1);
var settings = hdCamera.volumeStack.GetComponent <ScreenSpaceReflection>();
LightCluster lightClusterSettings = hdCamera.volumeStack.GetComponent <LightCluster>();
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.RaytracingIntegrateReflection)))
{
// Bind all the required data for ray tracing
BindRayTracedReflectionData(cmd, hdCamera, reflectionShader, settings, lightClusterSettings, intermediateBuffer0, intermediateBuffer1);
// Only use the shader variant that has multi bounce if the bounce count > 1
CoreUtils.SetKeyword(cmd, "MULTI_BOUNCE_INDIRECT", settings.bounceCount.value > 1);
// We are not in the diffuse only case
m_ShaderVariablesRayTracingCB._RayTracingDiffuseLightingOnly = 0;
ConstantBuffer.PushGlobal(cmd, m_ShaderVariablesRayTracingCB, HDShaderIDs._ShaderVariablesRaytracing);
// Run the computation
cmd.DispatchRays(reflectionShader, transparent ? m_RayGenIntegrationTransparentName : m_RayGenIntegrationName, (uint)hdCamera.actualWidth, (uint)hdCamera.actualHeight, (uint)hdCamera.viewCount);
// Disable multi-bounce
CoreUtils.SetKeyword(cmd, "MULTI_BOUNCE_INDIRECT", false);
}
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.RaytracingFilterReflection)))
{
if (settings.denoise.value && !transparent)
{
// Grab the history buffer
RTHandle reflectionHistory = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection)
?? hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection, ReflectionHistoryBufferAllocatorFunction, 1);
float historyValidity = 1.0f;
#if UNITY_HDRP_DXR_TESTS_DEFINE
if (Application.isPlaying)
{
historyValidity = 0.0f;
}
else
#endif
// We need to check if something invalidated the history buffers
historyValidity *= ValidRayTracingHistory(hdCamera) ? 1.0f : 0.0f;
HDReflectionDenoiser reflectionDenoiser = GetReflectionDenoiser();
reflectionDenoiser.DenoiseBuffer(cmd, hdCamera, settings.denoiserRadius.value, intermediateBuffer0, reflectionHistory, outputTexture, historyValidity: historyValidity);
}
else
{
HDUtils.BlitCameraTexture(cmd, intermediateBuffer0, outputTexture);
}
}
}
public void RenderShadows(ScriptableRenderContext renderContext, CommandBuffer cmd, in ShaderVariablesGlobal globalCB, CullingResults cullResults, HDCamera hdCamera)
private void Render(ScriptableRenderContext context, Camera camera)
{
/* Attempt to cull the current camera.
* If it fails to cull, don't render anything to this camera.
*/
ScriptableCullingParameters cullingParameters;
if (!camera.TryGetCullingParameters(out cullingParameters))
{
return;
}
#if UNITY_EDITOR
// For rendering UI in the scene view
if (camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
cullingResults = context.Cull(ref cullingParameters);
// Setup properties for a specific camera.
context.SetupCameraProperties(camera);
/* Creates a graphics command buffer.
* This particular one is told to clear the depth buffer, not the colour, and to set the clear colour to transparent.
* It finally releases the memory it has, as the commands have been sent to the internal buffer of the rendering context.
*/
//var buffer = new CommandBuffer();
//buffer.ClearRenderTarget(true, false, Color.clear);
//context.ExecuteCommandBuffer(buffer);
//buffer.Release();
/* Creates a graphics command buffer.
* This particular one is told to clear the depth buffer, not the colour, and to set the clear colour to transparent.
* It finally releases the memory it has, as the commands have been sent to the internal buffer of the rendering context.
*/
CameraClearFlags clearFlags = camera.clearFlags;
buffer.ClearRenderTarget((clearFlags & CameraClearFlags.Depth) != 0, (clearFlags & CameraClearFlags.Color) != 0, camera.backgroundColor);
buffer.BeginSample("Render Camera"); // Start nested grouping for command buffer (For Frame Debugger)
context.ExecuteCommandBuffer(buffer);
//buffer.Release();
buffer.Clear();
// Once culling and clearing have been completed we can draw the appropriate renderers.
var drawSettings = new DrawingSettings(new ShaderTagId("SRPDefaultUnlit"), new SortingSettings(camera));
var filterSettings = FilteringSettings.defaultValue;
// Only render the opaque objects first. To avoid transparent objects being drawn behind the skybox.
filterSettings.renderQueueRange = RenderQueueRange.opaque;
context.DrawRenderers(cullingResults, ref drawSettings, ref filterSettings);
// Check for any problems drawing objects with custom pipeline.
DrawDefaultPipeline(context, camera);
// Draws a skybox to the specified camera.
context.DrawSkybox(camera);
// After all the opaque objects have been drawn, draw the transparent objects.
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(cullingResults, ref drawSettings, ref filterSettings);
// End nested grouping for command buffer (For Frame Debugger)
buffer.EndSample("Render Camera");
context.ExecuteCommandBuffer(buffer);
buffer.Clear();
// Commands sent to the rendering context are just buffered. They are only excuted once we submit them.
context.Submit();
}
public override void SetupLights(ScriptableRenderContext context, ref RenderingData renderingData)
{
m_ForwardLights.Setup(context, ref renderingData);
}
protected override void Render(ScriptableRenderContext context, Camera[] cameras)
{
BeginFrameRendering(cameras);
foreach (Camera camera in cameras)
{
#if UNITY_EDITOR
bool isSceneViewCam = camera.cameraType == CameraType.SceneView;
if (isSceneViewCam)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera); //This makes the UI Canvas geometry appear on scene view
}
#endif
BeginCameraRendering(camera);
//Culling
ScriptableCullingParameters cullingParams;
if (!camera.TryGetCullingParameters(out cullingParams))
{
continue;
}
CullingResults cull = context.Cull(ref cullingParams);
//Camera setup some builtin variables e.g. camera projection matrices etc
context.SetupCameraProperties(camera);
//Get the setting from camera component
bool drawSkyBox = camera.clearFlags == CameraClearFlags.Skybox? true : false;
bool clearDepth = camera.clearFlags == CameraClearFlags.Nothing? false : true;
bool clearColor = camera.clearFlags == CameraClearFlags.Color? true : false;
//Setup DrawSettings and FilterSettings
var sortingSettings = new SortingSettings(camera);
DrawingSettings drawSettings = new DrawingSettings(m_PassName, sortingSettings);
FilteringSettings filterSettings = new FilteringSettings(RenderQueueRange.all);
//Camera clear flag
CommandBuffer cmd = new CommandBuffer();
cmd.name = "Cam:" + camera.name + " ClearFlag";
cmd.ClearRenderTarget(clearDepth, clearColor, camera.backgroundColor);
context.ExecuteCommandBuffer(cmd);
cmd.Release();
//Skybox
if (drawSkyBox)
{
context.DrawSkybox(camera);
}
//Opaque objects
sortingSettings.criteria = SortingCriteria.CommonOpaque;
drawSettings.sortingSettings = sortingSettings;
filterSettings.renderQueueRange = RenderQueueRange.opaque;
context.DrawRenderers(cull, ref drawSettings, ref filterSettings);
//Transparent objects
sortingSettings.criteria = SortingCriteria.CommonTransparent;
drawSettings.sortingSettings = sortingSettings;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(cull, ref drawSettings, ref filterSettings);
//SceneView fix, so that it draws the gizmos on scene view
#if UNITY_EDITOR
if (isSceneViewCam)
{
context.DrawGizmos(camera, GizmoSubset.PostImageEffects);
}
#endif
context.Submit();
}
}
public void RenderReflectionsT1(HDCamera hdCamera, CommandBuffer cmd, RTHandleSystem.RTHandle outputTexture, ScriptableRenderContext renderContext, int frameCount)
{
// First thing to check is: Do we have a valid ray-tracing environment?
HDRaytracingEnvironment rtEnvironment = m_RayTracingManager.CurrentEnvironment();
// If no ray tracing environment, then we do not want to evaluate this effect
if (rtEnvironment == null)
{
return;
}
// Fetch the required resources
BlueNoise blueNoise = m_RayTracingManager.GetBlueNoiseManager();
RayTracingShader reflectionShaderRT = m_Asset.renderPipelineRayTracingResources.reflectionRaytracingRT;
ComputeShader reflectionShaderCS = m_Asset.renderPipelineRayTracingResources.reflectionRaytracingCS;
ComputeShader reflectionFilter = m_Asset.renderPipelineRayTracingResources.reflectionBilateralFilterCS;
// Fetch all the settings
var settings = VolumeManager.instance.stack.GetComponent <ScreenSpaceReflection>();
LightCluster lightClusterSettings = VolumeManager.instance.stack.GetComponent <LightCluster>();
if (settings.deferredMode.value)
{
// Fetch the new sample kernel
int currentKernel = reflectionShaderCS.FindKernel(settings.fullResolution.value ? "RaytracingReflectionsFullRes" : "RaytracingReflectionsHalfRes");
// Bind all the required textures
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._OwenScrambledTexture, m_Asset.renderPipelineResources.textures.owenScrambledTex);
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._ScramblingTexture, m_Asset.renderPipelineResources.textures.scramblingTex);
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
RenderTargetIdentifier clearCoatMaskTexture = hdCamera.frameSettings.litShaderMode == LitShaderMode.Deferred ? m_GbufferManager.GetBuffersRTI()[2] : TextureXR.GetBlackTexture();
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._SsrClearCoatMaskTexture, clearCoatMaskTexture);
// Bind all the required scalars
cmd.SetComputeFloatParam(reflectionShaderCS, HDShaderIDs._RaytracingIntensityClamp, settings.clampValue.value);
cmd.SetComputeFloatParam(reflectionShaderCS, HDShaderIDs._RaytracingReflectionMinSmoothness, settings.minSmoothness.value);
cmd.SetComputeIntParam(reflectionShaderCS, HDShaderIDs._RaytracingReflectSky, settings.reflectSky.value ? 1 : 0);
// Bind the sampling data
int frameIndex = hdCamera.IsTAAEnabled() ? hdCamera.taaFrameIndex : (int)m_FrameCount % 8;
cmd.SetComputeIntParam(reflectionShaderCS, HDShaderIDs._RaytracingFrameIndex, frameIndex);
// Bind the output buffers
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._RaytracingDirectionBuffer, m_ReflIntermediateTexture1);
// Texture dimensions
int texWidth = hdCamera.actualWidth;
int texHeight = hdCamera.actualHeight;
if (settings.fullResolution.value)
{
// Evaluate the dispatch parameters
int areaTileSize = 8;
int numTilesXHR = (texWidth + (areaTileSize - 1)) / areaTileSize;
int numTilesYHR = (texHeight + (areaTileSize - 1)) / areaTileSize;
// Compute the directions
cmd.DispatchCompute(reflectionShaderCS, currentKernel, numTilesXHR, numTilesYHR, 1);
}
else
{
// Evaluate the dispatch parameters
int areaTileSize = 8;
int numTilesXHR = (texWidth / 2 + (areaTileSize - 1)) / areaTileSize;
int numTilesYHR = (texHeight / 2 + (areaTileSize - 1)) / areaTileSize;
// Compute the directions
cmd.DispatchCompute(reflectionShaderCS, currentKernel, numTilesXHR, numTilesYHR, 1);
}
// Evaluate the deferred lighting
cmd.SetGlobalInt(HDShaderIDs._RaytracingReflectSky, settings.reflectSky.value ? 1 : 0);
RenderRaytracingDeferredLighting(cmd, hdCamera, rtEnvironment, m_ReflIntermediateTexture1, settings.rayBinning.value, rtEnvironment.reflLayerMask, settings.rayLength.value, m_ReflIntermediateTexture0, disableSpecularLighting: true, halfResolution: !settings.fullResolution.value);
}
else
{
// Bind all the required data for ray tracing
BindRayTracedReflectionData(cmd, hdCamera, rtEnvironment, reflectionShaderRT, settings, lightClusterSettings);
// Set the data for the ray miss
cmd.SetRayTracingTextureParam(reflectionShaderRT, HDShaderIDs._SkyTexture, m_SkyManager.skyReflection);
// Force to disable specular lighting
cmd.SetGlobalInt(HDShaderIDs._EnableSpecularLighting, 0);
// Run the computation
if (settings.fullResolution.value)
{
cmd.DispatchRays(reflectionShaderRT, m_RayGenReflectionFullResName, (uint)hdCamera.actualWidth, (uint)hdCamera.actualHeight, 1);
}
else
{
// Run the computation
cmd.DispatchRays(reflectionShaderRT, m_RayGenReflectionHalfResName, (uint)(hdCamera.actualWidth / 2), (uint)(hdCamera.actualHeight / 2), 1);
}
// Restore the previous state of specular lighting
cmd.SetGlobalInt(HDShaderIDs._EnableSpecularLighting, hdCamera.frameSettings.IsEnabled(FrameSettingsField.SpecularLighting) ? 1 : 0);
}
using (new ProfilingSample(cmd, "Filter Reflection", CustomSamplerId.RaytracingFilterReflection.GetSampler()))
{
// Fetch the right filter to use
int currentKernel = 0;
if (settings.fullResolution.value)
{
currentKernel = reflectionFilter.FindKernel("ReflectionIntegrationUpscaleFullRes");
}
else
{
currentKernel = reflectionFilter.FindKernel("ReflectionIntegrationUpscaleHalfRes");
}
// Inject all the parameters for the compute
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._SsrLightingTextureRW, m_ReflIntermediateTexture0);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._SsrHitPointTexture, m_ReflIntermediateTexture1);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, "_NoiseTexture", blueNoise.textureArray16RGB);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, "_RaytracingReflectionTexture", outputTexture);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._ScramblingTexture, m_Asset.renderPipelineResources.textures.scramblingTex);
cmd.SetComputeIntParam(reflectionFilter, HDShaderIDs._SpatialFilterRadius, settings.spatialFilterRadius.value);
cmd.SetComputeIntParam(reflectionFilter, HDShaderIDs._RaytracingDenoiseRadius, settings.enableFilter.value ? settings.filterRadius.value : 0);
cmd.SetComputeFloatParam(reflectionFilter, HDShaderIDs._RaytracingReflectionMinSmoothness, settings.minSmoothness.value);
// Texture dimensions
int texWidth = hdCamera.actualWidth;
int texHeight = hdCamera.actualHeight;
// Evaluate the dispatch parameters
int areaTileSize = 8;
int numTilesXHR = (texWidth + (areaTileSize - 1)) / areaTileSize;
int numTilesYHR = (texHeight + (areaTileSize - 1)) / areaTileSize;
// Bind the right texture for clear coat support
RenderTargetIdentifier clearCoatMaskTexture = hdCamera.frameSettings.litShaderMode == LitShaderMode.Deferred ? m_GbufferManager.GetBuffersRTI()[2] : TextureXR.GetBlackTexture();
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._SsrClearCoatMaskTexture, clearCoatMaskTexture);
// Compute the texture
cmd.DispatchCompute(reflectionFilter, currentKernel, numTilesXHR, numTilesYHR, 1);
using (new ProfilingSample(cmd, "Filter Reflection", CustomSamplerId.RaytracingFilterReflection.GetSampler()))
{
if (settings.enableFilter.value)
{
// Grab the history buffer
RTHandleSystem.RTHandle reflectionHistory = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection)
?? hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection, ReflectionHistoryBufferAllocatorFunction, 1);
HDSimpleDenoiser simpleDenoiser = m_RayTracingManager.GetSimpleDenoiser();
simpleDenoiser.DenoiseBuffer(cmd, hdCamera, outputTexture, reflectionHistory, m_ReflIntermediateTexture0, settings.filterRadius.value, singleChannel: false);
HDUtils.BlitCameraTexture(cmd, m_ReflIntermediateTexture0, outputTexture);
}
}
}
}
private void RaymarchCloud(ScriptableRenderContext context, CommandBuffer cmd, ref RenderingData renderingData)
{
//raymarch cloud
//###############################################
//CloudColor----------------
solidCloudMaterial.SetColor(CloudColor_ID, settings.cloudAlbedoColor.value);
CoreUtils.SetKeyword(solidCloudMaterial, k_CLOUD_USE_XY_PLANE, settings.useXYPlane.value);
float scale = 0.01f / settings.noiseScale.value;
//CloudDistance_ID----------------
float distance = settings.distance.value;
float distanceFallOff = settings.distanceFallOff.value;
float maxLength = settings.maxLength.value;
float maxLengthFallOff = settings.maxLengthFallOff.value * maxLength + 1.0f;
CoreUtils.SetKeyword(solidCloudMaterial, k_CLOUD_DISTANCE_ON, distance > 0);
solidCloudMaterial.SetVector(CloudDistance_ID,
new Vector4(scale * scale * distance * distance, (distanceFallOff * distanceFallOff + 0.1f),
maxLength, maxLengthFallOff)); //, _distance * (1.0f - _distanceFallOff)));
//CloudWindDir_ID-----------------
windSpeedAcum += Time.deltaTime * settings.windDirection.value.normalized
* settings.windSpeed.value / scale;
if (windSpeedAcum.sqrMagnitude > 1000000) //1000*1000
{
windSpeedAcum = windSpeedAcum.normalized * windSpeedAcum.magnitude / 1000;
}
solidCloudMaterial.SetVector(CloudWindDir_ID, windSpeedAcum);
//CloudData_ID---------------------
Vector3 cloudAreaPosition = settings.cloudAreaPosition.value;
solidCloudMaterial.SetVector(CloudData_ID
, new Vector4(0, settings.height.value, 1.0f / settings.density.value, scale));
//CloudAreaPosition_ID---------------
// solidCloudMaterial.SetVector(CloudAreaPosition_ID,
// new Vector4(cloudAreaPosition.x, 0, cloudAreaPosition.z, 0));
solidCloudMaterial.SetVector(CloudAreaPosition_ID, cloudAreaPosition);
//CloudAreaData_ID-----------
float cloudAreaRadius = settings.cloudAreaRadius.value;
float cloudAreaHeight = settings.cloudAreaHeight.value;
float cloudAreaDepth = settings.cloudAreaDepth.value;
float cloudAreaFallOff = settings.cloudAreaFallOff.value;
Vector4 areaData = new Vector4(1.0f / (1.0f + cloudAreaRadius), 1.0f / (1.0f + cloudAreaHeight),
1.0f / (1.0f + cloudAreaDepth), cloudAreaFallOff);
if (cloudAreaHeight > 0 && cloudAreaDepth > 0)
{
solidCloudMaterial.DisableKeyword(k_CLOUD_AREA_SPHERE);
}
else
{
solidCloudMaterial.EnableKeyword(k_CLOUD_AREA_SPHERE);
areaData.y = cloudAreaRadius * cloudAreaRadius;
areaData.x /= scale;
areaData.z /= scale;
}
solidCloudMaterial.SetVector(CloudAreaData_ID, areaData);
//SunShadowsData_ID------------
float shadowStrength = settings.sunShadowsStrength.value;
if (shadowStrength <= 0)
{
solidCloudMaterial.DisableKeyword(k_CLOUD_SUN_SHADOWS_ON);
}
else
{
if (mainLightIndex >= 0)
{
solidCloudMaterial.EnableKeyword(k_CLOUD_SUN_SHADOWS_ON);
solidCloudMaterial.SetVector(SunShadowsData_ID,
new Vector4(shadowStrength
, settings.sunShadowsJitterStrength.value, settings.sunShadowsCancellation.value, 0));
}
else
{
solidCloudMaterial.DisableKeyword(k_CLOUD_SUN_SHADOWS_ON);
}
}
//CloudStepping_ID------------
float stepping = settings.stepping.value;
float steppingNear = settings.steppingNear.value;
float dithering = settings.ditherStrength.value;
Vector4 fogStepping = new Vector4(1.0f / (stepping + 1.0f), 1 / (1 + steppingNear), 0,
dithering * 0.1f);
solidCloudMaterial.SetVector(CloudStepping_ID, fogStepping);
//URP 7.5.3之后 cameraData.GetGPUProjectionMatrix() 进行y翻转
var cameraData = renderingData.cameraData;
if (cameraData.IsCameraProjectionMatrixFlipped())
{
Matrix4x4 viewAndProjectionMatrix =
GL.GetGPUProjectionMatrix(cameraData.GetProjectionMatrix(), false) * cameraData.GetViewMatrix();
Matrix4x4 inverseViewProjection = Matrix4x4.Inverse(viewAndProjectionMatrix);
cmd.SetGlobalMatrix(inverseViewAndProjectionMatrix, inverseViewProjection);
}
if (enableFrame)
{
CoreUtils.SetKeyword(solidCloudMaterial, k_CLOUD_FRAME_ON, true);
if (frameMode == 2 || frameMode == 3)
{
frame = (frame + 1) % 3;
}
else
{
frame = (frame + 1) % 4;
}
solidCloudMaterial.SetInt(Frame_ID, frame);
for (int i = 0; i < k_FRAME_MODE.Length; i++)
{
//手机的bug 短时间内对一个关键字快速的enable disable 如果shader过于麻烦 手机反应不过来会死机
if ((i == 0 && frameMode == 1) || (i == 1 && frameMode == 0))
{
CoreUtils.SetKeyword(solidCloudMaterial, k_FRAME_MODE[0], true);
}
else
{
CoreUtils.SetKeyword(solidCloudMaterial, k_FRAME_MODE[i], i == frameMode);
}
}
}
else
{
CoreUtils.SetKeyword(solidCloudMaterial, k_CLOUD_FRAME_ON, false);
frame = -1;
}
CoreUtils.SetKeyword(solidCloudMaterial, k_CLOUD_MUL_RT_ON, mulRTBlend);
int div = rtSize - 1;
int width = screenWidth >> div;
int height = screenHeight >> div;
if (settings.enableBlur.value)
{
if (div != 0)
{
if (mulRTBlend && !enableFrame)
{
solidCloudMaterial.SetVector(Step_TexelSize_ID,
new Vector4(1.5f / (div * width), 1.5f / (div * height)));
}
else if (!mulRTBlend && enableFrame)
{
solidCloudMaterial.SetVector(Step_TexelSize_ID,
new Vector4(1f / (div * width), 1f / (div * height)));
}
else if (mulRTBlend && enableFrame)
{
solidCloudMaterial.SetVector(Step_TexelSize_ID,
new Vector4(2f / (div * width), 2f / (div * height)));
}
else
{
solidCloudMaterial.SetVector(Step_TexelSize_ID,
new Vector4(1.5f / (div * width), 1.5f / (div * height)));
}
}
else
{
solidCloudMaterial.SetVector(Step_TexelSize_ID,
Vector4.zero);
}
}
//如果是mul叠加 则 用下面两级来叠加 1/2 1/4 1/8 1/16 步长则最短
if (mulRTBlend)
{
cmd.SetGlobalInt(DstBlend_ID, (int)BlendMode.Zero);
//blend
for (int i = 1; i < 3; i++)
{
if (enableFrame)
{
if ((frameMode == 2 || frameMode == 3) && frame == 2)
{
break;
}
if (frameMode == 4)
{
cmd.SetGlobalVector(MulRTScale_ID
, new Vector4(frameRTS[0].width, frameRTS[0].height, i - 1, i * 2));
}
//如果dontcare 出现花屏幕 改成 load
cmd.SetRenderTarget(frameRTS[i], RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.Store,
RenderBufferLoadAction.DontCare, RenderBufferStoreAction.DontCare);
//frame 叠加 如果clear了 覆盖不上去 而且还少了一个clear
// CoreUtils.ClearRenderTarget(cmd, ClearFlag.None, new Color(0, 0, 0, 0));
CoreUtils.DrawFullScreen(cmd, solidCloudMaterial, null, 0);
cmd.SetGlobalTexture(TempBlendTex_ID[i], frameRTS[i]);
}
else
{
//其实FPS够高 cmd.GetTemporaryRT 也有效果 但是我这里为了保险用了常驻的rt
cmd.GetTemporaryRT(TempBlendTex_ID[i], width / (2 * i), height / (2 * i), 0,
FilterMode.Bilinear, RenderTextureFormat.ARGB32);
cmd.SetRenderTarget(TempBlendTex_RTI[i], RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.Store,
RenderBufferLoadAction.DontCare, RenderBufferStoreAction.DontCare);
//frame 叠加 如果clear了 覆盖不上去 而且还少了一个clear
// CoreUtils.ClearRenderTarget(cmd, ClearFlag.Color, new Color(0, 0, 0, 0));
CoreUtils.DrawFullScreen(cmd, solidCloudMaterial, null, 0);
cmd.SetGlobalTexture(TempBlendTex_ID[i], TempBlendTex_RTI[i]);
}
}
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
if (!enableFrame && !settings.enableBlur.value)
{
cmd.SetGlobalInt(DstBlend_ID,
(int)(settings.enableBlend.value ? BlendMode.OneMinusSrcAlpha : BlendMode.Zero));
cmd.SetRenderTarget(CameraColorTexture_RTI);
CoreUtils.DrawFullScreen(cmd, solidCloudMaterial, null, 4);
}
else
{
if (enableFrame)
{
if (!((frameMode == 2 || frameMode == 3) && frame == 2))
{
//如果dontcare 出现花屏幕 改成 load
cmd.SetRenderTarget(frameRTS[0], RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.Store,
RenderBufferLoadAction.DontCare, RenderBufferStoreAction.DontCare);
CoreUtils.DrawFullScreen(cmd, solidCloudMaterial, null, 4);
cmd.SetGlobalTexture(BlendTex_ID, frameRTS[0]);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
}
}
else
{
cmd.GetTemporaryRT(BlendTex_ID, width, height, 0, FilterMode.Bilinear,
RenderTextureFormat.ARGB32);
cmd.SetRenderTarget(BlendTex_RTI, RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.Store,
RenderBufferLoadAction.DontCare, RenderBufferStoreAction.DontCare);
CoreUtils.DrawFullScreen(cmd, solidCloudMaterial, null, 4);
cmd.SetGlobalTexture(BlendTex_ID, BlendTex_RTI);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
for (int i = 1; i < 3; i++)
{
cmd.ReleaseTemporaryRT(TempBlendTex_ID[i]);
}
}
CoreUtils.SetKeyword(solidCloudMaterial, k_CLOUD_BLUR_ON, settings.enableBlur.value);
cmd.SetGlobalInt(DstBlend_ID,
(int)(settings.enableBlend.value ? BlendMode.OneMinusSrcAlpha : BlendMode.Zero));
cmd.SetRenderTarget(CameraColorTexture_RTI);
CoreUtils.DrawFullScreen(cmd, solidCloudMaterial, null, 3);
}
cmd.ReleaseTemporaryRT(BlendTex_ID);
}
else
{
if (rtSize == 1 && enableFrame == false)
{
CoreUtils.SetKeyword(solidCloudMaterial, k_CLOUD_BLUR_ON, false);
cmd.SetGlobalInt(DstBlend_ID,
(int)(settings.enableBlend.value ? BlendMode.OneMinusSrcAlpha : BlendMode.Zero));
cmd.SetRenderTarget(CameraColorTexture_RTI);
CoreUtils.DrawFullScreen(cmd, solidCloudMaterial, null, 0);
}
else
{
cmd.SetGlobalInt(DstBlend_ID, (int)BlendMode.Zero);
//blend
if (enableFrame)
{
if (!((frameMode == 2 || frameMode == 3) && frame == 2))
{
cmd.SetGlobalInt(DstBlend_ID, (int)BlendMode.Zero);
//如果dontcare 出现花屏幕 改成 load
cmd.SetRenderTarget(frameRTS[0], RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.Store);
CoreUtils.DrawFullScreen(cmd, solidCloudMaterial, null, 0);
cmd.SetGlobalTexture(BlendTex_ID, frameRTS[0]);
}
}
else
{
cmd.GetTemporaryRT(BlendTex_ID, width, height, 0, FilterMode.Bilinear,
RenderTextureFormat.ARGB32);
cmd.SetRenderTarget(BlendTex_RTI, RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.Store,
RenderBufferLoadAction.DontCare, RenderBufferStoreAction.DontCare);
CoreUtils.DrawFullScreen(cmd, solidCloudMaterial, null, 0);
cmd.SetGlobalTexture(BlendTex_ID, BlendTex_RTI);
}
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CoreUtils.SetKeyword(solidCloudMaterial, k_CLOUD_BLUR_ON, settings.enableBlur.value);
cmd.SetGlobalInt(DstBlend_ID,
(int)(settings.enableBlend.value ? BlendMode.OneMinusSrcAlpha : BlendMode.Zero));
cmd.SetRenderTarget(CameraColorTexture_RTI);
CoreUtils.DrawFullScreen(cmd, solidCloudMaterial, null, 3);
cmd.ReleaseTemporaryRT(BlendTex_ID);
}
}
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
}
public void RenderRayTracedReflections(HDCamera hdCamera, CommandBuffer cmd, RTHandleSystem.RTHandle outputTexture, ScriptableRenderContext renderContext, int frameCount)
{
RenderPipelineSettings.RaytracingTier currentTier = m_Asset.currentPlatformRenderPipelineSettings.supportedRaytracingTier;
switch (currentTier)
{
case RenderPipelineSettings.RaytracingTier.Tier1:
{
RenderReflectionsT1(hdCamera, cmd, outputTexture, renderContext, frameCount);
}
break;
case RenderPipelineSettings.RaytracingTier.Tier2:
{
RenderReflectionsT2(hdCamera, cmd, outputTexture, renderContext, frameCount);
}
break;
}
}
// Here you can implement the rendering logic.
// Use <c>ScriptableRenderContext</c> to issue drawing commands or execute command buffers
// https://docs.unity3d.com/ScriptReference/Rendering.ScriptableRenderContext.html
// You don't have to call ScriptableRenderContext.submit, the render pipeline will call it at specific points in the pipeline.
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
}
internal void ExecuteNativeRenderPass(ScriptableRenderContext context, ScriptableRenderPass renderPass, CameraData cameraData, ref RenderingData renderingData)
{
using (new ProfilingScope(null, Profiling.execute))
{
int currentPassIndex = renderPass.renderPassQueueIndex;
Hash128 currentPassHash = m_PassIndexToPassHash[currentPassIndex];
int[] currentMergeablePasses = m_MergeableRenderPassesMap[currentPassHash];
int validColorBuffersCount = m_RenderPassesAttachmentCount[currentPassHash];
bool isLastPass = renderPass.isLastPass;
// TODO: review the lastPassToBB logic to mak it work with merged passes
// keep track if this is the current camera's last pass and the RT is the backbuffer (BuiltinRenderTextureType.CameraTarget)
bool isLastPassToBB = isLastPass && (m_ActiveColorAttachmentDescriptors[0].loadStoreTarget ==
BuiltinRenderTextureType.CameraTarget);
var depthOnly = renderPass.depthOnly || (cameraData.targetTexture != null && cameraData.targetTexture.graphicsFormat == GraphicsFormat.DepthAuto);
bool useDepth = depthOnly || (!renderPass.overrideCameraTarget || (renderPass.overrideCameraTarget && renderPass.depthAttachment != BuiltinRenderTextureType.CameraTarget)) &&
(!(isLastPassToBB || (isLastPass && cameraData.camera.targetTexture != null)));
var attachments =
new NativeArray <AttachmentDescriptor>(useDepth && !depthOnly ? validColorBuffersCount + 1 : 1,
Allocator.Temp);
for (int i = 0; i < validColorBuffersCount; ++i)
{
attachments[i] = m_ActiveColorAttachmentDescriptors[i];
}
if (useDepth && !depthOnly)
{
attachments[validColorBuffersCount] = m_ActiveDepthAttachmentDescriptor;
}
var rpDesc = InitializeRenderPassDescriptor(cameraData, renderPass);
int validPassCount = GetValidPassIndexCount(currentMergeablePasses);
var attachmentIndicesCount = GetSubPassAttachmentIndicesCount(renderPass);
var attachmentIndices = new NativeArray <int>(!depthOnly ? (int)attachmentIndicesCount : 0, Allocator.Temp);
if (!depthOnly)
{
for (int i = 0; i < attachmentIndicesCount; ++i)
{
attachmentIndices[i] = renderPass.m_ColorAttachmentIndices[i];
}
}
if (validPassCount == 1 || currentMergeablePasses[0] == currentPassIndex) // Check if it's the first pass
{
if (PassHasInputAttachments(renderPass))
{
Debug.LogWarning("First pass in a RenderPass should not have input attachments.");
}
context.BeginRenderPass(rpDesc.w, rpDesc.h, Math.Max(rpDesc.samples, 1), attachments,
useDepth ? (!depthOnly ? validColorBuffersCount : 0) : -1);
attachments.Dispose();
context.BeginSubPass(attachmentIndices);
m_LastBeginSubpassPassIndex = currentPassIndex;
}
else
{
// Regarding input attachments, currently we always recreate a new subpass if it contains input attachments
// This might not the most optimal way though and it should be investigated in the future
// Whether merging subpasses with matching input attachments is a more viable option
if (!AreAttachmentIndicesCompatible(m_ActiveRenderPassQueue[m_LastBeginSubpassPassIndex], m_ActiveRenderPassQueue[currentPassIndex]))
{
context.EndSubPass();
if (PassHasInputAttachments(m_ActiveRenderPassQueue[currentPassIndex]))
{
context.BeginSubPass(attachmentIndices, m_ActiveRenderPassQueue[currentPassIndex].m_InputAttachmentIndices);
}
else
{
context.BeginSubPass(attachmentIndices);
}
m_LastBeginSubpassPassIndex = currentPassIndex;
}
else if (PassHasInputAttachments(m_ActiveRenderPassQueue[currentPassIndex]))
{
context.EndSubPass();
context.BeginSubPass(attachmentIndices, m_ActiveRenderPassQueue[currentPassIndex].m_InputAttachmentIndices);
m_LastBeginSubpassPassIndex = currentPassIndex;
}
}
attachmentIndices.Dispose();
renderPass.Execute(context, ref renderingData);
if (validPassCount == 1 || currentMergeablePasses[validPassCount - 1] == currentPassIndex) // Check if it's the last pass
{
context.EndSubPass();
context.EndRenderPass();
m_LastBeginSubpassPassIndex = 0;
}
for (int i = 0; i < m_ActiveColorAttachmentDescriptors.Length; ++i)
{
m_ActiveColorAttachmentDescriptors[i] = RenderingUtils.emptyAttachment;
}
m_ActiveDepthAttachmentDescriptor = RenderingUtils.emptyAttachment;
}
}
internal void Render(CommandBuffer cmd, HDCamera camera, ScriptableRenderContext renderContext, RTHandle depthTexture, RTHandle normalBuffer, in ShaderVariablesRaytracing globalRTCB, int frameCount)
private void CameraBeginRendering(ScriptableRenderContext context, Camera camera)
{
CameraPreCull(camera);
CameraPreRender(camera);
}
void RenderReflectionsT2(HDCamera hdCamera, CommandBuffer cmd, RTHandle outputTexture, ScriptableRenderContext renderContext, int frameCount)
{
// Fetch the shaders that we will be using
HDRaytracingEnvironment rtEnvironment = m_RayTracingManager.CurrentEnvironment();
ComputeShader reflectionFilter = m_Asset.renderPipelineRayTracingResources.reflectionBilateralFilterCS;
RayTracingShader reflectionShader = m_Asset.renderPipelineRayTracingResources.reflectionRaytracingRT;
var settings = VolumeManager.instance.stack.GetComponent <ScreenSpaceReflection>();
LightCluster lightClusterSettings = VolumeManager.instance.stack.GetComponent <LightCluster>();
// Bind all the required data for ray tracing
BindRayTracedReflectionData(cmd, hdCamera, rtEnvironment, reflectionShader, settings, lightClusterSettings);
// Only use the shader variant that has multi bounce if the bounce count > 1
CoreUtils.SetKeyword(cmd, "MULTI_BOUNCE_INDIRECT", settings.bounceCount.value > 1);
// We are not in the diffuse only case
CoreUtils.SetKeyword(cmd, "DIFFUSE_LIGHTING_ONLY", false);
// Run the computation
cmd.DispatchRays(reflectionShader, m_RayGenIntegrationName, (uint)hdCamera.actualWidth, (uint)hdCamera.actualHeight, (uint)hdCamera.viewCount);
// Disable multi-bounce
CoreUtils.SetKeyword(cmd, "MULTI_BOUNCE_INDIRECT", false);
using (new ProfilingSample(cmd, "Filter Reflection", CustomSamplerId.RaytracingFilterReflection.GetSampler()))
{
if (settings.denoise.value)
{
// Grab the history buffer
RTHandle reflectionHistory = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection)
?? hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection, ReflectionHistoryBufferAllocatorFunction, 1);
HDSimpleDenoiser simpleDenoiser = m_RayTracingManager.GetSimpleDenoiser();
simpleDenoiser.DenoiseBuffer(cmd, hdCamera, m_ReflIntermediateTexture0, reflectionHistory, outputTexture, settings.denoiserRadius.value, singleChannel: false);
}
else
{
HDUtils.BlitCameraTexture(cmd, m_ReflIntermediateTexture0, outputTexture);
}
}
}
private void CameraBeginFrameRendering(ScriptableRenderContext ctx, Camera[] cameras)
{
currentLWRPContext = ctx;
}
void RenderDirectionalCascadeShadowmap(ref ScriptableRenderContext context, ref CullResults cullResults, ref LightData lightData, ref ShadowData shadowData)
{
LightShadows shadowQuality = LightShadows.None;
int shadowLightIndex = lightData.mainLightIndex;
if (shadowLightIndex == -1)
{
return;
}
VisibleLight shadowLight = lightData.visibleLights[shadowLightIndex];
Light light = shadowLight.light;
Debug.Assert(shadowLight.lightType == LightType.Directional);
if (light.shadows == LightShadows.None)
{
return;
}
Bounds bounds;
if (!cullResults.GetShadowCasterBounds(shadowLightIndex, out bounds))
{
return;
}
CommandBuffer cmd = CommandBufferPool.Get(k_RenderDirectionalShadowmapTag);
using (new ProfilingSample(cmd, k_RenderDirectionalShadowmapTag))
{
m_ShadowCasterCascadesCount = shadowData.directionalLightCascadeCount;
int shadowResolution = LightweightShadowUtils.GetMaxTileResolutionInAtlas(shadowData.directionalShadowAtlasWidth, shadowData.directionalShadowAtlasHeight, m_ShadowCasterCascadesCount);
float shadowNearPlane = light.shadowNearPlane;
Matrix4x4 view, proj;
var settings = new DrawShadowsSettings(cullResults, shadowLightIndex);
m_DirectionalShadowmapTexture = RenderTexture.GetTemporary(shadowData.directionalShadowAtlasWidth,
shadowData.directionalShadowAtlasHeight, k_ShadowmapBufferBits, m_ShadowmapFormat);
m_DirectionalShadowmapTexture.filterMode = FilterMode.Bilinear;
m_DirectionalShadowmapTexture.wrapMode = TextureWrapMode.Clamp;
SetRenderTarget(cmd, m_DirectionalShadowmapTexture, RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.Store, ClearFlag.Depth, Color.black, TextureDimension.Tex2D);
bool success = false;
for (int cascadeIndex = 0; cascadeIndex < m_ShadowCasterCascadesCount; ++cascadeIndex)
{
success = LightweightShadowUtils.ExtractDirectionalLightMatrix(ref cullResults, ref shadowData, shadowLightIndex, cascadeIndex, shadowResolution, shadowNearPlane, out m_CascadeSplitDistances[cascadeIndex], out m_CascadeSlices[cascadeIndex], out view, out proj);
if (success)
{
LightweightShadowUtils.SetupShadowCasterConstants(cmd, ref shadowLight, proj, shadowResolution);
LightweightShadowUtils.RenderShadowSlice(cmd, ref context, ref m_CascadeSlices[cascadeIndex], proj,
view, settings);
}
}
if (success)
{
shadowQuality = (shadowData.supportsSoftShadows) ? light.shadows : LightShadows.Hard;
SetupDirectionalShadowReceiverConstants(cmd, ref shadowData, shadowLight);
}
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
// TODO: We should have RenderingData as a readonly but currently we need this to pass shadow rendering to litpass
shadowData.renderedDirectionalShadowQuality = shadowQuality;
}
public override void Setup(ScriptableRenderContext context, ref RenderingData renderingData)
{
ref CameraData cameraData = ref renderingData.cameraData;
public override void SetupLights(ScriptableRenderContext context, ref RenderingData renderingData)
{
}
