public void CullForRayTracing(CommandBuffer cmd, HDCamera hdCamera, HDRayTracingLights rayTracingLights)
{
// If there is no lights to process or no environment not the shader is missing
if (rayTracingLights.lightCount == 0 || !m_RenderPipeline.GetRayTracingState())
{
InvalidateCluster();
return;
}
// Build the Light volumes
BuildGPULightVolumes(rayTracingLights);
// If no valid light were found, invalidate the cluster and leave
if (totalLightCount == 0)
{
InvalidateCluster();
return;
}
// Evaluate the volume of the cluster
EvaluateClusterVolume(hdCamera);
// Cull the lights within the evaluated cluster range
CullLights(cmd);
// Build the light Cluster
BuildLightCluster(hdCamera, cmd);
}
public void BuildRayTracingLightData(CommandBuffer cmd, HDCamera hdCamera, HDRayTracingLights rayTracingLights, DebugDisplaySettings debugDisplaySettings)
{
// Build the light data
BuildLightData(cmd, hdCamera, rayTracingLights, debugDisplaySettings);
// Build the light data
BuildEnvLightData(cmd, hdCamera, rayTracingLights);
}
public void ReserveCookieAtlasSlots(HDRayTracingLights rayTracingLights)
{
for (int lightIdx = 0; lightIdx < rayTracingLights.hdLightArray.Count; ++lightIdx)
{
// Grab the additional light data to process
HDAdditionalLightData additionalLightData = rayTracingLights.hdLightArray[lightIdx];
// Fetch the light component for this light
additionalLightData.gameObject.TryGetComponent(out lightComponent);
// Reserve the cookie resolution in the 2D atlas
m_RenderPipeline.ReserveCookieAtlasTexture(additionalLightData, lightComponent, additionalLightData.type);
}
}
public void BuildLightClusterBuffer(CommandBuffer cmd, HDCamera hdCamera, HDRayTracingLights rayTracingLights)
{
// If there is no lights to process or no environment not the shader is missing
if (totalLightCount == 0 || rayTracingLights.lightCount == 0 || !m_RenderPipeline.GetRayTracingState())
{
return;
}
// Cull the lights within the evaluated cluster range
CullLights(cmd);
// Build the light Cluster
BuildLightCluster(hdCamera, cmd);
}
void BuildEnvLightData(CommandBuffer cmd, HDCamera hdCamera, HDRayTracingLights lights)
{
int totalReflectionProbes = lights.reflectionProbeArray.Count;
if (totalReflectionProbes == 0)
{
ResizeEnvLightDataBuffer(1);
return;
}
// Also we need to build the light list data
if (m_EnvLightDataCPUArray == null || m_EnvLightDataGPUArray == null || m_EnvLightDataGPUArray.count != totalReflectionProbes)
{
ResizeEnvLightDataBuffer(totalReflectionProbes);
}
// Make sure the Cpu list is empty
m_EnvLightDataCPUArray.Clear();
ProcessedProbeData processedProbe = new ProcessedProbeData();
// Build the data for every light
for (int lightIdx = 0; lightIdx < lights.reflectionProbeArray.Count; ++lightIdx)
{
HDProbe probeData = lights.reflectionProbeArray[lightIdx];
// Skip the probe if the probe has never rendered (in realtime cases) or if texture is null
if (!probeData.HasValidRenderedData())
{
continue;
}
HDRenderPipeline.PreprocessProbeData(ref processedProbe, probeData, hdCamera);
var envLightData = new EnvLightData();
m_RenderPipeline.GetEnvLightData(cmd, hdCamera, processedProbe, ref envLightData);
// 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.UpdateEnvLighCameraRelativetData(ref envLightData, camPosWS);
m_EnvLightDataCPUArray.Add(envLightData);
}
// Push the data to the GPU
m_EnvLightDataGPUArray.SetData(m_EnvLightDataCPUArray);
}
public void EvaluateLightClusters(CommandBuffer cmd, HDCamera hdCamera, HDRayTracingLights rayTracingLights)
{
// Grab the current ray-tracing environment, if no environment available stop right away
HDRaytracingEnvironment currentEnv = m_RaytracingManager.CurrentEnvironment();
ComputeShader lightClusterCS = m_RenderPipelineRayTracingResources.lightClusterBuildCS;
// If there is no lights to process or no environment not the shader is missing
if (currentEnv == null || (rayTracingLights.hdLightArray.Count == 0 && rayTracingLights.reflectionProbeArray.Count == 0))
{
// Invalidate the cluster's bounds so that we never access the buffer
minClusterPos.Set(float.MaxValue, float.MaxValue, float.MaxValue);
maxClusterPos.Set(-float.MaxValue, -float.MaxValue, -float.MaxValue);
punctualLightCount = 0;
areaLightCount = 0;
// Make sure the buffer is at least of size 1
if (m_LightCluster.count != 1)
{
ResizeClusterBuffer(1);
}
return;
}
// Build the Light volumes
BuildGPULightVolumes(rayTracingLights);
// Evaluate the volume of the cluster
EvaluateClusterVolume(currentEnv, hdCamera);
// Cull the lights within the evaluated cluster range
CullLights(cmd, lightClusterCS);
// Build the light Cluster
BuildLightCluster(cmd, lightClusterCS, currentEnv);
// Build the light data
BuildLightData(cmd, hdCamera, rayTracingLights.hdLightArray);
// Build the light data
BuildEnvLightData(cmd, hdCamera, rayTracingLights);
// Generate the debug view
EvaluateClusterDebugView(cmd, hdCamera, currentEnv);
}
public void EvaluateLightClusters(CommandBuffer cmd, HDCamera hdCamera, HDRayTracingLights rayTracingLights)
{
// Grab the current ray-tracing environment, if no environment available stop right away
HDRaytracingEnvironment currentEnv = m_RaytracingManager.CurrentEnvironment();
ComputeShader lightClusterCS = m_RenderPipelineRayTracingResources.lightClusterBuildCS;
// If there is no lights to process or no environment not the shader is missing
if (currentEnv == null || (rayTracingLights.hdLightArray.Count == 0 && rayTracingLights.reflectionProbeArray.Count == 0))
{
InvalidateCluster();
return;
}
// Build the Light volumes
BuildGPULightVolumes(rayTracingLights);
// If no valid light were found, invalidate the cluster and leave
if (totalLightCount == 0)
{
InvalidateCluster();
return;
}
// Evaluate the volume of the cluster
EvaluateClusterVolume(currentEnv, hdCamera);
// Cull the lights within the evaluated cluster range
CullLights(cmd, lightClusterCS);
// Build the light Cluster
BuildLightCluster(cmd, lightClusterCS, currentEnv);
// Build the light data
BuildLightData(cmd, hdCamera, rayTracingLights.hdLightArray);
// Build the light data
BuildEnvLightData(cmd, hdCamera, rayTracingLights);
// Generate the debug view
EvaluateClusterDebugView(cmd, hdCamera, currentEnv);
}
void BuildEnvLightData(CommandBuffer cmd, HDCamera hdCamera, HDRayTracingLights lights)
{
int totalReflectionProbes = lights.reflectionProbeArray.Count;
if (totalReflectionProbes == 0)
{
ResizeEnvLightDataBuffer(1);
return;
}
// Also we need to build the light list data
if (m_EnvLightDataCPUArray == null || m_EnvLightDataGPUArray == null || m_EnvLightDataGPUArray.count != totalReflectionProbes)
{
ResizeEnvLightDataBuffer(totalReflectionProbes);
}
// Make sure the Cpu list is empty
m_EnvLightDataCPUArray.Clear();
// Build the data for every light
for (int lightIdx = 0; lightIdx < lights.reflectionProbeArray.Count; ++lightIdx)
{
HDProbe probeData = lights.reflectionProbeArray[lightIdx];
var envLightData = new EnvLightData();
m_RenderPipeline.GetEnvLightData(cmd, hdCamera, probeData, m_RenderPipeline.m_CurrentDebugDisplaySettings, ref envLightData);
// 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;
m_RenderPipeline.UpdateEnvLighCameraRelativetData(ref envLightData, camPosWS);
m_EnvLightDataCPUArray.Add(envLightData);
}
// Push the data to the GPU
m_EnvLightDataGPUArray.SetData(m_EnvLightDataCPUArray);
}
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);
}
void BuildGPULightVolumes(HDCamera hdCamera, HDRayTracingLights rayTracingLights)
{
int totalNumLights = rayTracingLights.lightCount;
// Make sure the light volume buffer has the right size
if (m_LightVolumesCPUArray == null || totalNumLights != m_LightVolumesCPUArray.Length)
{
ResizeVolumeBuffer(totalNumLights);
}
// Set Light volume data to the CPU buffer
punctualLightCount = 0;
areaLightCount = 0;
envLightCount = 0;
totalLightCount = 0;
int realIndex = 0;
for (int lightIdx = 0; lightIdx < rayTracingLights.hdLightArray.Count; ++lightIdx)
{
HDAdditionalLightData currentLight = rayTracingLights.hdLightArray[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 not add it if it is null for that invalid frame
if (currentLight != null)
{
Light light = currentLight.gameObject.GetComponent <Light>();
if (light == null || !light.enabled)
{
continue;
}
if (hdCamera.frameSettings.IsEnabled(FrameSettingsField.RayTracing) && !currentLight.includeForRayTracing)
{
continue;
}
// Reserve space in the cookie atlas
m_RenderPipeline.ReserveCookieAtlasTexture(currentLight, light, currentLight.type);
// Compute the camera relative position
Vector3 lightPositionRWS = currentLight.gameObject.transform.position;
if (ShaderConfig.s_CameraRelativeRendering != 0)
{
lightPositionRWS -= hdCamera.camera.transform.position;
}
// Grab the light range
float lightRange = light.range;
if (currentLight.type != HDLightType.Area)
{
m_LightVolumesCPUArray[realIndex].range = new Vector3(lightRange, lightRange, lightRange);
m_LightVolumesCPUArray[realIndex].position = lightPositionRWS;
m_LightVolumesCPUArray[realIndex].active = (currentLight.gameObject.activeInHierarchy ? 1 : 0);
m_LightVolumesCPUArray[realIndex].lightIndex = (uint)lightIdx;
m_LightVolumesCPUArray[realIndex].shape = 0;
m_LightVolumesCPUArray[realIndex].lightType = 0;
punctualLightCount++;
}
else
{
// let's compute the oobb of the light influence volume first
Vector3 oobbDimensions = new Vector3(currentLight.shapeWidth + 2 * lightRange, currentLight.shapeHeight + 2 * lightRange, lightRange); // One-sided
Vector3 extents = 0.5f * oobbDimensions;
Vector3 oobbCenter = lightPositionRWS + extents.z * currentLight.gameObject.transform.forward;
// Let's now compute an AABB that matches the previously defined OOBB
OOBBToAABBBounds(oobbCenter, extents, currentLight.gameObject.transform.up, currentLight.gameObject.transform.right, currentLight.gameObject.transform.forward, ref bounds);
// Fill the volume data
m_LightVolumesCPUArray[realIndex].range = bounds.extents;
m_LightVolumesCPUArray[realIndex].position = bounds.center;
m_LightVolumesCPUArray[realIndex].active = (currentLight.gameObject.activeInHierarchy ? 1 : 0);
m_LightVolumesCPUArray[realIndex].lightIndex = (uint)lightIdx;
m_LightVolumesCPUArray[realIndex].shape = 1;
m_LightVolumesCPUArray[realIndex].lightType = 1;
areaLightCount++;
}
realIndex++;
}
}
int indexOffset = realIndex;
// Set Env Light volume data to the CPU buffer
for (int lightIdx = 0; lightIdx < rayTracingLights.reflectionProbeArray.Count; ++lightIdx)
{
HDProbe currentEnvLight = rayTracingLights.reflectionProbeArray[lightIdx];
// Compute the camera relative position
Vector3 probePositionRWS = currentEnvLight.influenceToWorld.GetColumn(3);
if (ShaderConfig.s_CameraRelativeRendering != 0)
{
probePositionRWS -= hdCamera.camera.transform.position;
}
if (currentEnvLight != null)
{
if (currentEnvLight.influenceVolume.shape == InfluenceShape.Sphere)
{
m_LightVolumesCPUArray[lightIdx + indexOffset].shape = 0;
m_LightVolumesCPUArray[lightIdx + indexOffset].range = new Vector3(currentEnvLight.influenceVolume.sphereRadius, currentEnvLight.influenceVolume.sphereRadius, currentEnvLight.influenceVolume.sphereRadius);
m_LightVolumesCPUArray[lightIdx + indexOffset].position = probePositionRWS;
}
else
{
m_LightVolumesCPUArray[lightIdx + indexOffset].shape = 1;
m_LightVolumesCPUArray[lightIdx + indexOffset].range = new Vector3(currentEnvLight.influenceVolume.boxSize.x / 2.0f, currentEnvLight.influenceVolume.boxSize.y / 2.0f, currentEnvLight.influenceVolume.boxSize.z / 2.0f);
m_LightVolumesCPUArray[lightIdx + indexOffset].position = probePositionRWS;
}
m_LightVolumesCPUArray[lightIdx + indexOffset].active = (currentEnvLight.gameObject.activeInHierarchy ? 1 : 0);
m_LightVolumesCPUArray[lightIdx + indexOffset].lightIndex = (uint)lightIdx;
m_LightVolumesCPUArray[lightIdx + indexOffset].lightType = 2;
envLightCount++;
}
}
totalLightCount = punctualLightCount + areaLightCount + envLightCount;
// Push the light volumes to the GPU
m_LightVolumeGPUArray.SetData(m_LightVolumesCPUArray);
}
void BuildGPULightVolumes(HDRayTracingLights lightArray)
{
int totalNumLights = lightArray.hdLightArray.Count + lightArray.reflectionProbeArray.Count;
// Make sure the light volume buffer has the right size
if (m_LightVolumesCPUArray == null || totalNumLights != m_LightVolumesCPUArray.Length)
{
ResizeVolumeBuffer(totalNumLights);
}
// Set Light volume data to the CPU buffer
punctualLightCount = 0;
areaLightCount = 0;
envLightCount = 0;
totalLightCount = 0;
int realIndex = 0;
for (int lightIdx = 0; lightIdx < lightArray.hdLightArray.Count; ++lightIdx)
{
HDAdditionalLightData currentLight = lightArray.hdLightArray[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 not add it if it is null for that invalid frame
if (currentLight != null)
{
Light light = currentLight.gameObject.GetComponent <Light>();
if (light == null || !light.enabled)
{
continue;
}
float lightRange = light.range;
m_LightVolumesCPUArray[realIndex].range = new Vector3(lightRange, lightRange, lightRange);
m_LightVolumesCPUArray[realIndex].position = currentLight.gameObject.transform.position;
m_LightVolumesCPUArray[realIndex].active = (currentLight.gameObject.activeInHierarchy ? 1 : 0);
m_LightVolumesCPUArray[realIndex].lightIndex = (uint)lightIdx;
if (currentLight.lightTypeExtent == LightTypeExtent.Punctual)
{
m_LightVolumesCPUArray[realIndex].lightType = 0;
punctualLightCount++;
}
else
{
m_LightVolumesCPUArray[realIndex].lightType = 1;
areaLightCount++;
}
realIndex++;
}
}
int indexOffset = realIndex;
// Set Env Light volume data to the CPU buffer
for (int lightIdx = 0; lightIdx < lightArray.reflectionProbeArray.Count; ++lightIdx)
{
HDProbe currentEnvLight = lightArray.reflectionProbeArray[lightIdx];
if (currentEnvLight != null)
{
if (currentEnvLight.influenceVolume.shape == InfluenceShape.Sphere)
{
m_LightVolumesCPUArray[lightIdx + indexOffset].shape = 0;
m_LightVolumesCPUArray[lightIdx + indexOffset].range = new Vector3(currentEnvLight.influenceVolume.sphereRadius, currentEnvLight.influenceVolume.sphereRadius, currentEnvLight.influenceVolume.sphereRadius);
m_LightVolumesCPUArray[lightIdx + indexOffset].position = currentEnvLight.influenceToWorld.GetColumn(3);
}
else
{
m_LightVolumesCPUArray[lightIdx + indexOffset].shape = 1;
m_LightVolumesCPUArray[lightIdx + indexOffset].range = new Vector3(currentEnvLight.influenceVolume.boxSize.x / 2.0f, currentEnvLight.influenceVolume.boxSize.y / 2.0f, currentEnvLight.influenceVolume.boxSize.z / 2.0f);
m_LightVolumesCPUArray[lightIdx + indexOffset].position = currentEnvLight.influenceToWorld.GetColumn(3);
}
m_LightVolumesCPUArray[lightIdx + indexOffset].active = (currentEnvLight.gameObject.activeInHierarchy ? 1 : 0);
m_LightVolumesCPUArray[lightIdx + indexOffset].lightIndex = (uint)lightIdx;
m_LightVolumesCPUArray[lightIdx + indexOffset].lightType = 2;
envLightCount++;
}
}
totalLightCount = punctualLightCount + areaLightCount + envLightCount;
// Push the light volumes to the GPU
m_LightVolumeGPUArray.SetData(m_LightVolumesCPUArray);
}
void BuildLightData(CommandBuffer cmd, HDCamera hdCamera, HDRayTracingLights rayTracingLights)
{
// 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();
// Build the data for every light
for (int lightIdx = 0; lightIdx < rayTracingLights.hdLightArray.Count; ++lightIdx)
{
var lightData = new LightData();
HDAdditionalLightData additionalLightData = rayTracingLights.hdLightArray[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;
LightVolumeType lightVolumeType = LightVolumeType.Count;
HDRenderPipeline.EvaluateGPULightType(light.type, additionalLightData.lightTypeExtent, additionalLightData.spotLightShape, ref lightCategory, ref gpuLightType, ref lightVolumeType);
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);
}
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);
}
