// Main entry point for our scriptable render loop
public static void Render(ScriptableRenderContext context, IEnumerable <Camera> cameras)
{
bool stereoEnabled = XRSettings.isDeviceActive;
foreach (Camera camera in cameras)
{
// Culling
ScriptableCullingParameters cullingParams;
// Stereo-aware culling parameters are configured to perform a single cull for both eyes
if (!CullResults.GetCullingParameters(camera, stereoEnabled, out cullingParams))
{
continue;
}
CullResults cull = new CullResults();
CullResults.Cull(ref cullingParams, context, ref cull);
// Setup camera for rendering (sets render target, view/projection matrices and other
// per-camera built-in shader variables).
// If stereo is enabled, we also configure stereo matrices, viewports, and XR device render targets
context.SetupCameraProperties(camera, stereoEnabled);
// Draws in-between [Start|Stop]MultiEye are stereo-ized by engine
if (stereoEnabled)
{
context.StartMultiEye(camera);
}
// clear depth buffer
CommandBuffer cmd = new CommandBuffer();
cmd.ClearRenderTarget(true, false, Color.black);
context.ExecuteCommandBuffer(cmd);
cmd.Release();
// Setup global lighting shader variables
SetupLightShaderVariables(cull.visibleLights, context);
// Draw skybox
context.DrawSkybox(camera);
// Setup DrawSettings and FilterSettings
ShaderPassName passName = new ShaderPassName("BasicPass");
DrawRendererSettings drawSettings = new DrawRendererSettings(camera, passName);
FilterRenderersSettings filterSettings = new FilterRenderersSettings(true);
//*************************************************************
// Block
RenderStateBlock rsb = new RenderStateBlock(RenderStateMask.Depth | RenderStateMask.Blend | RenderStateMask.Raster | RenderStateMask.Stencil);
DepthState ds = rsb.depthState;//
ds.writeEnabled = true;
ds.compareFunction = CompareFunction.LessEqual;
rsb.depthState = ds; //
BlendState bs = rsb.blendState; //
RenderTargetBlendState rs0 = bs.blendState0; //
bs.alphaToMask = false;
rs0.sourceColorBlendMode = BlendMode.SrcAlpha;
rs0.destinationColorBlendMode = BlendMode.One;
rs0.colorBlendOperation = BlendOp.Add;
rs0.sourceAlphaBlendMode = BlendMode.Zero;
rs0.destinationAlphaBlendMode = BlendMode.One;
rs0.alphaBlendOperation = BlendOp.Add;
rs0.writeMask = ColorWriteMask.All;
bs.blendState0 = rs0; //
rsb.blendState = bs; //
RasterState rs = rsb.rasterState; //
rs.cullingMode = CullMode.Off;
rs.depthClip = false;
rs.offsetFactor = 0;
rs.offsetUnits = 0;
rsb.rasterState = rs;//
StencilState ss = rsb.stencilState;//
rsb.stencilReference = 0;
ss.compareFunction = CompareFunction.Disabled;
ss.compareFunctionBack = CompareFunction.Disabled;
ss.compareFunctionFront = CompareFunction.Disabled;
ss.failOperation = StencilOp.Keep;
ss.failOperationBack = StencilOp.Keep;
ss.failOperationFront = StencilOp.Keep;
ss.passOperation = StencilOp.Keep;
ss.passOperationBack = StencilOp.Keep;
ss.passOperationFront = StencilOp.Keep;
ss.zFailOperation = StencilOp.Keep;
ss.zFailOperationBack = StencilOp.Keep;
ss.zFailOperationFront = StencilOp.Keep;
ss.readMask = 255;
ss.writeMask = 255;
ss.enabled = true;
rsb.stencilState = ss;//
//**************************************************************
//mapping
RenderStateBlock rsb_opaque = new RenderStateBlock(RenderStateMask.Raster | RenderStateMask.Stencil);
rsb_opaque.rasterState = rsb.rasterState;
rsb_opaque.stencilState = rsb.stencilState;
rsb_opaque.stencilReference = rsb.stencilReference;
RenderStateBlock rsb_trans = new RenderStateBlock(RenderStateMask.Blend);
rsb_trans.blendState = rsb.blendState;
RenderStateBlock rsb_over = new RenderStateBlock(RenderStateMask.Raster | RenderStateMask.Depth | RenderStateMask.Stencil);
rsb_over.depthState = rsb.depthState;
rsb_over.rasterState = rsb.rasterState;
rsb_over.stencilState = rsb.stencilState;
rsb_over.stencilReference = rsb.stencilReference;
List <RenderStateMapping> rsm = new List <RenderStateMapping>
{
new RenderStateMapping("Opaque", rsb_opaque),
new RenderStateMapping("Transparent", rsb_trans),
new RenderStateMapping("Overlay", rsb_over)
};
//**************************************************************
// Draw opaque objects using BasicPass shader pass
filterSettings.layerMask = LayerMask.GetMask("Default");
drawSettings.sorting.flags = SortFlags.CommonOpaque;
filterSettings.renderQueueRange = RenderQueueRange.opaque;
context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
// WITH RENDERSTATEBLOCK OPAQUE
filterSettings.layerMask = LayerMask.GetMask("TransparentFX");
drawSettings.sorting.flags = SortFlags.CommonOpaque;
filterSettings.renderQueueRange = RenderQueueRange.opaque;
context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings, rsb);
// WITH RENDERSTATEMAPPING OPAQUE
filterSettings.layerMask = LayerMask.GetMask("Ignore Raycast");
drawSettings.sorting.flags = SortFlags.CommonOpaque;
filterSettings.renderQueueRange = RenderQueueRange.opaque;
context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings, rsm);
//**************************************************************
// Draw transparent objects using BasicPass shader pass
filterSettings.layerMask = LayerMask.GetMask("Default");
drawSettings.sorting.flags = SortFlags.CommonTransparent;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
// WITH RENDERSTATEBLOCK TRANSPARENT
filterSettings.layerMask = LayerMask.GetMask("TransparentFX");
drawSettings.sorting.flags = SortFlags.CommonTransparent;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings, rsb);
// WITH RENDERSTATEMAPPING TRANSPARENT
filterSettings.layerMask = LayerMask.GetMask("Ignore Raycast");
drawSettings.sorting.flags = SortFlags.CommonTransparent;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings, rsm);
//**************************************************************
if (stereoEnabled)
{
context.StopMultiEye(camera);
// StereoEndRender will reset state on the camera to pre-Stereo settings,
// and invoke XR based events/callbacks.
context.StereoEndRender(camera);
}
context.Submit();
}
}
protected override void Render(ScriptableRenderContext context, Camera[] cameras)
{
BeginFrameRendering(context, cameras);
foreach (Camera camera in cameras)
{
BeginCameraRendering(context, camera);
//Culling
ScriptableCullingParameters cullingParams;
if (!camera.TryGetCullingParameters(out cullingParams))
{
continue;
}
CullingResults cull = context.Cull(ref cullingParams);
//Camera setup some builtin variables e.g. camera projection matrices etc
context.SetupCameraProperties(camera);
//Get the setting from camera component
bool drawSkyBox = camera.clearFlags == CameraClearFlags.Skybox? true : false;
bool clearDepth = camera.clearFlags == CameraClearFlags.Nothing? false : true;
bool clearColor = camera.clearFlags == CameraClearFlags.Color? true : false;
//Camera clear flag
CommandBuffer cmd = new CommandBuffer();
cmd.ClearRenderTarget(clearDepth, clearColor, camera.backgroundColor);
context.ExecuteCommandBuffer(cmd);
cmd.Release();
//Setup DrawSettings and FilterSettings
SortingSettings sortingSettings = new SortingSettings(camera);
DrawingSettings drawSettings = new DrawingSettings(m_PassName, sortingSettings);
FilteringSettings filterSettings = new FilteringSettings(RenderQueueRange.all);
//Skybox
if (drawSkyBox)
{
context.DrawSkybox(camera);
}
//Opaque objects
sortingSettings.criteria = SortingCriteria.CommonOpaque;
drawSettings.sortingSettings = sortingSettings;
filterSettings.renderQueueRange = RenderQueueRange.opaque;
context.DrawRenderers(cull, ref drawSettings, ref filterSettings);
//Error Opaque
//DrawErrorShader(context,sortingSettings,cull,filterSettings);
//Transparent objects
sortingSettings.criteria = SortingCriteria.CommonTransparent;
drawSettings.sortingSettings = sortingSettings;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(cull, ref drawSettings, ref filterSettings);
//Error Opaque+Transparent
DrawErrorShader(context, sortingSettings, cull, filterSettings);
context.Submit();
EndCameraRendering(context, camera);
}
EndFrameRendering(context, cameras);
}
private void Render(ScriptableRenderContext context, Camera camera)
{
/* Attempt to cull the current camera.
* If it fails to cull, don't render anything to this camera.
*/
ScriptableCullingParameters cullingParameters;
if (!camera.TryGetCullingParameters(out cullingParameters))
{
return;
}
#if UNITY_EDITOR
// For rendering UI in the scene view
if (camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
cullingResults = context.Cull(ref cullingParameters);
// Setup properties for a specific camera.
context.SetupCameraProperties(camera);
/* Creates a graphics command buffer.
* This particular one is told to clear the depth buffer, not the colour, and to set the clear colour to transparent.
* It finally releases the memory it has, as the commands have been sent to the internal buffer of the rendering context.
*/
//var buffer = new CommandBuffer();
//buffer.ClearRenderTarget(true, false, Color.clear);
//context.ExecuteCommandBuffer(buffer);
//buffer.Release();
/* Creates a graphics command buffer.
* This particular one is told to clear the depth buffer, not the colour, and to set the clear colour to transparent.
* It finally releases the memory it has, as the commands have been sent to the internal buffer of the rendering context.
*/
CameraClearFlags clearFlags = camera.clearFlags;
buffer.ClearRenderTarget((clearFlags & CameraClearFlags.Depth) != 0, (clearFlags & CameraClearFlags.Color) != 0, camera.backgroundColor);
buffer.BeginSample("Render Camera"); // Start nested grouping for command buffer (For Frame Debugger)
context.ExecuteCommandBuffer(buffer);
//buffer.Release();
buffer.Clear();
// Once culling and clearing have been completed we can draw the appropriate renderers.
var drawSettings = new DrawingSettings(new ShaderTagId("SRPDefaultUnlit"), new SortingSettings(camera));
var filterSettings = FilteringSettings.defaultValue;
// Only render the opaque objects first. To avoid transparent objects being drawn behind the skybox.
filterSettings.renderQueueRange = RenderQueueRange.opaque;
context.DrawRenderers(cullingResults, ref drawSettings, ref filterSettings);
// Check for any problems drawing objects with custom pipeline.
DrawDefaultPipeline(context, camera);
// Draws a skybox to the specified camera.
context.DrawSkybox(camera);
// After all the opaque objects have been drawn, draw the transparent objects.
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(cullingResults, ref drawSettings, ref filterSettings);
// End nested grouping for command buffer (For Frame Debugger)
buffer.EndSample("Render Camera");
context.ExecuteCommandBuffer(buffer);
buffer.Clear();
// Commands sent to the rendering context are just buffered. They are only excuted once we submit them.
context.Submit();
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
context.DrawSkybox(renderingData.cameraData.camera);
}
void Render(ScriptableRenderContext context, Camera camera)
{
ScriptableCullingParameters cullingParameters;
if (!CullResults.GetCullingParameters(camera, out cullingParameters))
{
return;
}
cullingParameters.shadowDistance = Mathf.Min(shadowDistance, camera.farClipPlane);
#if UNITY_EDITOR
if (camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
CullResults.Cull(ref cullingParameters, context, ref cull);
if (cull.visibleLights.Count > 0)
{
ConfigureLights();
if (mainLightExist)
{
RendercascadeShadows(context);
}
else
{
cameraBuffer.DisableShaderKeyword(cascadeShadowsHardKeyword);
cameraBuffer.DisableShaderKeyword(cascadeShadowsSoftKeyword);
}
if (shadowTileCount > 0)
{
RenderShadows(context);
}
else
{
cameraBuffer.DisableShaderKeyword(shadowsSoftKeyword);
cameraBuffer.DisableShaderKeyword(shadowsHardKeyword);
}
}
else
{
cameraBuffer.SetGlobalVector(lightIndicesOffsetAndCountID, Vector4.zero);
cameraBuffer.DisableShaderKeyword(cascadeShadowsHardKeyword);
cameraBuffer.DisableShaderKeyword(cascadeShadowsSoftKeyword);
cameraBuffer.DisableShaderKeyword(shadowsSoftKeyword);
cameraBuffer.DisableShaderKeyword(shadowsHardKeyword);
}
context.SetupCameraProperties(camera);
var myPipelineCamera = camera.GetComponent <MyPipelineCamera>();
MyPostprocessingStack activeStack = myPipelineCamera ?
myPipelineCamera.PostProcessingStack : defaultStack;
bool scaledRendering = (renderScale <1f || renderScale> 1f) && camera.cameraType == CameraType.Game;
int renderWidth = camera.pixelWidth;
int renderHeight = camera.pixelHeight;
if (scaledRendering)
{
renderWidth = (int)(renderWidth * renderScale);
renderHeight = (int)(renderHeight * renderScale);
}
int renderSamples = camera.allowMSAA ? msaaSamples : 1;
bool renderToTexture = scaledRendering || renderSamples > 1 || activeStack;
bool needsDepth = activeStack && activeStack.NeedsDepth;
bool needsDirectDepth = needsDepth && renderSamples == 1;
bool needsDepthOnlyPass = needsDepth && renderSamples > 1;
RenderTextureFormat format = allowHDR && camera.allowHDR ?
RenderTextureFormat.DefaultHDR : RenderTextureFormat.Default;
if (renderToTexture)
{
cameraBuffer.GetTemporaryRT(cameraColorTextureID, renderWidth, renderHeight, needsDirectDepth ? 0 : 24, FilterMode.Bilinear,
format, RenderTextureReadWrite.Default, renderSamples);
if (needsDepth)
{
cameraBuffer.GetTemporaryRT(cameraDepthTextureID, renderWidth, renderHeight, 24, FilterMode.Point, RenderTextureFormat.Depth,
RenderTextureReadWrite.Linear, 1);
}
if (needsDirectDepth)
{
cameraBuffer.SetRenderTarget(cameraColorTextureID, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store,
cameraDepthTextureID, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store);
}
else
{
cameraBuffer.SetRenderTarget(cameraColorTextureID, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store);
}
}
CameraClearFlags clearFlags = camera.clearFlags;
cameraBuffer.ClearRenderTarget(
(clearFlags & CameraClearFlags.Depth) != 0,
(clearFlags & CameraClearFlags.Color) != 0,
camera.backgroundColor
//new Color(0, 0, 0, 0)
);
cameraBuffer.BeginSample("Render Camera");
cameraBuffer.SetGlobalVectorArray(visibleLightColorID, visibleLightColors);
cameraBuffer.SetGlobalVectorArray(visibleLightDirectionOrPositionID, visibleLightDirectionsOrPositions);
cameraBuffer.SetGlobalVectorArray(visibleLightAttenuationsID, visibleLightAttenuations);
cameraBuffer.SetGlobalVectorArray(visibleLightSpotDirectionID, visibleLightSpotDirections);
cameraBuffer.SetGlobalVectorArray(visibleLightOcclusionMasksID, visibleLightOcclusionMasks);
globalShadowData.z = 1f - cullingParameters.shadowDistance * globalShadowData.y;
cameraBuffer.SetGlobalVector(globalShadowDataID, globalShadowData);
context.ExecuteCommandBuffer(cameraBuffer);
cameraBuffer.Clear();
ShaderPassName passName = new ShaderPassName("SRPDefaultUnlit");
var drawSettings = new DrawRendererSettings(camera, passName)
{
flags = drawFlags
};
if (cull.visibleLights.Count > 0)
{
drawSettings.rendererConfiguration = RendererConfiguration.PerObjectLightIndices8;
}
drawSettings.rendererConfiguration |=
RendererConfiguration.PerObjectReflectionProbes |
RendererConfiguration.PerObjectLightmaps |
RendererConfiguration.PerObjectLightProbe |
RendererConfiguration.PerObjectLightProbeProxyVolume |
RendererConfiguration.PerObjectShadowMask |
RendererConfiguration.PerObjectOcclusionProbe |
RendererConfiguration.PerObjectOcclusionProbeProxyVolume;
// drawSettings.flags = drawFlags;
drawSettings.sorting.flags = SortFlags.CommonOpaque;
var filterSettings = new FilterRenderersSettings(true)
{
renderQueueRange = RenderQueueRange.opaque
};
context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
context.DrawSkybox(camera);
if (activeStack)
{
if (needsDepthOnlyPass)
{
var depthOnlyDrawSettings = new DrawRendererSettings(camera, new ShaderPassName("DepthOnly"))
{
flags = drawFlags
};
depthOnlyDrawSettings.sorting.flags = SortFlags.CommonOpaque;
cameraBuffer.SetRenderTarget(cameraDepthTextureID, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store);
cameraBuffer.ClearRenderTarget(true, false, Color.clear);
context.ExecuteCommandBuffer(cameraBuffer);
cameraBuffer.Clear();
context.DrawRenderers(cull.visibleRenderers, ref depthOnlyDrawSettings, filterSettings);
}
activeStack.RenderAfterOpaque(postProcessingBuffer, cameraColorTextureID, cameraDepthTextureID, renderWidth, renderHeight, renderSamples, format);
context.ExecuteCommandBuffer(postProcessingBuffer);
postProcessingBuffer.Clear();
if (needsDirectDepth)
{
cameraBuffer.SetRenderTarget(cameraColorTextureID, RenderBufferLoadAction.Load, RenderBufferStoreAction.Store,
cameraDepthTextureID, RenderBufferLoadAction.Load, RenderBufferStoreAction.Store);
}
else
{
cameraBuffer.SetRenderTarget(cameraColorTextureID, RenderBufferLoadAction.Load, RenderBufferStoreAction.Store);
}
context.ExecuteCommandBuffer(cameraBuffer);
cameraBuffer.Clear();
}
drawSettings.sorting.flags = SortFlags.CommonTransparent;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
DrawDefaultPipeline(context, camera);
if (renderToTexture)
{
if (activeStack)
{
activeStack.RenderAfterTransparent(postProcessingBuffer, cameraColorTextureID, cameraDepthTextureID, renderWidth, renderHeight, renderSamples, format);
context.ExecuteCommandBuffer(postProcessingBuffer);
postProcessingBuffer.Clear();
}
else
{
cameraBuffer.Blit(cameraColorTextureID, BuiltinRenderTextureType.CameraTarget);
}
cameraBuffer.ReleaseTemporaryRT(cameraColorTextureID);
if (needsDepth)
{
cameraBuffer.ReleaseTemporaryRT(cameraDepthTextureID);
}
}
cameraBuffer.EndSample("Render Camera");
context.ExecuteCommandBuffer(cameraBuffer);
cameraBuffer.Clear();
context.Submit();
if (shadowMap)
{
RenderTexture.ReleaseTemporary(shadowMap);
shadowMap = null;
}
if (cascadeShadowMap)
{
RenderTexture.ReleaseTemporary(cascadeShadowMap);
cascadeShadowMap = null;
}
}
public override void Render(ScriptableRenderContext context, Camera camera, ref CullingResults cullingResults)
{
context.DrawSkybox(camera);
}
public override void Render(ScriptableRenderContext context, Camera[] cameras)
{
base.Render(context, cameras);
bool stereoEnabled = XRSettings.isDeviceActive;
foreach (Camera camera in cameras)
{
m_CurrCamera = camera;
ScriptableCullingParameters cullingParameters;
if (!CullResults.GetCullingParameters(m_CurrCamera, stereoEnabled, out cullingParameters))
{
continue;
}
cullingParameters.shadowDistance = Mathf.Min(m_ShadowSettings.maxShadowDistance, m_CurrCamera.farClipPlane);
CullResults.Cull(ref cullingParameters, context, ref m_CullResults);
VisibleLight[] visibleLights = m_CullResults.visibleLights.ToArray();
LightData lightData;
InitializeLightData(visibleLights, out lightData);
// Render Shadow Map
if (lightData.shadowLightIndex > -1)
{
lightData.shadowsRendered = RenderShadows(ref m_CullResults, ref visibleLights[lightData.shadowLightIndex], lightData.shadowLightIndex, ref context);
}
// Setup camera matrices and RT
context.SetupCameraProperties(m_CurrCamera, stereoEnabled);
// Setup light and shadow shader constants
SetupShaderLightConstants(visibleLights, ref lightData, ref m_CullResults, ref context);
if (lightData.shadowsRendered)
{
SetupShadowShaderConstants(ref context, ref visibleLights[lightData.shadowLightIndex], lightData.shadowLightIndex, m_ShadowCasterCascadesCount);
}
SetShaderKeywords(ref lightData, ref context);
RendererConfiguration configuration = RendererConfiguration.PerObjectReflectionProbes;
if (m_Asset.EnableLightmap)
{
configuration |= RendererConfiguration.PerObjectLightmaps;
}
if (m_Asset.EnableAmbientProbe)
{
configuration |= RendererConfiguration.PerObjectLightProbe;
}
if (!lightData.isSingleDirectionalLight)
{
configuration |= RendererConfiguration.PerObjectLightIndices8;
}
PostProcessLayer postProcessLayer = GetCurrCameraPostProcessLayer();
bool postProcessEnabled = postProcessLayer != null && postProcessLayer.enabled;
m_RenderToIntermediateTarget = postProcessEnabled || GetRenderToIntermediateTarget();
BeginForwardRendering(ref context, stereoEnabled);
var litDrawSettings = new DrawRendererSettings(m_CurrCamera, m_LitPassName);
litDrawSettings.sorting.flags = SortFlags.CommonOpaque;
litDrawSettings.rendererConfiguration = configuration;
var unlitDrawSettings = new DrawRendererSettings(m_CurrCamera, m_UnlitPassName);
unlitDrawSettings.sorting.flags = SortFlags.CommonTransparent;
// Render Opaques
var opaqueFilterSettings = new FilterRenderersSettings(true)
{
renderQueueRange = RenderQueueRange.opaque
};
context.DrawRenderers(m_CullResults.visibleRenderers, ref litDrawSettings, opaqueFilterSettings);
// TODO: Check skybox shader
context.DrawSkybox(m_CurrCamera);
// Render Alpha blended
var transparentFilterSettings = new FilterRenderersSettings(true)
{
renderQueueRange = RenderQueueRange.transparent
};
litDrawSettings.sorting.flags = SortFlags.CommonTransparent;
context.DrawRenderers(m_CullResults.visibleRenderers, ref litDrawSettings, transparentFilterSettings);
context.DrawRenderers(m_CullResults.visibleRenderers, ref unlitDrawSettings, transparentFilterSettings);
if (postProcessEnabled)
{
RenderPostProcess(ref context, postProcessLayer);
}
EndForwardRendering(ref context, stereoEnabled, postProcessEnabled);
// Release temporary RT
var discardRT = CommandBufferPool.Get();
discardRT.ReleaseTemporaryRT(m_ShadowMapProperty);
discardRT.ReleaseTemporaryRT(m_CameraRTProperty);
context.ExecuteCommandBuffer(discardRT);
CommandBufferPool.Release(discardRT);
}
context.Submit();
}
protected override void Render(ScriptableRenderContext context, Camera[] cameras)
{
BeginFrameRendering(cameras);
foreach (Camera camera in cameras)
{
BeginCameraRendering(camera);
//Culling
ScriptableCullingParameters cullingParams;
if (!camera.TryGetCullingParameters(out cullingParams))
{
continue;
}
CullingResults cull = context.Cull(ref cullingParams);
//Camera setup some builtin variables e.g. camera projection matrices etc
context.SetupCameraProperties(camera);
//Get the setting from camera component
bool drawSkyBox = camera.clearFlags == CameraClearFlags.Skybox? true : false;
bool clearDepth = camera.clearFlags == CameraClearFlags.Nothing? false : true;
bool clearColor = camera.clearFlags == CameraClearFlags.Color? true : false;
//Set Depth texture temp RT
CommandBuffer cmdTempId = new CommandBuffer();
cmdTempId.name = "(" + camera.name + ")" + "Setup TempRT";
RenderTextureDescriptor depthRTDesc = new RenderTextureDescriptor(camera.pixelWidth, camera.pixelHeight);
depthRTDesc.colorFormat = RenderTextureFormat.Depth;
depthRTDesc.depthBufferBits = depthBufferBits;
cmdTempId.GetTemporaryRT(m_DepthRTid, depthRTDesc, FilterMode.Bilinear);
context.ExecuteCommandBuffer(cmdTempId);
cmdTempId.Release();
//Setup DrawSettings and FilterSettings
var sortingSettings = new SortingSettings(camera);
DrawingSettings drawSettings = new DrawingSettings(m_PassName, sortingSettings);
FilteringSettings filterSettings = new FilteringSettings(RenderQueueRange.all);
DrawingSettings drawSettingsDepth = new DrawingSettings(m_PassName, sortingSettings)
{
perObjectData = PerObjectData.None,
overrideMaterial = depthOnlyMaterial,
overrideMaterialPassIndex = 0
};
//Clear Depth Texture
CommandBuffer cmdDepth = new CommandBuffer();
cmdDepth.name = "(" + camera.name + ")" + "Depth Clear Flag";
cmdDepth.SetRenderTarget(m_DepthRT); //Set CameraTarget to the depth texture
cmdDepth.ClearRenderTarget(true, true, Color.black);
context.ExecuteCommandBuffer(cmdDepth);
cmdDepth.Release();
//Draw Depth with Opaque objects
sortingSettings.criteria = SortingCriteria.CommonOpaque;
drawSettingsDepth.sortingSettings = sortingSettings;
filterSettings.renderQueueRange = RenderQueueRange.opaque;
context.DrawRenderers(cull, ref drawSettingsDepth, ref filterSettings);
//To let shader has _CameraDepthTexture
CommandBuffer cmdDepthTexture = new CommandBuffer();
cmdDepthTexture.name = "(" + camera.name + ")" + "Depth Texture";
cmdDepthTexture.SetGlobalTexture(m_DepthRTid, m_DepthRT);
context.ExecuteCommandBuffer(cmdDepthTexture);
cmdDepthTexture.Release();
//Camera clear flag
CommandBuffer cmd = new CommandBuffer();
cmd.SetRenderTarget(BuiltinRenderTextureType.CameraTarget); //Rember to reset target
cmd.ClearRenderTarget(clearDepth, clearColor, camera.backgroundColor);
context.ExecuteCommandBuffer(cmd);
cmd.Release();
//Skybox
if (drawSkyBox)
{
context.DrawSkybox(camera);
}
//Opaque objects
sortingSettings.criteria = SortingCriteria.CommonOpaque;
drawSettings.sortingSettings = sortingSettings;
filterSettings.renderQueueRange = RenderQueueRange.opaque;
context.DrawRenderers(cull, ref drawSettings, ref filterSettings);
//Transparent objects
sortingSettings.criteria = SortingCriteria.CommonTransparent;
drawSettings.sortingSettings = sortingSettings;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(cull, ref drawSettings, ref filterSettings);
//Clean Up
CommandBuffer cmdclean = new CommandBuffer();
cmdclean.name = "(" + camera.name + ")" + "Clean Up";
cmdclean.ReleaseTemporaryRT(m_DepthRTid);
context.ExecuteCommandBuffer(cmdclean);
cmdclean.Release();
context.Submit();
}
}
void DrawVisibleGeometry()
{
context.DrawSkybox(camera);
}
private void DrawSkyBox(ScriptableRenderContext pRenderContext, Camera pCamera)
{
pRenderContext.DrawSkybox(pCamera);
}
protected virtual void RenderCamera(ScriptableRenderContext context, Camera camera)
{
var p = Matrix4x4.Perspective(30, 16.0f / 9, .3f, 1000);
var v = new Vector4(.5f, .5f, 10, 1);
camera.TryGetCullingParameters(out var cullingParameters);
var cmd = CommandBufferPool.Get(camera.name);
cmd.Clear();
if (camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
var cullResults = context.Cull(ref cullingParameters);
var projectionMat = camera.projectionMatrix;
var jitteredProjectionMat = projectionMat;
jitteredProjectionMat.m02 += (projectionJitter.Current.x * 2 - 1) / camera.pixelWidth;
jitteredProjectionMat.m12 += (projectionJitter.Current.x * 2 - 1) / camera.pixelHeight;
var renderingData = new RenderingData()
{
camera = camera,
cullResults = cullResults,
ColorTarget = BuiltinRenderTextureType.CameraTarget,
DepthTarget = BuiltinRenderTextureType.CameraTarget,
ColorBufferFormat = RenderTextureFormat.Default,
shadowMapData = new Dictionary <Light, ShadowMapData>(),
FrameID = frameID,
DiscardFrameBuffer = true,
ViewMatrix = camera.worldToCameraMatrix,
ProjectionMatrix = projectionMat,
JitteredProjectionMatrix = jitteredProjectionMat,
ProjectionJitter = new Vector2(.5f, .5f),
NextProjectionJitter = new Vector2(.5f, .5f),
};
this.Setup(context, ref renderingData);
context.SetupCameraProperties(camera, false);
InitRenderQueue(camera);
SetupLight(ref renderingData);
/*RenderTargetBinding binding = new RenderTargetBinding();
* binding.colorRenderTargets = new RenderTargetIdentifier[] { ColorTarget };
* binding.colorLoadActions = new RenderBufferLoadAction[] { RenderBufferLoadAction.Clear };
* binding.depthRenderTarget = DepthTarget;
* binding.depthLoadAction = RenderBufferLoadAction.Clear;
* binding.colorStoreActions = new RenderBufferStoreAction[] { RenderBufferStoreAction.Store };
* binding.depthStoreAction = RenderBufferStoreAction.Store;*/
cmd.SetRenderTarget(ColorTarget, DepthTarget);
cmd.ClearRenderTarget(true, true, Color.black, 1);
cmd.SetRenderTarget(DepthTarget, DepthTarget);
cmd.ClearRenderTarget(true, true, Color.black, 1);
cmd.SetRenderTarget(ColorTarget, DepthTarget);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
context.DrawSkybox(camera);
foreach (var pass in RenderPassQueue)
{
pass.Setup(context, ref renderingData);
pass.Render(context, ref renderingData);
}
// Draw global user passes
foreach (var pass in globalUserPasses)
{
pass.Setup(context, ref renderingData);
pass.Render(context, ref renderingData);
}
// Draw user passes
var userPasses = camera.GetComponents <UserPass>();
foreach (var pass in userPasses)
{
if (pass.Global)
{
continue;
}
pass.Setup(context, ref renderingData);
pass.Render(context, ref renderingData);
}
cmd.Blit(renderingData.ColorTarget, BuiltinRenderTextureType.CameraTarget);
//cmd.CopyTexture(renderingData.DepthTarget, BuiltinRenderTextureType.CameraTarget);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
if (camera.cameraType == CameraType.SceneView)
{
context.DrawGizmos(camera, GizmoSubset.PreImageEffects);
context.DrawGizmos(camera, GizmoSubset.PostImageEffects);
}
foreach (var pass in RenderPassQueue)
{
pass.Cleanup(context, ref renderingData);
}
foreach (var pass in globalUserPasses)
{
pass.Cleanup(context, ref renderingData);
}
foreach (var pass in userPasses)
{
pass.Cleanup(context, ref renderingData);
}
this.Cleanup(context, ref renderingData);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
context.Submit();
projectionJitter.Next = renderingData.NextProjectionJitter;
}
private void RenderScene(Camera camera) {
// Clear the screen
var clearFlags = camera.clearFlags;
_currentBuffer.ClearRenderTarget((clearFlags & CameraClearFlags.Depth) != 0, (clearFlags & CameraClearFlags.Color) != 0, camera.backgroundColor);
// Set up view port, view matrix and projection matrix
// context.SetupCameraProperties(camera);
var cameraTransform = camera.transform;
var cameraForward = cameraTransform.forward;
var cameraPosition = cameraTransform.position;
var viewPort = camera.pixelRect;
var viewMatrix = camera.worldToCameraMatrix;
var projectionMatrix = camera.projectionMatrix;
_currentBuffer.SetViewport(viewPort);
_currentBuffer.SetViewProjectionMatrices(viewMatrix, projectionMatrix);
var farClipPlane = camera.farClipPlane;
var nearClipPlane = camera.nearClipPlane;
var clipDistance = farClipPlane - nearClipPlane;
var zBufferParams = new Vector4(clipDistance / nearClipPlane, 1, clipDistance / (farClipPlane * nearClipPlane), 1 / farClipPlane);
_currentBuffer.SetGlobalFloat(ShaderManager.ALPHA_TEST_DEPTH_CUTOFF, @params.alphaTestDepthCutoff);
_currentBuffer.SetGlobalVector(ShaderManager.Z_BUFFER_PARAMS, zBufferParams);
_currentBuffer.SetComputeVectorParam(@params.tbrComputeShader, ShaderManager.Z_BUFFER_PARAMS, zBufferParams);
_currentBuffer.SetComputeMatrixParam(@params.tbrComputeShader, ShaderManager.UNITY_MATRIX_V, viewMatrix);
_currentBuffer.SetComputeMatrixParam(@params.tbrComputeShader, ShaderManager.UNITY_INVERSE_P, projectionMatrix.inverse);
ExecuteCurrentBuffer();
// Only need to construct UI meshes under Editor mode
#if UNITY_EDITOR
if (camera.cameraType == CameraType.SceneView) ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
#endif
// Object culling
// todo maybe add gpu culling pipeline in the future (compute shader based, AABB/OBB intersection tests)
if (!camera.TryGetCullingParameters(out var cullingParameters)) return;
cullingParameters.shadowDistance = Mathf.Min(@params.sunlightParams.shadowDistance, farClipPlane);
var cull = _context.Cull(ref cullingParameters);
var sortingSettings = new SortingSettings(camera) { criteria = SortingCriteria.QuantizedFrontToBack | SortingCriteria.OptimizeStateChanges };
// Render depth and normal textures
var drawSettings = new DrawingSettings(ShaderTagManager.SRP_DEFAULT_UNLIT, sortingSettings) {
enableDynamicBatching = @params.enableDynamicBatching,
enableInstancing = @params.enableInstancing
};
var filterSettings = FilteringSettings.defaultValue;
filterSettings.layerMask = camera.cullingMask;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
var pixelWidth = camera.pixelWidth;
var pixelHeight = camera.pixelHeight;
GenerateRTs(pixelWidth, pixelHeight);
ResetRenderTarget(OpaqueNormalId, DepthId, true, true, 1, Color.black);
ExecuteCurrentBuffer();
// Depth prepass (with opaque normal rendered)
var depthNormalDrawSettings = new DrawingSettings(ShaderTagManager.DEPTH_NORMAL, sortingSettings) {
enableDynamicBatching = @params.enableDynamicBatching,
enableInstancing = @params.enableInstancing
};
filterSettings.renderQueueRange = ShaderManager.OPAQUE_RENDER_QUEUE_RANGE;
_context.DrawRenderers(cull, ref depthNormalDrawSettings, ref filterSettings);
sortingSettings.criteria = SortingCriteria.OptimizeStateChanges;
depthNormalDrawSettings.sortingSettings = sortingSettings;
filterSettings.renderQueueRange = ShaderManager.ALPHA_TEST_QUEUE_RANGE;
_context.DrawRenderers(cull, ref depthNormalDrawSettings, ref filterSettings);
var screenThreadGroupsX = pixelWidth / 8;
var screenThreadGroupsY = pixelHeight / 8;
if (pixelWidth % 8 != 0) screenThreadGroupsX++;
if (pixelHeight % 8 != 0) screenThreadGroupsY++;
var depthCopyKernel = @params.generalComputeShader.FindKernel("CopyDepth");
_currentBuffer.SetComputeTextureParam(@params.generalComputeShader, depthCopyKernel, ShaderManager.DEPTH_TEXTURE, DepthId);
_currentBuffer.SetComputeTextureParam(@params.generalComputeShader, depthCopyKernel, ShaderManager.OPAQUE_DEPTH_TEXTURE, OpaqueDepthId);
_currentBuffer.DispatchCompute(@params.generalComputeShader, depthCopyKernel, screenThreadGroupsX, screenThreadGroupsY, 1);
_currentBuffer.SetGlobalTexture(ShaderManager.OPAQUE_DEPTH_TEXTURE, OpaqueDepthId);
// Stencil prepass
ResetRenderTarget(OpaqueNormalId, DepthId, false, false, 1, Color.black);
ExecuteCurrentBuffer();
var stencilDrawSettings = new DrawingSettings(ShaderTagManager.STENCIL, sortingSettings) {
enableDynamicBatching = @params.enableDynamicBatching,
enableInstancing = @params.enableInstancing
};
filterSettings.renderQueueRange = RenderQueueRange.all;
_context.DrawRenderers(cull, ref stencilDrawSettings, ref filterSettings);
var transparentDepthDrawSettings = new DrawingSettings(ShaderTagManager.DEPTH, sortingSettings) {
enableDynamicBatching = @params.enableDynamicBatching,
enableInstancing = @params.enableInstancing
};
filterSettings.renderQueueRange = RenderQueueRange.transparent;
_context.DrawRenderers(cull, ref transparentDepthDrawSettings, ref filterSettings);
// Tile-based light culling
var depthBoundTextureWidth = pixelWidth / @params.depthTileResolution;
var depthBoundTextureHeight = pixelHeight / @params.depthTileResolution;
if (pixelWidth % @params.depthTileResolution != 0) depthBoundTextureWidth++;
if (pixelHeight % @params.depthTileResolution != 0) depthBoundTextureHeight++;
var tileThreadGroupsX = depthBoundTextureWidth / 16;
var tileThreadGroupsY = depthBoundTextureHeight / 9;
if (depthBoundTextureWidth % 16 != 0) tileThreadGroupsX++;
if (depthBoundTextureHeight % 9 != 0) tileThreadGroupsY++;
// Debug.Log(pixelWidth + ", " + pixelHeight);
var depthBoundKernel = @params.tbrComputeShader.FindKernel("GenerateDepthBound");
_currentBuffer.SetComputeFloatParams(@params.tbrComputeShader, ShaderManager.TILE_NUMBER, (float) depthBoundTextureWidth, (float) depthBoundTextureHeight);
_currentBuffer.SetComputeTextureParam(@params.tbrComputeShader, depthBoundKernel, ShaderManager.DEPTH_TEXTURE, DepthId);
_currentBuffer.SetComputeTextureParam(@params.tbrComputeShader, depthBoundKernel, ShaderManager.OPAQUE_DEPTH_TEXTURE, OpaqueDepthId);
_currentBuffer.SetComputeTextureParam(@params.tbrComputeShader, depthBoundKernel, ShaderManager.DEPTH_BOUND_TEXTURE, DepthBoundId);
_currentBuffer.DispatchCompute(@params.tbrComputeShader, depthBoundKernel, tileThreadGroupsX, tileThreadGroupsY, 1);
ExecuteCurrentBuffer();
var depthMaskKernel = @params.tbrComputeShader.FindKernel("GenerateDepthMask");
_currentBuffer.SetComputeTextureParam(@params.tbrComputeShader, depthMaskKernel, ShaderManager.DEPTH_TEXTURE, DepthId);
_currentBuffer.SetComputeTextureParam(@params.tbrComputeShader, depthMaskKernel, ShaderManager.OPAQUE_DEPTH_TEXTURE, OpaqueDepthId);
_currentBuffer.SetComputeTextureParam(@params.tbrComputeShader, depthMaskKernel, ShaderManager.DEPTH_BOUND_TEXTURE, DepthBoundId);
_currentBuffer.SetComputeTextureParam(@params.tbrComputeShader, depthMaskKernel, ShaderManager.DEPTH_MASK_TEXTURE, DepthMaskId);
_currentBuffer.DispatchCompute(@params.tbrComputeShader, depthMaskKernel, tileThreadGroupsX, tileThreadGroupsY, 1);
ExecuteCurrentBuffer();
var depthFrustumKernel = @params.tbrComputeShader.FindKernel("GenerateDepthFrustum");
_currentBuffer.SetComputeFloatParams(@params.tbrComputeShader, ShaderManager.CAMERA_FORWARD, cameraForward.x, cameraForward.y, cameraForward.z);
_currentBuffer.SetComputeFloatParams(@params.tbrComputeShader, ShaderManager.CAMERA_POSITION, cameraPosition.x, cameraPosition.y, cameraPosition.z);
// _currentBuffer.SetComputeVectorParam(@params.tbrComputeShader, ShaderManager.Z_BUFFER_PARAMS, zBufferParams);
_currentBuffer.SetComputeMatrixParam(@params.tbrComputeShader, ShaderManager.UNITY_INVERSE_VP, (camera.projectionMatrix * camera.worldToCameraMatrix).inverse);
_currentBuffer.SetComputeTextureParam(@params.tbrComputeShader, depthFrustumKernel, ShaderManager.DEPTH_BOUND_TEXTURE, DepthBoundId);
_currentBuffer.SetComputeTextureParam(@params.tbrComputeShader, depthFrustumKernel, ShaderManager.DEPTH_FRUSTUM_TEXTURE, DepthFrustumId);
_currentBuffer.DispatchCompute(@params.tbrComputeShader, depthFrustumKernel, tileThreadGroupsX, tileThreadGroupsY, 1);
ExecuteCurrentBuffer();
var allLights = cull.visibleLights;
var lightIndexMap = cull.GetLightIndexMap(Allocator.Temp);
var sunlightColor = new Vector4(0, 0, 0);
var sunlightDirection = new Vector4(0, 0, 0);
if (sunlight.Exists()) {
sunlightDirection = sunlight.transform.localToWorldMatrix.GetDirectionFromLocalTransform();
sunlightColor = sunlight.color * sunlight.intensity;
}
_currentBuffer.SetGlobalVector(ShaderManager.SUNLIGHT_COLOR, sunlightColor);
_currentBuffer.SetGlobalVector(ShaderManager.SUNLIGHT_DIRECTION, sunlightDirection);
var pointLightCountMax = @params.pointLightParams.enabled ? @params.pointLightParams.maxPerFrame : 0;
var spotLightCountMax = @params.spotLightParams.enabled ? @params.spotLightParams.maxPerFrame : 0;
var pointLightShadowMax = @params.pointLightParams.enabled ? @params.pointLightParams.maxShadowCount : 0;
var spotLightShadowMax = @params.spotLightParams.enabled ? @params.spotLightParams.maxShadowCount : 0;
var sunlightIndex = 0;
var pointLightIndices = new int[pointLightShadowMax];
var spotLightIndices = new int[spotLightShadowMax];
var shadowPointLights = new Light[pointLightShadowMax];
var shadowSpotLights = new Light[spotLightShadowMax];
var pointLightIndex = 0;
var spotLightIndex = 0;
var pointLightShadowIndex = 0u;
var spotLightShadowIndex = 0u;
for (int i = 0, l = allLights.Length; i < l; i++) {
var visibleLight = allLights[i];
var lightType = allLights[i].lightType;
switch (lightType) {
case LightType.Point:
if (pointLightIndex >= pointLightCountMax) continue;
var originalPointLight = visibleLight.light;
var pointLightColor = visibleLight.finalColor;
var pointLight = new PointLight {
// color = new float3(pointLightColor.r, pointLightColor.g, pointLightColor.b),
sphere = new float4(visibleLight.light.transform.position, visibleLight.range)
};
if (originalPointLight.shadows != LightShadows.None && pointLightShadowIndex < pointLightShadowMax) {
// pointLight.shadowStrength = originalPointLight.shadowStrength;
pointLight.shadowIndex = pointLightShadowIndex + 1;
pointLightIndices[pointLightShadowIndex] = lightIndexMap[i];
shadowPointLights[pointLightShadowIndex] = originalPointLight;
pointLightShadowIndex++;
} else pointLight.shadowIndex = 0;
_pointLights[pointLightIndex] = pointLight;
pointLightIndex++;
break;
case LightType.Spot:
if (spotLightIndex >= spotLightCountMax) continue;
var originalSpotLight = visibleLight.light;
var spotLightColor = visibleLight.finalColor;
var spotLightDirection = visibleLight.localToWorldMatrix.GetDirectionFromLocalTransform();
var spotLightAngle = Mathf.Deg2Rad * visibleLight.spotAngle * .5f;
var spotLight = new SpotLight {
// color = new float3(spotLightColor.r, spotLightColor.g, spotLightColor.b),
cone = new Cone(visibleLight.localToWorldMatrix.GetPositionFromLocalTransform(), spotLightAngle, visibleLight.range, new float3(spotLightDirection.x, spotLightDirection.y, spotLightDirection.z)),
// innerAngle = Mathf.Deg2Rad * originalSpotLight.innerSpotAngle * .5f,
// nearClip = originalSpotLight.shadowNearPlane
};
if (originalSpotLight.shadows != LightShadows.None && spotLightShadowIndex < spotLightShadowMax) {
// spotLight.shadowStrength = originalSpotLight.shadowStrength;
spotLight.shadowIndex = spotLightShadowIndex + 1;
spotLightIndices[spotLightShadowIndex] = lightIndexMap[i];
shadowSpotLights[spotLightShadowIndex] = originalSpotLight;
spotLightShadowIndex++;
} else spotLight.shadowIndex = 0;
_spotLights[spotLightIndex] = spotLight;
spotLightIndex++;
break;
case LightType.Directional:
if (allLights[i].light == sunlight) sunlightIndex = lightIndexMap[i];
break;
}
}
if (@params.sunlightParams.shadowOn && sunlight.Exists() && sunlight.shadows != LightShadows.None) {
_currentBuffer.EnableShaderKeyword(ShaderManager.SUNLIGHT_SHADOWS);
RenderCascadedDirectionalShadow(cull, sunlightIndex, sunlight, cullingParameters.shadowDistance);
} else _currentBuffer.DisableShaderKeyword(ShaderManager.SUNLIGHT_SHADOWS);
if (@params.pointLightParams.shadowOn) {
_currentBuffer.EnableShaderKeyword(ShaderManager.POINT_LIGHT_SHADOWS);
RenderPointLightShadow(cull, (int) pointLightShadowIndex, shadowPointLights, pointLightIndices);
// if (pointLightShadowCount > 0) RenderPointLightShadow(context, cull, shadowPointLights[0], pointLightIndices[0]);
} else _currentBuffer.DisableShaderKeyword(ShaderManager.POINT_LIGHT_SHADOWS);
if (@params.spotLightParams.shadowOn) {
_currentBuffer.EnableShaderKeyword(ShaderManager.SPOT_LIGHT_SHADOWS);
RenderSpotLightShadow(cull, (int) spotLightShadowIndex, shadowSpotLights, spotLightIndices);
} else _currentBuffer.DisableShaderKeyword(ShaderManager.SPOT_LIGHT_SHADOWS);
Extensions.Resize(ref _pointLightBuffer, pointLightIndex);
Extensions.Resize(ref _spotLightBuffer, spotLightIndex);
_pointLightBuffer.SetData(_pointLights, 0, 0, pointLightIndex);
_spotLightBuffer.SetData(_spotLights, 0, 0, spotLightIndex);
var pointLightKernel = @params.tbrComputeShader.FindKernel("CullPointLight");
_currentBuffer.SetComputeIntParam(@params.tbrComputeShader, ShaderManager.POINT_LIGHT_COUNT, pointLightIndex);
_currentBuffer.SetComputeBufferParam(@params.tbrComputeShader, pointLightKernel, ShaderManager.POINT_LIGHT_BUFFER, _pointLightBuffer);
_currentBuffer.SetComputeTextureParam(@params.tbrComputeShader, pointLightKernel, ShaderManager.DEPTH_BOUND_TEXTURE, DepthBoundId);
_currentBuffer.SetComputeTextureParam(@params.tbrComputeShader, pointLightKernel, ShaderManager.DEPTH_MASK_TEXTURE, DepthMaskId);
_currentBuffer.SetComputeTextureParam(@params.tbrComputeShader, pointLightKernel, ShaderManager.DEPTH_FRUSTUM_TEXTURE, DepthFrustumId);
_currentBuffer.SetComputeTextureParam(@params.tbrComputeShader, pointLightKernel, ShaderManager.CULLED_POINT_LIGHT_TEXTURE, CulledPointLightId);
_currentBuffer.DispatchCompute(@params.tbrComputeShader, pointLightKernel, tileThreadGroupsX, tileThreadGroupsY, 1);
var spotLightKernel = @params.tbrComputeShader.FindKernel("CullSpotLight");
_currentBuffer.SetComputeIntParam(@params.tbrComputeShader, ShaderManager.SPOT_LIGHT_COUNT, spotLightIndex);
_currentBuffer.SetComputeBufferParam(@params.tbrComputeShader, spotLightKernel, ShaderManager.SPOT_LIGHT_BUFFER, _spotLightBuffer);
_currentBuffer.SetComputeTextureParam(@params.tbrComputeShader, spotLightKernel, ShaderManager.DEPTH_FRUSTUM_TEXTURE, DepthFrustumId);
_currentBuffer.SetComputeTextureParam(@params.tbrComputeShader, spotLightKernel, ShaderManager.CULLED_SPOT_LIGHT_TEXTURE, CulledSpotLightId);
_currentBuffer.DispatchCompute(@params.tbrComputeShader, spotLightKernel, tileThreadGroupsX, tileThreadGroupsY, 1);
ExecuteCurrentBuffer();
_currentBuffer.SetGlobalTexture(ShaderManager.CULLED_POINT_LIGHT_TEXTURE, CulledPointLightId);
_currentBuffer.SetGlobalTexture(ShaderManager.CULLED_SPOT_LIGHT_TEXTURE, CulledSpotLightId);
_currentBuffer.SetGlobalBuffer(ShaderManager.POINT_LIGHT_BUFFER, _pointLightBuffer);
_currentBuffer.SetGlobalBuffer(ShaderManager.SPOT_LIGHT_BUFFER, _spotLightBuffer);
ExecuteCurrentBuffer();
_context.SetupCameraProperties(camera);
ResetRenderTarget(ColorBufferId, OpaqueDepthId, false, true, 0, Color.black);
ExecuteCurrentBuffer();
// Opaque pass
sortingSettings.criteria = SortingCriteria.OptimizeStateChanges;
drawSettings.overrideMaterial = null;
filterSettings.renderQueueRange = ShaderManager.OPAQUE_RENDER_QUEUE_RANGE;
_context.DrawRenderers(cull, ref drawSettings, ref filterSettings);
// Alpha test pass
sortingSettings.criteria = SortingCriteria.OptimizeStateChanges;
filterSettings.renderQueueRange = ShaderManager.ALPHA_TEST_QUEUE_RANGE;
_context.DrawRenderers(cull, ref drawSettings, ref filterSettings);
// Skybox Pass
if ((camera.clearFlags & CameraClearFlags.Skybox) != 0) _context.DrawSkybox(camera);
ResetRenderTarget(ColorBufferId, DepthId, false, false, 1, Color.black);
ExecuteCurrentBuffer();
// Transparent Pass
filterSettings.renderQueueRange = RenderQueueRange.transparent;
_context.DrawRenderers(cull, ref drawSettings, ref filterSettings);
if (@params.ditherTransparentParams.blurOn && @params.ditherTransparentParams.blurMaterial != null) DitherTransparentBlur(pixelWidth >> @params.ditherTransparentParams.downSamples, pixelHeight >> @params.ditherTransparentParams.downSamples);
// Blit color buffer to camera target (normally screen)
_currentBuffer.Blit(ColorBufferId, BuiltinRenderTextureType.CameraTarget);
#if UNITY_EDITOR
if (@params.testMaterialOn) {
@params.testMaterial.SetInt("_TestInt", @params.testInt);
_currentBuffer.Blit(BuiltinRenderTextureType.CurrentActive, BuiltinRenderTextureType.CurrentActive, @params.testMaterial);
// _currentBuffer.Blit(PointLightShadowmapId, BuiltinRenderTextureType.CurrentActive);
if (@params.depthBoundOn) _currentBuffer.Blit(DepthBoundId, BuiltinRenderTextureType.CurrentActive);
}
#endif
ExecuteCurrentBuffer();
#if UNITY_EDITOR
if (@params.gizmosOn) _context.DrawGizmos(camera, GizmoSubset.PostImageEffects);
#endif
// Release temporary render textures
ReleaseRTs();
// Release unmanaged objects
// DisposeComputeBuffers();
ExecuteCurrentBuffer();
_context.Submit();
// allLights.Dispose();
lightIndexMap.Dispose();
}
void Render(ScriptableRenderContext context, Camera camera)
{
ScriptableCullingParameters cullingParameters;
if (!CullResults.GetCullingParameters(camera, out cullingParameters))
{
return;
}
cullingParameters.shadowDistance =
Mathf.Min(shadowDistance, camera.farClipPlane);
#if UNITY_EDITOR
if (camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
CullResults.Cull(ref cullingParameters, context, ref cull);
if (cull.visibleLights.Count > 0)
{
ConfigureLights();
if (mainLightExists)
{
RenderCascadedShadows(context);
}
else
{
cameraBuffer.DisableShaderKeyword(cascadedShadowsHardKeyword);
cameraBuffer.DisableShaderKeyword(cascadedShadowsSoftKeyword);
}
if (shadowTileCount > 0)
{
RenderShadows(context);
}
else
{
cameraBuffer.DisableShaderKeyword(shadowsHardKeyword);
cameraBuffer.DisableShaderKeyword(shadowsSoftKeyword);
}
}
else
{
cameraBuffer.SetGlobalVector(
lightIndicesOffsetAndCountID, Vector4.zero
);
cameraBuffer.DisableShaderKeyword(cascadedShadowsHardKeyword);
cameraBuffer.DisableShaderKeyword(cascadedShadowsSoftKeyword);
cameraBuffer.DisableShaderKeyword(shadowsHardKeyword);
cameraBuffer.DisableShaderKeyword(shadowsSoftKeyword);
}
context.SetupCameraProperties(camera);
CameraClearFlags clearFlags = camera.clearFlags;
cameraBuffer.ClearRenderTarget(
(clearFlags & CameraClearFlags.Depth) != 0,
(clearFlags & CameraClearFlags.Color) != 0,
camera.backgroundColor
);
cameraBuffer.BeginSample("Render Camera");
cameraBuffer.SetGlobalVectorArray(
visibleLightColorsId, visibleLightColors
);
cameraBuffer.SetGlobalVectorArray(
visibleLightDirectionsOrPositionsId, visibleLightDirectionsOrPositions
);
cameraBuffer.SetGlobalVectorArray(
visibleLightAttenuationsId, visibleLightAttenuations
);
cameraBuffer.SetGlobalVectorArray(
visibleLightSpotDirectionsId, visibleLightSpotDirections
);
context.ExecuteCommandBuffer(cameraBuffer);
cameraBuffer.Clear();
var drawSettings = new DrawRendererSettings(
camera, new ShaderPassName("SRPDefaultUnlit")
)
{
flags = drawFlags
};
if (cull.visibleLights.Count > 0)
{
drawSettings.rendererConfiguration =
RendererConfiguration.PerObjectLightIndices8;
}
drawSettings.rendererConfiguration |=
RendererConfiguration.PerObjectReflectionProbes |
RendererConfiguration.PerObjectLightmaps |
RendererConfiguration.PerObjectLightProbe |
RendererConfiguration.PerObjectLightProbeProxyVolume;
drawSettings.sorting.flags = SortFlags.CommonOpaque;
var filterSettings = new FilterRenderersSettings(true)
{
renderQueueRange = RenderQueueRange.opaque
};
context.DrawRenderers(
cull.visibleRenderers, ref drawSettings, filterSettings
);
context.DrawSkybox(camera);
drawSettings.sorting.flags = SortFlags.CommonTransparent;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(
cull.visibleRenderers, ref drawSettings, filterSettings
);
DrawDefaultPipeline(context, camera);
cameraBuffer.EndSample("Render Camera");
context.ExecuteCommandBuffer(cameraBuffer);
cameraBuffer.Clear();
context.Submit();
if (shadowMap)
{
RenderTexture.ReleaseTemporary(shadowMap);
shadowMap = null;
}
if (cascadedShadowMap)
{
RenderTexture.ReleaseTemporary(cascadedShadowMap);
cascadedShadowMap = null;
}
}
protected override void Render(ScriptableRenderContext context, Camera[] cameras)
{
BeginFrameRendering(context, cameras);
foreach (Camera camera in cameras)
{
BeginCameraRendering(context, camera);
//Culling
ScriptableCullingParameters cullingParams;
if (!camera.TryGetCullingParameters(out cullingParams))
{
continue;
}
CullingResults cull = context.Cull(ref cullingParams);
//Camera setup some builtin variables e.g. camera projection matrices etc
context.SetupCameraProperties(camera);
//Get the setting from camera component
bool drawSkyBox = camera.clearFlags == CameraClearFlags.Skybox? true : false;
bool clearDepth = camera.clearFlags == CameraClearFlags.Nothing? false : true;
bool clearColor = camera.clearFlags == CameraClearFlags.Color? true : false;
//Color Texture Descriptor
RenderTextureDescriptor colorRTDesc = new RenderTextureDescriptor(camera.pixelWidth, camera.pixelHeight);
colorRTDesc.colorFormat = m_ColorFormat;
colorRTDesc.depthBufferBits = depthBufferBits;
colorRTDesc.sRGB = (QualitySettings.activeColorSpace == ColorSpace.Linear);
colorRTDesc.msaaSamples = 1;
colorRTDesc.enableRandomWrite = false;
//Get Temp Texture for Color Texture
CommandBuffer cmdTempId = new CommandBuffer();
cmdTempId.name = "(" + camera.name + ")" + "Setup TempRT";
cmdTempId.GetTemporaryRT(m_ColorRTid, colorRTDesc, FilterMode.Bilinear);
cmdTempId.SetRenderTarget(m_ColorRT); //so that result won't flip
context.ExecuteCommandBuffer(cmdTempId);
cmdTempId.Release();
//Setup DrawSettings and FilterSettings
var sortingSettings = new SortingSettings(camera);
DrawingSettings drawSettings1 = new DrawingSettings(m_PassName1, sortingSettings);
DrawingSettings drawSettings2 = new DrawingSettings(m_PassName2, sortingSettings);
FilteringSettings filterSettings = new FilteringSettings(RenderQueueRange.all);
//Native Arrays for Attachaments
NativeArray <AttachmentDescriptor> renderPassAttachments = new NativeArray <AttachmentDescriptor>(4, Allocator.Temp);
renderPassAttachments[0] = m_Albedo;
renderPassAttachments[1] = m_Emission;
renderPassAttachments[2] = m_Output;
renderPassAttachments[3] = m_Depth;
NativeArray <int> renderPassColorAttachments = new NativeArray <int>(2, Allocator.Temp);
renderPassColorAttachments[0] = 0;
renderPassColorAttachments[1] = 1;
NativeArray <int> renderPassOutputAttachments = new NativeArray <int>(1, Allocator.Temp);
renderPassOutputAttachments[0] = 2;
//Clear Attachements
m_Output.ConfigureTarget(m_ColorRT, false, true);
m_Output.ConfigureClear(new Color(0.0f, 0.0f, 0.0f, 0.0f), 1, 0);
m_Albedo.ConfigureClear(camera.backgroundColor, 1, 0);
m_Emission.ConfigureClear(new Color(0.0f, 0.0f, 0.0f, 0.0f), 1, 0);
m_Depth.ConfigureClear(new Color(), 1, 0);
//More clean to use ScopedRenderPass instead of BeginRenderPass+EndRenderPass
using (context.BeginScopedRenderPass(camera.pixelWidth, camera.pixelHeight, 1, renderPassAttachments, 3))
{
//Output to Albedo & Emission
using (context.BeginScopedSubPass(renderPassColorAttachments, false))
{
//Opaque objects
sortingSettings.criteria = SortingCriteria.CommonOpaque;
drawSettings1.sortingSettings = sortingSettings;
filterSettings.renderQueueRange = RenderQueueRange.opaque;
context.DrawRenderers(cull, ref drawSettings1, ref filterSettings);
//Transparent objects
sortingSettings.criteria = SortingCriteria.CommonTransparent;
drawSettings1.sortingSettings = sortingSettings;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(cull, ref drawSettings1, ref filterSettings);
}
//Read from Albedo & Emission, then output to Output
using (context.BeginScopedSubPass(renderPassOutputAttachments, renderPassColorAttachments))
{
//Skybox
if (drawSkyBox)
{
context.DrawSkybox(camera);
}
//Opaque objects
sortingSettings.criteria = SortingCriteria.CommonOpaque;
drawSettings2.sortingSettings = sortingSettings;
filterSettings.renderQueueRange = RenderQueueRange.opaque;
context.DrawRenderers(cull, ref drawSettings2, ref filterSettings);
//Transparent objects
sortingSettings.criteria = SortingCriteria.CommonTransparent;
drawSettings2.sortingSettings = sortingSettings;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(cull, ref drawSettings2, ref filterSettings);
}
}
//Blit To Camera so that the CameraTarget has content and make sceneview works
CommandBuffer cmd = new CommandBuffer();
cmd.name = "Cam:" + camera.name + " BlitToCamera";
cmd.Blit(m_ColorRT, BuiltinRenderTextureType.CameraTarget);
context.ExecuteCommandBuffer(cmd);
cmd.Release();
//CleanUp Texture
CommandBuffer cmdclean = new CommandBuffer();
cmdclean.name = "(" + camera.name + ")" + "Clean Up";
cmdclean.ReleaseTemporaryRT(m_ColorRTid);
context.ExecuteCommandBuffer(cmdclean);
cmdclean.Release();
//Submit the CommandBuffers
context.Submit();
//CleanUp NativeArrays
renderPassAttachments.Dispose();
renderPassColorAttachments.Dispose();
renderPassOutputAttachments.Dispose();
EndCameraRendering(context, camera);
}
EndFrameRendering(context, cameras);
}
protected override void Render(ScriptableRenderContext context, Camera[] cameras)
{
BeginFrameRendering(context, cameras);
foreach (Camera camera in cameras)
{
BeginCameraRendering(context, camera);
//Culling
ScriptableCullingParameters cullingParams;
if (!camera.TryGetCullingParameters(out cullingParams))
{
continue;
}
CullingResults cull = context.Cull(ref cullingParams);
//Camera setup some builtin variables e.g. camera projection matrices etc
context.SetupCameraProperties(camera);
//Get the setting from camera component
bool drawSkyBox = camera.clearFlags == CameraClearFlags.Skybox? true : false;
bool clearDepth = camera.clearFlags == CameraClearFlags.Nothing? false : true;
bool clearColor = camera.clearFlags == CameraClearFlags.Color? true : false;
//************************** Start Set TempRT ************************************
CommandBuffer cmdTempId = new CommandBuffer();
cmdTempId.name = "(" + camera.name + ")" + "Setup TempRT";
//Color
RenderTextureDescriptor colorRTDesc = new RenderTextureDescriptor(camera.pixelWidth, camera.pixelHeight);
colorRTDesc.graphicsFormat = camera.allowHDR ? m_ColorFormatHDR : m_ColorFormat;
colorRTDesc.depthBufferBits = depthBufferBits;
//colorRTDesc.sRGB = (QualitySettings.activeColorSpace == ColorSpace.Linear);
colorRTDesc.msaaSamples = camera.allowMSAA ? QualitySettings.antiAliasing : 1;
colorRTDesc.enableRandomWrite = false;
cmdTempId.GetTemporaryRT(m_ColorRTid, colorRTDesc, FilterMode.Bilinear);
context.ExecuteCommandBuffer(cmdTempId);
cmdTempId.Release();
//************************** End Set TempRT ************************************
//Set RenderTarget & Camera clear flag
CommandBuffer cmd = new CommandBuffer();
cmd.SetRenderTarget(m_ColorRT); //Set CameraTarget to the color texture
cmd.ClearRenderTarget(clearDepth, clearColor, camera.backgroundColor);
context.ExecuteCommandBuffer(cmd);
cmd.Release();
//Setup DrawSettings and FilterSettings
var sortingSettings = new SortingSettings(camera);
DrawingSettings drawSettings = new DrawingSettings(m_PassName, sortingSettings);
FilteringSettings filterSettings = new FilteringSettings(RenderQueueRange.all);
//Skybox
if (drawSkyBox)
{
context.DrawSkybox(camera);
}
//Opaque objects
sortingSettings.criteria = SortingCriteria.CommonOpaque;
drawSettings.sortingSettings = sortingSettings;
filterSettings.renderQueueRange = RenderQueueRange.opaque;
context.DrawRenderers(cull, ref drawSettings, ref filterSettings);
//Transparent objects
sortingSettings.criteria = SortingCriteria.CommonTransparent;
drawSettings.sortingSettings = sortingSettings;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(cull, ref drawSettings, ref filterSettings);
//Blit the content back to screen
CommandBuffer cmdBlitToCam = new CommandBuffer();
cmdBlitToCam.name = "(" + camera.name + ")" + "Blit back to Camera";
cmdBlitToCam.Blit(m_ColorRTid, BuiltinRenderTextureType.CameraTarget);
context.ExecuteCommandBuffer(cmdBlitToCam);
cmdBlitToCam.Release();
//************************** Clean Up ************************************
CommandBuffer cmdclean = new CommandBuffer();
cmdclean.name = "(" + camera.name + ")" + "Clean Up";
cmdclean.ReleaseTemporaryRT(m_ColorRTid);
context.ExecuteCommandBuffer(cmdclean);
cmdclean.Release();
context.Submit();
EndCameraRendering(context, camera);
}
EndFrameRendering(context, cameras);
}
public static void Render(ScriptableRenderContext context, IEnumerable <Camera> cameras, SRP07CustomParameter SRP07CP)
{
string tx = "";
foreach (Camera camera in cameras)
{
ScriptableCullingParameters cullingParams;
// Stereo-aware culling parameters are configured to perform a single cull for both eyes
if (!CullResults.GetCullingParameters(camera, out cullingParams))
{
continue;
}
CullResults cull = new CullResults();
CullResults.Cull(ref cullingParams, context, ref cull);
// Setup camera for rendering (sets render target, view/projection matrices and other
// per-camera built-in shader variables).
context.SetupCameraProperties(camera);
// clear depth buffer
CommandBuffer cmd = new CommandBuffer();
cmd.ClearRenderTarget(true, !SRP07CP.DrawSkybox, SRP07CP.ClearColor);
context.ExecuteCommandBuffer(cmd);
cmd.Release();
// Setup global lighting shader variables
SetupLightShaderVariables(cull.visibleLights, context);
if (SRP07CP.DrawSkybox)
{
// Draw skybox
context.DrawSkybox(camera);
}
// Setup DrawSettings and FilterSettings
ShaderPassName passName = new ShaderPassName("BasicPass");
DrawRendererSettings drawSettings = new DrawRendererSettings(camera, passName);
FilterRenderersSettings filterSettings = new FilterRenderersSettings(true);
// ////////////////////////////////////////////////////////////
VisibleLight[] ls = cull.visibleLights.ToArray();
DrawShadowsSettings[] shadowsSettings = new DrawShadowsSettings[ls.Length];
for (int i = 0; i < shadowsSettings.Length; i++)
{
shadowsSettings[i] = new DrawShadowsSettings(cull, i);
}
/*
* if(camera == Camera.main) //Only generate result from main cam
* {
* tx += "DrawShadowsSettings" + "\n"+ "\n";
*
* for (int i=0; i<ls.Length; i++)
* {
* tx += "lightIndex = " + shadowsSettings[i].lightIndex + " (" + ls[i].light.name + ") " + "\n";
* tx += "splitData.cullingPlaneCount = " + shadowsSettings[i].splitData.cullingPlaneCount + "\n";
* tx += "splitData.cullingSphere = " + shadowsSettings[i].splitData.cullingSphere + "\n"+ "\n";
* }
*
* // Output to text
* if (textMesh != null)
* {
* textMesh.text = tx;
* Debug.Log("<color=#0F0>TextMesh is updated</color>");
* }
* else
* {
* tx = "<color=#F00>TextMesh is null</color> Please hit play if you hasn't";
* Debug.Log(tx);
* }
* }
*/
// ////////////////////////////////////////////////////////////
if (SRP07CP.DrawOpaque)
{
// Draw opaque objects using BasicPass shader pass
drawSettings.sorting.flags = SortFlags.CommonOpaque;
filterSettings.renderQueueRange = RenderQueueRange.opaque;
context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
for (int i = 0; i < shadowsSettings.Length; i++)
{
//if(ls[i].light.shadows != LightShadows.None)
//context.DrawShadows(ref shadowsSettings[i]);
}
}
if (SRP07CP.DrawTransparent)
{
// Draw transparent objects using BasicPass shader pass
drawSettings.sorting.flags = SortFlags.CommonTransparent;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
}
context.Submit();
}
}
void Render(ScriptableRenderContext context, Camera camera)
{
ScriptableCullingParameters cullingParameters;
if (!CullResults.GetCullingParameters(camera, out cullingParameters))
{
return;
}
#if UNITY_EDITOR
if (camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
CullResults.Cull(ref cullingParameters, context, ref cull);
context.SetupCameraProperties(camera);
CameraClearFlags clearFlags = camera.clearFlags;
cameraBuffer.ClearRenderTarget(
(clearFlags & CameraClearFlags.Depth) != 0,
(clearFlags & CameraClearFlags.Color) != 0,
camera.backgroundColor
);
if (cull.visibleLights.Count > 0)
{
ConfigureLights();
}
else
{
cameraBuffer.SetGlobalVector(
lightIndicesOffsetAndCountID, Vector4.zero
);
}
cameraBuffer.BeginSample("Render Camera");
cameraBuffer.SetGlobalVectorArray(
visibleLightColorsId, visibleLightColors
);
cameraBuffer.SetGlobalVectorArray(
visibleLightDirectionsOrPositionsId, visibleLightDirectionsOrPositions
);
cameraBuffer.SetGlobalVectorArray(
visibleLightAttenuationsId, visibleLightAttenuations
);
cameraBuffer.SetGlobalVectorArray(
visibleLightSpotDirectionsId, visibleLightSpotDirections
);
context.ExecuteCommandBuffer(cameraBuffer);
cameraBuffer.Clear();
var drawSettings = new DrawRendererSettings(
camera, new ShaderPassName("SRPDefaultUnlit")
)
{
flags = drawFlags
};
if (cull.visibleLights.Count > 0)
{
drawSettings.rendererConfiguration =
RendererConfiguration.PerObjectLightIndices8;
}
drawSettings.sorting.flags = SortFlags.CommonOpaque;
var filterSettings = new FilterRenderersSettings(true)
{
renderQueueRange = RenderQueueRange.opaque
};
context.DrawRenderers(
cull.visibleRenderers, ref drawSettings, filterSettings
);
context.DrawSkybox(camera);
drawSettings.sorting.flags = SortFlags.CommonTransparent;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(
cull.visibleRenderers, ref drawSettings, filterSettings
);
DrawDefaultPipeline(context, camera);
cameraBuffer.EndSample("Render Camera");
context.ExecuteCommandBuffer(cameraBuffer);
cameraBuffer.Clear();
context.Submit();
}
protected override void Render(ScriptableRenderContext context, Camera[] cameras)
{
context.DrawSkybox(cameras[0]);
context.Submit();
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
CameraData cameraData = renderingData.cameraData;
Camera camera = cameraData.camera;
if ((DebugHandler != null) && DebugHandler.IsActiveForCamera(ref cameraData))
{
// TODO: The skybox needs to work the same as the other shaders, but until it does we'll not render it
// when certain debug modes are active (e.g. wireframe/overdraw modes)
if (DebugHandler.IsScreenClearNeeded)
{
return;
}
}
#if ENABLE_VR && ENABLE_XR_MODULE
// XRTODO: Remove this code once Skybox pass is moved to SRP land.
if (cameraData.xr.enabled)
{
// Setup Legacy XR buffer states
if (cameraData.xr.singlePassEnabled)
{
// Setup legacy skybox stereo buffer
camera.SetStereoProjectionMatrix(Camera.StereoscopicEye.Left, cameraData.GetProjectionMatrix(0));
camera.SetStereoViewMatrix(Camera.StereoscopicEye.Left, cameraData.GetViewMatrix(0));
camera.SetStereoProjectionMatrix(Camera.StereoscopicEye.Right, cameraData.GetProjectionMatrix(1));
camera.SetStereoViewMatrix(Camera.StereoscopicEye.Right, cameraData.GetViewMatrix(1));
CommandBuffer cmd = CommandBufferPool.Get();
// Use legacy stereo instancing mode to have legacy XR code path configured
cmd.SetSinglePassStereo(SystemInfo.supportsMultiview ? SinglePassStereoMode.Multiview : SinglePassStereoMode.Instancing);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
// Calling into built-in skybox pass
context.DrawSkybox(camera);
// Disable Legacy XR path
cmd.SetSinglePassStereo(SinglePassStereoMode.None);
context.ExecuteCommandBuffer(cmd);
// We do not need to submit here due to special handling of stereo matrices in core.
// context.Submit();
CommandBufferPool.Release(cmd);
camera.ResetStereoProjectionMatrices();
camera.ResetStereoViewMatrices();
}
else
{
camera.projectionMatrix = cameraData.GetProjectionMatrix(0);
camera.worldToCameraMatrix = cameraData.GetViewMatrix(0);
context.DrawSkybox(camera);
// XRTODO: remove this call because it creates issues with nested profiling scopes
// See examples in UniversalRenderPipeline.RenderSingleCamera() and in ScriptableRenderer.Execute()
context.Submit(); // Submit and execute the skybox pass before resetting the matrices
camera.ResetProjectionMatrix();
camera.ResetWorldToCameraMatrix();
}
}
else
#endif
{
context.DrawSkybox(camera);
}
}
protected void RenderCamera(ScriptableRenderContext context, Camera camera)
{
m_CameraRender.Render(context, camera);
return;
BeginCameraRendering(context, camera);
if (camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
//setup camera
//culling
ScriptableCullingParameters cullingParams;
camera.TryGetCullingParameters(out cullingParams);
//setup shadow
cullingParams.shadowDistance = Mathf.Min(m_PipelineConfig.ShadowSetting.maxDistance, camera.farClipPlane);
#if UNITY_EDITOR
if (camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
CullingResults cullResult = context.Cull(ref cullingParams);
SetupRenderContext(ref context, ref cullResult, camera);
#if UNITY_EDITOR
RenderGizmo(context, camera, GizmoSubset.PreImageEffects);
#endif
RenderShadow(ref m_RenderContext);
context.SetupCameraProperties(camera);
cmd.Clear();
cmd.ClearRenderTarget(true, true, Color.clear);
context.ExecuteCommandBuffer(cmd);
context.Submit();
RenderObject(context, camera, ref cullResult);
//draw skybox
context.DrawSkybox(camera);
#if UNITY_EDITOR
RenderGizmo(context, camera, GizmoSubset.PostImageEffects);
#endif
Cleanup(ref m_RenderContext);
context.Submit();
EndCameraRendering(context, camera);
}
/// <summary>
/// 描画処理
/// </summary>
protected override void Render(ScriptableRenderContext context, Camera[] cameras)
{
for (int i = 0; i < cameras.Length; i++)
{
var camera = cameras[i];
var commandBuffer = commandBuffers[i];
// カメラプロパティ設定
context.SetupCameraProperties(camera);
// カメラからカリングのための情報を取得
if (!camera.TryGetCullingParameters(false, out var cullingParameters))
{
continue;
}
// ScriptableCullingParametersに基づいてカリングをスケジュール
cullingResults = context.Cull(ref cullingParameters);
// RenderTexture作成
CreateRenderTexture(context, camera, commandBuffer);
// モデル描画用RTのClear
ClearModelRenderTexture(context, camera, commandBuffer);
// ライト情報のセットアップ
SetupLights(context, camera, commandBuffer);
// 不透明オブジェクト描画
DrawOpaque(context, camera, commandBuffer);
// Skybox描画
if (camera.clearFlags == CameraClearFlags.Skybox)
{
context.DrawSkybox(camera);
}
// 半透明オブジェクト描画
DrawTransparent(context, camera, commandBuffer);
// CameraTargetに描画
RestoreCameraTarget(context, commandBuffer);
#if UNITY_EDITOR
// Gizmo
if (UnityEditor.Handles.ShouldRenderGizmos())
{
context.DrawGizmos(camera, GizmoSubset.PreImageEffects);
}
#endif
// PostProcessing
#if UNITY_EDITOR
// Gizmo
if (UnityEditor.Handles.ShouldRenderGizmos())
{
context.DrawGizmos(camera, GizmoSubset.PostImageEffects);
}
#endif
// RenderTexture解放
ReleaseRenderTexture(context, commandBuffer);
}
context.Submit();
}
private void RenderCamera(ref ScriptableRenderContext context, Camera camera)
{
if (m_ShadowMap == null)
{
m_ShadowMap = new RenderTexture(1024, 1024, 24, RenderTextureFormat.Shadowmap);
m_ShadowMap.name = "Shadow Map";
m_ShadowMap.Create();
}
if (camera.TryGetCullingParameters(out ScriptableCullingParameters cullingParameters))
{
// Start camera render
RenderPipeline.BeginCameraRendering(context, camera);
cullingParameters.shadowDistance = 30;
// Perform culling operations
CullingResults cullingResults = context.Cull(ref cullingParameters);
// Shadow map rendering
Matrix4x4 worldToShadowMatrix = Matrix4x4.identity;
bool didRenderShadowMap = RenderShadowMaps(ref context, ref cullingResults, ref worldToShadowMatrix);
// Setup camera for rendering
context.SetupCameraProperties(camera);
// Clear camera
CommandBuffer cb_ClearCamera = new CommandBuffer();
cb_ClearCamera.name = "ClearCamera";
cb_ClearCamera.SetRenderTarget(camera.targetTexture);
cb_ClearCamera.ClearRenderTarget(true, true, camera.backgroundColor);
context.ExecuteCommandBuffer(cb_ClearCamera);
// Draw opaque objects
SortingSettings sortSettings = new SortingSettings(camera);
sortSettings.criteria = SortingCriteria.CommonOpaque;
FilteringSettings filterSettings = FilteringSettings.defaultValue;
filterSettings.renderQueueRange = RenderQueueRange.opaque;
if (didRenderShadowMap)
{
CommandBuffer cb = new CommandBuffer();
cb.name = "Set up shadow shader properties";
cb.SetGlobalTexture("_ShadowMapTexture", m_ShadowMap);
cb.SetGlobalMatrix("_WorldToShadowMatrix", worldToShadowMatrix);
cb.SetGlobalVector("_LightDirection", -cullingResults.visibleLights[0].light.transform.forward); // Direction towards the light
context.ExecuteCommandBuffer(cb);
}
DrawingSettings opaqueDrawSettings = new DrawingSettings(s_OpaquePassTag, sortSettings);
context.DrawRenderers(cullingResults, ref opaqueDrawSettings, ref filterSettings);
// Draw skybox
context.DrawSkybox(camera);
// Final submission
context.Submit();
// End camera render
RenderPipeline.EndCameraRendering(context, camera);
}
}
public void Render(ScriptableRenderContext context, Camera camera)
{
if (!CullResults.GetCullingParameters(camera, out var cullingParameters))
{
return;
}
cullingParameters.shadowDistance = Mathf.Min(shadowDistance, camera.farClipPlane);
#if UNITY_EDITOR
if (camera.cameraType == CameraType.SceneView)
{
//将UI几何体发射到“场景”视图中以进行渲染。
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
else if (mainCamera == null && camera.cameraType == CameraType.Game && camera == Camera.main)
{
mainCamera = camera;
}
#endif
//CullResults cull = CullResults.Cull(ref cullingParameters, context);
CullResults.Cull(ref cullingParameters, context, ref cull);
if (cull.visibleLights.Count > 0)
{
ConfigureLights();
if (mainLightExists)
{
RenderCascadedShadows(context);
}
else
{
cameraBuffer.DisableShaderKeyword(cascadedShadowsHardKeyword);
cameraBuffer.DisableShaderKeyword(cascadedShadowsSoftKeyword);
}
if (shadowTileCount > 0)
{
RenderShadows(context);
}
else
{
cameraBuffer.DisableShaderKeyword(shadowsHardKeyword);
cameraBuffer.DisableShaderKeyword(shadowsSoftKeyword);
}
}
else
{
cameraBuffer.SetGlobalVector(lightIndicesOffsetAndCountID, Vector4.zero);
cameraBuffer.DisableShaderKeyword(cascadedShadowsHardKeyword);
cameraBuffer.DisableShaderKeyword(cascadedShadowsSoftKeyword);
cameraBuffer.DisableShaderKeyword(shadowsHardKeyword);
cameraBuffer.DisableShaderKeyword(shadowsSoftKeyword);
}
context.SetupCameraProperties(camera);
var myPipelineCamera = camera.GetComponent <MyPipelineCamera>();
MyPostProcessingStack activeStack = myPipelineCamera ? myPipelineCamera.PostProcessingStack : defaultStack;
activeStack.Setup(postProcessingAsset);
bool scaledRendering = renderScale != 1f && camera.cameraType == CameraType.Game;
int renderWidth = camera.pixelWidth;
int renderHeight = camera.pixelHeight;
if (scaledRendering)
{
renderWidth = (int)(renderWidth * renderScale);
renderHeight = (int)(renderHeight * renderScale);
}
int renderSamples = camera.allowMSAA ? msaaSamples : 1;
bool renderToTexture = scaledRendering || renderSamples > 1 || activeStack;
bool needsDepth = activeStack && activeStack.NeedsDepth;
//如果MSAA != 1 , 则 主贴图需要 24位深度 用来ZTestWrite画
bool needsDirectDepth = needsDepth && renderSamples == 1;
//专门用DepthOnly 来画深度图
bool needsDepthOnlyPass = needsDepth && renderSamples > 1;
RenderTextureFormat format =
allowHDR && camera.allowHDR ? RenderTextureFormat.DefaultHDR : RenderTextureFormat.Default;
if (renderToTexture)
{
//需要深度进行处理的的时候 要单独的深度图 不让它进行MSAA
//否则可以跟随主颜色进行MSAA
cameraBuffer.GetTemporaryRT(cameraColorTextureID, renderWidth, renderHeight, needsDirectDepth ? 0 : 24
, FilterMode.Bilinear, format, RenderTextureReadWrite.Default, renderSamples);
if (needsDepth)
{
cameraBuffer.GetTemporaryRT(cameraDepthTextureID, renderWidth, renderHeight, 24
, FilterMode.Point, RenderTextureFormat.Depth, RenderTextureReadWrite.Linear, 1);
}
if (needsDirectDepth)
{
cameraBuffer.SetRenderTarget(cameraColorTextureID, RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.Store, cameraDepthTextureID, RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.Store);
}
else
{
cameraBuffer.SetRenderTarget(cameraColorTextureID, RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.Store);
}
}
CameraClearFlags clearFlags = camera.clearFlags;
cameraBuffer.ClearRenderTarget((clearFlags & CameraClearFlags.Depth) != 0
, (clearFlags & CameraClearFlags.Color) != 0, camera.backgroundColor);
cameraBuffer.BeginSample("Render Camera");
cameraBuffer.SetGlobalVectorArray(visibleLightColorsID, visibleLightColors);
cameraBuffer.SetGlobalVectorArray(visibleLightDirectionsOrPositionsID, visibleLightDirectionsOrPositions);
cameraBuffer.SetGlobalVectorArray(visibleLightAttenuationsID, visibleLightAttenuations);
cameraBuffer.SetGlobalVectorArray(visibleLightSpotDirectionsID, visibleLightSpotDirections);
cameraBuffer.SetGlobalVectorArray(visibleLightOcclusionMaskID, visibleLightOcclusionMasks);
globalShadowData.z = 1f - cullingParameters.shadowDistance * globalShadowData.y;
cameraBuffer.SetGlobalVector(globalShadowDataID, globalShadowData);
context.ExecuteCommandBuffer(cameraBuffer);
cameraBuffer.Clear();
//这样就可以走SRP的SubShader 如果没有则都走
//Shader SubShader Tags{"RenderPipeline"="MySRPPipeline"}
//Shader.globalRenderPipeline = "MySRPPipeline";
//我们必须通过提供相机和一个shader pass 作为draw setting的构造函数的参数。
//这个相机用来设置排序和裁剪层级(culling layers),
//而shader pass 控制使用那个shader pass进行渲染。
//如果Pass未指定LightMode，Unity会自动将其设置为SRPDefaultUnlit
var drawSettings = new DrawRendererSettings(camera, new ShaderPassName("SRPDefaultUnlit"))
{
flags = drawFlags,
rendererConfiguration = RendererConfiguration.None
};
if (cull.visibleLights.Count > 0)
{
drawSettings.rendererConfiguration = RendererConfiguration.PerObjectLightIndices8;
}
drawSettings.rendererConfiguration |= RendererConfiguration.PerObjectReflectionProbes
| RendererConfiguration.PerObjectLightmaps
| RendererConfiguration.PerObjectLightProbe
| RendererConfiguration.PerObjectLightProbeProxyVolume
| RendererConfiguration.PerObjectShadowMask
| RendererConfiguration.PerObjectOcclusionProbe
| RendererConfiguration.PerObjectOcclusionProbeProxyVolume;
drawSettings.sorting.flags = SortFlags.CommonOpaque;
//因为 Unity 更喜欢将对象空间化地分组以减少overdraw
var filterSettings = new FilterRenderersSettings(true)
{
renderQueueRange = RenderQueueRange.opaque
};
context.DrawRenderers(
cull.visibleRenderers, ref drawSettings, filterSettings);
context.DrawSkybox(camera);
// var moonOnlyDrawSettings = new DrawRendererSettings(
// camera, new ShaderPassName("MoonOnly"))
// {
// flags = drawFlags,
// sorting = {flags = SortFlags.CommonOpaque}
// };
// context.DrawRenderers(cull.visibleRenderers, ref moonOnlyDrawSettings, filterSettings);
//
// var moon1OnlyDrawSettings = new DrawRendererSettings(
// camera, new ShaderPassName("MoonOnly1"))
// {
// flags = drawFlags,
// sorting = { flags = SortFlags.CommonOpaque }
// };
// context.DrawRenderers(cull.visibleRenderers, ref moon1OnlyDrawSettings, filterSettings);
if (activeStack)
{
postProcessingBuffer.BeginSample("Render Other Objects");
if (activeStack.stencil)
{
drawSettings.SetShaderPassName(0, new ShaderPassName("SRPStencil"));
drawSettings.sorting.flags = SortFlags.CommonOpaque;
filterSettings.renderQueueRange = RenderQueueRange.all;
context.DrawRenderers(
cull.visibleRenderers, ref drawSettings, filterSettings);
drawSettings.SetShaderPassName(0, new ShaderPassName("SRPDefaultUnlit"));
}
activeStack.DrawSky(postProcessingBuffer, camera);
context.ExecuteCommandBuffer(postProcessingBuffer);
postProcessingBuffer.Clear();
activeStack.DrawDistantRainShafts(postProcessingBuffer, camera);
context.ExecuteCommandBuffer(postProcessingBuffer);
postProcessingBuffer.Clear();
activeStack.DrawMoon(postProcessingBuffer, camera);
context.ExecuteCommandBuffer(postProcessingBuffer);
postProcessingBuffer.Clear();
activeStack.DrawLightnings(postProcessingBuffer, camera);
context.ExecuteCommandBuffer(postProcessingBuffer);
postProcessingBuffer.Clear();
postProcessingBuffer.EndSample("Render Other Objects");
if (needsDepth)
{
if (needsDepthOnlyPass)
{
var depthOnlyDrawSettings = new DrawRendererSettings(
camera, new ShaderPassName("DepthOnly"))
{
flags = drawFlags, sorting = { flags = SortFlags.CommonOpaque }
};
cameraBuffer.SetRenderTarget(cameraDepthTextureID, RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.Store);
cameraBuffer.ClearRenderTarget(true, false, Color.clear);
context.ExecuteCommandBuffer(cameraBuffer);
cameraBuffer.Clear();
context.DrawRenderers(cull.visibleRenderers, ref depthOnlyDrawSettings, filterSettings);
}
}
activeStack.RenderAfterOpaque(
postProcessingBuffer, cameraColorTextureID, cameraDepthTextureID
, renderWidth, renderHeight, renderSamples, format);
context.ExecuteCommandBuffer(postProcessingBuffer);
postProcessingBuffer.Clear();
if (needsDirectDepth)
{
cameraBuffer.SetRenderTarget(
cameraColorTextureID, RenderBufferLoadAction.Load, RenderBufferStoreAction.Store
, cameraDepthTextureID, RenderBufferLoadAction.Load, RenderBufferStoreAction.Store);
}
else
{
cameraBuffer.SetRenderTarget(cameraColorTextureID, RenderBufferLoadAction.Load,
RenderBufferStoreAction.Store);
}
context.ExecuteCommandBuffer(cameraBuffer);
cameraBuffer.Clear();
}
drawSettings.sorting.flags = SortFlags.CommonTransparent;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(
cull.visibleRenderers, ref drawSettings, filterSettings);
DrawDefaultPipeline(context, camera);
if (renderToTexture)
{
if (activeStack && camera.cameraType == CameraType.Game)
{
activeStack.RenderAfterTransparent(postProcessingBuffer, cameraColorTextureID, cameraDepthTextureID
, renderWidth, renderHeight, renderSamples, format);
context.ExecuteCommandBuffer(postProcessingBuffer);
postProcessingBuffer.Clear();
}
else
{
cameraBuffer.Blit(cameraColorTextureID, BuiltinRenderTextureType.CameraTarget);
}
cameraBuffer.ReleaseTemporaryRT(cameraColorTextureID);
if (needsDepth)
{
cameraBuffer.ReleaseTemporaryRT(cameraDepthTextureID);
}
}
cameraBuffer.EndSample("Render Camera");
context.ExecuteCommandBuffer(cameraBuffer);
cameraBuffer.Clear();
context.Submit();
if (shadowMap)
{
RenderTexture.ReleaseTemporary(shadowMap);
shadowMap = null;
}
if (cascadedShadowMap)
{
RenderTexture.ReleaseTemporary(cascadedShadowMap);
cascadedShadowMap = null;
}
}
// Main entry point for our scriptable render loop
public static void Render(ScriptableRenderContext context, IEnumerable <Camera> cameras, bool useIntermediateBlitPath)
{
bool stereoEnabled = XRSettings.isDeviceActive;
foreach (var camera in cameras)
{
// Culling
ScriptableCullingParameters cullingParams;
// Stereo-aware culling parameters are configured to perform a single cull for both eyes
if (!CullResults.GetCullingParameters(camera, stereoEnabled, out cullingParams))
{
continue;
}
CullResults cull = new CullResults();
CullResults.Cull(ref cullingParams, context, ref cull);
// Setup camera for rendering (sets render target, view/projection matrices and other
// per-camera built-in shader variables).
// If stereo is enabled, we also configure stereo matrices, viewports, and XR device render targets
context.SetupCameraProperties(camera, stereoEnabled);
// Draws in-between [Start|Stop]MultiEye are stereo-ized by engine
if (stereoEnabled)
{
context.StartMultiEye(camera);
}
RenderTargetIdentifier intermediateRTID = new RenderTargetIdentifier(BuiltinRenderTextureType.CurrentActive);
bool isIntermediateRTTexArray = false;
if (useIntermediateBlitPath)
{
ConfigureAndBindIntermediateRenderTarget(context, camera, stereoEnabled, out intermediateRTID, out isIntermediateRTTexArray);
}
// clear depth buffer
var cmd = CommandBufferPool.Get();
cmd.ClearRenderTarget(true, false, Color.black);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
// Setup global lighting shader variables
SetupLightShaderVariables(cull.visibleLights, context);
// Draw opaque objects using BasicPass shader pass
var drawSettings = new DrawRendererSettings(camera, new ShaderPassName("BasicPass"))
{
sorting = { flags = SortFlags.CommonOpaque }
};
var filterSettings = new FilterRenderersSettings(true)
{
renderQueueRange = RenderQueueRange.opaque
};
context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
// Draw skybox
context.DrawSkybox(camera);
// Draw transparent objects using BasicPass shader pass
drawSettings.sorting.flags = SortFlags.CommonTransparent;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
if (useIntermediateBlitPath)
{
BlitFromIntermediateToCameraTarget(context, intermediateRTID, isIntermediateRTTexArray);
}
if (stereoEnabled)
{
context.StopMultiEye(camera);
// StereoEndRender will reset state on the camera to pre-Stereo settings,
// and invoke XR based events/callbacks.
context.StereoEndRender(camera);
}
context.Submit();
}
}
//完整的基本的兰伯特光照脚本
protected void Render_mutil_light(ScriptableRenderContext renderContext, Camera[] cameras)
{
//渲染开始后，创建CommandBuffer;
if (myCommandBuffer == null)
{
myCommandBuffer = new CommandBuffer()
{
name = "SRP Study CB"
}
}
;
//将shader中需要的属性参数映射为ID，加速传参
var D_LightDir = Shader.PropertyToID("_DLightDir");
var D_LightColor = Shader.PropertyToID("_DLightColor");
//在设置灯光参数ID下面增加相机参数ID：
var _CameraPos = Shader.PropertyToID("_CameraPos");
var _PLightPos = Shader.PropertyToID("_PLightPos");
var _PLightColor = Shader.PropertyToID("_PLightColor");
//所有相机开始逐次渲染
foreach (var camera in cameras)
{
myCommandBuffer.BeginSample("Render " + camera.name);
//设置渲染相关相机参数,包含相机的各个矩阵和剪裁平面等
renderContext.SetupCameraProperties(camera);
//清理myCommandBuffer，设置渲染目标的颜色为摄像机背景
var flags = camera.clearFlags;
//myCommandBuffer.ClearRenderTarget(true,true,camera.backgroundColor);
myCommandBuffer.ClearRenderTarget((flags & CameraClearFlags.Depth) != 0, (flags & CameraClearFlags.Color) != 0, camera.backgroundColor);
#if UNITY_EDITOR
//为了在场景视图中看到UI
//尽管Unity帮我们适配了UI在游戏窗口中显示，但不会在场景窗口显示。
//UI始终存在于场景窗口中的世界空间中，但是我们必须手动将其注入场景中。
//通过调用static ScriptableRenderContext.EmitWorldGeometryForSceneView方法（以当前摄像机为参数）来添加UI 。
//必须在cull之前完成此操作。
//为了避免游戏窗口中第二次添加UI。我们仅在渲染场景窗口时才发出UI几何。
//cameraType相机的等于时就是这种情况CameraType.SceneView。
if (camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
//剔除：拿到场景中的所有渲染器，然后剔除那些在摄像机视锥范围之外的渲染器。
//渲染器：它是附着在游戏对象上的组件，可将它们转变为可以渲染的东西。通常是一个MeshRenderer组件。
ScriptableCullingParameters cullParam = new ScriptableCullingParameters();
camera.TryGetCullingParameters(out cullParam);
cullParam.isOrthographic = false;
//TODO：避免没有任何可渲染的物体时，往下渲染
CullingResults cullResults = renderContext.Cull(ref cullParam);
renderContext.DrawSkybox(camera);
//在剪裁结果中获取灯光并进行参数获取
var lights = cullResults.visibleLights;
int dLightIndex = 0;
int pLightIndex = 0;
foreach (var light in lights)
{
//判断灯光类型
if (light.lightType == LightType.Directional)
{
//在限定的灯光数量下，获取参数
if (dLightIndex < maxDirectionalLights)
{
//获取灯光参数,平行光朝向即为灯光Z轴方向。矩阵第一到三列分别为xyz轴项，第四列为位置。
Vector4 lightpos = light.localToWorldMatrix.GetColumn(2);
//这边获取的灯光的finalColor是灯光颜色乘上强度之后的值，也正好是shader需要的值
DLightColors[dLightIndex] = light.finalColor;
DLightDirections[dLightIndex] = -lightpos;
DLightDirections[dLightIndex].w = 0;//方向光的第四个值(W值)为0，点为1.
dLightIndex++;
}
}
else
{
if (light.lightType != LightType.Point)
{
//其他类型光源部分
continue;
}
else
{
if (pLightIndex < maxPointLights)
{
PLightColors[pLightIndex] = light.finalColor;
//将点光源的距离设置塞到颜色的A通道
PLightColors[pLightIndex].w = light.range;
//矩阵第4列为位置
PLightPos[pLightIndex] = light.localToWorldMatrix.GetColumn(3);
pLightIndex++;
}
}
}
}
//传入相机参数。注意是世界空间位置。
Vector4 cameraPos = camera.transform.position;
myCommandBuffer.SetGlobalVector(_CameraPos, cameraPos);
//利用CommandBuffer进将灯光参数组传入Shader
myCommandBuffer.SetGlobalVectorArray(D_LightColor, DLightColors);
myCommandBuffer.SetGlobalVectorArray(D_LightDir, DLightDirections);
myCommandBuffer.SetGlobalVectorArray(_PLightColor, PLightColors);
myCommandBuffer.SetGlobalVectorArray(_PLightPos, PLightPos);
myCommandBuffer.EndSample("Render " + camera.name);
//执行CommandBuffer中的指令
renderContext.ExecuteCommandBuffer(myCommandBuffer);
myCommandBuffer.Clear();
//过滤：决定使用哪些渲染器
FilteringSettings filtSet = new FilteringSettings(RenderQueueRange.opaque, -1);
//filtSet.renderQueueRange = RenderQueueRange.opaque;
//filtSet.layerMask = -1;
//相机用于设置排序和剔除层，而DrawingSettings控制使用哪个着色器过程进行渲染。
//决定使用何种渲染排序顺序 对应shader里的 Tags{ "Queue" = "Geometry" } 这属性(不是这个单一属性)
//opaque涵盖了从0到2500（包括2500）之间的渲染队列。
SortingSettings sortSet = new SortingSettings(camera)
{
criteria = SortingCriteria.CommonOpaque
};
//决定使用何种light mode，对应shader的pass的tag中的LightMode
DrawingSettings drawSet = new DrawingSettings(new ShaderTagId("BaseLit"), sortSet);
//1.绘制不透明物体
renderContext.DrawRenderers(cullResults, ref drawSet, ref filtSet);
//2.绘制天空球,在不透明物体之后绘制。early-z避免不必要的overdraw。
renderContext.DrawSkybox(camera);
//3.绘制透明物体
//，RenderQueueRange.transparent在渲染天空盒之后，将队列范围更改为从2501到5000，包括5000，然后再次渲染。
filtSet.renderQueueRange = RenderQueueRange.transparent;
sortSet.criteria = SortingCriteria.CommonTransparent;
//由于我们仅在管道中支持未照明的材质，因此我们将使用Unity的默认未照明通道，该通道由SRPDefaultUnlit标识。
drawSet = new DrawingSettings(new ShaderTagId("SRPDefaultUnlit"), sortSet);
renderContext.DrawRenderers(cullResults, ref drawSet, ref filtSet);
//绘制错误
//由于我们的管道仅支持未着色的着色器，因此不会渲染使用不同着色器的对象，从而使它们不可见。尽管这是正确的，
//但它掩盖了某些对象使用错误着色器的事实。如果我们使用Unity的错误着色器可视化这些对象，那将是很好的，
//因此它们显示为明显不正确的洋红色形状。让我们DrawDefaultPipeline为此添加一个专用方法，其中包含一个上下文和一个camera参数。
//在绘制透明形状之后，我们将在最后调用它。
DrawErrorShaderObject(cullResults, renderContext, camera);
//开始执行渲染内容
renderContext.Submit();
}
}
RenderTexture shadowMap;
//void RenderShadows(ScriptableRenderContext context)
//{
// shadowMap = RenderTexture.GetTemporary(512, 512, 16, RenderTextureFormat.Shadowmap);
// shadowMap.filterMode = FilterMode.Bilinear;
// shadowMap.wrapMode = TextureWrapMode.Clamp;
// CoreUtils.SetRenderTarget(shadowBuffer, shadowMap, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, ClearFlag.Depth);
// shadowBuffer.BeginSample("Render Shadows");
// context.ExecuteCommandBuffer(shadowBuffer);
// shadowBuffer.Clear();
// shadowBuffer.EndSample("Render shadows");
// context.ExecuteCommandBuffer(shadowBuffer);
// shadowBuffer.Clear();
//}
}
void Render(ScriptableRenderContext context, Camera camera)
{
ScriptableCullingParameters cullingParameters;
if (!CullResults.GetCullingParameters(camera, out cullingParameters))
{
return;
}
#if UNITY_EDITOR
if (camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
CullResults.Cull(ref cullingParameters, context, ref cull);
context.SetupCameraProperties(camera);
CameraClearFlags clearFlags = camera.clearFlags;
cameraBuffer.ClearRenderTarget(
(clearFlags & CameraClearFlags.Depth) != 0,
(clearFlags & CameraClearFlags.Color) != 0,
camera.backgroundColor
);
cameraBuffer.BeginSample("Render Camera");
context.ExecuteCommandBuffer(cameraBuffer);
cameraBuffer.Clear();
var drawSettings = new DrawRendererSettings(
camera, new ShaderPassName("SRPDefaultUnlit")
);
drawSettings.flags = drawFlags;
drawSettings.sorting.flags = SortFlags.CommonOpaque;
var filterSettings = new FilterRenderersSettings(true)
{
renderQueueRange = RenderQueueRange.opaque
};
context.DrawRenderers(
cull.visibleRenderers, ref drawSettings, filterSettings
);
context.DrawSkybox(camera);
drawSettings.sorting.flags = SortFlags.CommonTransparent;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(
cull.visibleRenderers, ref drawSettings, filterSettings
);
DrawDefaultPipeline(context, camera);
cameraBuffer.EndSample("Render Camera");
context.ExecuteCommandBuffer(cameraBuffer);
cameraBuffer.Clear();
context.Submit();
}
private static readonly ShaderPassName m_UnlitPassName = new ShaderPassName("SRPDefaultUnlit"); //For default shaders
public static void Render(ScriptableRenderContext context, Camera[] cameras, SRP02CustomParameter SRP02CP)
{
RenderPipeline.BeginFrameRendering(cameras);
foreach (Camera camera in cameras)
{
RenderPipeline.BeginCameraRendering(camera);
//Culling
ScriptableCullingParameters cullingParams;
if (!CullResults.GetCullingParameters(camera, out cullingParams))
{
continue;
}
CullResults cull = new CullResults();
CullResults.Cull(ref cullingParams, context, ref cull);
context.SetupCameraProperties(camera);
if (camera.renderingPath == RenderingPath.UsePlayerSettings)
{
// clear depth buffer
CommandBuffer cmd = new CommandBuffer();
cmd.ClearRenderTarget(true, !SRP02CP.DrawSkybox, SRP02CP.ClearColor);
context.ExecuteCommandBuffer(cmd);
cmd.Release();
// Setup global lighting shader variables
//SetupLightShaderVariables(cull.visibleLights, context);
// Setup DrawSettings and FilterSettings
ShaderPassName passName = new ShaderPassName("BasicPass");
DrawRendererSettings drawSettings = new DrawRendererSettings(camera, passName);
FilterRenderersSettings filterSettings = new FilterRenderersSettings(true);
//Draw passes that has no light mode (default)
ShaderPassName passNameDefault = new ShaderPassName("");
DrawRendererSettings drawSettingsDefault = new DrawRendererSettings(camera, passNameDefault);
drawSettingsDefault.SetShaderPassName(1, m_UnlitPassName);
if (SRP02CP.DrawSkybox)
{
context.DrawSkybox(camera);
}
if (SRP02CP.DrawOpaque)
{
drawSettings.sorting.flags = SortFlags.CommonOpaque;
filterSettings.renderQueueRange = RenderQueueRange.opaque;
context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
}
// Default
drawSettingsDefault.sorting.flags = SortFlags.CommonOpaque;
context.DrawRenderers(cull.visibleRenderers, ref drawSettingsDefault, filterSettings);
if (SRP02CP.DrawTransparent)
{
drawSettings.sorting.flags = SortFlags.CommonTransparent;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
}
// Default
drawSettingsDefault.sorting.flags = SortFlags.CommonTransparent;
context.DrawRenderers(cull.visibleRenderers, ref drawSettingsDefault, filterSettings);
}
context.Submit();
}
}
private void Render(ScriptableRenderContext context, Camera camera)
{
ScriptableCullingParameters cullingParameters;
if (!camera.TryGetCullingParameters(false, out cullingParameters))
{
return;
}
GraphicsSettings.lightsUseLinearIntensity = true;
_cameraBuffer = CommandBufferPool.Get(camera.name);
context.SetupCameraProperties(camera);
CameraClearFlags clearFlags = camera.clearFlags;
_cameraBuffer.ClearRenderTarget((clearFlags & CameraClearFlags.Depth) != 0, (clearFlags & CameraClearFlags.Color) != 0, camera.backgroundColor, 1.0f);
#if UNITY_EDITOR
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
#endif
var cullingResult = context.Cull(ref cullingParameters);
SetupCameraClusters(camera);
UpdateLightBuffer(cullingResult);
LightCulling(camera);
//context.ExecuteCommandBuffer(cameraBuffer);
//cameraBuffer.Clear();
//SetupLights(cullingResult);
//cameraBuffer.BeginSample("Render Camera");
if (camera.cameraType == CameraType.SceneView)
{
//debugClusterRendering();
//context.ExecuteCommandBuffer(cameraBuffer);
//cameraBuffer.Clear();
}
//cameraBuffer.SetGlobalVectorArray(shaderVisibleLightColorsId, visibleLightColors);
//cameraBuffer.SetGlobalVectorArray(shaderVisibleLightDirectionsId, visibleLightDirections);
_ClusterXCount = Mathf.CeilToInt((float)Screen.width / clusterWidth);
_ClusterYCount = Mathf.CeilToInt((float)Screen.height / clusterHeight);
_cameraBuffer.SetGlobalBuffer("g_lights", _LightBuffer);
_cameraBuffer.SetGlobalBuffer("g_lightIndexList", g_lightIndexList);
_cameraBuffer.SetGlobalBuffer("g_lightGrid", g_lightGrid);
_cameraBuffer.SetGlobalVector("clusterSize", new Vector2(clusterWidth, (float)clusterHeight));
_cameraBuffer.SetGlobalVector("cb_clusterCount", new Vector3(_ClusterXCount, _ClusterYCount, clusterZCount));
_cameraBuffer.SetGlobalVector("cb_clusterSize", new Vector3(clusterWidth, clusterHeight, Mathf.CeilToInt((camera.farClipPlane - camera.nearClipPlane) / clusterZCount)));
_cameraBuffer.SetGlobalVector("cb_screenSize", new Vector4(Screen.width, Screen.height, 1.0f / Screen.width, 1.0f / Screen.height));
context.ExecuteCommandBuffer(_cameraBuffer);
_cameraBuffer.Clear();
//cameraBuffer.EndSample("Render Camera");
var drawSettings = new DrawingSettings(new ShaderTagId("ForwardLit"), new SortingSettings(camera)
{
criteria = SortingCriteria.QuantizedFrontToBack,
});
//drawSettings.enableInstancing = true;
//drawSettings.perObjectData = PerObjectData.LightIndices;
var filterSettings = new FilteringSettings(RenderQueueRange.opaque);
context.DrawRenderers(cullingResult, ref drawSettings, ref filterSettings);
context.DrawSkybox(camera);
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(cullingResult, ref drawSettings, ref filterSettings);
if (camera.cameraType == CameraType.SceneView)
{
context.DrawGizmos(camera, GizmoSubset.PostImageEffects);
}
context.Submit();
}
protected override void Render(ScriptableRenderContext context, Camera[] cameras)
{
BeginFrameRendering(cameras);
foreach (Camera camera in cameras)
{
#if UNITY_EDITOR
bool isSceneViewCam = camera.cameraType == CameraType.SceneView;
if (isSceneViewCam)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera); //This makes the UI Canvas geometry appear on scene view
}
#endif
BeginCameraRendering(camera);
//Culling
ScriptableCullingParameters cullingParams;
if (!camera.TryGetCullingParameters(out cullingParams))
{
continue;
}
CullingResults cull = context.Cull(ref cullingParams);
//Camera setup some builtin variables e.g. camera projection matrices etc
context.SetupCameraProperties(camera);
//Get the setting from camera component
bool drawSkyBox = camera.clearFlags == CameraClearFlags.Skybox? true : false;
bool clearDepth = camera.clearFlags == CameraClearFlags.Nothing? false : true;
bool clearColor = camera.clearFlags == CameraClearFlags.Color? true : false;
//Setup DrawSettings and FilterSettings
var sortingSettings = new SortingSettings(camera);
DrawingSettings drawSettings = new DrawingSettings(m_PassName, sortingSettings);
FilteringSettings filterSettings = new FilteringSettings(RenderQueueRange.all);
//Camera clear flag
CommandBuffer cmd = new CommandBuffer();
cmd.name = "Cam:" + camera.name + " ClearFlag";
cmd.ClearRenderTarget(clearDepth, clearColor, camera.backgroundColor);
context.ExecuteCommandBuffer(cmd);
cmd.Release();
//Skybox
if (drawSkyBox)
{
context.DrawSkybox(camera);
}
//Opaque objects
sortingSettings.criteria = SortingCriteria.CommonOpaque;
drawSettings.sortingSettings = sortingSettings;
filterSettings.renderQueueRange = RenderQueueRange.opaque;
context.DrawRenderers(cull, ref drawSettings, ref filterSettings);
//Transparent objects
sortingSettings.criteria = SortingCriteria.CommonTransparent;
drawSettings.sortingSettings = sortingSettings;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(cull, ref drawSettings, ref filterSettings);
//SceneView fix, so that it draws the gizmos on scene view
#if UNITY_EDITOR
if (isSceneViewCam)
{
context.DrawGizmos(camera, GizmoSubset.PostImageEffects);
}
#endif
context.Submit();
}
}
void Render(ScriptableRenderContext context, Camera camera)
{
// 剔除参数
ScriptableCullingParameters cullingParameters;
// 获取剔除参数
if (!CullResults.GetCullingParameters(camera, out cullingParameters))
{
// 如果相机设定非法，直接返回
return;
}
// 设置阴影参数
cullingParameters.shadowDistance = Mathf.Min(shadowDistance, camera.farClipPlane);
// 仅在编辑模式下
#if UNITY_EDITOR
// 仅在渲染场景视图时。否则游戏视图中的UI元素会被渲染两次
if (camera.cameraType == CameraType.SceneView)
{
// 当canvas的渲染被设置在世界空间时，UI元素不会出现在场景视图中
// 需要手动指定以使其正确显示
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
// 剔除
CullResults.Cull(ref cullingParameters, context, ref cull);
if (cull.visibleLights.Count > 0)
{
ConfigureLights();
if (mainLightExists)
{
RenderCascadedShadows(context);
}
else
{
cameraBuffer.DisableShaderKeyword(cascadedShadowsHardKeyword);
cameraBuffer.DisableShaderKeyword(cascadedShadowsSoftKeyword);
}
if (shadowTileCount > 0)
{
RenderShadows(context);
}
else
{
cameraBuffer.DisableShaderKeyword(shadowsHardKeyword);
cameraBuffer.DisableShaderKeyword(shadowsSoftKeyword);
}
}
else
{
// 由于该值会被保留为上一个物体使用的值，因此需要手动设置
cameraBuffer.SetGlobalVector(lightIndicesOffsetAndCountID, Vector4.zero);
cameraBuffer.DisableShaderKeyword(cascadedShadowsHardKeyword);
cameraBuffer.DisableShaderKeyword(cascadedShadowsSoftKeyword);
cameraBuffer.DisableShaderKeyword(shadowsHardKeyword);
cameraBuffer.DisableShaderKeyword(shadowsSoftKeyword);
}
// 设置unity_MatrixVP，以及一些其他属性
context.SetupCameraProperties(camera);
// 获取摄像机的定制后处理栈
var myPipelineCamera = camera.GetComponent <MyPipelineCamera>();
MyPostProcessingStack activeStack = myPipelineCamera ? myPipelineCamera.PostProcessingStack : defaultStack;
// 只影响游戏摄像机
bool scaledRendering = (renderScale <1f || renderScale> 1f) && camera.cameraType == CameraType.Game;
int renderWidth = camera.pixelWidth;
int renderHeight = camera.pixelHeight;
if (scaledRendering)
{
renderWidth = (int)(renderWidth * renderScale);
renderHeight = (int)(renderHeight * renderScale);
}
// 摄像机是否开启MSAA
int renderSamples = camera.allowMSAA ? msaaSamples : 1;
// 开启渲染到纹理
bool renderToTexture = scaledRendering || renderSamples > 1 || activeStack;
// 是否需要深度纹理（深度纹理不支持MSAA）
bool needsDepth = activeStack && activeStack.NeedsDepth;
bool needsDirectDepth = needsDepth && renderSamples == 1; // 不使用MSAA
bool needsDepthOnlyPass = needsDepth && renderSamples > 1; // 使用MSAA、
// 纹理格式
RenderTextureFormat format = allowHDR && camera.allowHDR ? RenderTextureFormat.DefaultHDR : RenderTextureFormat.Default;
// 获取并设置渲染目标，用于后处理
if (renderToTexture)
{
cameraBuffer.GetTemporaryRT(
cameraColorTextureId, renderWidth, renderHeight, needsDirectDepth ? 0 : 24,
FilterMode.Bilinear, format,
RenderTextureReadWrite.Default, renderSamples
);
if (needsDepth)
{
cameraBuffer.GetTemporaryRT(
cameraDepthTextureId, renderWidth, renderHeight, 24,
FilterMode.Point, RenderTextureFormat.Depth,
RenderTextureReadWrite.Linear, 1 // 1表示不使用MSAA
);
}
if (needsDirectDepth)
{
cameraBuffer.SetRenderTarget(
cameraColorTextureId,
RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store,
cameraDepthTextureId,
RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store
);
}
else
{
cameraBuffer.SetRenderTarget(
cameraColorTextureId,
RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store
);
}
}
// 清空
CameraClearFlags clearFlags = camera.clearFlags;
cameraBuffer.ClearRenderTarget((clearFlags & CameraClearFlags.Depth) != 0, (clearFlags & CameraClearFlags.Color) != 0, camera.backgroundColor);
// 设置采样标志，用于在Frame Debugger中组织结构
cameraBuffer.BeginSample("HY Render Camera");
// 设置光数据
cameraBuffer.SetGlobalVectorArray(visibleLightColorsId, visibleLightColors);
cameraBuffer.SetGlobalVectorArray(visibleLightDirectionsOrPositionsId, visibleLightDirectionsOrPositions);
cameraBuffer.SetGlobalVectorArray(visibleLightAttenuationsId, visibleLightAttenuations);
cameraBuffer.SetGlobalVectorArray(visibleLightSpotDirectionsId, visibleLightSpotDirections);
// 执行指令缓冲。这并不会立即执行指令，只是将指令拷贝到上下文的内部缓冲中
context.ExecuteCommandBuffer(cameraBuffer);
cameraBuffer.Clear();
// 绘制设定
// camera参数设定排序和剔除层，pass参数指定使用哪一个shader pass
var drawSettings = new DrawRendererSettings(camera, new ShaderPassName("SRPDefaultUnlit"))
{
flags = drawFlags
};
// 仅在有可见光时设置，否则Unity会崩溃
if (cull.visibleLights.Count > 0)
{
// 指定Unity为每个物体传输光索引数据
drawSettings.rendererConfiguration = RendererConfiguration.PerObjectLightIndices8;
}
// 指定使用反射探针，如果场景中没有反射探针，则使用天空球的立方体贴图
drawSettings.rendererConfiguration |= RendererConfiguration.PerObjectReflectionProbes | RendererConfiguration.PerObjectLightmaps;
// 指定排序，从前往后
drawSettings.sorting.flags = SortFlags.CommonOpaque;
// 过滤设定
// true表示包括所有物体
var filterSettings = new FilterRenderersSettings(true)
{
// 绘制不透明物体，渲染队列为[0，2500]
renderQueueRange = RenderQueueRange.opaque
};
context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
// 绘制天空盒
// camera参数仅用来判断是否绘制天空盒（根据camera的清空标志位）
context.DrawSkybox(camera);
// 后处理
if (activeStack)
{
// depth-only pass
if (needsDepthOnlyPass)
{
var depthOnlyDrawSettings = new DrawRendererSettings(
camera, new ShaderPassName("DepthOnly")
)
{
flags = drawFlags
};
depthOnlyDrawSettings.sorting.flags = SortFlags.CommonOpaque;
cameraBuffer.SetRenderTarget(
cameraDepthTextureId,
RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store
);
cameraBuffer.ClearRenderTarget(true, false, Color.clear);
context.ExecuteCommandBuffer(cameraBuffer);
cameraBuffer.Clear();
context.DrawRenderers(
cull.visibleRenderers, ref depthOnlyDrawSettings, filterSettings
);
}
activeStack.RenderAfterOpaque(
postProcessingBuffer, cameraColorTextureId, cameraDepthTextureId,
renderWidth, renderHeight, renderSamples, format
);
context.ExecuteCommandBuffer(postProcessingBuffer);
postProcessingBuffer.Clear();
if (needsDirectDepth)
{
cameraBuffer.SetRenderTarget(
cameraColorTextureId,
RenderBufferLoadAction.Load, RenderBufferStoreAction.Store,
cameraDepthTextureId,
RenderBufferLoadAction.Load, RenderBufferStoreAction.Store
);
}
else
{
cameraBuffer.SetRenderTarget(
cameraColorTextureId,
RenderBufferLoadAction.Load, RenderBufferStoreAction.Store
);
}
context.ExecuteCommandBuffer(cameraBuffer);
cameraBuffer.Clear();
}
// 指定排序，从后往前
drawSettings.sorting.flags = SortFlags.CommonTransparent;
// 绘制透明物体，渲染队列为[2501，5000]
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
DrawDefaultPipeline(context, camera);
// 后处理
if (renderToTexture)
{
if (activeStack)
{
activeStack.RenderAfterTransparent(
postProcessingBuffer, cameraColorTextureId,
cameraDepthTextureId, renderWidth, renderHeight, renderSamples, format
);
context.ExecuteCommandBuffer(postProcessingBuffer);
postProcessingBuffer.Clear();
}
else
{
cameraBuffer.Blit(
cameraColorTextureId, BuiltinRenderTextureType.CameraTarget
);
}
cameraBuffer.ReleaseTemporaryRT(cameraColorTextureId);
if (needsDepth)
{
cameraBuffer.ReleaseTemporaryRT(cameraDepthTextureId);
}
}
cameraBuffer.EndSample("HY Render Camera");
context.ExecuteCommandBuffer(cameraBuffer);
cameraBuffer.Clear();
// 提交指令
context.Submit();
// 释放阴影纹理
if (shadowMap)
{
RenderTexture.ReleaseTemporary(shadowMap);
shadowMap = null;
}
// 释放层级阴影纹理
if (cascadedShadowMap)
{
RenderTexture.ReleaseTemporary(cascadedShadowMap);
cascadedShadowMap = null;
}
}
