public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
bool isLitView = true;
#if UNITY_EDITOR
if (renderingData.cameraData.isSceneViewCamera)
{
isLitView = UnityEditor.SceneView.currentDrawingSceneView.sceneLighting;
}
if (renderingData.cameraData.camera.cameraType == CameraType.Preview)
{
isLitView = false;
}
if (!Application.isPlaying)
{
s_SortingLayers = SortingLayer.layers;
}
#endif
Camera camera = renderingData.cameraData.camera;
FilteringSettings filterSettings = new FilteringSettings();
filterSettings.renderQueueRange = RenderQueueRange.all;
filterSettings.layerMask = -1;
filterSettings.renderingLayerMask = 0xFFFFFFFF;
filterSettings.sortingLayerRange = SortingLayerRange.all;
bool isSceneLit = Light2D.IsSceneLit(camera);
if (isSceneLit)
{
RendererLighting.Setup(renderingData, m_Renderer2DData);
CommandBuffer cmd = CommandBufferPool.Get();
cmd.Clear();
using (new ProfilingScope(cmd, m_ProfilingSampler))
{
RendererLighting.CreateNormalMapRenderTexture(cmd);
cmd.SetGlobalFloat("_HDREmulationScale", m_Renderer2DData.hdrEmulationScale);
cmd.SetGlobalFloat("_InverseHDREmulationScale", 1.0f / m_Renderer2DData.hdrEmulationScale);
cmd.SetGlobalFloat("_UseSceneLighting", isLitView ? 1.0f : 0.0f);
cmd.SetGlobalColor("_RendererColor", Color.white);
RendererLighting.SetShapeLightShaderGlobals(cmd);
context.ExecuteCommandBuffer(cmd);
DrawingSettings combinedDrawSettings = CreateDrawingSettings(k_ShaderTags, ref renderingData, SortingCriteria.CommonTransparent);
DrawingSettings normalsDrawSettings = CreateDrawingSettings(k_NormalsRenderingPassName, ref renderingData, SortingCriteria.CommonTransparent);
SortingSettings sortSettings = combinedDrawSettings.sortingSettings;
GetTransparencySortingMode(camera, ref sortSettings);
combinedDrawSettings.sortingSettings = sortSettings;
normalsDrawSettings.sortingSettings = sortSettings;
for (int i = 0; i < m_BlendStyleInitialized.Length; ++i)
{
m_BlendStyleInitialized[i] = false;
}
for (int i = 0; i < s_SortingLayers.Length; i++)
{
// 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.
short layerValue = (short)s_SortingLayers[i].value;
var lowerBound = (i == 0) ? short.MinValue : layerValue;
var upperBound = (i == s_SortingLayers.Length - 1) ? short.MaxValue : layerValue;
filterSettings.sortingLayerRange = new SortingLayerRange(lowerBound, upperBound);
int layerToRender = s_SortingLayers[i].id;
Light2D.LightStats lightStats;
lightStats = Light2D.GetLightStatsByLayer(layerToRender, camera);
cmd.Clear();
for (int blendStyleIndex = 0; blendStyleIndex < k_BlendStylesCount; blendStyleIndex++)
{
uint blendStyleMask = (uint)(1 << blendStyleIndex);
bool blendStyleUsed = (lightStats.blendStylesUsed & blendStyleMask) > 0;
if (blendStyleUsed && !m_BlendStyleInitialized[blendStyleIndex])
{
RendererLighting.CreateBlendStyleRenderTexture(cmd, blendStyleIndex);
m_BlendStyleInitialized[blendStyleIndex] = true;
}
RendererLighting.EnableBlendStyle(cmd, blendStyleIndex, blendStyleUsed);
}
context.ExecuteCommandBuffer(cmd);
// Start Rendering
if (lightStats.totalNormalMapUsage > 0)
{
RendererLighting.RenderNormals(context, renderingData.cullResults, normalsDrawSettings,
filterSettings, depthAttachment);
}
cmd.Clear();
if (lightStats.totalLights > 0)
{
RendererLighting.RenderLights(camera, cmd, layerToRender, lightStats.blendStylesUsed);
}
else
{
RendererLighting.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();
RendererLighting.RenderLightVolumes(camera, cmd, layerToRender, colorAttachment,
depthAttachment, lightStats.blendStylesUsed);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
}
}
cmd.Clear();
Profiler.BeginSample("RenderSpritesWithLighting - Release RenderTextures");
RendererLighting.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
{
DrawingSettings unlitDrawSettings = CreateDrawingSettings(k_ShaderTags, ref renderingData,
SortingCriteria.CommonTransparent);
CommandBuffer cmd = CommandBufferPool.Get();
using (new ProfilingScope(cmd, m_ProfilingSamplerUnlit))
{
CoreUtils.SetRenderTarget(cmd, colorAttachment, depthAttachment, ClearFlag.None, Color.white);
cmd.SetGlobalTexture("_ShapeLightTexture0", Texture2D.blackTexture);
cmd.SetGlobalTexture("_ShapeLightTexture1", Texture2D.blackTexture);
cmd.SetGlobalTexture("_ShapeLightTexture2", Texture2D.blackTexture);
cmd.SetGlobalTexture("_ShapeLightTexture3", Texture2D.blackTexture);
cmd.SetGlobalFloat("_UseSceneLighting", isLitView ? 1.0f : 0.0f);
cmd.SetGlobalColor("_RendererColor", 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);
}
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
#if UNITY_EDITOR
if (!Application.isPlaying)
{
s_SortingLayers = SortingLayer.layers;
}
#endif
Camera camera = renderingData.cameraData.camera;
RendererLighting.Setup(m_RendererData);
CommandBuffer cmd = CommandBufferPool.Get("Render 2D Lighting");
cmd.Clear();
Profiler.BeginSample("RenderSpritesWithLighting - Create Render Textures");
RendererLighting.CreateRenderTextures(cmd, camera);
Profiler.EndSample();
cmd.SetGlobalFloat("_HDREmulationScale", m_RendererData.hdrEmulationScale);
cmd.SetGlobalFloat("_InverseHDREmulationScale", 1.0f / m_RendererData.hdrEmulationScale);
RendererLighting.SetShapeLightShaderGlobals(cmd);
context.ExecuteCommandBuffer(cmd);
Profiler.BeginSample("RenderSpritesWithLighting - Prepare");
DrawingSettings combinedDrawSettings = CreateDrawingSettings(k_ShaderTags, ref renderingData, SortingCriteria.CommonTransparent);
DrawingSettings normalsDrawSettings = CreateDrawingSettings(k_NormalsRenderingPassName, ref renderingData, SortingCriteria.CommonTransparent);
FilteringSettings filterSettings = new FilteringSettings();
filterSettings.renderQueueRange = RenderQueueRange.all;
filterSettings.layerMask = -1;
filterSettings.renderingLayerMask = 0xFFFFFFFF;
filterSettings.sortingLayerRange = SortingLayerRange.all;
Profiler.EndSample();
for (int i = 0; i < s_SortingLayers.Length; i++)
{
// The canvas renderer overrides its sorting layer value with short.MaxValue in the editor.
// When drawing the last sorting layer, include the range from layerValue to short.MaxValue
// so that UI can be rendered in the scene view.
short layerValue = (short)s_SortingLayers[i].value;
var upperBound = (i == s_SortingLayers.Length - 1) ? short.MaxValue : layerValue;
filterSettings.sortingLayerRange = new SortingLayerRange(layerValue, upperBound);
int layerToRender = s_SortingLayers[i].id;
Light2D.LightStats lightStats;
lightStats = Light2D.GetLightStatsByLayer(layerToRender);
if (lightStats.totalNormalMapUsage > 0)
{
RendererLighting.RenderNormals(context, renderingData.cullResults, normalsDrawSettings, filterSettings);
}
cmd.Clear();
if (lightStats.totalLights > 0)
{
#if UNITY_EDITOR
cmd.name = "Render Lights - " + SortingLayer.IDToName(layerToRender);
#endif
RendererLighting.RenderLights(camera, cmd, layerToRender);
}
else
{
RendererLighting.ClearDirtyLighting(cmd);
}
CoreUtils.SetRenderTarget(cmd, colorAttachment, RenderBufferLoadAction.Load, RenderBufferStoreAction.Store, 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();
#if UNITY_EDITOR
cmd.name = "Render Light Volumes" + SortingLayer.IDToName(layerToRender);
#endif
RendererLighting.RenderLightVolumes(camera, cmd, layerToRender);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
}
}
cmd.Clear();
Profiler.BeginSample("RenderSpritesWithLighting - Release RenderTextures");
RendererLighting.ReleaseRenderTextures(cmd);
Profiler.EndSample();
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
filterSettings.sortingLayerRange = SortingLayerRange.all;
RenderingUtils.RenderObjectsWithError(context, ref renderingData.cullResults, camera, filterSettings, SortingCriteria.None);
}