void BuildLightData(CommandBuffer cmd, HDCamera hdCamera, List <HDAdditionalLightData> lightArray)
{
// Also we need to build the light list data
if (m_LightDataGPUArray == null || m_LightDataGPUArray.count != lightArray.Count)
{
ResizeLightDataBuffer(lightArray.Count);
}
// 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[lightIdx] = 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 - hdCamera.camera.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.GetInnerSpotPercent01();
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.contactShadowIndex = -1;
lightData.cookieIndex = -1;
lightData.shadowIndex = -1;
lightData.rayTracedAreaShadowIndex = -1;
if (light != null && light.cookie != null)
{
// TODO: add texture atlas support for cookie textures.
switch (light.type)
{
case LightType.Spot:
lightData.cookieIndex = m_LightLoop.cookieTexArray.FetchSlice(cmd, light.cookie);
break;
case LightType.Point:
lightData.cookieIndex = m_LightLoop.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_LightLoop.cookieTexArray.FetchSlice(cmd, Texture2D.whiteTexture);
}
else if (lightData.lightType == GPULightType.Rectangle && additionalLightData.areaLightCookie != null)
{
lightData.cookieIndex = m_LightLoop.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;
}
// Set the data for this light
m_LightDataCPUArray[lightIdx] = lightData;
}
//Push the data to the GPU
m_LightDataGPUArray.SetData(m_LightDataCPUArray);
}
