void SetupMainLightConstants(CommandBuffer cmd, ref LightData lightData)
{
Vector4 lightPos, lightColor, lightAttenuation, lightSpotDir;
InitializeLightConstants(lightData.visibleLights, lightData.mainLightIndex, out lightPos, out lightColor, out lightAttenuation, out lightSpotDir);
cmd.SetGlobalVector(LightConstantBuffer._MainLightPosition, lightPos);
cmd.SetGlobalVector(LightConstantBuffer._MainLightColor, lightColor);
}
void SetupShaderLightConstants(CommandBuffer cmd, ref LightData lightData)
{
// Clear to default all light constant data
for (int i = 0; i < maxVisibleAdditionalLights; ++i)
{
InitializeLightConstants(lightData.visibleLights, -1, out m_AdditionalLightPositions[i],
out m_AdditionalLightColors[i],
out m_AdditionalLightAttenuations[i],
out m_AdditionalLightSpotDirections[i]);
}
m_MixedLightingSetup = MixedLightingSetup.None;
// Main light has an optimized shader path for main light. This will benefit games that only care about a single light.
// Lightweight pipeline also supports only a single shadow light, if available it will be the main light.
SetupMainLightConstants(cmd, ref lightData);
SetupAdditionalLightConstants(cmd, ref lightData);
}
void SetupAdditionalLightConstants(CommandBuffer cmd, ref LightData lightData)
{
List <VisibleLight> lights = lightData.visibleLights;
if (lightData.additionalLightsCount > 0)
{
int additionalLightsCount = 0;
for (int i = 0; i < lights.Count && additionalLightsCount < maxVisibleAdditionalLights; ++i)
{
VisibleLight light = lights[i];
if (light.lightType != LightType.Directional)
{
InitializeLightConstants(lights, i, out m_AdditionalLightPositions[additionalLightsCount],
out m_AdditionalLightColors[additionalLightsCount],
out m_AdditionalLightAttenuations[additionalLightsCount],
out m_AdditionalLightSpotDirections[additionalLightsCount]);
additionalLightsCount++;
}
}
cmd.SetGlobalVector(LightConstantBuffer._AdditionalLightsCount, new Vector4(lightData.maxPerObjectAdditionalLightsCount,
0.0f, 0.0f, 0.0f));
// if not using a compute buffer, engine will set indices in 2 vec4 constants
// unity_4LightIndices0 and unity_4LightIndices1
if (perObjectLightIndices != null)
{
cmd.SetGlobalBuffer(LightConstantBuffer._AdditionalLightsBuffer, perObjectLightIndices);
}
}
else
{
cmd.SetGlobalVector(LightConstantBuffer._AdditionalLightsCount, Vector4.zero);
}
cmd.SetGlobalVectorArray(LightConstantBuffer._AdditionalLightsPosition, m_AdditionalLightPositions);
cmd.SetGlobalVectorArray(LightConstantBuffer._AdditionalLightsColor, m_AdditionalLightColors);
cmd.SetGlobalVectorArray(LightConstantBuffer._AdditionalLightsAttenuation, m_AdditionalLightAttenuations);
cmd.SetGlobalVectorArray(LightConstantBuffer._AdditionalLightsSpotDir, m_AdditionalLightSpotDirections);
}
static void InitializeLightData(PipelineSettings settings, List <VisibleLight> visibleLights, int mainLightIndex, int maxAdditionalLights,
int maxPerObjectAdditionalLights, out LightData lightData)
{
lightData.mainLightIndex = mainLightIndex;
if (settings.additionalLightsRenderingMode != LightRenderingMode.Disabled)
{
lightData.additionalLightsCount =
Math.Min((mainLightIndex != -1) ? visibleLights.Count - 1 : visibleLights.Count,
maxAdditionalLights);
lightData.maxPerObjectAdditionalLightsCount = Math.Min(settings.maxAdditionalLights, maxPerObjectAdditionalLights);
}
else
{
lightData.additionalLightsCount = 0;
lightData.maxPerObjectAdditionalLightsCount = 0;
}
lightData.shadeAdditionalLightsPerVertex = settings.additionalLightsRenderingMode == LightRenderingMode.PerVertex;
lightData.visibleLights = visibleLights;
lightData.supportsMixedLighting = settings.mixedLightingSupported;
}
public void SetupPerObjectLightIndices(ref CullResults cullResults, ref LightData lightData)
{
if (lightData.additionalLightsCount == 0)
{
return;
}
List <VisibleLight> visibleLights = lightData.visibleLights;
int[] perObjectLightIndexMap = cullResults.GetLightIndexMap();
int directionalLightsCount = 0;
int additionalLightsCount = 0;
// Disable all directional lights from the perobject light indices
// Pipeline handles them globally.
for (int i = 0; i < visibleLights.Count; ++i)
{
if (additionalLightsCount >= maxVisibleAdditionalLights)
{
break;
}
VisibleLight light = visibleLights[i];
if (light.lightType == LightType.Directional)
{
perObjectLightIndexMap[i] = -1;
++directionalLightsCount;
}
else
{
perObjectLightIndexMap[i] -= directionalLightsCount;
++additionalLightsCount;
}
}
// Disable all remaining lights we cannot fit into the global light buffer.
for (int i = directionalLightsCount + additionalLightsCount; i < visibleLights.Count; ++i)
{
perObjectLightIndexMap[i] = -1;
}
cullResults.SetLightIndexMap(perObjectLightIndexMap);
// if not using a compute buffer, engine will set indices in 2 vec4 constants
// unity_4LightIndices0 and unity_4LightIndices1
if (useStructuredBufferForLights)
{
int lightIndicesCount = cullResults.GetLightIndicesCount();
if (lightIndicesCount > 0)
{
if (perObjectLightIndices == null)
{
perObjectLightIndices = new ComputeBuffer(lightIndicesCount, sizeof(int));
}
else if (perObjectLightIndices.count < lightIndicesCount)
{
perObjectLightIndices.Release();
perObjectLightIndices = new ComputeBuffer(lightIndicesCount, sizeof(int));
}
cullResults.FillLightIndices(perObjectLightIndices);
}
}
}
void RenderAdditionalShadowmapAtlas(ref ScriptableRenderContext context, ref CullResults cullResults, ref LightData lightData, ref ShadowData shadowData)
{
List <VisibleLight> visibleLights = lightData.visibleLights;
bool additionalLightHasSoftShadows = false;
CommandBuffer cmd = CommandBufferPool.Get(k_RenderAdditionalLightShadows);
using (new ProfilingSample(cmd, k_RenderAdditionalLightShadows))
{
int shadowmapWidth = shadowData.additionalLightsShadowmapWidth;
int shadowmapHeight = shadowData.additionalLightsShadowmapHeight;
m_AdditionalLightsShadowmapTexture = RenderTexture.GetTemporary(shadowmapWidth, shadowmapHeight,
k_ShadowmapBufferBits, m_AdditionalShadowmapFormat);
m_AdditionalLightsShadowmapTexture.filterMode = FilterMode.Bilinear;
m_AdditionalLightsShadowmapTexture.wrapMode = TextureWrapMode.Clamp;
SetRenderTarget(cmd, m_AdditionalLightsShadowmapTexture, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store,
ClearFlag.Depth, Color.black, TextureDimension.Tex2D);
for (int i = 0; i < m_AdditionalShadowCastingLightIndices.Count; ++i)
{
int shadowLightIndex = m_AdditionalShadowCastingLightIndices[i];
VisibleLight shadowLight = visibleLights[shadowLightIndex];
if (m_AdditionalShadowCastingLightIndices.Count > 1)
{
ShadowUtils.ApplySliceTransform(ref m_AdditionalLightSlices[i], shadowmapWidth, shadowmapHeight);
}
var settings = new DrawShadowsSettings(cullResults, shadowLightIndex);
Vector4 shadowBias = ShadowUtils.GetShadowBias(ref shadowLight, shadowLightIndex,
ref shadowData, m_AdditionalLightSlices[i].projectionMatrix, m_AdditionalLightSlices[i].resolution);
ShadowUtils.SetupShadowCasterConstantBuffer(cmd, ref shadowLight, shadowBias);
ShadowUtils.RenderShadowSlice(cmd, ref context, ref m_AdditionalLightSlices[i], ref settings, m_AdditionalLightSlices[i].projectionMatrix, m_AdditionalLightSlices[i].viewMatrix);
additionalLightHasSoftShadows |= shadowLight.light.shadows == LightShadows.Soft;
}
SetupAdditionalLightsShadowReceiverConstants(cmd, ref shadowData);
}
// We share soft shadow settings for main light and additional lights to save keywords.
// So we check here if pipeline supports soft shadows and either main light or any additional light has soft shadows
// to enable the keyword.
// TODO: In PC and Consoles we can upload shadow data per light and branch on shader. That will be more likely way faster.
bool mainLightHasSoftShadows = shadowData.supportsMainLightShadows &&
lightData.mainLightIndex != -1 &&
visibleLights[lightData.mainLightIndex].light.shadows == LightShadows.Soft;
bool softShadows = shadowData.supportsSoftShadows && (mainLightHasSoftShadows || additionalLightHasSoftShadows);
CoreUtils.SetKeyword(cmd, ShaderKeywordStrings.AdditionalLightShadows, true);
CoreUtils.SetKeyword(cmd, ShaderKeywordStrings.SoftShadows, softShadows);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
void RenderMainLightCascadeShadowmap(ref ScriptableRenderContext context, ref CullResults cullResults, ref LightData lightData, ref ShadowData shadowData)
{
int shadowLightIndex = lightData.mainLightIndex;
if (shadowLightIndex == -1)
{
return;
}
VisibleLight shadowLight = lightData.visibleLights[shadowLightIndex];
CommandBuffer cmd = CommandBufferPool.Get(k_RenderMainLightShadowmapTag);
using (new ProfilingSample(cmd, k_RenderMainLightShadowmapTag))
{
var settings = new DrawShadowsSettings(cullResults, shadowLightIndex);
m_MainLightShadowmapTexture = RenderTexture.GetTemporary(shadowData.mainLightShadowmapWidth,
shadowData.mainLightShadowmapHeight, k_ShadowmapBufferBits, m_ShadowmapFormat);
m_MainLightShadowmapTexture.filterMode = FilterMode.Bilinear;
m_MainLightShadowmapTexture.wrapMode = TextureWrapMode.Clamp;
SetRenderTarget(cmd, m_MainLightShadowmapTexture, RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.Store, ClearFlag.Depth, Color.black, TextureDimension.Tex2D);
for (int cascadeIndex = 0; cascadeIndex < m_ShadowCasterCascadesCount; ++cascadeIndex)
{
settings.splitData.cullingSphere = m_CascadeSplitDistances[cascadeIndex];
Vector4 shadowBias = ShadowUtils.GetShadowBias(ref shadowLight, shadowLightIndex, ref shadowData, m_CascadeSlices[cascadeIndex].projectionMatrix, m_CascadeSlices[cascadeIndex].resolution);
ShadowUtils.SetupShadowCasterConstantBuffer(cmd, ref shadowLight, shadowBias);
ShadowUtils.RenderShadowSlice(cmd, ref context, ref m_CascadeSlices[cascadeIndex],
ref settings, m_CascadeSlices[cascadeIndex].projectionMatrix, m_CascadeSlices[cascadeIndex].viewMatrix);
}
SetupMainLightShadowReceiverConstants(cmd, ref shadowData, shadowLight);
}
CoreUtils.SetKeyword(cmd, ShaderKeywordStrings.MainLightShadows, true);
CoreUtils.SetKeyword(cmd, ShaderKeywordStrings.MainLightShadowCascades, shadowData.mainLightShadowCascadesCount > 1);
CoreUtils.SetKeyword(cmd, ShaderKeywordStrings.SoftShadows, shadowLight.light.shadows == LightShadows.Soft && shadowData.supportsSoftShadows);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
