static float EvaluateHistoryValidityPointShadow(HDCamera hdCamera, LightData lightData, HDAdditionalLightData additionalLightData)
{
// We need to set the history as invalid if the light has moved (rotated or translated),
float historyValidity = 1.0f;
if (additionalLightData.previousTransform != additionalLightData.transform.localToWorldMatrix ||
!hdCamera.ValidShadowHistory(additionalLightData, lightData.screenSpaceShadowIndex, lightData.lightType))
{
historyValidity = 0.0f;
}
// We need to check if the camera implied an invalidation
historyValidity *= EvaluateHistoryValidity(hdCamera);
return(historyValidity);
}
bool RenderLightScreenSpaceShadows(HDCamera hdCamera, CommandBuffer cmd)
{
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.RaytracingLightShadow)))
{
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.RaytracingLightShadow)))
{
// Loop through all the potential screen space light shadows
for (int lightIdx = 0; lightIdx < m_ScreenSpaceShadowIndex; ++lightIdx)
{
// This matches the directional light
if (!m_CurrentScreenSpaceShadowData[lightIdx].valid)
{
continue;
}
// Fetch the light data and additional light data
LightData currentLight = m_lightList.lights[m_CurrentScreenSpaceShadowData[lightIdx].lightDataIndex];
HDAdditionalLightData currentAdditionalLightData = m_CurrentScreenSpaceShadowData[lightIdx].additionalLightData;
// Trigger the right algorithm based on the light type
switch (currentLight.lightType)
{
case GPULightType.Rectangle:
{
RenderAreaScreenSpaceShadow(cmd, hdCamera, currentLight, currentAdditionalLightData, m_CurrentScreenSpaceShadowData[lightIdx].lightDataIndex);
}
break;
case GPULightType.Point:
case GPULightType.Spot:
{
RenderPunctualScreenSpaceShadow(cmd, hdCamera, currentLight, currentAdditionalLightData, m_CurrentScreenSpaceShadowData[lightIdx].lightDataIndex);
}
break;
}
}
}
return(true);
}
}
bool RenderLightScreenSpaceShadows(RenderGraph renderGraph, HDCamera hdCamera,
PrepassOutput prepassOutput, TextureHandle depthBuffer, TextureHandle normalBuffer, TextureHandle motionVectorsBuffer, TextureHandle historyValidityBuffer,
TextureHandle rayCountTexture, TextureHandle screenSpaceShadowArray)
{
// Loop through all the potential screen space light shadows
for (int lightIdx = 0; lightIdx < m_ScreenSpaceShadowIndex; ++lightIdx)
{
// This matches the directional light
if (!m_CurrentScreenSpaceShadowData[lightIdx].valid)
{
continue;
}
// Fetch the light data and additional light data
LightData currentLight = m_GpuLightsBuilder.lights[m_CurrentScreenSpaceShadowData[lightIdx].lightDataIndex];
HDAdditionalLightData currentAdditionalLightData = m_CurrentScreenSpaceShadowData[lightIdx].additionalLightData;
// Trigger the right algorithm based on the light type
switch (currentLight.lightType)
{
case GPULightType.Rectangle:
{
RenderAreaScreenSpaceShadow(renderGraph, hdCamera, currentLight, currentAdditionalLightData, m_CurrentScreenSpaceShadowData[lightIdx].lightDataIndex,
prepassOutput, depthBuffer, normalBuffer, motionVectorsBuffer, rayCountTexture, screenSpaceShadowArray);
}
break;
case GPULightType.Point:
case GPULightType.Spot:
{
RenderPunctualScreenSpaceShadow(renderGraph, hdCamera, currentLight, currentAdditionalLightData, m_CurrentScreenSpaceShadowData[lightIdx].lightDataIndex,
prepassOutput, depthBuffer, normalBuffer, motionVectorsBuffer, historyValidityBuffer, rayCountTexture, screenSpaceShadowArray);
}
break;
}
}
return(true);
}
void BuildLightData(CommandBuffer cmd, HDCamera hdCamera, HDRayTracingLights rayTracingLights, DebugDisplaySettings debugDisplaySettings)
{
// If no lights, exit
if (rayTracingLights.lightCount == 0)
{
ResizeLightDataBuffer(1);
return;
}
// Also we need to build the light list data
if (m_LightDataGPUArray == null || m_LightDataGPUArray.count != rayTracingLights.lightCount)
{
ResizeLightDataBuffer(rayTracingLights.lightCount);
}
m_LightDataCPUArray.Clear();
// Grab the shadow settings
var hdShadowSettings = hdCamera.volumeStack.GetComponent <HDShadowSettings>();
BoolScalableSetting contactShadowScalableSetting = HDAdditionalLightData.ScalableSettings.UseContactShadow(m_RenderPipeline.asset);
// Build the data for every light
for (int lightIdx = 0; lightIdx < rayTracingLights.hdLightArray.Count; ++lightIdx)
{
// Grab the additinal light data to process
HDAdditionalLightData additionalLightData = rayTracingLights.hdLightArray[lightIdx];
LightData lightData = new LightData();
// When the user deletes a light source in the editor, there is a single frame where the light is null before the collection of light in the scene is triggered
// the workaround for this is simply to add an invalid light for that frame
if (additionalLightData == null)
{
m_LightDataCPUArray.Add(lightData);
continue;
}
// Evaluate all the light type data that we need
LightCategory lightCategory = LightCategory.Count;
GPULightType gpuLightType = GPULightType.Point;
LightVolumeType lightVolumeType = LightVolumeType.Count;
HDLightType lightType = additionalLightData.type;
HDRenderPipeline.EvaluateGPULightType(lightType, additionalLightData.spotLightShape, additionalLightData.areaLightShape, ref lightCategory, ref gpuLightType, ref lightVolumeType);
// Fetch the light component for this light
additionalLightData.gameObject.TryGetComponent(out lightComponent);
// Build the processed light data that we need
ProcessedLightData processedData = new ProcessedLightData();
processedData.additionalLightData = additionalLightData;
processedData.lightType = additionalLightData.type;
processedData.lightCategory = lightCategory;
processedData.gpuLightType = gpuLightType;
processedData.lightVolumeType = lightVolumeType;
// Both of these positions are non-camera-relative.
processedData.distanceToCamera = (additionalLightData.gameObject.transform.position - hdCamera.camera.transform.position).magnitude;
processedData.lightDistanceFade = HDUtils.ComputeLinearDistanceFade(processedData.distanceToCamera, additionalLightData.fadeDistance);
processedData.volumetricDistanceFade = HDUtils.ComputeLinearDistanceFade(processedData.distanceToCamera, additionalLightData.volumetricFadeDistance);
processedData.isBakedShadowMask = HDRenderPipeline.IsBakedShadowMaskLight(lightComponent);
// Build a visible light
Color finalColor = lightComponent.color.linear * lightComponent.intensity;
if (additionalLightData.useColorTemperature)
{
finalColor *= Mathf.CorrelatedColorTemperatureToRGB(lightComponent.colorTemperature);
}
visibleLight.finalColor = finalColor;
visibleLight.range = lightComponent.range;
// This should be done explicitely, localtoworld matrix doesn't work here
localToWorldMatrix.SetColumn(3, lightComponent.gameObject.transform.position);
localToWorldMatrix.SetColumn(2, lightComponent.transform.forward);
localToWorldMatrix.SetColumn(1, lightComponent.transform.up);
localToWorldMatrix.SetColumn(0, lightComponent.transform.right);
visibleLight.localToWorldMatrix = localToWorldMatrix;
visibleLight.spotAngle = lightComponent.spotAngle;
int shadowIndex = additionalLightData.shadowIndex;
int screenSpaceShadowIndex = -1;
int screenSpaceChannelSlot = -1;
Vector3 lightDimensions = new Vector3(0.0f, 0.0f, 0.0f);
// Use the shared code to build the light data
m_RenderPipeline.GetLightData(cmd, hdCamera, hdShadowSettings, visibleLight, lightComponent, in processedData,
shadowIndex, contactShadowScalableSetting, isRasterization: false, ref lightDimensions, ref screenSpaceShadowIndex, ref screenSpaceChannelSlot, ref lightData);
// We make the light position camera-relative as late as possible in order
// to allow the preceding code to work with the absolute world space coordinates.
Vector3 camPosWS = hdCamera.mainViewConstants.worldSpaceCameraPos;
HDRenderPipeline.UpdateLightCameraRelativetData(ref lightData, camPosWS);
// Set the data for this light
m_LightDataCPUArray.Add(lightData);
}
// Push the data to the GPU
m_LightDataGPUArray.SetData(m_LightDataCPUArray);
}
RTSAreaRayTraceParameters PrepareRTSAreaRayTraceParameters(HDCamera hdCamera, HDAdditionalLightData additionalLightData, LightData lightData, int lightIndex)
{
RTSAreaRayTraceParameters rtsartParams = new RTSAreaRayTraceParameters();
// Set the camera parameters
rtsartParams.texWidth = hdCamera.actualWidth;
rtsartParams.texHeight = hdCamera.actualHeight;
rtsartParams.viewCount = hdCamera.viewCount;
// Evaluation parameters
rtsartParams.numSamples = additionalLightData.numRayTracingSamples;
rtsartParams.lightIndex = lightIndex;
// We need to build the world to area light matrix
rtsartParams.worldToLocalMatrix.SetColumn(0, lightData.right);
rtsartParams.worldToLocalMatrix.SetColumn(1, lightData.up);
rtsartParams.worldToLocalMatrix.SetColumn(2, lightData.forward);
// Compensate the relative rendering if active
Vector3 lightPositionWS = lightData.positionRWS;
if (ShaderConfig.s_CameraRelativeRendering != 0)
{
lightPositionWS -= hdCamera.camera.transform.position;
}
rtsartParams.worldToLocalMatrix.SetColumn(3, lightPositionWS);
rtsartParams.worldToLocalMatrix.m33 = 1.0f;
rtsartParams.worldToLocalMatrix = m_WorldToLocalArea.inverse;
rtsartParams.historyValidity = EvaluateHistoryValidity(hdCamera);
rtsartParams.filterTracedShadow = additionalLightData.filterTracedShadow;
rtsartParams.areaShadowSlot = m_lightList.lights[lightIndex].screenSpaceShadowIndex;
rtsartParams.filterSize = additionalLightData.filterSizeTraced;
// Kernels
rtsartParams.areaRaytracingShadowPrepassKernel = m_AreaRaytracingShadowPrepassKernel;
rtsartParams.areaRaytracingShadowNewSampleKernel = m_AreaRaytracingShadowNewSampleKernel;
rtsartParams.areaShadowApplyTAAKernel = m_AreaShadowApplyTAAKernel;
rtsartParams.areaUpdateAnalyticHistoryKernel = m_AreaUpdateAnalyticHistoryKernel;
rtsartParams.areaUpdateShadowHistoryKernel = m_AreaUpdateShadowHistoryKernel;
rtsartParams.areaEstimateNoiseKernel = m_AreaEstimateNoiseKernel;
rtsartParams.areaFirstDenoiseKernel = m_AreaFirstDenoiseKernel;
rtsartParams.areaSecondDenoiseKernel = m_AreaSecondDenoiseKernel;
rtsartParams.areaShadowNoDenoiseKernel = m_AreaShadowNoDenoiseKernel;
// Other parameters
// Grab the acceleration structure for the target camera
rtsartParams.accelerationStructure = RequestAccelerationStructure();
rtsartParams.shaderVariablesRayTracingCB = m_ShaderVariablesRayTracingCB;
rtsartParams.screenSpaceShadowsCS = m_ScreenSpaceShadowsCS;
rtsartParams.screenSpaceShadowsRT = m_ScreenSpaceShadowsRT;
rtsartParams.screenSpaceShadowsFilterCS = m_ScreenSpaceShadowsFilterCS;
rtsartParams.scramblingTex = m_Asset.renderPipelineResources.textures.scramblingTex;
BlueNoise blueNoise = GetBlueNoiseManager();
rtsartParams.ditheredTextureSet = blueNoise.DitheredTextureSet8SPP();
return(rtsartParams);
}
void BuildLightData(CommandBuffer cmd, HDCamera hdCamera, List <HDAdditionalLightData> lightArray)
{
// If no lights, exit
if (lightArray.Count == 0)
{
ResizeLightDataBuffer(1);
return;
}
// Also we need to build the light list data
if (m_LightDataGPUArray == null || m_LightDataGPUArray.count != lightArray.Count)
{
ResizeLightDataBuffer(lightArray.Count);
}
m_LightDataCPUArray.Clear();
// Build the data for every light
for (int lightIdx = 0; lightIdx < lightArray.Count; ++lightIdx)
{
var lightData = new LightData();
HDAdditionalLightData additionalLightData = lightArray[lightIdx];
// When the user deletes a light source in the editor, there is a single frame where the light is null before the collection of light in the scene is triggered
// the workaround for this is simply to add an invalid light for that frame
if (additionalLightData == null)
{
m_LightDataCPUArray.Add(lightData);
continue;
}
Light light = additionalLightData.gameObject.GetComponent <Light>();
// Both of these positions are non-camera-relative.
float distanceToCamera = (light.gameObject.transform.position - hdCamera.camera.transform.position).magnitude;
float lightDistanceFade = HDUtils.ComputeLinearDistanceFade(distanceToCamera, additionalLightData.fadeDistance);
bool contributesToLighting = ((additionalLightData.lightDimmer > 0) && (additionalLightData.affectDiffuse || additionalLightData.affectSpecular)) || (additionalLightData.volumetricDimmer > 0);
contributesToLighting = contributesToLighting && (lightDistanceFade > 0);
if (!contributesToLighting)
{
continue;
}
lightData.lightLayers = additionalLightData.GetLightLayers();
LightCategory lightCategory = LightCategory.Count;
GPULightType gpuLightType = GPULightType.Point;
GetLightGPUType(additionalLightData, light, ref gpuLightType, ref lightCategory);
lightData.lightType = gpuLightType;
lightData.positionRWS = light.gameObject.transform.position;
bool applyRangeAttenuation = additionalLightData.applyRangeAttenuation && (gpuLightType != GPULightType.ProjectorBox);
lightData.range = light.range;
if (applyRangeAttenuation)
{
lightData.rangeAttenuationScale = 1.0f / (light.range * light.range);
lightData.rangeAttenuationBias = 1.0f;
if (lightData.lightType == GPULightType.Rectangle)
{
// Rect lights are currently a special case because they use the normalized
// [0, 1] attenuation range rather than the regular [0, r] one.
lightData.rangeAttenuationScale = 1.0f;
}
}
else // Don't apply any attenuation but do a 'step' at range
{
// Solve f(x) = b - (a * x)^2 where x = (d/r)^2.
// f(0) = huge -> b = huge.
// f(1) = 0 -> huge - a^2 = 0 -> a = sqrt(huge).
const float hugeValue = 16777216.0f;
const float sqrtHuge = 4096.0f;
lightData.rangeAttenuationScale = sqrtHuge / (light.range * light.range);
lightData.rangeAttenuationBias = hugeValue;
if (lightData.lightType == GPULightType.Rectangle)
{
// Rect lights are currently a special case because they use the normalized
// [0, 1] attenuation range rather than the regular [0, r] one.
lightData.rangeAttenuationScale = sqrtHuge;
}
}
Color value = light.color.linear * light.intensity;
if (additionalLightData.useColorTemperature)
{
value *= Mathf.CorrelatedColorTemperatureToRGB(light.colorTemperature);
}
lightData.color = new Vector3(value.r, value.g, value.b);
lightData.forward = light.transform.forward;
lightData.up = light.transform.up;
lightData.right = light.transform.right;
if (lightData.lightType == GPULightType.ProjectorBox)
{
// Rescale for cookies and windowing.
lightData.right *= 2.0f / Mathf.Max(additionalLightData.shapeWidth, 0.001f);
lightData.up *= 2.0f / Mathf.Max(additionalLightData.shapeHeight, 0.001f);
}
else if (lightData.lightType == GPULightType.ProjectorPyramid)
{
// Get width and height for the current frustum
var spotAngle = light.spotAngle;
float frustumWidth, frustumHeight;
if (additionalLightData.aspectRatio >= 1.0f)
{
frustumHeight = 2.0f * Mathf.Tan(spotAngle * 0.5f * Mathf.Deg2Rad);
frustumWidth = frustumHeight * additionalLightData.aspectRatio;
}
else
{
frustumWidth = 2.0f * Mathf.Tan(spotAngle * 0.5f * Mathf.Deg2Rad);
frustumHeight = frustumWidth / additionalLightData.aspectRatio;
}
// Rescale for cookies and windowing.
lightData.right *= 2.0f / frustumWidth;
lightData.up *= 2.0f / frustumHeight;
}
if (lightData.lightType == GPULightType.Spot)
{
var spotAngle = light.spotAngle;
var innerConePercent = additionalLightData.innerSpotPercent01;
var cosSpotOuterHalfAngle = Mathf.Clamp(Mathf.Cos(spotAngle * 0.5f * Mathf.Deg2Rad), 0.0f, 1.0f);
var sinSpotOuterHalfAngle = Mathf.Sqrt(1.0f - cosSpotOuterHalfAngle * cosSpotOuterHalfAngle);
var cosSpotInnerHalfAngle = Mathf.Clamp(Mathf.Cos(spotAngle * 0.5f * innerConePercent * Mathf.Deg2Rad), 0.0f, 1.0f); // inner cone
var val = Mathf.Max(0.0001f, (cosSpotInnerHalfAngle - cosSpotOuterHalfAngle));
lightData.angleScale = 1.0f / val;
lightData.angleOffset = -cosSpotOuterHalfAngle * lightData.angleScale;
// Rescale for cookies and windowing.
float cotOuterHalfAngle = cosSpotOuterHalfAngle / sinSpotOuterHalfAngle;
lightData.up *= cotOuterHalfAngle;
lightData.right *= cotOuterHalfAngle;
}
else
{
// These are the neutral values allowing GetAngleAnttenuation in shader code to return 1.0
lightData.angleScale = 0.0f;
lightData.angleOffset = 1.0f;
}
if (lightData.lightType != GPULightType.Directional && lightData.lightType != GPULightType.ProjectorBox)
{
// Store the squared radius of the light to simulate a fill light.
lightData.size = new Vector2(additionalLightData.shapeRadius * additionalLightData.shapeRadius, 0);
}
if (lightData.lightType == GPULightType.Rectangle || lightData.lightType == GPULightType.Tube)
{
lightData.size = new Vector2(additionalLightData.shapeWidth, additionalLightData.shapeHeight);
}
lightData.lightDimmer = lightDistanceFade * (additionalLightData.lightDimmer);
lightData.diffuseDimmer = lightDistanceFade * (additionalLightData.affectDiffuse ? additionalLightData.lightDimmer : 0);
lightData.specularDimmer = lightDistanceFade * (additionalLightData.affectSpecular ? additionalLightData.lightDimmer * hdCamera.frameSettings.specularGlobalDimmer : 0);
lightData.volumetricLightDimmer = lightDistanceFade * (additionalLightData.volumetricDimmer);
lightData.contactShadowMask = 0;
lightData.cookieIndex = -1;
lightData.shadowIndex = -1;
lightData.screenSpaceShadowIndex = -1;
if (light != null && light.cookie != null)
{
// TODO: add texture atlas support for cookie textures.
switch (light.type)
{
case LightType.Spot:
lightData.cookieIndex = m_RenderPipeline.m_TextureCaches.cookieTexArray.FetchSlice(cmd, light.cookie);
break;
case LightType.Point:
lightData.cookieIndex = m_RenderPipeline.m_TextureCaches.cubeCookieTexArray.FetchSlice(cmd, light.cookie);
break;
}
}
else if (light.type == LightType.Spot && additionalLightData.spotLightShape != SpotLightShape.Cone)
{
// Projectors lights must always have a cookie texture.
// As long as the cache is a texture array and not an atlas, the 4x4 white texture will be rescaled to 128
lightData.cookieIndex = m_RenderPipeline.m_TextureCaches.cookieTexArray.FetchSlice(cmd, Texture2D.whiteTexture);
}
else if (lightData.lightType == GPULightType.Rectangle && additionalLightData.areaLightCookie != null)
{
lightData.cookieIndex = m_RenderPipeline.m_TextureCaches.areaLightCookieManager.FetchSlice(cmd, additionalLightData.areaLightCookie);
}
{
lightData.shadowDimmer = 1.0f;
lightData.volumetricShadowDimmer = 1.0f;
}
{
// fix up shadow information
lightData.shadowIndex = additionalLightData.shadowIndex;
}
// Value of max smoothness is from artists point of view, need to convert from perceptual smoothness to roughness
lightData.minRoughness = (1.0f - additionalLightData.maxSmoothness) * (1.0f - additionalLightData.maxSmoothness);
// No usage for the shadow masks
lightData.shadowMaskSelector = Vector4.zero;
{
// use -1 to say that we don't use shadow mask
lightData.shadowMaskSelector.x = -1.0f;
lightData.nonLightMappedOnly = 0;
}
if (ShaderConfig.s_CameraRelativeRendering != 0)
{
// Caution: 'LightData.positionWS' is camera-relative after this point.
Vector3 camPosWS = hdCamera.mainViewConstants.worldSpaceCameraPos;
lightData.positionRWS -= camPosWS;
}
// Set the data for this light
m_LightDataCPUArray.Add(lightData);
}
// Push the data to the GPU
m_LightDataGPUArray.SetData(m_LightDataCPUArray);
}
SSSPunctualRayTraceParameters PrepareSSSPunctualRayTraceParameters(HDCamera hdCamera, HDAdditionalLightData additionalLightData, LightData lightData, int lightIndex)
{
SSSPunctualRayTraceParameters ssprtParams = new SSSPunctualRayTraceParameters();
// Set the camera parameters
ssprtParams.texWidth = hdCamera.actualWidth;
ssprtParams.texHeight = hdCamera.actualHeight;
ssprtParams.viewCount = hdCamera.viewCount;
// Evaluation parameters
ssprtParams.softShadow = additionalLightData.shapeRadius > 0.0 ? true : false;
// If the surface is infinitively small, we force it to one sample.
ssprtParams.numShadowSamples = ssprtParams.softShadow ? additionalLightData.numRayTracingSamples : 1;
ssprtParams.distanceBasedFiltering = additionalLightData.distanceBasedFiltering;
ssprtParams.semiTransparentShadow = additionalLightData.semiTransparentShadow;
ssprtParams.lightType = lightData.lightType;
ssprtParams.spotAngle = additionalLightData.legacyLight.spotAngle;
ssprtParams.shapeRadius = additionalLightData.shapeRadius;
ssprtParams.lightIndex = lightIndex;
// Kernels
ssprtParams.clearShadowKernel = m_ClearShadowTexture;
ssprtParams.shadowKernel = lightData.lightType == GPULightType.Point ? m_RaytracingPointShadowSample : m_RaytracingSpotShadowSample;
// Grab the acceleration structure for the target camera
ssprtParams.accelerationStructure = RequestAccelerationStructure();
ssprtParams.screenSpaceShadowCS = m_ScreenSpaceShadowsCS;
ssprtParams.screenSpaceShadowRT = m_ScreenSpaceShadowsRT;
ssprtParams.shaderVariablesRayTracingCB = m_ShaderVariablesRayTracingCB;
BlueNoise blueNoise = GetBlueNoiseManager();
ssprtParams.ditheredTextureSet = blueNoise.DitheredTextureSet8SPP();
return(ssprtParams);
}
bool RenderAreaShadows(HDCamera hdCamera, CommandBuffer cmd, int frameCount)
{
// Let's check all the resources and states to see if we should render the effect
HDRaytracingEnvironment rtEnvironment = m_RayTracingManager.CurrentEnvironment();
// Make sure everything is valid
bool invalidState = !hdCamera.frameSettings.IsEnabled(FrameSettingsField.RayTracing) ||
rtEnvironment == null ||
hdCamera.frameSettings.litShaderMode != LitShaderMode.Deferred;
// If invalid state or ray-tracing acceleration structure, we stop right away
if (invalidState)
{
return(false);
}
RayTracingShader shadowRayTrace = m_Asset.renderPipelineRayTracingResources.shadowRaytracingRT;
ComputeShader shadowsCompute = m_Asset.renderPipelineRayTracingResources.shadowRaytracingCS;
ComputeShader shadowFilter = m_Asset.renderPipelineRayTracingResources.shadowFilterCS;
// Grab the TAA history buffers (SN/UN and Analytic value)
RTHandle shadowHistoryArray = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.RaytracedShadow)
?? hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.RaytracedShadow, ShadowHistoryBufferAllocatorFunction, 1);
RTHandle areaAnalyticHistoryArray = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.RaytracedAreaAnalytic)
?? hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.RaytracedAreaAnalytic, AreaAnalyticHistoryBufferAllocatorFunction, 1);
// Grab the acceleration structure for the target camera
RayTracingAccelerationStructure accelerationStructure = m_RayTracingManager.RequestAccelerationStructure(rtEnvironment.shadowLayerMask);
// Define the shader pass to use for the reflection pass
cmd.SetRayTracingShaderPass(shadowRayTrace, "VisibilityDXR");
// Set the acceleration structure for the pass
cmd.SetRayTracingAccelerationStructure(shadowRayTrace, HDShaderIDs._RaytracingAccelerationStructureName, accelerationStructure);
// Inject the ray-tracing sampling data
cmd.SetGlobalTexture(HDShaderIDs._OwenScrambledRGTexture, m_Asset.renderPipelineResources.textures.owenScrambledRGBATex);
cmd.SetGlobalTexture(HDShaderIDs._OwenScrambledTexture, m_Asset.renderPipelineResources.textures.owenScrambled256Tex);
cmd.SetGlobalTexture(HDShaderIDs._ScramblingTexture, m_Asset.renderPipelineResources.textures.scramblingTex);
int frameIndex = hdCamera.IsTAAEnabled() ? hdCamera.taaFrameIndex : (int)frameCount % 8;
cmd.SetGlobalInt(HDShaderIDs._RaytracingFrameIndex, frameIndex);
// Temporal Filtering kernels
int applyTAAKernel = shadowFilter.FindKernel("AreaShadowApplyTAA");
int updateAnalyticHistory = shadowFilter.FindKernel("AreaAnalyticHistoryCopy");
int updateShadowHistory = shadowFilter.FindKernel("AreaShadowHistoryCopy");
// Spatial Filtering kernels
int estimateNoiseKernel = shadowFilter.FindKernel("AreaShadowEstimateNoise");
int firstDenoiseKernel = shadowFilter.FindKernel("AreaShadowDenoiseFirstPass");
int secondDenoiseKernel = shadowFilter.FindKernel("AreaShadowDenoiseSecondPass");
// Texture dimensions
int texWidth = hdCamera.actualWidth;
int texHeight = hdCamera.actualHeight;
// Evaluate the dispatch parameters
int areaTileSize = 8;
int numTilesX = (texWidth + (areaTileSize - 1)) / areaTileSize;
int numTilesY = (texHeight + (areaTileSize - 1)) / areaTileSize;
// Inject the ray generation data
cmd.SetGlobalFloat(HDShaderIDs._RaytracingRayBias, rtEnvironment.rayBias);
int numLights = m_lightList.lights.Count;
for (int lightIdx = 0; lightIdx < numLights; ++lightIdx)
{
// If this is not a rectangular area light or it won't have shadows, skip it
if (m_lightList.lights[lightIdx].lightType != GPULightType.Rectangle || m_lightList.lights[lightIdx].screenSpaceShadowIndex == -1)
{
continue;
}
LightData currentLight = m_lightList.lights[lightIdx];
HDAdditionalLightData currentAdditionalLightData = GetCurrentRayTracedShadow(currentLight.screenSpaceShadowIndex);
using (new ProfilingSample(cmd, "Ray Traced Area Shadow", CustomSamplerId.RaytracingShadowIntegration.GetSampler()))
{
// We need to build the world to area light matrix
worldToLocalArea.SetColumn(0, currentLight.right);
worldToLocalArea.SetColumn(1, currentLight.up);
worldToLocalArea.SetColumn(2, currentLight.forward);
// Compensate the relative rendering if active
Vector3 lightPositionWS = currentLight.positionRWS;
if (ShaderConfig.s_CameraRelativeRendering != 0)
{
lightPositionWS += hdCamera.camera.transform.position;
}
worldToLocalArea.SetColumn(3, lightPositionWS);
worldToLocalArea.m33 = 1.0f;
worldToLocalArea = worldToLocalArea.inverse;
// We have noticed from extensive profiling that ray-trace shaders are not as effective for running per-pixel computation. In order to reduce that,
// we do a first prepass that compute the analytic term and probability and generates the first integration sample
if (true)
{
int shadowComputeKernel = shadowsCompute.FindKernel("RaytracingAreaShadowPrepass");
// This pass evaluates the analytic value and the generates and outputs the first sample
cmd.SetComputeBufferParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._LightDatas, m_LightLoopLightData.lightData);
cmd.SetComputeIntParam(shadowsCompute, HDShaderIDs._RaytracingTargetAreaLight, lightIdx);
cmd.SetComputeIntParam(shadowsCompute, HDShaderIDs._RaytracingNumSamples, currentAdditionalLightData.numRayTracingSamples);
cmd.SetComputeMatrixParam(shadowsCompute, HDShaderIDs._RaytracingAreaWorldToLocal, worldToLocalArea);
cmd.SetComputeTextureParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetComputeTextureParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
cmd.SetComputeTextureParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._GBufferTexture[0], m_GbufferManager.GetBuffer(0));
cmd.SetComputeTextureParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._GBufferTexture[1], m_GbufferManager.GetBuffer(1));
cmd.SetComputeTextureParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._GBufferTexture[2], m_GbufferManager.GetBuffer(2));
cmd.SetComputeTextureParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._GBufferTexture[3], m_GbufferManager.GetBuffer(3));
cmd.SetComputeTextureParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._AreaCookieTextures, m_TextureCaches.areaLightCookieManager.GetTexCache());
cmd.SetComputeTextureParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._RaytracedAreaShadowIntegration, m_DenoiseBuffer0);
cmd.SetComputeTextureParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._RaytracedAreaShadowSample, m_DenoiseBuffer1);
cmd.SetComputeTextureParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._RaytracingDirectionBuffer, m_RaytracingDirectionBuffer);
cmd.SetComputeTextureParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._RaytracingDistanceBuffer, m_RaytracingDistanceBuffer);
cmd.SetComputeTextureParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._AnalyticProbBuffer, m_AnalyticProbBuffer);
cmd.DispatchCompute(shadowsCompute, shadowComputeKernel, numTilesX, numTilesY, 1);
// This pass will use the previously generated sample and add it to the integration buffer
cmd.SetRayTracingBufferParam(shadowRayTrace, HDShaderIDs._LightDatas, m_LightLoopLightData.lightData);
cmd.SetRayTracingTextureParam(shadowRayTrace, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetRayTracingTextureParam(shadowRayTrace, HDShaderIDs._RaytracedAreaShadowSample, m_DenoiseBuffer1);
cmd.SetRayTracingTextureParam(shadowRayTrace, HDShaderIDs._RaytracedAreaShadowIntegration, m_DenoiseBuffer0);
cmd.SetRayTracingTextureParam(shadowRayTrace, HDShaderIDs._RaytracingDirectionBuffer, m_RaytracingDirectionBuffer);
cmd.SetRayTracingTextureParam(shadowRayTrace, HDShaderIDs._RaytracingDistanceBuffer, m_RaytracingDistanceBuffer);
cmd.SetRayTracingTextureParam(shadowRayTrace, HDShaderIDs._AnalyticProbBuffer, m_AnalyticProbBuffer);
cmd.DispatchRays(shadowRayTrace, m_RayGenAreaShadowSingleName, (uint)hdCamera.actualWidth, (uint)hdCamera.actualHeight, 1);
// Let's do the following samples (if any)
for (int sampleIndex = 1; sampleIndex < currentAdditionalLightData.numRayTracingSamples; ++sampleIndex)
{
shadowComputeKernel = shadowsCompute.FindKernel("RaytracingAreaShadowNewSample");
// This pass generates a new sample based on the initial pre-pass
cmd.SetComputeBufferParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._LightDatas, m_LightLoopLightData.lightData);
cmd.SetComputeIntParam(shadowsCompute, HDShaderIDs._RaytracingTargetAreaLight, lightIdx);
cmd.SetComputeIntParam(shadowsCompute, HDShaderIDs._RaytracingNumSamples, currentAdditionalLightData.numRayTracingSamples);
cmd.SetComputeIntParam(shadowsCompute, HDShaderIDs._RaytracingSampleIndex, sampleIndex);
cmd.SetComputeMatrixParam(shadowsCompute, HDShaderIDs._RaytracingAreaWorldToLocal, worldToLocalArea);
cmd.SetComputeTextureParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetComputeTextureParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
cmd.SetComputeTextureParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._GBufferTexture[0], m_GbufferManager.GetBuffer(0));
cmd.SetComputeTextureParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._GBufferTexture[1], m_GbufferManager.GetBuffer(1));
cmd.SetComputeTextureParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._GBufferTexture[2], m_GbufferManager.GetBuffer(2));
cmd.SetComputeTextureParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._GBufferTexture[3], m_GbufferManager.GetBuffer(3));
cmd.SetComputeTextureParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._AreaCookieTextures, m_TextureCaches.areaLightCookieManager.GetTexCache());
cmd.SetComputeTextureParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._RaytracedAreaShadowIntegration, m_DenoiseBuffer0);
cmd.SetComputeTextureParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._RaytracedAreaShadowSample, m_DenoiseBuffer1);
cmd.SetComputeTextureParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._RaytracingDirectionBuffer, m_RaytracingDirectionBuffer);
cmd.SetComputeTextureParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._RaytracingDistanceBuffer, m_RaytracingDistanceBuffer);
cmd.SetComputeTextureParam(shadowsCompute, shadowComputeKernel, HDShaderIDs._AnalyticProbBuffer, m_AnalyticProbBuffer);
cmd.DispatchCompute(shadowsCompute, shadowComputeKernel, numTilesX, numTilesY, 1);
// This pass will use the previously generated sample and add it to the integration buffer
cmd.SetRayTracingBufferParam(shadowRayTrace, HDShaderIDs._LightDatas, m_LightLoopLightData.lightData);
cmd.SetRayTracingTextureParam(shadowRayTrace, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetRayTracingTextureParam(shadowRayTrace, HDShaderIDs._RaytracedAreaShadowSample, m_DenoiseBuffer1);
cmd.SetRayTracingTextureParam(shadowRayTrace, HDShaderIDs._RaytracedAreaShadowIntegration, m_DenoiseBuffer0);
cmd.SetRayTracingTextureParam(shadowRayTrace, HDShaderIDs._RaytracingDirectionBuffer, m_RaytracingDirectionBuffer);
cmd.SetRayTracingTextureParam(shadowRayTrace, HDShaderIDs._RaytracingDistanceBuffer, m_RaytracingDistanceBuffer);
cmd.SetRayTracingTextureParam(shadowRayTrace, HDShaderIDs._AnalyticProbBuffer, m_AnalyticProbBuffer);
cmd.DispatchRays(shadowRayTrace, m_RayGenAreaShadowSingleName, (uint)hdCamera.actualWidth, (uint)hdCamera.actualHeight, 1);
}
}
else
{
// This pass generates the analytic value and will do the full integration
cmd.SetRayTracingBufferParam(shadowRayTrace, HDShaderIDs._LightDatas, m_LightLoopLightData.lightData);
cmd.SetRayTracingIntParam(shadowRayTrace, HDShaderIDs._RaytracingTargetAreaLight, lightIdx);
cmd.SetRayTracingIntParam(shadowRayTrace, HDShaderIDs._RaytracingNumSamples, currentAdditionalLightData.numRayTracingSamples);
cmd.SetRayTracingMatrixParam(shadowRayTrace, HDShaderIDs._RaytracingAreaWorldToLocal, worldToLocalArea);
cmd.SetRayTracingTextureParam(shadowRayTrace, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetRayTracingTextureParam(shadowRayTrace, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
cmd.SetRayTracingTextureParam(shadowRayTrace, HDShaderIDs._GBufferTexture[0], m_GbufferManager.GetBuffer(0));
cmd.SetRayTracingTextureParam(shadowRayTrace, HDShaderIDs._GBufferTexture[1], m_GbufferManager.GetBuffer(1));
cmd.SetRayTracingTextureParam(shadowRayTrace, HDShaderIDs._GBufferTexture[2], m_GbufferManager.GetBuffer(2));
cmd.SetRayTracingTextureParam(shadowRayTrace, HDShaderIDs._GBufferTexture[3], m_GbufferManager.GetBuffer(3));
cmd.SetRayTracingIntParam(shadowRayTrace, HDShaderIDs._RayCountEnabled, m_RayTracingManager.rayCountManager.RayCountIsEnabled());
cmd.SetRayTracingTextureParam(shadowRayTrace, HDShaderIDs._RayCountTexture, m_RayTracingManager.rayCountManager.rayCountTexture);
cmd.SetRayTracingTextureParam(shadowRayTrace, HDShaderIDs._AreaCookieTextures, m_TextureCaches.areaLightCookieManager.GetTexCache());
cmd.SetRayTracingTextureParam(shadowRayTrace, HDShaderIDs._AnalyticProbBuffer, m_AnalyticProbBuffer);
cmd.SetRayTracingTextureParam(shadowRayTrace, HDShaderIDs._RaytracedAreaShadowIntegration, m_DenoiseBuffer0);
cmd.DispatchRays(shadowRayTrace, m_RayGenAreaShadowName, (uint)hdCamera.actualWidth, (uint)hdCamera.actualHeight, 1);
}
}
using (new ProfilingSample(cmd, "Combine Area Shadow", CustomSamplerId.RaytracingShadowCombination.GetSampler()))
{
// Global parameters
cmd.SetComputeIntParam(shadowFilter, HDShaderIDs._RaytracingDenoiseRadius, currentAdditionalLightData.filterSizeTraced);
cmd.SetComputeIntParam(shadowFilter, HDShaderIDs._RaytracingShadowSlot, m_lightList.lights[lightIdx].screenSpaceShadowIndex);
// Apply a vectorized temporal filtering pass and store it back in the denoisebuffer0 with the analytic value in the third channel
var historyScale = new Vector2(hdCamera.actualWidth / (float)shadowHistoryArray.rt.width, hdCamera.actualHeight / (float)shadowHistoryArray.rt.height);
cmd.SetComputeVectorParam(shadowFilter, HDShaderIDs._RTHandleScaleHistory, historyScale);
cmd.SetComputeTextureParam(shadowFilter, applyTAAKernel, HDShaderIDs._AnalyticProbBuffer, m_AnalyticProbBuffer);
cmd.SetComputeTextureParam(shadowFilter, applyTAAKernel, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetComputeTextureParam(shadowFilter, applyTAAKernel, HDShaderIDs._AreaShadowHistory, shadowHistoryArray);
cmd.SetComputeTextureParam(shadowFilter, applyTAAKernel, HDShaderIDs._AnalyticHistoryBuffer, areaAnalyticHistoryArray);
cmd.SetComputeTextureParam(shadowFilter, applyTAAKernel, HDShaderIDs._DenoiseInputTexture, m_DenoiseBuffer0);
cmd.SetComputeTextureParam(shadowFilter, applyTAAKernel, HDShaderIDs._DenoiseOutputTextureRW, m_DenoiseBuffer1);
cmd.DispatchCompute(shadowFilter, applyTAAKernel, numTilesX, numTilesY, 1);
// Update the shadow history buffer
cmd.SetComputeTextureParam(shadowFilter, updateAnalyticHistory, HDShaderIDs._AnalyticProbBuffer, m_AnalyticProbBuffer);
cmd.SetComputeTextureParam(shadowFilter, updateAnalyticHistory, HDShaderIDs._AnalyticHistoryBuffer, areaAnalyticHistoryArray);
cmd.DispatchCompute(shadowFilter, updateAnalyticHistory, numTilesX, numTilesY, 1);
// Update the analytic history buffer
cmd.SetComputeTextureParam(shadowFilter, updateShadowHistory, HDShaderIDs._DenoiseInputTexture, m_DenoiseBuffer1);
cmd.SetComputeTextureParam(shadowFilter, updateShadowHistory, HDShaderIDs._AreaShadowHistoryRW, shadowHistoryArray);
cmd.DispatchCompute(shadowFilter, updateShadowHistory, numTilesX, numTilesY, 1);
if (currentAdditionalLightData.filterSizeTraced > 0)
{
// Inject parameters for noise estimation
cmd.SetComputeTextureParam(shadowFilter, estimateNoiseKernel, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetComputeTextureParam(shadowFilter, estimateNoiseKernel, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
cmd.SetComputeTextureParam(shadowFilter, estimateNoiseKernel, HDShaderIDs._ScramblingTexture, m_Asset.renderPipelineResources.textures.scramblingTex);
// Noise estimation pre-pass
cmd.SetComputeTextureParam(shadowFilter, estimateNoiseKernel, HDShaderIDs._DenoiseInputTexture, m_DenoiseBuffer1);
cmd.SetComputeTextureParam(shadowFilter, estimateNoiseKernel, HDShaderIDs._DenoiseOutputTextureRW, m_DenoiseBuffer0);
cmd.DispatchCompute(shadowFilter, estimateNoiseKernel, numTilesX, numTilesY, 1);
// Reinject parameters for denoising
cmd.SetComputeTextureParam(shadowFilter, firstDenoiseKernel, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetComputeTextureParam(shadowFilter, firstDenoiseKernel, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
cmd.SetComputeTextureParam(shadowFilter, firstDenoiseKernel, HDShaderIDs._ScreenSpaceShadowsTextureRW, m_ScreenSpaceShadowTextureArray);
// First denoising pass
cmd.SetComputeTextureParam(shadowFilter, firstDenoiseKernel, HDShaderIDs._DenoiseInputTexture, m_DenoiseBuffer0);
cmd.SetComputeTextureParam(shadowFilter, firstDenoiseKernel, HDShaderIDs._DenoiseOutputTextureRW, m_DenoiseBuffer1);
cmd.DispatchCompute(shadowFilter, firstDenoiseKernel, numTilesX, numTilesY, 1);
}
// Re-inject parameters for denoising
cmd.SetComputeTextureParam(shadowFilter, secondDenoiseKernel, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetComputeTextureParam(shadowFilter, secondDenoiseKernel, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
cmd.SetComputeTextureParam(shadowFilter, secondDenoiseKernel, HDShaderIDs._ScreenSpaceShadowsTextureRW, m_ScreenSpaceShadowTextureArray);
// Second (and final) denoising pass
cmd.SetComputeTextureParam(shadowFilter, secondDenoiseKernel, HDShaderIDs._DenoiseInputTexture, m_DenoiseBuffer1);
cmd.DispatchCompute(shadowFilter, secondDenoiseKernel, numTilesX, numTilesY, 1);
}
}
return(true);
}
bool RenderLightScreenSpaceShadows(HDCamera hdCamera, CommandBuffer cmd)
{
// Fetch the ray tracing environment
HDRaytracingEnvironment rtEnvironment = m_RayTracingManager.CurrentEnvironment();
// If invalid state, we stop right away
if (!hdCamera.frameSettings.IsEnabled(FrameSettingsField.RayTracing) || rtEnvironment == null)
{
return(false);
}
// Grab the history buffer
RTHandle shadowHistoryArray = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.RaytracedShadow)
?? hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.RaytracedShadow, ShadowHistoryBufferAllocatorFunction, 1);
// Grab the acceleration structure for the target camera
RayTracingAccelerationStructure accelerationStructure = m_RayTracingManager.RequestAccelerationStructure(rtEnvironment.shadowLayerMask);
// Set the acceleration structure for the pass
cmd.SetRayTracingAccelerationStructure(m_ScreenSpaceShadowsRT, HDShaderIDs._RaytracingAccelerationStructureName, accelerationStructure);
// Define the shader pass to use for the reflection pass
cmd.SetRayTracingShaderPass(m_ScreenSpaceShadowsRT, "VisibilityDXR");
// Inject the ray-tracing sampling data
m_BlueNoise.BindDitheredRNGData8SPP(cmd);
// Compute and inject the frame data
int frameIndex = hdCamera.IsTAAEnabled() ? hdCamera.taaFrameIndex : (int)m_FrameCount % 8;
cmd.SetGlobalInt(HDShaderIDs._RaytracingFrameIndex, frameIndex);
// Inject the ray generation data
cmd.SetGlobalFloat(HDShaderIDs._RaytracingRayBias, rtEnvironment.rayBias);
using (new ProfilingSample(cmd, "Ray Traced Shadows", CustomSamplerId.RaytracingShadowIntegration.GetSampler()))
{
// Loop through all the potential screen space light shadows
for (int lightIdx = 0; lightIdx < m_ScreenSpaceShadowIndex; ++lightIdx)
{
// This matches the directional light
if (!m_CurrentScreenSpaceShadowData[lightIdx].valid)
{
continue;
}
// Fetch the light data and additional light data
LightData currentLight = m_lightList.lights[m_CurrentScreenSpaceShadowData[lightIdx].lightDataIndex];
HDAdditionalLightData currentAdditionalLightData = m_CurrentScreenSpaceShadowData[lightIdx].additionalLightData;
// Trigger the right algorithm based on the light type
switch (currentLight.lightType)
{
case GPULightType.Rectangle:
{
RenderAreaScreenSpaceShadow(cmd, hdCamera, rtEnvironment, currentLight, currentAdditionalLightData, m_CurrentScreenSpaceShadowData[lightIdx].lightDataIndex, shadowHistoryArray);
}
break;
case GPULightType.Point:
{
RenderPunctualScreenSpaceShadow(cmd, hdCamera, rtEnvironment, currentLight, currentAdditionalLightData, m_CurrentScreenSpaceShadowData[lightIdx].lightDataIndex, shadowHistoryArray);
}
break;
}
}
}
return(true);
}
void BuildLightData(CommandBuffer cmd, HDCamera hdCamera, HDRayTracingLights rayTracingLights, DebugDisplaySettings debugDisplaySettings)
{
// If no lights, exit
if (rayTracingLights.lightCount == 0)
{
ResizeLightDataBuffer(1);
return;
}
// Also we need to build the light list data
if (m_LightDataGPUArray == null || m_LightDataGPUArray.count != rayTracingLights.lightCount)
{
ResizeLightDataBuffer(rayTracingLights.lightCount);
}
m_LightDataCPUArray.Clear();
// Grab the shadow settings
var hdShadowSettings = hdCamera.volumeStack.GetComponent <HDShadowSettings>();
BoolScalableSetting contactShadowScalableSetting = HDAdditionalLightData.ScalableSettings.UseContactShadow(m_RenderPipeline.asset);
// Build the data for every light
HDLightRenderDatabase lightEntities = HDLightRenderDatabase.instance;
var processedLightEntity = new HDProcessedVisibleLight()
{
shadowMapFlags = HDProcessedVisibleLightsBuilder.ShadowMapFlags.None
};
var globalConfig = HDGpuLightsBuilder.CreateGpuLightDataJobGlobalConfig.Create(hdCamera, hdShadowSettings);
var shadowInitParams = m_RenderPipeline.currentPlatformRenderPipelineSettings.hdShadowInitParams;
for (int lightIdx = 0; lightIdx < rayTracingLights.hdLightEntityArray.Count; ++lightIdx)
{
// Grab the additinal light data to process
int dataIndex = lightEntities.GetEntityDataIndex(rayTracingLights.hdLightEntityArray[lightIdx]);
HDAdditionalLightData additionalLightData = lightEntities.hdAdditionalLightData[dataIndex];
LightData lightData = new LightData();
// When the user deletes a light source in the editor, there is a single frame where the light is null before the collection of light in the scene is triggered
// the workaround for this is simply to add an invalid light for that frame
if (additionalLightData == null)
{
m_LightDataCPUArray.Add(lightData);
continue;
}
// Evaluate all the light type data that we need
LightCategory lightCategory = LightCategory.Count;
GPULightType gpuLightType = GPULightType.Point;
LightVolumeType lightVolumeType = LightVolumeType.Count;
HDLightType lightType = additionalLightData.type;
HDRenderPipeline.EvaluateGPULightType(lightType, additionalLightData.spotLightShape, additionalLightData.areaLightShape, ref lightCategory, ref gpuLightType, ref lightVolumeType);
// Fetch the light component for this light
additionalLightData.gameObject.TryGetComponent(out lightComponent);
ref HDLightRenderData lightRenderData = ref lightEntities.GetLightDataAsRef(dataIndex);
// Build the processed light data that we need
processedLightEntity.dataIndex = dataIndex;
processedLightEntity.gpuLightType = gpuLightType;
processedLightEntity.lightType = additionalLightData.type;
processedLightEntity.distanceToCamera = (additionalLightData.transform.position - hdCamera.camera.transform.position).magnitude;
processedLightEntity.lightDistanceFade = HDUtils.ComputeLinearDistanceFade(processedLightEntity.distanceToCamera, lightRenderData.fadeDistance);
processedLightEntity.lightVolumetricDistanceFade = HDUtils.ComputeLinearDistanceFade(processedLightEntity.distanceToCamera, lightRenderData.volumetricFadeDistance);
processedLightEntity.isBakedShadowMask = HDRenderPipeline.IsBakedShadowMaskLight(lightComponent);
// Build a visible light
visibleLight.finalColor = LightUtils.EvaluateLightColor(lightComponent, additionalLightData);
visibleLight.range = lightComponent.range;
// This should be done explicitly, localToWorld matrix doesn't work here
localToWorldMatrix.SetColumn(3, lightComponent.gameObject.transform.position);
localToWorldMatrix.SetColumn(2, lightComponent.transform.forward);
localToWorldMatrix.SetColumn(1, lightComponent.transform.up);
localToWorldMatrix.SetColumn(0, lightComponent.transform.right);
visibleLight.localToWorldMatrix = localToWorldMatrix;
visibleLight.spotAngle = lightComponent.spotAngle;
int shadowIndex = additionalLightData.shadowIndex;
Vector3 lightDimensions = new Vector3(0.0f, 0.0f, 0.0f);
// Use the shared code to build the light data
HDGpuLightsBuilder.CreateGpuLightDataJob.ConvertLightToGPUFormat(
lightCategory, gpuLightType, globalConfig,
lightComponent.lightShadowCasterMode, lightComponent.bakingOutput,
visibleLight, processedLightEntity, lightRenderData, out var _, ref lightData);
m_RenderPipeline.gpuLightList.ProcessLightDataShadowIndex(cmd, shadowInitParams, lightType, lightComponent, additionalLightData, shadowIndex, ref lightData);
// We make the light position camera-relative as late as possible in order
// to allow the preceding code to work with the absolute world space coordinates.
Vector3 camPosWS = hdCamera.mainViewConstants.worldSpaceCameraPos;
HDRenderPipeline.UpdateLightCameraRelativetData(ref lightData, camPosWS);
// Set the data for this light
m_LightDataCPUArray.Add(lightData);
}
