//Alex: Draws to screen?
//Tyler: Draws to whatever the camera is drawing to (which can be set in the editor.
public override void Render(ScriptableRenderContext renderContext, Camera[] cameras)
{
//Tyler: Performs sanity checks (not well documented)
base.Render(renderContext, cameras);
//Tyler: Obtains a CommandBuffer instance from the pool to save on GC pressure.
CommandBuffer cb = CommandBufferPool.Get(); //Alex: Obtain CommandBuffer queue from pool.
//Alex: Call render for a camera?
//Tyler: Process rendering for each camera in the order provided.
foreach (Camera camera in cameras)
{
//Tyler: Sets up Unity's internal camera variables (not well documented) and binds the render target to the camera's target.
renderContext.SetupCameraProperties(camera); //Alex: Does some interesting things(?)
cb.ClearRenderTarget(true, true, AssetReference.Color); //Alex: Set Color. Tyler: Clear background color to the color in the FP Asset and clear out the depth buffer.
foreach (FPRenderComponent FPRenderComponent in FPRenderPipelineAsset.ListOfRenderComponent)
{
cb.DrawRenderer(FPRenderComponent.DefaultUnityMeshRenderer, FPRenderComponent.DefaultUnityMeshRenderer.sharedMaterial, 0);
}
#if UNITY_EDITOR
// Emit scene view UI
if (camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
renderContext.ExecuteCommandBuffer(cb); //Alex: Execute commands in queue.
}
renderContext.Submit(); //Alex: Submit changes.
cb.Release(); //Alex: Release obtained CommandBuffer.
}
partial void PrepareForSceneWindow() //准备场景窗口（使UI在场景窗口中可见）
{
if (camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
}
/// <summary>
/// 在编辑下显示UI
/// </summary>
protected void prepareForSceneWindow()
{
if (m_camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(m_camera);
}
}
/// <summary>
/// 确保在场景中绘制, 必须剔除前使用
/// </summary>
private void PrepareForSceneWindow(Camera camera)
{
if (camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
}
protected override void Render(ScriptableRenderContext context, Camera[] cameras)
{
BeginFrameRendering(context, cameras);
foreach (var camera in cameras)
{
if (false == camera.TryGetCullingParameters(out _cullParam))
{
continue;
}
BeginCameraRendering(context, camera);
#if UNITY_EDITOR
if (CameraType.SceneView == camera.cameraType)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
var ppLayer = camera.GetComponent <PostProcessLayer>();
if (null == ppLayer)
{
NormalRendering(context, camera);
}
else
{
PostProcessingRendering(context, camera, ppLayer);
}
EndCameraRendering(context, camera);
}
EndFrameRendering(context, cameras);
}
protected override void Render(ScriptableRenderContext context, Camera[] cameras)
{
if (happyAsset.Passes == null)
{
return;
}
if (happyAsset.Passes.Count == 0)
{
return;
}
foreach (Camera camera in cameras)
{
#if UNITY_EDITOR
if (camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
camera.TryGetCullingParameters(out cullingParameters);
CullingResults cullingResults = context.Cull(ref cullingParameters);
context.SetupCameraProperties(camera);
happyAsset.Passes[0].Execute(context, camera, cullingResults);
context.Submit();
}
}
public void CullingAndDraw(ScriptableRenderContext context, Camera cam)
{
if (!CullResults.GetCullingParameters(cam, out cullingParameters))
{
return;
}
#if UNITY_EDITOR
if (cam.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(cam);
}
#endif
UnityEngine.Profiling.Profiler.BeginSample("GCSource");
CullResults.Cull(ref cullingParameters, context, ref cull);
UnityEngine.Profiling.Profiler.EndSample();
DrawRendererSettings drawSettings = new DrawRendererSettings(cam, new ShaderPassName("CstRP"));
if (asset.enableDynamicBatching)
{
drawSettings.flags = DrawRendererFlags.EnableDynamicBatching;
}
if (asset.enableInstancing)
{
drawSettings.flags |= DrawRendererFlags.EnableInstancing;
}
drawSettings.sorting.flags = SortFlags.CommonOpaque;
FilterRenderersSettings filterSettings = new FilterRenderersSettings(true)
{
renderQueueRange = RenderQueueRange.opaque
};
context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
context.DrawSkybox(cam);
drawSettings.sorting.flags = SortFlags.CommonTransparent;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
}
public static void RenderSingleCamera(ScriptableRenderContext context, Camera camera)
{
if (!camera.TryGetCullingParameters(IsStereoEnabled(camera), out var cullingParameters))
{
return;
}
var settings = asset;
LWRPAdditionalCameraData additionalCameraData = null;
if (camera.cameraType == CameraType.Game || camera.cameraType == CameraType.VR)
#if UNITY_2019_2_OR_NEWER
{ camera.gameObject.TryGetComponent(out additionalCameraData); }
#else
{ additionalCameraData = camera.gameObject.GetComponent <LWRPAdditionalCameraData>(); }
#endif
InitializeCameraData(settings, camera, additionalCameraData, out var cameraData);
SetupPerCameraShaderConstants(cameraData);
ScriptableRenderer renderer = (additionalCameraData != null) ? additionalCameraData.scriptableRenderer : settings.scriptableRenderer;
if (renderer == null)
{
Debug.LogWarning(string.Format("Trying to render {0} with an invalid renderer. Camera rendering will be skipped.", camera.name));
return;
}
#if UNITY_EDITOR
string tag = camera.name;
#else
string tag = k_RenderCameraTag;
#endif
CommandBuffer cmd = CommandBufferPool.Get(tag);
using (new ProfilingSample(cmd, tag))
{
renderer.Clear();
renderer.SetupCullingParameters(ref cullingParameters, ref cameraData);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
#if UNITY_EDITOR
// Emit scene view UI
if (cameraData.isSceneViewCamera)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
var cullResults = context.Cull(ref cullingParameters);
InitializeRenderingData(settings, ref cameraData, ref cullResults, out var renderingData);
renderer.Setup(context, ref renderingData);
renderer.Execute(context, ref renderingData);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
context.Submit();
}
public override void Render(ScriptableRenderContext renderContext, Camera[] cameras) {
base.Render(renderContext, cameras);
BeginFrameRendering(cameras);
foreach (var camera in cameras) {
BeginCameraRendering(camera);
var vxgi = camera.GetComponent<VXGI>();
if (vxgi != null && vxgi.isActiveAndEnabled) {
vxgi.Render(renderContext, _renderer);
} else {
#if UNITY_EDITOR
bool rendered = false;
if (camera.cameraType == UnityEngine.CameraType.SceneView) {
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
if (Camera.main != null) {
vxgi = Camera.main.GetComponent<VXGI>();
if (vxgi != null && vxgi.isActiveAndEnabled) {
vxgi.Render(renderContext, camera, _renderer);
rendered = true;
}
}
if (!rendered) RenderFallback(renderContext, camera);
#else
RenderFallback(renderContext, camera);
#endif
}
}
}
protected override void Render(ScriptableRenderContext context, Camera[] cameras)
{
BeginFrameRendering(context, cameras);
foreach (var RenderCamera in cameras)
{
#if UNITY_EDITOR
//seting UI in SceneEdit
bool isSceneViewCam = RenderCamera.cameraType == CameraType.SceneView;
if (isSceneViewCam)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(RenderCamera);
}
#endif
//////Set Camera Property
BeginCameraRendering(context, RenderCamera);
context.SetupCameraProperties(RenderCamera);
/////Cull Object
ScriptableCullingParameters cullingParameters;
if (!RenderCamera.TryGetCullingParameters(out cullingParameters))
{
continue;
}
CullingResults CullingData = context.Cull(ref cullingParameters);
//Drwa PipeLine Pass
RenderingContent(isSceneViewCam, RenderCamera, CullingData, context);
///Submit RenderContent
context.Submit();
EndCameraRendering(context, RenderCamera);
}
}
partial void EmitSceneUIGeometry()
{
if (_camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(_camera);
}
}
private void RenderCamera(ScriptableRenderContext context, Camera camera)
{
//设置摄像机属性给上下文
context.SetupCameraProperties(camera);
//清除背景
CameraClearFlags clearFlags = camera.clearFlags;
cameraClearBuff.ClearRenderTarget(
(clearFlags & CameraClearFlags.Depth) != 0,
(clearFlags & CameraClearFlags.Color) != 0,
camera.backgroundColor
);
context.ExecuteCommandBuffer(cameraClearBuff);
cameraClearBuff.Clear();
//剔除视图外的物体
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);
//绘制物体
DrawOpaqueRenders(context, camera, cull);
DrawDefaultPipeline(context, camera);
context.DrawSkybox(camera);
DrawTransparentRenders(context, camera, cull);
context.Submit();
}
protected override void Render(ScriptableRenderContext context, Camera[] cameras)
{
int maxWidth = 1;
int maxHeight = 1;
foreach (var camera in cameras)
{
maxWidth = Mathf.Max(maxWidth, camera.pixelWidth);
maxHeight = Mathf.Max(maxHeight, camera.pixelHeight);
}
//RTHandles.SetReferenceSize(maxWidth,maxHeight,m_MSAASample);
RTHandles.SetReferenceSize(1920, 1080, m_MSAASample);
ShaderBindings.SetPerFrameShaderVariables(context);
foreach (Camera camera in cameras)
{
#if UNITY_EDITOR
if (camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
CullingResults cullingResults = Cull(context, camera);
ShaderBindings.SetPerCameraShaderVariables(context, camera);
DrawCamera(context, cullingResults, camera);
}
}
partial void PrepareForSceneWindow()
{
if (_camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(_camera);
}
}
public static void RenderSingleCamera(ScriptableRenderContext context, Camera camera)
{
if (!camera.TryGetCullingParameters(IsStereoEnabled(camera), out var cullingParameters))
{
return;
}
var settings = asset;
LWRPAdditionalCameraData additionalCameraData = null;
if (camera.cameraType == CameraType.Game || camera.cameraType == CameraType.VR)
{
additionalCameraData = camera.gameObject.GetComponent <LWRPAdditionalCameraData>();
}
InitializeCameraData(settings, camera, additionalCameraData, out var cameraData);
SetupPerCameraShaderConstants(cameraData);
ScriptableRenderer renderer = (additionalCameraData != null) ? additionalCameraData.scriptableRenderer : settings.scriptableRenderer;
if (renderer == null)
{
Debug.LogWarning(string.Format("Trying to render {0} with an invalid renderer. Camera rendering will be skipped.", camera.name));
return;
}
camera.cullingMatrix = Matrix4x4.Ortho(-99999, 99999, -99999, 99999, 0.001f, 99999) *
Matrix4x4.Translate(Vector3.forward * -99999 / 2f) *
camera.worldToCameraMatrix;
CommandBuffer cmd = CommandBufferPool.Get(camera.name);
using (new ProfilingSample(cmd, camera.name))
{
renderer.Clear();
renderer.SetupCullingParameters(ref cullingParameters, ref cameraData);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
#if UNITY_EDITOR
// Emit scene view UI
if (cameraData.isSceneViewCamera)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
var cullResults = context.Cull(ref cullingParameters);
InitializeRenderingData(settings, ref cameraData, ref cullResults, out var renderingData);
renderer.Setup(context, ref renderingData);
renderer.Execute(context, ref renderingData);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
context.Submit();
}
void Render(ScriptableRenderContext context, Camera camera)
{
ScriptableCullingParameters scriptableCullingParameters;
if (!camera.TryGetCullingParameters(out scriptableCullingParameters))
{
return;
}
#if UNITY_EDITOR
if (camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
BeginCameraRendering(context, camera);
_cullingResults = context.Cull(ref scriptableCullingParameters);
context.SetupCameraProperties(camera);
CameraClearFlags clearFlags = camera.clearFlags;
commandBuffer.ClearRenderTarget((clearFlags & CameraClearFlags.Depth) != 0,
(clearFlags & CameraClearFlags.Color) != 0, camera.backgroundColor);
ConfigureLights();
commandBuffer.BeginSample("Render Camera");
commandBuffer.SetGlobalVectorArray(visibleLightColorsId, visibleLightColors);
commandBuffer.SetGlobalVectorArray(visibleLightDirectionsOrPositionsId, visibleLightDirectionsOrPositions);
commandBuffer.SetGlobalVectorArray(visibleLightAttenuationsId, visibleLightAttenuations);
commandBuffer.SetGlobalVectorArray(visibleLightSpotDirectionsId, visibleLightSpotDirections);
context.ExecuteCommandBuffer(commandBuffer);
commandBuffer.Clear();
SortingSettings sortingSettings = new SortingSettings(camera);
sortingSettings.criteria = SortingCriteria.CommonOpaque;
DrawingSettings drawingSettings = new DrawingSettings(new ShaderTagId("SRPDefaultUnlit"), sortingSettings);
drawingSettings.enableInstancing = _instancing;
drawingSettings.enableDynamicBatching = _dynamicBatching;
FilteringSettings filteringSettings = FilteringSettings.defaultValue;
filteringSettings.renderQueueRange = RenderQueueRange.opaque;
context.DrawRenderers(_cullingResults, ref drawingSettings, ref filteringSettings);
context.DrawSkybox(camera);
sortingSettings.criteria = SortingCriteria.CommonTransparent;
filteringSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(_cullingResults, ref drawingSettings, ref filteringSettings);
DrawDefaultPipeline(context, camera);
commandBuffer.EndSample("Render Camera");
context.ExecuteCommandBuffer(commandBuffer);
commandBuffer.Clear();
context.Submit();
EndCameraRendering(context, camera);
}
public static void RenderSingleCamera(LightweightRenderPipeline pipelineInstance, ScriptableRenderContext context, Camera camera)
{
if (pipelineInstance == null)
{
Debug.LogError("Trying to render a camera with an invalid render pipeline instance.");
return;
}
if (!camera.TryGetCullingParameters(IsStereoEnabled(camera), out var cullingParameters))
{
return;
}
CommandBuffer cmd = CommandBufferPool.Get(k_RenderCameraTag);
using (new ProfilingSample(cmd, k_RenderCameraTag))
{
ScriptableRenderer renderer = pipelineInstance.renderer;
var settings = asset;
LWRPAdditionalCameraData additionalCameraData = camera.gameObject.GetComponent <LWRPAdditionalCameraData>();
InitializeCameraData(settings, camera, additionalCameraData, out var cameraData);
SetupPerCameraShaderConstants(cameraData);
// TODO: PerObjectCulling also affect reflection probes. Enabling it for now.
// if (asset.additionalLightsRenderingMode == LightRenderingMode.Disabled ||
// asset.maxAdditionalLightsCount == 0)
// {
// cullingParameters.cullingOptions |= CullingOptions.DisablePerObjectCulling;
// }
cullingParameters.shadowDistance = Mathf.Min(cameraData.maxShadowDistance, camera.farClipPlane);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
#if UNITY_EDITOR
// Emit scene view UI
if (cameraData.isSceneViewCamera)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
var cullResults = context.Cull(ref cullingParameters);
InitializeRenderingData(settings, ref cameraData, ref cullResults,
renderer.maxVisibleAdditionalLights, renderer.maxPerObjectAdditionalLights, out var renderingData);
renderer.Clear();
IRendererSetup rendererSetup = (additionalCameraData != null) ? additionalCameraData.rendererSetup : settings.rendererSetup;
rendererSetup.Setup(renderer, ref renderingData);
renderer.Execute(context, ref renderingData);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
context.Submit();
}
partial void PrepareForSceneWindow()
{
if (camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
useScaledRendering = false;
}
}
partial void PrepareForSceneWindow()
{
//Emit UI geometry into the Scene view for rendering.
if (camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
}
protected override void Render(ScriptableRenderContext context, Camera[] cameras)
{
FilteringSettings opaqueFilteringSettings = new FilteringSettings(RenderQueueRange.opaque);
FilteringSettings transparentFilteringSettings = new FilteringSettings(RenderQueueRange.transparent);
bool enableDynamicBatching = false;
bool enableInstancing = false;
PerObjectData perObjectData = PerObjectData.None;
foreach (Camera camera in cameras)
{
#if UNITY_EDITOR
if (camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
// Culling. Adjust culling parameters for your needs. One could enable/disable
// per-object lighting or control shadow caster distance.
camera.TryGetCullingParameters(m_IsStereoSupported, out var cullingParameters);
var cullingResults = context.Cull(ref cullingParameters);
SortingSettings opaqueSortingSettings = new SortingSettings(camera);
opaqueSortingSettings.criteria = SortingCriteria.CommonOpaque;
// ShaderTagId must match the "LightMode" tag inside the shader pass.
// If not "LightMode" tag is found the object won't render.
DrawingSettings opaqueDrawingSettings = new DrawingSettings(m_ShaderTagId, opaqueSortingSettings);
opaqueDrawingSettings.enableDynamicBatching = enableDynamicBatching;
opaqueDrawingSettings.enableInstancing = enableInstancing;
opaqueDrawingSettings.perObjectData = perObjectData;
// Helper method to setup some per-camera shader constants and camera matrices.
context.SetupCameraProperties(camera, m_IsStereoSupported);
// Sets active render target and clear based on camera backgroud color.
var cmd = CommandBufferPool.Get();
cmd.SetRenderTarget(BuiltinRenderTextureType.CameraTarget);
cmd.ClearRenderTarget(true, true, camera.backgroundColor);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
// Render Opaque objects given the filtering and settings computed above.
// This functions will sort and batch objects.
context.DrawRenderers(cullingResults, ref opaqueDrawingSettings, ref opaqueFilteringSettings);
// Renders skybox if required
if (camera.clearFlags == CameraClearFlags.Skybox && RenderSettings.skybox != null)
{
context.DrawSkybox(camera);
}
// Submit commands to GPU. Up to this point all commands have been enqueued in the context.
// Several submits can be done in a frame to better controls CPU/GPU workload.
context.Submit();
}
}
public static void RenderSingleCamera(DoomSRPPipeline pipelineInstance, ScriptableRenderContext context, Camera camera, ref CullResults cullResults, IRendererSetup setup = null)
{
if (pipelineInstance == null)
{
Debug.LogError("Trying to render a camera with an invalid render pipeline instance.");
return;
}
ScriptableCullingParameters cullingParameters;
if (!CullResults.GetCullingParameters(camera, out cullingParameters))
{
return;
}
CommandBuffer cmd = CommandBufferPool.Get(k_RenderCameraTag);
using (new ProfilingSample(cmd, k_RenderCameraTag))
{
CameraData cameraData;
PipelineSettings settings = pipelineInstance.settings;
ScriptableRenderer renderer = pipelineInstance.renderer;
LightLoop lightloop = pipelineInstance.GetLightLoop();
InitializeCameraData(pipelineInstance.settings, camera, out cameraData);
SetupPerCameraShaderConstants(cameraData);
cullingParameters.shadowDistance = Mathf.Min(cameraData.maxShadowDistance, camera.farClipPlane);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
#if UNITY_EDITOR
// Emit scene view UI
if (cameraData.isSceneViewCamera)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
CullResults.Cull(ref cullingParameters, context, ref cullResults);
RenderingData renderingData;
InitializeRenderingData(settings, ref cameraData, ref cullResults, ref lightloop, out renderingData);
var setupToUse = setup;
if (setupToUse == null)
{
setupToUse = defaultRendererSetup;
}
renderer.Clear();
setupToUse.Setup(renderer, ref renderingData);
renderer.Execute(context, ref renderingData);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
context.Submit();
#if UNITY_EDITOR
Handles.DrawGizmos(camera);
#endif
}
public override void Render(ScriptableRenderContext renderContext, Camera[] cameras)
{
base.Render(renderContext, cameras);
BeginFrameRendering(cameras);
foreach (var camera in cameras)
{
var layer = camera.GetComponent <PostProcessLayer>();
if (layer != null && layer.isActiveAndEnabled)
{
layer.UpdateVolumeSystem(camera, _command);
renderContext.ExecuteCommandBuffer(_command);
_command.Clear();
}
BeginCameraRendering(camera);
var vxgi = camera.GetComponent <VXGI>();
if (vxgi != null && vxgi.isActiveAndEnabled)
{
vxgi.Render(renderContext, _renderer);
}
else
{
#if UNITY_EDITOR
bool rendered = false;
if (camera.cameraType == UnityEngine.CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
if (Camera.main != null)
{
vxgi = Camera.main.GetComponent <VXGI>();
if (vxgi != null && vxgi.isActiveAndEnabled)
{
vxgi.Render(renderContext, camera, _renderer);
rendered = true;
}
}
if (!rendered)
{
RenderFallback(renderContext, camera);
}
#else
RenderFallback(renderContext, camera);
#endif
}
renderContext.Submit();
}
}
partial void PrepareForSceneWindow()
{
//标识为摄像机Scene窗口模式
if (camera.cameraType == CameraType.SceneView)
{
//Scene 窗口模式画 UI将UI几何体到“场景”视图中以进行渲染。
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
}
public static void RenderSingleCamera(LightweightRenderPipeline pipelineInstance, ScriptableRenderContext context, Camera camera, IRendererSetup setup = null)
{
if (pipelineInstance == null)
{
Debug.LogError("Trying to render a camera with an invalid render pipeline instance.");
return;
}
if (!camera.TryGetCullingParameters(IsStereoEnabled(camera), out var cullingParameters))
{
return;
}
CommandBuffer cmd = CommandBufferPool.Get(k_RenderCameraTag);
using (new ProfilingSample(cmd, k_RenderCameraTag))
{
PipelineSettings settings = pipelineInstance.settings;
ScriptableRenderer renderer = pipelineInstance.renderer;
InitializeCameraData(settings, camera, out var cameraData);
SetupPerCameraShaderConstants(cameraData);
if (pipelineInstance.settings.additionalLightsRenderingMode == LightRenderingMode.Disabled ||
pipelineInstance.settings.maxAdditionalLights == 0)
{
cullingParameters.cullingOptions |= CullingOptions.DisablePerObjectCulling;
}
cullingParameters.shadowDistance = Mathf.Min(cameraData.maxShadowDistance, camera.farClipPlane);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
#if UNITY_EDITOR
// Emit scene view UI
if (cameraData.isSceneViewCamera)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
var cullResults = context.Cull(ref cullingParameters);
InitializeRenderingData(settings, ref cameraData, ref cullResults,
renderer.maxVisibleAdditionalLights, renderer.maxPerObjectAdditionalLights, out var renderingData);
renderer.Clear();
var rendererSetup = setup ?? settings.rendererSetup;
rendererSetup.Setup(renderer, ref renderingData);
renderer.Execute(context, ref renderingData);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
context.Submit();
}
private void DrawSceneView()
{
if (camera.cameraType != CameraType.SceneView)
{
return;
}
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
private void PrepareForSceneWindow()
{
#if UNITY_EDITOR
if (camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
}
public override void Render(ScriptableRenderContext renderContext, Camera[] cameras)
{
base.Render(renderContext, cameras);
foreach (var camera in cameras)
{
renderContext.SetupCameraProperties(camera);
CameraClearFlags clearFlags = camera.clearFlags;
cameraBuffer.ClearRenderTarget((clearFlags & CameraClearFlags.Depth) != 0, (clearFlags & CameraClearFlags.Color) != 0, camera.backgroundColor);
renderContext.ExecuteCommandBuffer(cameraBuffer);
cameraBuffer.Clear();
if (!CullResults.GetCullingParameters(camera, out ScriptableCullingParameters cullingParameters))
{
return;
}
#if UNITY_EDITOR
if (camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
CullResults.Cull(ref cullingParameters, renderContext, ref cull);
var drawSettings = new DrawRendererSettings(camera, new ShaderPassName("SRPDefaultUnlit"));
//先渲染不透明
//This instructs Unity to sort the renderers by distance, from front to back, plus a few other criteria.
drawSettings.sorting.flags = SortFlags.CommonOpaque;
//筛选不透明物体
var filterSettings = new FilterRenderersSettings(true)
{
renderQueueRange = RenderQueueRange.opaque
};
renderContext.DrawRenderers(
cull.visibleRenderers, ref drawSettings, filterSettings
);
//渲染天空
renderContext.DrawSkybox(camera);
//筛选透明物体
drawSettings.sorting.flags = SortFlags.CommonTransparent;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
//渲染透明
renderContext.DrawRenderers(
cull.visibleRenderers, ref drawSettings, filterSettings
);
#if UNITY_EDITOR
DrawDefaultPipeline(renderContext, camera);
#endif
}
renderContext.Submit();
}
partial void PrepareForSceneView()
{
//Add the UI as geo to render in SceneView camera. for betterUP
if (camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
useScaledRendering = false;//no need for scaled rendering for editor window
}
}
public static void RenderSingleCamera(ScriptableRenderContext context, Camera camera, Camera uiCamera = null)
{
if (!camera.TryGetCullingParameters(IsStereoEnabled(camera), out var cullingParameters))
{
return;
}
var settings = asset;
LWRPAdditionalCameraData additionalCameraData = null;
if (camera.cameraType == CameraType.Game || camera.cameraType == CameraType.VR || camera.cameraType == CameraType.Reflection)
{
additionalCameraData = camera.gameObject.GetComponent <LWRPAdditionalCameraData>();
}
InitializeCameraData(settings, camera, additionalCameraData, out var cameraData);
SetupPerCameraShaderConstants(cameraData);
ScriptableRenderer renderer = camera.name == FeedbackGlobals.FeedbackCamName ? settings.feedbackRenderer : (additionalCameraData != null) ? additionalCameraData.scriptableRenderer : settings.scriptableRenderer;
// renderer = settings.scriptableRenderer;
if (renderer == null)
{
Debug.LogWarning(string.Format("Trying to render {0} with an invalid renderer. Camera rendering will be skipped.", camera.name));
return;
}
string camera_tag_string = string.Format("{0},{1}", k_RenderCameraTag, camera.name);
CommandBuffer cmd = CommandBufferPool.Get(camera_tag_string);
using (new ProfilingSample(cmd, camera_tag_string))
{
renderer.Clear();
renderer.SetupCullingParameters(ref cullingParameters, ref cameraData);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
#if UNITY_EDITOR
// Emit scene view UI
if (cameraData.isSceneViewCamera)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
var cullResults = context.Cull(ref cullingParameters);
InitializeRenderingData(settings, ref cameraData, ref cullResults, out var renderingData);
renderingData.uiCmaera = uiCamera;
renderer.Setup(context, ref renderingData);
renderer.Execute(context, ref renderingData);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
context.Submit();
}
public static void RenderSingleCamera(ScriptableRenderContext context, PipelineSettings settings, Camera camera, ref CullResults cullResults, IRendererSetup setup, ScriptableRenderer renderer)
{
string renderCameraTag = camera.name;
CommandBuffer cmd = CommandBufferPool.Get(renderCameraTag);
using (new ProfilingSample(cmd, renderCameraTag))
{
CameraData cameraData;
InitializeCameraData(settings, camera, out cameraData);
SetupPerCameraShaderConstants(cameraData);
ScriptableCullingParameters cullingParameters;
if (!CullResults.GetCullingParameters(camera, cameraData.isStereoEnabled, out cullingParameters))
{
CommandBufferPool.Release(cmd);
return;
}
cullingParameters.shadowDistance = Mathf.Min(cameraData.maxShadowDistance, camera.farClipPlane);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
#if UNITY_EDITOR
// Emit scene view UI
if (cameraData.isSceneViewCamera)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
CullResults.Cull(ref cullingParameters, context, ref cullResults);
List <VisibleLight> visibleLights = cullResults.visibleLights;
RenderingData renderingData;
InitializeRenderingData(settings, ref cameraData, visibleLights,
renderer.maxSupportedLocalLightsPerPass, renderer.maxSupportedVertexLights,
out renderingData);
var setupToUse = setup;
if (setupToUse == null)
{
setupToUse = defaultRendererSetup;
}
setupToUse.Setup(renderer, ref context, ref cullResults, ref renderingData);
renderer.Execute(ref context, ref cullResults, ref renderingData);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
context.Submit();
#if UNITY_EDITOR
Handles.DrawGizmos(camera);
#endif
}
}
