private short GetCameraSortingLayerBoundsIndex()
{
SortingLayer[] sortingLayers = Light2DManager.GetCachedSortingLayer();
for (short i = 0; i < sortingLayers.Length; i++)
{
if (sortingLayers[i].id == m_Renderer2DData.cameraSortingLayerTextureBound)
{
return((short)sortingLayers[i].value);
}
}
return(short.MinValue);
}
public static void RenderLights(this IRenderPass2D pass, RenderingData renderingData, CommandBuffer cmd, int layerToRender, ref LayerBatch layerBatch, ref RenderTextureDescriptor rtDesc)
{
var blendStyles = pass.rendererData.lightBlendStyles;
for (var i = 0; i < blendStyles.Length; ++i)
{
if ((layerBatch.lightStats.blendStylesUsed & (uint)(1 << i)) == 0)
{
continue;
}
var sampleName = blendStyles[i].name;
cmd.BeginSample(sampleName);
if (!Light2DManager.GetGlobalColor(layerToRender, i, out var clearColor))
{
clearColor = Color.black;
}
var anyLights = (layerBatch.lightStats.blendStylesWithLights & (uint)(1 << i)) != 0;
var desc = rtDesc;
if (!anyLights) // No lights -- create tiny texture
{
desc.width = desc.height = 4;
}
var identifier = layerBatch.GetRTId(cmd, desc, i);
cmd.SetRenderTarget(identifier,
RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.Store,
RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.DontCare);
cmd.ClearRenderTarget(false, true, clearColor);
if (anyLights)
{
RenderLightSet(
pass, renderingData,
i,
cmd,
layerToRender,
identifier,
pass.rendererData.lightCullResult.visibleLights
);
}
cmd.EndSample(sampleName);
}
}
static public void RenderLights(Camera camera, CommandBuffer cmdBuffer, int layerToRender, uint blendStylesUsed)
{
for (int i = 0; i < s_BlendStyles.Length; ++i)
{
if ((blendStylesUsed & (uint)(1 << i)) == 0)
{
continue;
}
string sampleName = s_BlendStyles[i].name;
cmdBuffer.BeginSample(sampleName);
cmdBuffer.SetRenderTarget(s_LightRenderTargets[i].Identifier());
bool rtDirty = false;
Color clearColor;
var globalLight = Light2DManager.GetGlobalLight(layerToRender, i, out clearColor);
//Global light Color
if (!globalLight)
{
clearColor = Color.black;
}
else
{
rtDirty = true;
}
if (s_LightRenderTargetsDirty[i] || rtDirty)
{
cmdBuffer.ClearRenderTarget(false, true, clearColor);
}
//全局光方向
if (globalLight)
{
cmdBuffer.SetGlobalVector("_GlobalLightDirection", globalLight.LightDirection);
}
else
{
cmdBuffer.SetGlobalVector("_GlobalLightDirection", new Vector3(1, 1, 5));
}
rtDirty |= RenderLightSet(camera, i, cmdBuffer, layerToRender, s_LightRenderTargets[i].Identifier(), Light2D.GetLightsByBlendStyle(i));
s_LightRenderTargetsDirty[i] = rtDirty;
cmdBuffer.EndSample(sampleName);
}
}
static public void RenderLights(Camera camera, CommandBuffer cmdBuffer, int layerToRender)
{
for (int i = 0; i < s_BlendStyles.Length; ++i)
{
if (!s_BlendStyles[i].enabled)
{
continue;
}
string sampleName = s_BlendStyles[i].name;
cmdBuffer.BeginSample(sampleName);
cmdBuffer.SetRenderTarget(s_LightRenderTargets[i].Identifier());
bool rtDirty = false;
Color clearColor;
if (!Light2DManager.GetGlobalColor(layerToRender, i, out clearColor))
{
clearColor = Color.black;
}
else
{
rtDirty = true;
}
if (s_LightRenderTargetsDirty[i] || rtDirty)
{
cmdBuffer.ClearRenderTarget(false, true, clearColor);
}
rtDirty |= RenderLightSet(
camera,
i,
cmdBuffer,
layerToRender,
s_LightRenderTargets[i].Identifier(),
Light2D.GetLightsByBlendStyle(i)
);
s_LightRenderTargetsDirty[i] = rtDirty;
cmdBuffer.EndSample(sampleName);
}
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
var isLitView = true;
#if UNITY_EDITOR
if (renderingData.cameraData.isSceneViewCamera)
{
isLitView = UnityEditor.SceneView.currentDrawingSceneView.sceneLighting;
}
if (renderingData.cameraData.camera.cameraType == CameraType.Preview)
{
isLitView = false;
}
#endif
var cachedSortingLayers = Light2DManager.GetCachedSortingLayer();
var camera = renderingData.cameraData.camera;
var filterSettings = new FilteringSettings();
filterSettings.renderQueueRange = RenderQueueRange.all;
filterSettings.layerMask = -1;
filterSettings.renderingLayerMask = 0xFFFFFFFF;
filterSettings.sortingLayerRange = SortingLayerRange.all;
var isSceneLit = m_Renderer2DData.lightCullResult.IsSceneLit();
if (isSceneLit)
{
var cmd = CommandBufferPool.Get();
cmd.Clear();
using (new ProfilingScope(cmd, m_ProfilingSampler))
{
this.CreateNormalMapRenderTexture(renderingData, cmd);
cmd.SetGlobalFloat(k_HDREmulationScaleID, m_Renderer2DData.hdrEmulationScale);
cmd.SetGlobalFloat(k_InverseHDREmulationScaleID, 1.0f / m_Renderer2DData.hdrEmulationScale);
cmd.SetGlobalFloat(k_UseSceneLightingID, isLitView ? 1.0f : 0.0f);
cmd.SetGlobalColor(k_RendererColorID, Color.white);
this.SetShapeLightShaderGlobals(cmd);
context.ExecuteCommandBuffer(cmd);
var combinedDrawSettings = CreateDrawingSettings(k_ShaderTags, ref renderingData, SortingCriteria.CommonTransparent);
var normalsDrawSettings = CreateDrawingSettings(k_NormalsRenderingPassName, ref renderingData, SortingCriteria.CommonTransparent);
var sortSettings = combinedDrawSettings.sortingSettings;
GetTransparencySortingMode(camera, ref sortSettings);
combinedDrawSettings.sortingSettings = sortSettings;
normalsDrawSettings.sortingSettings = sortSettings;
var blendStylesCount = m_Renderer2DData.lightBlendStyles.Length;
for (var i = 0; i < cachedSortingLayers.Length;)
{
var layerToRender = cachedSortingLayers[i].id;
var lightStats = m_Renderer2DData.lightCullResult.GetLightStatsByLayer(layerToRender);
cmd.Clear();
for (var blendStyleIndex = 0; blendStyleIndex < blendStylesCount; blendStyleIndex++)
{
var blendStyleMask = (uint)(1 << blendStyleIndex);
var blendStyleUsed = (lightStats.blendStylesUsed & blendStyleMask) > 0;
if (blendStyleUsed && !m_Renderer2DData.lightBlendStyles[blendStyleIndex].hasRenderTarget)
{
this.CreateBlendStyleRenderTexture(renderingData, cmd, blendStyleIndex);
}
RendererLighting.EnableBlendStyle(cmd, blendStyleIndex, blendStyleUsed);
}
context.ExecuteCommandBuffer(cmd);
// find the highest layer that share the same set of lights as this layer
var upperLayerInBatch = FindUpperBoundInBatch(i, cachedSortingLayers);
// Some renderers override their sorting layer value with short.MinValue or short.MaxValue.
// When drawing the first sorting layer, we should include the range from short.MinValue to layerValue.
// Similarly, when drawing the last sorting layer, include the range from layerValue to short.MaxValue.
var startLayerValue = (short)cachedSortingLayers[i].value;
var lowerBound = (i == 0) ? short.MinValue : startLayerValue;
var endLayerValue = (short)cachedSortingLayers[upperLayerInBatch].value;
var upperBound = (upperLayerInBatch == cachedSortingLayers.Length - 1) ? short.MaxValue : endLayerValue;
// renderer within this range share the same set of lights so they should be rendered together
filterSettings.sortingLayerRange = new SortingLayerRange(lowerBound, upperBound);
// Start Rendering
if (lightStats.totalNormalMapUsage > 0)
{
this.RenderNormals(context, renderingData.cullResults, normalsDrawSettings, filterSettings, depthAttachment);
}
cmd.Clear();
if (lightStats.totalLights > 0)
{
this.RenderLights(renderingData, cmd, layerToRender, lightStats.blendStylesUsed);
}
else
{
this.ClearDirtyLighting(cmd, lightStats.blendStylesUsed);
}
CoreUtils.SetRenderTarget(cmd, colorAttachment, depthAttachment, ClearFlag.None, Color.white);
context.ExecuteCommandBuffer(cmd);
Profiler.BeginSample("RenderSpritesWithLighting - Draw Transparent Renderers");
context.DrawRenderers(renderingData.cullResults, ref combinedDrawSettings, ref filterSettings);
Profiler.EndSample();
if (lightStats.totalVolumetricUsage > 0)
{
cmd.Clear();
this.RenderLightVolumes(renderingData, cmd, layerToRender, colorAttachment, depthAttachment, lightStats.blendStylesUsed);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
}
// move on to the next one
i = upperLayerInBatch + 1;
}
cmd.Clear();
Profiler.BeginSample("RenderSpritesWithLighting - Release RenderTextures");
this.ReleaseRenderTextures(cmd);
Profiler.EndSample();
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
filterSettings.sortingLayerRange = SortingLayerRange.all;
RenderingUtils.RenderObjectsWithError(context, ref renderingData.cullResults, camera, filterSettings, SortingCriteria.None);
}
else
{
var unlitDrawSettings = CreateDrawingSettings(k_ShaderTags, ref renderingData, SortingCriteria.CommonTransparent);
var cmd = CommandBufferPool.Get();
using (new ProfilingScope(cmd, m_ProfilingSamplerUnlit))
{
CoreUtils.SetRenderTarget(cmd, colorAttachment, depthAttachment, ClearFlag.None, Color.white);
cmd.SetGlobalTexture(k_ShapeLightTexture0ID, Texture2D.blackTexture);
cmd.SetGlobalTexture(k_ShapeLightTexture1ID, Texture2D.blackTexture);
cmd.SetGlobalTexture(k_ShapeLightTexture2ID, Texture2D.blackTexture);
cmd.SetGlobalTexture(k_ShapeLightTexture3ID, Texture2D.blackTexture);
cmd.SetGlobalFloat(k_UseSceneLightingID, isLitView ? 1.0f : 0.0f);
cmd.SetGlobalColor(k_RendererColorID, Color.white);
cmd.EnableShaderKeyword("USE_SHAPE_LIGHT_TYPE_0");
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
Profiler.BeginSample("Render Sprites Unlit");
context.DrawRenderers(renderingData.cullResults, ref unlitDrawSettings, ref filterSettings);
Profiler.EndSample();
RenderingUtils.RenderObjectsWithError(context, ref renderingData.cullResults, camera, filterSettings, SortingCriteria.None);
}
}
