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();
}
public override void Execute(ScriptableRenderContext context, ref UnityEngine.Rendering.Universal.RenderingData renderingData)
{
SortingCriteria sortingCriteria = (renderQueueType == RenderQueueType.Transparent)
? SortingCriteria.CommonTransparent
: renderingData.cameraData.defaultOpaqueSortFlags;
DrawingSettings drawingSettings =
CreateDrawingSettings(m_ShaderTagIdList, ref renderingData, sortingCriteria);
drawingSettings.overrideMaterial = overrideMaterial;
drawingSettings.overrideMaterialPassIndex = overrideMaterialPassIndex;
GraphicsFence portalsRenderedFence;
Camera camera = renderingData.cameraData.camera;
float cameraAspect = (float)camera.pixelWidth / (float)camera.pixelHeight;
CommandBuffer cmd = CommandBufferPool.Get(m_ProfilerTag);
using (new ProfilingSample(cmd, m_ProfilerTag))
{
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
cmd.SetRandomWriteTarget(1, portalRenderContext.computeBuffer);
if (m_CameraSettings.overrideCamera)
{
//Matrix4x4 projectionMatrix = Matrix4x4.Perspective(m_CameraSettings.cameraFieldOfView, cameraAspect,
// camera.nearClipPlane, camera.farClipPlane);
//Matrix4x4 viewMatrix = camera.worldToCameraMatrix;
//Vector4 cameraTranslation = viewMatrix.GetColumn(3);
//viewMatrix.SetColumn(3, cameraTranslation + m_CameraSettings.offset);
//cmd.SetViewProjectionMatrices(viewMatrix, projectionMatrix);
portalRenderContext.exitPortal = GameObject.FindGameObjectWithTag("ExitPortal");
Camera exitCam = portalRenderContext.exitPortal.GetComponentInChildren <Camera>();
GameObject entryGO = GameObject.FindGameObjectWithTag("EntryPortal");
//Vector3 normal = exitCam.transform.forward;
//Vector3 pos = exitCam.transform.position;
//Vector4 clipPlaneWorldSpace = new Vector4(normal.x, normal.y, normal.z, -Vector3.Dot(normal, pos));
//Vector4 clipPlaneCameraSpace = exitCam.worldToCameraMatrix * clipPlaneWorldSpace;
Matrix4x4 projectionMatrix = camera.projectionMatrix;//exitCam.CalculateObliqueMatrix(clipPlaneCameraSpace);
Matrix4x4 destView = camera.worldToCameraMatrix * entryGO.transform.localToWorldMatrix
* Matrix4x4.Rotate(entryGO.transform.rotation)
* exitCam.transform.localToWorldMatrix.inverse;
//* glm::rotate(glm::mat4(1.0f), 180.0f, glm::vec3(0.0f, 1.0f, 0.0f) * portal.orientation())
//* glm::inverse(portal.destination()->modelMat());
projectionMatrix = clippedProjMat(destView, projectionMatrix, entryGO.transform.position, entryGO.transform.rotation);
//cmd.Clear();
cmd.SetViewProjectionMatrices(destView, projectionMatrix);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
}
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref m_FilteringSettings,
ref m_RenderStateBlock);
//ScriptableCullingParameters param;
//context.Cull()
if (m_CameraSettings.overrideCamera && m_CameraSettings.restoreCamera)
{
Matrix4x4 projectionMatrix = Matrix4x4.Perspective(camera.fieldOfView, cameraAspect,
camera.nearClipPlane, camera.farClipPlane);
cmd.Clear();
cmd.SetViewProjectionMatrices(camera.worldToCameraMatrix, projectionMatrix);
}
//portalsRenderedFence = cmd.CreateGraphicsFence(GraphicsFenceType.CPUSynchronisation,
// SynchronisationStageFlags.PixelProcessing);
//if (PortalDebugRenderOverlay.Instance?.renderTarget)
//{
// PortalDebugRenderOverlay.Instance?.renderTarget = new RenderTexture(depthAttachment)
//}
//PortalDebugRenderOverlay.Instance?.fullscreenOverlay?.mainTexture = this.depthAttachment;
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
context.Submit();
//Debug.Log("Fence support:"+ SystemInfo.supportsGraphicsFence);
//while (!portalsRenderedFence.passed) ;
//Int32[] perPortalPixelCount = new Int32[255];
//portalRenderContext.computeBuffer.GetData(perPortalPixelCount, 0, 0, 255);
//for (int i = 0; i < 5; i++)
//{
// Debug.Log(i + "Portal count: " + perPortalPixelCount[i]);
//}
//portalRenderContext.computeBuffer.SetData(new Int32[255]);
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
if (!renderingData.shadowData.supportsDeepShadowMaps)
{
return;
}
LightData lightData = renderingData.lightData;
int shadowLightIndex = lightData.mainLightIndex;
if (shadowLightIndex == -1)
{
return;
}
VisibleLight shadowLight = lightData.visibleLights[shadowLightIndex];
ShadowData shadowData = renderingData.shadowData;
if (!GetVPMatrix(shadowLight.light))
{
return;
}
if (null == _ResetCompute)
{
_ResetCompute = renderer.GetCompute(ComputeHandle.ResetDeepShadowDataCompute);
KernelResetBuffer = _ResetCompute.FindKernel("KernelResetBuffer");
}
CommandBuffer cmd = CommandBufferPool.Get(k_RenderDeepShadowCaster);
using (new ProfilingSample(cmd, k_RenderDeepShadowCaster))
{
int deepShadowMapsSize = shadowData.deepShadowMapsSize;
int deepShadowMapsDepth = shadowData.deepShadowMapsDepth;
// Reset
cmd.SetComputeBufferParam(_ResetCompute, KernelResetBuffer, "_CountBuffer", _CountBuffer);
cmd.SetComputeBufferParam(_ResetCompute, KernelResetBuffer, "_DataBuffer", _DataBuffer);
cmd.SetComputeIntParam(_ResetCompute, "_DeepShadowMapSize", deepShadowMapsSize);
cmd.SetComputeIntParam(_ResetCompute, "_DeepShadowMapDepth", deepShadowMapsDepth);
cmd.DispatchCompute(_ResetCompute, KernelResetBuffer, deepShadowMapsSize / 8, deepShadowMapsSize / 8, 1);
_Temp = RenderTexture.GetTemporary(deepShadowMapsSize, deepShadowMapsSize, 0, RenderTextureFormat.R8); //Without rt, the second row of the vp matrix is negated
// Cast
SetRenderTarget(cmd, _Temp, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.DontCare,
ClearFlag.Color, Color.black, TextureDimension.Tex2D);
cmd.SetViewport(new Rect(Vector2.zero, Vector2.one * deepShadowMapsSize));
Vector4 shadowBias = ShadowUtils.GetShadowBias(ref shadowLight, shadowLightIndex, ref shadowData, _ProjMatrix, shadowData.deepShadowMapsSize);
ShadowUtils.SetupShadowCasterConstantBuffer(cmd, ref shadowLight, shadowBias);
cmd.SetViewProjectionMatrices(_ViewMatrix, _ProjMatrix);
cmd.SetRandomWriteTarget(1, _CountBuffer);
cmd.SetRandomWriteTarget(2, _DataBuffer);
cmd.SetGlobalInt("_DeepShadowMapSize", deepShadowMapsSize);
cmd.SetGlobalInt("_DeepShadowMapDepth", deepShadowMapsDepth);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
//foreach (var r in _Renderers)
//{
// for (int i = 0, imax = r.sharedMaterials.Length; i < imax; i++)
// {
// cmd.DrawRenderer(r, r.sharedMaterials[i], i, r.sharedMaterials[i].FindPass("DeepShadowCaster"));
// }
//}
ShadowSliceData slice = new ShadowSliceData()
{
offsetX = 0,
offsetY = 0,
resolution = deepShadowMapsSize,
};
cmd.SetGlobalMatrix("_DeepShadowMapsWorldToShadow", _DeepShadowMatrix);
DrawShadowsSettings settings = new DrawShadowsSettings(renderingData.cullResults, shadowLightIndex);
settings.splitData.cullingSphere = _CullingSphere;
cmd.EnableShaderKeyword("_DEEP_SHADOW_CASTER");
cmd.SetGlobalInt("_ShadowCasterZWrite", 0);
ShadowUtils.RenderShadowSlice(cmd, ref context, ref slice, ref settings, _ProjMatrix, _ViewMatrix);
cmd.DisableShaderKeyword("_DEEP_SHADOW_CASTER");
cmd.SetGlobalInt("_ShadowCasterZWrite", 1);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
// For Resolve
SetupDeepShadowMapResolverConstants(cmd, ref shadowData, shadowLight);
cmd.ClearRandomWriteTargets();
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
void RenderAdditionalShadowmapAtlas(ref ScriptableRenderContext context, ref CullingResults cullResults, ref LightData lightData, ref ShadowData shadowData)
{
NativeArray <VisibleLight> visibleLights = lightData.visibleLights;
bool additionalLightHasSoftShadows = false;
// NOTE: Do NOT mix ProfilingScope with named CommandBuffers i.e. CommandBufferPool.Get("name").
// Currently there's an issue which results in mismatched markers.
CommandBuffer cmd = CommandBufferPool.Get();
using (new ProfilingScope(cmd, ProfilingSampler.Get(URPProfileId.AdditionalLightsShadow)))
{
bool anyShadowSliceRenderer = false;
int shadowSlicesCount = m_AdditionalShadowCastingLightIndices.Count;
for (int i = 0; i < shadowSlicesCount; ++i)
{
// we do the shadow strength check here again here because when using
// the uniform array path we might have zero strength shadow lights.
// In that case we need the shadow data buffer but we can skip
// rendering them to shadowmap.
if (!m_UseStructuredBuffer && Mathf.Approximately(m_AdditionalLightsShadowParams[i].x, 0.0f))
{
continue;
}
// Index of the VisibleLight
int shadowLightIndex = m_AdditionalShadowCastingLightIndices[i];
VisibleLight shadowLight = visibleLights[shadowLightIndex];
ShadowSliceData shadowSliceData = m_AdditionalLightSlices[i];
var settings = new ShadowDrawingSettings(cullResults, shadowLightIndex);
Vector4 shadowBias = ShadowUtils.GetShadowBias(ref shadowLight, shadowLightIndex,
ref shadowData, shadowSliceData.projectionMatrix, shadowSliceData.resolution);
ShadowUtils.SetupShadowCasterConstantBuffer(cmd, ref shadowLight, shadowBias);
ShadowUtils.RenderShadowSlice(cmd, ref context, ref shadowSliceData, ref settings);
additionalLightHasSoftShadows |= shadowLight.light.shadows == LightShadows.Soft;
anyShadowSliceRenderer = true;
}
// We share soft shadow settings for main light and additional lights to save keywords.
// So we check here if pipeline supports soft shadows and either main light or any additional light has soft shadows
// to enable the keyword.
// TODO: In PC and Consoles we can upload shadow data per light and branch on shader. That will be more likely way faster.
bool mainLightHasSoftShadows = shadowData.supportsMainLightShadows &&
lightData.mainLightIndex != -1 &&
visibleLights[lightData.mainLightIndex].light.shadows ==
LightShadows.Soft;
bool softShadows = shadowData.supportsSoftShadows &&
(mainLightHasSoftShadows || additionalLightHasSoftShadows);
CoreUtils.SetKeyword(cmd, ShaderKeywordStrings.AdditionalLightShadows, anyShadowSliceRenderer);
CoreUtils.SetKeyword(cmd, ShaderKeywordStrings.SoftShadows, softShadows);
if (anyShadowSliceRenderer)
{
SetupAdditionalLightsShadowReceiverConstants(cmd, ref shadowData, softShadows);
}
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public override void Enable(bool fromInspector)
{
base.Enable(fromInspector);
node = nodeTarget as PreviewNode;
var colorPickerValues = new Label();
colorPickerValues.AddToClassList("Indent");
if (!fromInspector)
{
controlsContainer.Add(colorPickerValues);
// Stop right click when the mouse is over the preview because we use it for light position
previewContainer.RegisterCallback <ContextualMenuPopulateEvent>(e => {
e.StopImmediatePropagation();
}, TrickleDown.TrickleDown);
previewContainer.AddManipulator(new ContextualMenuManipulator(evt => {}));
}
else
{
owner.graph.afterCommandBufferExecuted += UpdateViewData;
controlsContainer.RegisterCallback <DetachFromPanelEvent>(e => {
owner.graph.afterCommandBufferExecuted -= UpdateViewData;
});
var histogram = new HistogramView(node.histogramData, owner);
controlsContainer.Add(histogram);
}
void UpdateViewData()
{
if (node.output != null)
{
// Update histogram
var cmd = CommandBufferPool.Get("Update Histogram");
HistogramUtility.ComputeHistogram(cmd, node.output, node.histogramData);
Graphics.ExecuteCommandBuffer(cmd);
// Update color picker data
UpdateColorPickerValues();
}
}
void UpdateColorPickerValues()
{
int texturePosX = Mathf.RoundToInt(node.mousePosition.x * node.output.width);
int texturePosY = Mathf.RoundToInt(node.mousePosition.y * node.output.height);
texturePosX = Mathf.Clamp(texturePosX, 0, node.output.width - 1);
texturePosY = Mathf.Clamp(texturePosY, 0, node.output.height - 1);
var a = AsyncGPUReadback.Request(node.output, 0, texturePosX, 1, texturePosY, 1, 0, 1, (data) => {
var colors = data.GetData <Color>();
if (data.hasError || colors.Length == 0)
{
return;
}
var pixel = colors[0];
colorPickerValues.text = $"R: {pixel.r:F3} G: {pixel.g:F3} B: {pixel.b:F3} A: {pixel.a:F3}";
});
schedule.Execute(() => {
a.Update();
}).Until(() => a.done);
}
var preview = previewContainer.Q("ImGUIPreview");
preview.RegisterCallback <MouseMoveEvent>(e => {
var localPos = GetPreviewMousePositionRatio(e.mousePosition);
node.mousePosition = localPos;
UpdateColorPickerValues();
if (e.imguiEvent.button == 1)
{
NotifyNodeChanged();
node.lightPosition = (new Vector2(localPos.x, 1 - localPos.y) * 2 - Vector2.one) * node.tiling;
}
});
// TODO: add source mip slider
UpdateViewData();
UpdateColorPickerValues();
}
protected override void Render(ScriptableRenderContext RenderContext, Camera[] Views)
{
//Init FrameContext
GPUScene.Gather(GetWorld().GetMeshBatchColloctor(), true);
//Debug.Log("X : " + Screen.width + "__" + "Y : " + Screen.height);
RTHandles.Initialize(Screen.width, Screen.height, false, MSAASamples.None);
//Render Pipeline
BeginFrameRendering(RenderContext, Views);
for (int ViewIndex = 0; ViewIndex < Views.Length; ViewIndex++)
{
//Init View
Camera View = Views[ViewIndex];
CommandBuffer CmdBuffer = CommandBufferPool.Get("");
CameraComponent HDView = View.GetComponent <CameraComponent>();
//Render View
BeginCameraRendering(RenderContext, View);
{
using (new ProfilingScope(CmdBuffer, HDView ? HDView.ViewProfiler : ProfilingSampler.Get(ERGProfileId.InfinityRenderer)))
{
#region InitViewContext
bool bSceneView = View.cameraType == CameraType.SceneView;
bool bRendererView = View.cameraType == CameraType.Game || View.cameraType == CameraType.Reflection || View.cameraType == CameraType.SceneView;
#if UNITY_EDITOR
if (bSceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(View);
}
#endif
VFXManager.PrepareCamera(View);
ViewUnifrom.UnpateBufferData(false, View);
ViewUnifrom.BindGPUParameter(CmdBuffer);
RenderContext.SetupCameraProperties(View);
VFXManager.ProcessCameraCommand(View, CmdBuffer);
//Culling Context
FCullingData CullingData = new FCullingData();
{ CullingData.bRendererView = bRendererView; }
ScriptableCullingParameters CullingParameters;
View.TryGetCullingParameters(out CullingParameters);
CullingResults CullingResult = RenderContext.Cull(ref CullingParameters); //Unity Culling
RenderContext.DispatchCull(GPUScene, ref CullingParameters, ref CullingData); //Infinity Culling
#endregion //InitViewContext
#region InitViewCommand
RenderOpaqueDepth(View, CullingData, CullingResult);
RenderOpaqueGBuffer(View, CullingData, CullingResult);
RenderOpaqueMotion(View, CullingData, CullingResult);
RenderOpaqueForward(View, CullingData, CullingResult);
RenderSkyBox(View);
RenderGizmo(View, GizmoSubset.PostImageEffects);
RenderPresentView(View, GraphBuilder.ScopeTexture(InfinityShaderIDs.DiffuseBuffer), View.targetTexture);
#endregion //InitViewCommand
#region ExecuteViewRender
GraphBuilder.Execute(RenderContext, GetWorld(), CmdBuffer, ViewUnifrom.FrameIndex);
#endregion //ExecuteViewRender
#region ReleaseViewContext
CullingData.Release();
ViewUnifrom.UnpateBufferData(true, View);
#endregion //ReleaseViewContext
}
}
EndCameraRendering(RenderContext, View);
//Submit View
RenderContext.ExecuteCommandBuffer(CmdBuffer);
CommandBufferPool.Release(CmdBuffer);
RenderContext.Submit();
}
EndFrameRendering(RenderContext, Views);
//Release FrameContext
GPUScene.Release();
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
if (containerVis == null)
{
return;
}
var cmd = CommandBufferPool.Get(k_CloudWithGodRayPass);
using (new ProfilingScope(cmd, profilingSampler))
{
var pos = containerVis.transform.position;
var halfSize = containerVis.transform.lossyScale / 2.0f;
cloudMaterial.SetVector(BoundsMin_ID, value: pos - halfSize);
cloudMaterial.SetVector(BoundsMax_ID, pos + halfSize);
cloudMaterial.SetTexture(NoiseTex_ID, shapeTexture);
cloudMaterial.SetTexture(NoiseDetail3D_ID, detailTexture);
cloudMaterial.SetTexture(WeatherMap_ID, weatherMap);
cloudMaterial.SetTexture(MaskNoise_ID, maskNoise);
cloudMaterial.SetTexture(BlueNoise_ID, blueNoise);
Vector4 screenUV = new Vector4(1, 1, 0, 0);
if (blueNoise != null)
{
screenUV.x = (float)cameraTextureDescriptor.width / blueNoise.width;
screenUV.y = (float)cameraTextureDescriptor.height / blueNoise.height;
}
cloudMaterial.SetVector(BlueNoiseCoords_ID, screenUV);
cloudMaterial.SetFloat(ShapeTiling_ID, cloudSettings.shapeTiling.value);
cloudMaterial.SetFloat(DetailTiling_ID, cloudSettings.detailTiling.value);
cloudMaterial.SetFloat(Step_ID, cloudSettings.step.value);
cloudMaterial.SetFloat(RayStep_ID, cloudSettings.rayStep.value);
cloudMaterial.SetFloat(DensityOffset_ID, cloudSettings.densityOffset.value);
cloudMaterial.SetFloat(DensityMultiplier_ID, cloudSettings.densityMultiplier.value);
cloudMaterial.SetColor(ColA_ID, cloudSettings.colA.value);
cloudMaterial.SetColor(ColB_ID, cloudSettings.colB.value);
cloudMaterial.SetFloat(ColorOffset1_ID, cloudSettings.colorOffset1.value);
cloudMaterial.SetFloat(ColorOffset2_ID, cloudSettings.colorOffset2.value);
cloudMaterial.SetFloat(LightAbsorptionTowardSun_ID,
cloudSettings.lightAbsorptionTowardSun.value);
cloudMaterial.SetFloat(LightAbsorptionThroughCloud_ID,
cloudSettings.lightAbsorptionThroughCloud.value);
cloudMaterial.SetFloat(DarknessThreshold_ID,
cloudSettings.darknessThreshold.value);
cloudMaterial.SetFloat(RayOffsetStrength_ID, cloudSettings.rayOffsetStrength.value);
cloudMaterial.SetVector(PhaseParams_ID, cloudSettings.phaseParams.value);
cloudMaterial.SetVector(XY_Speed_ZW_Warp_ID, cloudSettings.xy_Speed_zw_Warp.value);
cloudMaterial.SetVector(ShapeNoiseWeights_ID, cloudSettings.shapeNoiseWeights.value);
cloudMaterial.SetFloat(HeightWeights_ID, cloudSettings.heightWeights.value);
cloudMaterial.SetFloat(DetailWeights_ID, cloudSettings.detailWeights.value);
cloudMaterial.SetFloat(DetailNoiseWeight_ID, cloudSettings.detailNoiseWeight.value);
cloudMaterial.SetVector(DetailNoiseWeights_ID, cloudSettings.detailNoiseWeights.value);
//URP 7.5.3之后 cameraData.GetGPUProjectionMatrix() 进行y翻转
var cameraData = renderingData.cameraData;
if (cameraData.IsCameraProjectionMatrixFlipped())
{
Matrix4x4 viewAndProjectionMatrix = GL.GetGPUProjectionMatrix(cameraData.GetProjectionMatrix(), false) * cameraData.GetViewMatrix();
Matrix4x4 inverseViewProjection = Matrix4x4.Inverse(viewAndProjectionMatrix);
cmd.SetGlobalMatrix(inverseViewAndProjectionMatrix, inverseViewProjection);
}
//降深度采样
cmd.GetTemporaryRT(DownsampleDepthTex_ID
, cameraTextureDescriptor.width / cloudSettings.downsample.value
, cameraTextureDescriptor.height / cloudSettings.downsample.value
, 0, FilterMode.Point, RenderTextureFormat.R16);
cmd.SetRenderTarget(DownsampleDepthTex_RTI, RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.Store);
CoreUtils.DrawFullScreen(cmd, cloudMaterial, null, 1);
cmd.SetGlobalTexture(DownsampleDepthTex_ID, DownsampleDepthTex_RTI);
//降cloud分辨率 并使用第1个pass 渲染云
cmd.GetTemporaryRT(DownsampleColorTex_ID
, cameraTextureDescriptor.width / cloudSettings.downsample.value
, cameraTextureDescriptor.height / cloudSettings.downsample.value
, 0, FilterMode.Point, RenderTextureFormat.ARGB32);
cmd.SetRenderTarget(DownsampleColorTex_RTI, RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.Store);
CoreUtils.DrawFullScreen(cmd, cloudMaterial, null, 0);
//降分辨率后的云设置回_DownsampleColor
cmd.SetGlobalTexture(DownsampleColorTex_ID, DownsampleColorTex_RTI);
//使用第2个Pass 合成
cmd.SetRenderTarget(CameraColorTex_RTI);
CoreUtils.DrawFullScreen(cmd, cloudMaterial, null, 2);
cmd.ReleaseTemporaryRT(DownsampleDepthTex_ID);
cmd.ReleaseTemporaryRT(DownsampleColorTex_ID);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
private bool RenderShadows(ref CullResults cullResults, ref VisibleLight shadowLight, int shadowLightIndex, ref ScriptableRenderContext context)
{
m_ShadowCasterCascadesCount = m_ShadowSettings.directionalLightCascadeCount;
if (shadowLight.lightType == LightType.Spot)
{
m_ShadowCasterCascadesCount = 1;
}
int shadowResolution = GetMaxTileResolutionInAtlas(m_ShadowSettings.shadowAtlasWidth, m_ShadowSettings.shadowAtlasHeight, m_ShadowCasterCascadesCount);
Bounds bounds;
if (!cullResults.GetShadowCasterBounds(shadowLightIndex, out bounds))
{
return(false);
}
var setRenderTargetCommandBuffer = CommandBufferPool.Get();
setRenderTargetCommandBuffer.name = "Render packed shadows";
setRenderTargetCommandBuffer.GetTemporaryRT(m_ShadowMapProperty, m_ShadowSettings.shadowAtlasWidth,
m_ShadowSettings.shadowAtlasHeight, kShadowDepthBufferBits, FilterMode.Bilinear, RenderTextureFormat.Depth);
setRenderTargetCommandBuffer.SetRenderTarget(m_ShadowMapRTID);
setRenderTargetCommandBuffer.ClearRenderTarget(true, true, Color.black);
context.ExecuteCommandBuffer(setRenderTargetCommandBuffer);
CommandBufferPool.Release(setRenderTargetCommandBuffer);
float shadowNearPlane = m_Asset.ShadowNearOffset;
Vector3 splitRatio = m_ShadowSettings.directionalLightCascades;
Matrix4x4 view, proj;
var settings = new DrawShadowsSettings(cullResults, shadowLightIndex);
bool needRendering = false;
if (shadowLight.lightType == LightType.Spot)
{
needRendering = cullResults.ComputeSpotShadowMatricesAndCullingPrimitives(shadowLightIndex, out view, out proj,
out settings.splitData);
if (!needRendering)
{
return(false);
}
SetupShadowSliceTransform(0, shadowResolution, proj, view);
RenderShadowSlice(ref context, 0, proj, view, settings);
}
else if (shadowLight.lightType == LightType.Directional)
{
for (int cascadeIdx = 0; cascadeIdx < m_ShadowCasterCascadesCount; ++cascadeIdx)
{
needRendering = cullResults.ComputeDirectionalShadowMatricesAndCullingPrimitives(shadowLightIndex,
cascadeIdx, m_ShadowCasterCascadesCount, splitRatio, shadowResolution, shadowNearPlane, out view, out proj,
out settings.splitData);
m_DirectionalShadowSplitDistances[cascadeIdx] = settings.splitData.cullingSphere;
m_DirectionalShadowSplitDistances[cascadeIdx].w *= settings.splitData.cullingSphere.w;
if (!needRendering)
{
return(false);
}
SetupShadowSliceTransform(cascadeIdx, shadowResolution, proj, view);
RenderShadowSlice(ref context, cascadeIdx, proj, view, settings);
}
}
else
{
Debug.LogWarning("Only spot and directional shadow casters are supported in lightweight pipeline");
return(false);
}
return(true);
}
private void BeginForwardRendering(ref ScriptableRenderContext context, bool stereoEnabled)
{
if (stereoEnabled)
{
context.StartMultiEye(m_CurrCamera);
}
var cmd = CommandBufferPool.Get("SetCameraRenderTarget");
if (m_RenderToIntermediateTarget)
{
if (m_CurrCamera.activeTexture == null)
{
m_IntermediateTextureArray = false;
if (stereoEnabled)
{
RenderTextureDescriptor xrDesc = XRSettings.eyeTextureDesc;
xrDesc.depthBufferBits = kCameraDepthBufferBits;
xrDesc.colorFormat = m_ColorFormat;
xrDesc.msaaSamples = m_Asset.MSAASampleCount;
m_IntermediateTextureArray = (xrDesc.dimension == TextureDimension.Tex2DArray);
cmd.GetTemporaryRT(m_CameraRTProperty, xrDesc, FilterMode.Bilinear);
}
else
{
cmd.GetTemporaryRT(m_CameraRTProperty, Screen.width, Screen.height, kCameraDepthBufferBits,
FilterMode.Bilinear, m_ColorFormat, RenderTextureReadWrite.Default, m_Asset.MSAASampleCount);
}
if (m_IntermediateTextureArray)
{
cmd.SetRenderTarget(m_CameraRTID, 0, CubemapFace.Unknown, -1);
}
else
{
cmd.SetRenderTarget(m_CameraRTID);
}
}
else
{
cmd.SetRenderTarget(new RenderTargetIdentifier(m_CurrCamera.activeTexture));
}
}
else
{
cmd.SetRenderTarget(BuiltinRenderTextureType.CurrentActive);
}
// Clear RenderTarget to avoid tile initialization on mobile GPUs
// https://community.arm.com/graphics/b/blog/posts/mali-performance-2-how-to-correctly-handle-framebuffers
if (m_CurrCamera.clearFlags != CameraClearFlags.Nothing)
{
bool clearDepth = (m_CurrCamera.clearFlags != CameraClearFlags.Nothing);
bool clearColor = (m_CurrCamera.clearFlags == CameraClearFlags.Color);
cmd.ClearRenderTarget(clearDepth, clearColor, m_CurrCamera.backgroundColor);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
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();
}
private void SetupShaderLightListConstants(VisibleLight[] lights, ref LightData lightData, ref ScriptableRenderContext context)
{
int maxLights = Math.Min(kMaxVisibleLights, lights.Length);
for (int i = 0; i < maxLights; ++i)
{
VisibleLight currLight = lights [i];
if (currLight.lightType == LightType.Directional)
{
Vector4 dir = -currLight.localToWorld.GetColumn(2);
m_LightPositions [i] = new Vector4(dir.x, dir.y, dir.z, 0.0f);
}
else
{
Vector4 pos = currLight.localToWorld.GetColumn(3);
m_LightPositions [i] = new Vector4(pos.x, pos.y, pos.z, 1.0f);
}
m_LightColors[i] = currLight.finalColor;
float rangeSq = currLight.range * currLight.range;
float quadAtten = (currLight.lightType == LightType.Directional) ? 0.0f : 25.0f / rangeSq;
if (currLight.lightType == LightType.Spot)
{
Vector4 dir = currLight.localToWorld.GetColumn(2);
m_LightSpotDirections [i] = new Vector4(-dir.x, -dir.y, -dir.z, 0.0f);
float spotAngle = Mathf.Deg2Rad * currLight.spotAngle;
float cosOuterAngle = Mathf.Cos(spotAngle * 0.5f);
float cosInneAngle = Mathf.Cos(spotAngle * 0.25f);
float angleRange = cosInneAngle - cosOuterAngle;
m_LightAttenuations [i] = new Vector4(cosOuterAngle,
Mathf.Approximately(angleRange, 0.0f) ? 1.0f : angleRange, quadAtten, rangeSq);
}
else
{
m_LightSpotDirections [i] = new Vector4(0.0f, 0.0f, 1.0f, 0.0f);
m_LightAttenuations [i] = new Vector4(-1.0f, 1.0f, quadAtten, rangeSq);
}
}
// Lightweight pipeline only upload kMaxVisibleLights to shader cbuffer.
// We tell the pipe to disable remaining lights by setting it to -1.
int[] lightIndexMap = m_CullResults.GetLightIndexMap();
for (int i = kMaxVisibleLights; i < lightIndexMap.Length; ++i)
{
lightIndexMap[i] = -1;
}
m_CullResults.SetLightIndexMap(lightIndexMap);
CommandBuffer cmd = CommandBufferPool.Get("SetupShadowShaderConstants");
cmd.SetGlobalVector("globalLightCount", new Vector4(lightData.pixelLightsCount, lightData.vertexLightsCount, 0.0f, 0.0f));
cmd.SetGlobalVectorArray("globalLightPos", m_LightPositions);
cmd.SetGlobalVectorArray("globalLightColor", m_LightColors);
cmd.SetGlobalVectorArray("globalLightAtten", m_LightAttenuations);
cmd.SetGlobalVectorArray("globalLightSpotDir", m_LightSpotDirections);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
/// <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);
}
}
public override void Render(ScriptableRenderContext context, ref MyRenderingData renderingData)
{
if (!asset.enablePass)
{
return;
}
if (renderingData.camera.cameraType == CameraType.Preview)
{
return;
}
if (!asset.material || !screenMesh)
{
return;
}
var cmd = CommandBufferPool.Get(k_profilingTag);
using (new ProfilingScope(cmd, profilingSampler))
{
if (curlNoiseMotionRenderer != null)
{
//不运行
var buffer = curlNoiseMotionRenderer.Update(cmd);
cmd.SetGlobalBuffer("_MotionPosBuffer", buffer);
var size = curlNoiseMotionRenderer.size;
cmd.SetGlobalVector("_MotionPosBufferSize", new Vector3(size.x, size.y, size.z));
}
cmd.SetGlobalVector("_WorldCameraPos", renderingData.camera.transform.position);
cmd.SetGlobalVector("_CameraClipPlane",
new Vector3(renderingData.camera.nearClipPlane, renderingData.camera.farClipPlane,
renderingData.camera.farClipPlane - renderingData.camera.nearClipPlane));
cmd.SetGlobalMatrix("_ViewProjectionInverseMatrix",
RenderUtils.ProjectionToWorldMatrix(renderingData.camera));
//Resources.FindObjectsOfTypeAll 在内存中的资源
var curlNoiseMotion = Resources.FindObjectsOfTypeAll <CurlNoiseMotion2D>().FirstOrDefault();
if (curlNoiseMotion)
{
cmd.SetGlobalTexture("_CurlNoiseMotionTex", curlNoiseMotion.currentMotionTexture);
}
if (asset.drawFullScreen)
{
cmd.DrawMesh(screenMesh, RenderUtils.ProjectionToWorldMatrix(renderingData.camera), asset.material,
0,
0);
}
else
{
//美术效果不是很好 而且有问题算了
var cubes = Object.FindObjectsOfType <VolumetricCloudCube>();
foreach (var cube in cubes)
{
cmd.SetGlobalVector("_CubeSize", cube.transform.localScale);
cmd.SetGlobalVector("_CubePos", cube.transform.position);
cmd.DrawRenderer(cube.GetComponent <MeshRenderer>(), asset.material, 0, 1);
}
}
}
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CommandBufferPool.Release(cmd);
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
if (m_CopyDepthMaterial == null)
{
Debug.LogErrorFormat("Missing {0}. {1} render pass will not execute. Check for missing reference in the renderer resources.", m_CopyDepthMaterial, GetType().Name);
return;
}
CommandBuffer cmd = CommandBufferPool.Get();
using (new ProfilingScope(cmd, ProfilingSampler.Get(URPProfileId.CopyDepth)))
{
RenderTextureDescriptor descriptor = renderingData.cameraData.cameraTargetDescriptor;
int cameraSamples = descriptor.msaaSamples;
CameraData cameraData = renderingData.cameraData;
switch (cameraSamples)
{
case 8:
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa2);
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa4);
cmd.EnableShaderKeyword(ShaderKeywordStrings.DepthMsaa8);
break;
case 4:
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa2);
cmd.EnableShaderKeyword(ShaderKeywordStrings.DepthMsaa4);
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa8);
break;
case 2:
cmd.EnableShaderKeyword(ShaderKeywordStrings.DepthMsaa2);
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa4);
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa8);
break;
// MSAA disabled
default:
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa2);
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa4);
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa8);
break;
}
cmd.SetGlobalTexture("_CameraDepthAttachment", source.Identifier());
#if ENABLE_VR && ENABLE_XR_MODULE
// XR uses procedural draw instead of cmd.blit or cmd.DrawFullScreenMesh
if (renderingData.cameraData.xr.enabled)
{
// XR flip logic is not the same as non-XR case because XR uses draw procedure
// and draw procedure does not need to take projection matrix yflip into account
// We y-flip if
// 1) we are bliting from render texture to back buffer and
// 2) renderTexture starts UV at top
// XRTODO: handle scalebias and scalebiasRt for src and dst separately
bool isRenderToBackBufferTarget = destination.Identifier() == cameraData.xr.renderTarget && !cameraData.xr.renderTargetIsRenderTexture;
bool yflip = isRenderToBackBufferTarget && SystemInfo.graphicsUVStartsAtTop;
float flipSign = (yflip) ? -1.0f : 1.0f;
Vector4 scaleBiasRt = (flipSign < 0.0f)
? new Vector4(flipSign, 1.0f, -1.0f, 1.0f)
: new Vector4(flipSign, 0.0f, 1.0f, 1.0f);
cmd.SetGlobalVector(ShaderPropertyId.scaleBiasRt, scaleBiasRt);
cmd.DrawProcedural(Matrix4x4.identity, m_CopyDepthMaterial, 0, MeshTopology.Quads, 4);
}
else
#endif
{
// Blit has logic to flip projection matrix when rendering to render texture.
// Currently the y-flip is handled in CopyDepthPass.hlsl by checking _ProjectionParams.x
// If you replace this Blit with a Draw* that sets projection matrix double check
// to also update shader.
// scaleBias.x = flipSign
// scaleBias.y = scale
// scaleBias.z = bias
// scaleBias.w = unused
float flipSign = (cameraData.IsCameraProjectionMatrixFlipped()) ? -1.0f : 1.0f;
Vector4 scaleBiasRt = (flipSign < 0.0f)
? new Vector4(flipSign, 1.0f, -1.0f, 1.0f)
: new Vector4(flipSign, 0.0f, 1.0f, 1.0f);
cmd.SetGlobalVector(ShaderPropertyId.scaleBiasRt, scaleBiasRt);
cmd.DrawMesh(RenderingUtils.fullscreenMesh, Matrix4x4.identity, m_CopyDepthMaterial);
}
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
void RenderDirectionalCascadeShadowmap(ref ScriptableRenderContext context, ref CullResults cullResults, ref LightData lightData, ref ShadowData shadowData)
{
LightShadows shadowQuality = LightShadows.None;
int shadowLightIndex = lightData.mainLightIndex;
if (shadowLightIndex == -1)
{
return;
}
VisibleLight shadowLight = lightData.visibleLights[shadowLightIndex];
Light light = shadowLight.light;
Debug.Assert(shadowLight.lightType == LightType.Directional);
if (light.shadows == LightShadows.None)
{
return;
}
Bounds bounds;
if (!cullResults.GetShadowCasterBounds(shadowLightIndex, out bounds))
{
return;
}
CommandBuffer cmd = CommandBufferPool.Get(k_RenderDirectionalShadowmapTag);
using (new ProfilingSample(cmd, k_RenderDirectionalShadowmapTag))
{
m_ShadowCasterCascadesCount = shadowData.directionalLightCascadeCount;
int shadowResolution = LightweightShadowUtils.GetMaxTileResolutionInAtlas(shadowData.directionalShadowAtlasWidth, shadowData.directionalShadowAtlasHeight, m_ShadowCasterCascadesCount);
float shadowNearPlane = light.shadowNearPlane;
Matrix4x4 view, proj;
var settings = new DrawShadowsSettings(cullResults, shadowLightIndex);
m_DirectionalShadowmapTexture = RenderTexture.GetTemporary(shadowData.directionalShadowAtlasWidth,
shadowData.directionalShadowAtlasHeight, k_ShadowmapBufferBits, m_ShadowmapFormat);
m_DirectionalShadowmapTexture.filterMode = FilterMode.Bilinear;
m_DirectionalShadowmapTexture.wrapMode = TextureWrapMode.Clamp;
SetRenderTarget(cmd, m_DirectionalShadowmapTexture, RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.Store, ClearFlag.Depth, Color.black, TextureDimension.Tex2D);
bool success = false;
for (int cascadeIndex = 0; cascadeIndex < m_ShadowCasterCascadesCount; ++cascadeIndex)
{
success = LightweightShadowUtils.ExtractDirectionalLightMatrix(ref cullResults, ref shadowData, shadowLightIndex, cascadeIndex, shadowResolution, shadowNearPlane, out m_CascadeSplitDistances[cascadeIndex], out m_CascadeSlices[cascadeIndex], out view, out proj);
if (success)
{
LightweightShadowUtils.SetupShadowCasterConstants(cmd, ref shadowLight, proj, shadowResolution);
LightweightShadowUtils.RenderShadowSlice(cmd, ref context, ref m_CascadeSlices[cascadeIndex], proj,
view, settings);
}
}
if (success)
{
shadowQuality = (shadowData.supportsSoftShadows) ? light.shadows : LightShadows.Hard;
SetupDirectionalShadowReceiverConstants(cmd, ref shadowData, shadowLight);
}
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
// TODO: We should have RenderingData as a readonly but currently we need this to pass shadow rendering to litpass
shadowData.renderedDirectionalShadowQuality = shadowQuality;
}
// Here you can implement the rendering logic.
// Use <c>ScriptableRenderContext</c> to issue drawing commands or execute command buffers
// https://docs.unity3d.com/ScriptReference/Rendering.ScriptableRenderContext.html
// You don't have to call ScriptableRenderContext.submit, the render pipeline will call it at specific points in the pipeline.
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
var cmd = CommandBufferPool.Get(profilerSampler.name);
renderBounds = StylizedGrassRenderer.Instance.bounds;
frustrumPlanes = GeometryUtility.CalculateFrustumPlanes(StylizedGrassRenderer.Instance.renderCam);
using (new ProfilingScope(cmd, profilerSampler))
{
foreach (KeyValuePair <int, List <GrassBender> > layer in StylizedGrassRenderer.GrassBenders)
{
foreach (GrassBender b in layer.Value)
{
if (b.enabled == false)
{
continue;
}
props.SetVector("_Params", new Vector4(b.strength, b.heightOffset, b.pushStrength, b.scaleMultiplier));
if (b.benderType == GrassBenderBase.BenderType.Trail)
{
if (!b.trailRenderer)
{
continue;
}
if (!b.trailRenderer.emitting)
{
continue;
}
if (!GeometryUtility.TestPlanesAABB(frustrumPlanes, b.trailRenderer.bounds))
{
continue;
}
m_TrailRenderer = b.trailRenderer;
m_TrailRenderer.SetPropertyBlock(props);
//Trail
m_TrailRenderer.emitting = b.gameObject.activeInHierarchy;
m_TrailRenderer.generateLightingData = true;
m_TrailRenderer.widthMultiplier = b.trailRadius;
m_TrailRenderer.time = b.trailLifetime;
m_TrailRenderer.minVertexDistance = b.trailAccuracy;
m_TrailRenderer.widthCurve = b.widthOverLifetime;
m_TrailRenderer.colorGradient = GrassBenderBase.GetGradient(b.strengthOverLifetime);
//If disabled, temporarly enable in order to bake mesh
trailEnabled = m_TrailRenderer.enabled ? true : false;
if (!trailEnabled)
{
m_TrailRenderer.enabled = true;
}
if (b.bakedMesh == null)
{
b.bakedMesh = new Mesh();
}
m_TrailRenderer.BakeMesh(b.bakedMesh, renderingData.cameraData.camera, false);
cmd.DrawMesh(b.bakedMesh, Matrix4x4.identity, GrassBenderBase.TrailMaterial, 0, 0, props);
//Note: Faster, but crashed when trails are disabled (Case 1200430)
//cmd.DrawRenderer(m_TrailRenderer, GrassBenderBase.TrailMaterial, 0, 0);
if (!trailEnabled)
{
m_TrailRenderer.enabled = false;
}
//trailMesh.Clear();
}
if (b.benderType == GrassBenderBase.BenderType.ParticleSystem)
{
if (!b.particleSystem)
{
continue;
}
if (!GeometryUtility.TestPlanesAABB(frustrumPlanes, b.particleRenderer.bounds))
{
continue;
}
m_ParticleRenderer = b.particleRenderer;
m_ParticleRenderer.SetPropertyBlock(props);
var grad = b.particleSystem.colorOverLifetime;
grad.enabled = true;
grad.color = GrassBenderBase.GetGradient(b.strengthOverLifetime);
bool localSpace = b.particleSystem.main.simulationSpace == ParticleSystemSimulationSpace.Local;
//Note: DrawRenderes with particle systems appear to be broken. Only renders to scene cam when it redraws. Bake the mesh down and render it instead.
//Todo: Create repo project and file bug report.
//cmd.DrawRenderer(m_ParticleRenderer, m_Material, 0, 0);
if (!b.bakedMesh)
{
b.bakedMesh = new Mesh();
}
m_ParticleRenderer.BakeMesh(b.bakedMesh, renderingData.cameraData.camera);
cmd.DrawMesh(b.bakedMesh, localSpace ? m_ParticleRenderer.localToWorldMatrix : Matrix4x4.identity, GrassBenderBase.MeshMaterial, 0, b.alphaBlending ? 1 : 0, props);
//Also draw particle trails
if (b.hasParticleTrails)
{
if (!b.particleTrailMesh)
{
b.particleTrailMesh = new Mesh();
}
m_ParticleRenderer.BakeTrailsMesh(b.particleTrailMesh, renderingData.cameraData.camera);
cmd.DrawMesh(b.particleTrailMesh, m_ParticleRenderer.localToWorldMatrix, GrassBenderBase.TrailMaterial, 1, 0, props);
//cmd.DrawRenderer(m_ParticleRenderer, GrassBenderBase.TrailMaterial, 1, 0);
}
}
if (b.benderType == GrassBenderBase.BenderType.Mesh)
{
if (!b.meshRenderer)
{
continue;
}
if (!GeometryUtility.TestPlanesAABB(frustrumPlanes, b.meshRenderer.bounds))
{
continue;
}
m_MeshRenderer = b.meshRenderer;
m_MeshRenderer.SetPropertyBlock(props);
cmd.DrawRenderer(m_MeshRenderer, GrassBenderBase.MeshMaterial, 0, b.alphaBlending ? 1 : 0);
}
}
}
//Mask edges of bend area, avoids streaking at edges
if (enableEdgeMasking)
{
cmd.SetGlobalTexture("_BendMapInput", BuiltinRenderTextureType.CurrentActive);
cmd.Blit(BuiltinRenderTextureType.CurrentActive, bendVectorID, m_MaskMat);
cmd.SetGlobalTexture(StylizedGrassRenderer.VECTOR_MAP_PARAM, bendVectorID);
}
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
protected override void Render(ScriptableRenderContext RenderContext, Camera[] RenderCameras)
{
//Gather MeshBatch
NativeList <FMeshBatch> MeshBatchList = GetWorld().GetMeshBatchColloctor().GetMeshBatchList();
//Render Pipeline
BeginFrameRendering(RenderContext, RenderCameras);
foreach (Camera RenderCamera in RenderCameras)
{
RenderCamera.allowHDR = true;
bool isSceneViewCam = RenderCamera.cameraType == CameraType.SceneView;
#if UNITY_EDITOR
if (isSceneViewCam)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(RenderCamera);
}
#endif
//Prepare VisualEffects
VFXManager.PrepareCamera(RenderCamera);
//Prepare ViewUnifrom
ViewUnifrom.UnpateBufferData(false, RenderCamera);
//View RenderFamily
CommandBuffer CmdBuffer = CommandBufferPool.Get("");
//Binding ViewParameter
BeginCameraRendering(RenderContext, RenderCamera);
CmdBuffer.DisableScissorRect();
ViewUnifrom.BindGPUProperty(CmdBuffer);
RenderContext.SetupCameraProperties(RenderCamera);
//Binding VisualEffects
VFXManager.ProcessCameraCommand(RenderCamera, CmdBuffer);
//Culling MeshBatch
NativeArray <FPlane> ViewFrustum = new NativeArray <FPlane>(6, Allocator.Persistent);
NativeArray <FVisibleMeshBatch> VisibleMeshBatchList = new NativeArray <FVisibleMeshBatch>(MeshBatchList.Length, Allocator.TempJob);
Plane[] FrustumPlane = GeometryUtility.CalculateFrustumPlanes(RenderCamera);
for (int PlaneIndex = 0; PlaneIndex < 6; PlaneIndex++)
{
ViewFrustum[PlaneIndex] = FrustumPlane[PlaneIndex];
}
CullMeshBatch CullTask = new CullMeshBatch();
{
CullTask.ViewFrustum = ViewFrustum;
CullTask.ViewOrigin = RenderCamera.transform.position;
CullTask.MeshBatchList = MeshBatchList;
CullTask.VisibleMeshBatchList = VisibleMeshBatchList;
}
JobHandle CullTaskHandle = CullTask.Schedule(MeshBatchList.Length, 256);
/*SortMeshBatch SortTask = new SortMeshBatch();
* {
* SortTask.VisibleMeshBatchList = VisibleMeshBatchList;
* }
* JobHandle SortTaskHandle = SortTask.Schedule(CullTaskHandle);*/
//Culling Context
ScriptableCullingParameters CullingParameter;
RenderCamera.TryGetCullingParameters(out CullingParameter);
CullingResults CullingResult = RenderContext.Cull(ref CullingParameter);
CullTaskHandle.Complete();
//SortTaskHandle.Complete();
//Render Family
RenderOpaqueDepth(RenderCamera, CullingResult);
RenderOpaqueGBuffer(RenderCamera, CullingResult, VisibleMeshBatchList);
RenderOpaqueMotion(RenderCamera, CullingResult);
RenderSkyAtmosphere(RenderCamera);
RenderPresentView(RenderCamera, GraphBuilder.ScopeTexture(InfinityShaderIDs.RT_ThinGBufferA), RenderCamera.targetTexture);
//Draw DrawGizmos
#if UNITY_EDITOR
if (Handles.ShouldRenderGizmos())
{
RenderGizmo(RenderCamera, GizmoSubset.PostImageEffects);
}
#endif
//Execute RenderGraph
GraphBuilder.Execute(RenderContext, GetWorld(), CmdBuffer, ViewUnifrom.FrameIndex);
EndCameraRendering(RenderContext, RenderCamera);
//Execute ViewRender
RenderContext.ExecuteCommandBuffer(CmdBuffer);
CommandBufferPool.Release(CmdBuffer);
RenderContext.Submit();
//Prepare ViewUnifrom
ViewUnifrom.UnpateBufferData(true, RenderCamera);
//Release View
ViewFrustum.Dispose();
VisibleMeshBatchList.Dispose();
}
EndFrameRendering(RenderContext, RenderCameras);
}
public static void SetPerCameraShaderVariables(ScriptableRenderContext context, Camera camera, bool renderIntoTexture = true)
{
Rect pixelRect = camera.pixelRect;
float cameraWidth = (float)pixelRect.width;
float cameraHeight = (float)pixelRect.height;
Matrix4x4 projMatrix = GL.GetGPUProjectionMatrix(camera.projectionMatrix, renderIntoTexture);
Matrix4x4 viewMatrix = camera.worldToCameraMatrix;
Matrix4x4 viewProjMatrix = projMatrix * viewMatrix;
Matrix4x4 invViewMatrix = Matrix4x4.Inverse(viewMatrix);
Matrix4x4 invProjectionMatrix = Matrix4x4.Inverse(projMatrix);
Matrix4x4 invViewProjMatrix = Matrix4x4.Inverse(viewProjMatrix);
float projectionFlip = SystemInfo.graphicsUVStartsAtTop ? -1.0f : 1.0f;
float near = camera.nearClipPlane;
float far = camera.farClipPlane;
float invNear = Mathf.Approximately(near, 0.0f) ? 0.0f : 1.0f / near;
float invFar = Mathf.Approximately(far, 0.0f) ? 0.0f : 1.0f / far;
float isOrthographic = camera.orthographic ? 1.0f : 0.0f;
// From http://www.humus.name/temp/Linearize%20depth.txt
// But as depth component textures on OpenGL always return in 0..1 range (as in D3D), we have to use
// the same constants for both D3D and OpenGL here.
// OpenGL would be this:
// zc0 = (1.0 - far / near) / 2.0;
// zc1 = (1.0 + far / near) / 2.0;
// D3D is this:
float zc0 = 1.0f - far * invNear;
float zc1 = far * invNear;
Vector4 zBufferParams = new Vector4(zc0, zc1, zc0 * invFar, zc1 * invFar);
if (SystemInfo.usesReversedZBuffer)
{
zBufferParams.y += zBufferParams.x;
zBufferParams.x = -zBufferParams.x;
zBufferParams.w += zBufferParams.z;
zBufferParams.z = -zBufferParams.z;
}
Vector4 projectionParams = new Vector4(projectionFlip, near, far, 1.0f * invFar);
Vector4 orthoParams = new Vector4(camera.orthographicSize * camera.aspect, camera.orthographicSize, 0.0f, isOrthographic);
CommandBuffer cmd = CommandBufferPool.Get(kPerCameraShaderVariablesTag);
cmd.SetGlobalVector(ShaderBindings.worldSpaceCameraPos, camera.transform.position);
cmd.SetGlobalVector(ShaderBindings.projectionParams, projectionParams);
cmd.SetGlobalVector(ShaderBindings.screenParams, new Vector4(cameraWidth, cameraHeight, 1.0f + 1.0f / cameraWidth, 1.0f + 1.0f / cameraHeight));
cmd.SetGlobalVector(ShaderBindings.screenSize, new Vector4(cameraWidth, cameraHeight, 1.0f / cameraWidth, 1.0f / cameraHeight));
cmd.SetGlobalVector(ShaderBindings.zBufferParams, zBufferParams);
cmd.SetGlobalVector(ShaderBindings.orthoParams, orthoParams);
// TODO: missing unity_CameraWorldClipPlanes[6], currently set by context.SetupCameraProperties
cmd.SetGlobalMatrix(ShaderBindings.matrixV, viewMatrix);
cmd.SetGlobalMatrix(ShaderBindings.matrixP, projMatrix);
cmd.SetGlobalMatrix(ShaderBindings.matrixVP, viewProjMatrix);
cmd.SetGlobalMatrix(ShaderBindings.matrixIV, invViewMatrix);
cmd.SetGlobalMatrix(ShaderBindings.matrixIP, viewMatrix);
cmd.SetGlobalMatrix(ShaderBindings.matrixIVP, invViewProjMatrix);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
// NOTE: Do NOT mix ProfilingScope with named CommandBuffers i.e. CommandBufferPool.Get("name").
// Currently there's an issue which results in mismatched markers.
CommandBuffer cmd = CommandBufferPool.Get();
using (new ProfilingScope(cmd, m_ProfilingSampler))
{
// Global render pass data containing various settings.
// x,y,z are currently unused
// w is used for knowing whether the object is opaque(1) or alpha blended(0)
Vector4 drawObjectPassData = new Vector4(0.0f, 0.0f, 0.0f, (m_IsOpaque) ? 1.0f : 0.0f);
cmd.SetGlobalVector(s_DrawObjectPassDataPropID, drawObjectPassData);
// scaleBias.x = flipSign
// scaleBias.y = scale
// scaleBias.z = bias
// scaleBias.w = unused
float flipSign = (renderingData.cameraData.IsCameraProjectionMatrixFlipped()) ? -1.0f : 1.0f;
Vector4 scaleBias = (flipSign < 0.0f)
? new Vector4(flipSign, 1.0f, -1.0f, 1.0f)
: new Vector4(flipSign, 0.0f, 1.0f, 1.0f);
cmd.SetGlobalVector(ShaderPropertyId.scaleBiasRt, scaleBias);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
Camera camera = renderingData.cameraData.camera;
var sortFlags = (m_IsOpaque) ? renderingData.cameraData.defaultOpaqueSortFlags : SortingCriteria.CommonTransparent;
if (renderingData.cameraData.renderer.useDepthPriming && m_IsOpaque && (renderingData.cameraData.renderType == CameraRenderType.Base || renderingData.cameraData.clearDepth))
{
sortFlags = SortingCriteria.SortingLayer | SortingCriteria.RenderQueue | SortingCriteria.OptimizeStateChanges | SortingCriteria.CanvasOrder;
}
var filterSettings = m_FilteringSettings;
#if UNITY_EDITOR
// When rendering the preview camera, we want the layer mask to be forced to Everything
if (renderingData.cameraData.isPreviewCamera)
{
filterSettings.layerMask = -1;
}
#endif
DrawingSettings drawSettings = CreateDrawingSettings(m_ShaderTagIdList, ref renderingData, sortFlags);
var activeDebugHandler = GetActiveDebugHandler(renderingData);
if (activeDebugHandler != null)
{
activeDebugHandler.DrawWithDebugRenderState(context, cmd, ref renderingData, ref drawSettings, ref filterSettings, ref m_RenderStateBlock,
(ScriptableRenderContext ctx, ref RenderingData data, ref DrawingSettings ds, ref FilteringSettings fs, ref RenderStateBlock rsb) =>
{
ctx.DrawRenderers(data.cullResults, ref ds, ref fs, ref rsb);
});
}
else
{
context.DrawRenderers(renderingData.cullResults, ref drawSettings, ref filterSettings, ref m_RenderStateBlock);
// Render objects that did not match any shader pass with error shader
RenderingUtils.RenderObjectsWithError(context, ref renderingData.cullResults, camera, filterSettings, SortingCriteria.None);
}
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public override void Enable(bool fromInspector)
{
levelsNode = nodeTarget as Levels;
base.Enable(fromInspector);
var slider = new MinMaxSlider("Luminance", levelsNode.min, levelsNode.max, 0, 1);
sliders.Add(slider);
slider.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Changed Luminance remap");
levelsNode.min = e.newValue.x;
levelsNode.max = e.newValue.y;
foreach (var s in sliders)
{
if (s != null && s.parent != null)
{
s.SetValueWithoutNotify(e.newValue);
}
}
NotifyNodeChanged();
});
controlsContainer.Add(slider);
var mode = this.Q <EnumField>();
mode.RegisterValueChangedCallback((m) => {
UpdateMinMaxSliderVisibility((Levels.Mode)m.newValue);
});
UpdateMinMaxSliderVisibility(levelsNode.mode);
// Compute histogram only when the inspector is selected
if (fromInspector)
{
owner.graph.afterCommandBufferExecuted += UpdateHistogram;
controlsContainer.RegisterCallback <DetachFromPanelEvent>(e => {
owner.graph.afterCommandBufferExecuted -= UpdateHistogram;
});
}
void UpdateHistogram()
{
if (levelsNode.output != null)
{
var cmd = CommandBufferPool.Get("Update Histogram");
HistogramUtility.ComputeHistogram(cmd, levelsNode.output, levelsNode.histogramData);
Graphics.ExecuteCommandBuffer(cmd);
}
}
UpdateHistogram();
void UpdateMinMaxSliderVisibility(Levels.Mode mode)
{
if (mode == Levels.Mode.Automatic)
{
slider.style.display = DisplayStyle.None;
}
else
{
slider.style.display = DisplayStyle.Flex;
}
}
if (fromInspector)
{
var histogram = new HistogramView(levelsNode.histogramData, owner);
controlsContainer.Add(histogram);
}
}
public static void RenderSingleCamera(LightweightRenderPipeline 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;
}
CommandBuffer cmd = CommandBufferPool.Get(k_RenderCameraTag);
using (new ProfilingSample(cmd, k_RenderCameraTag))
{
CameraData cameraData;
PipelineSettings settings = pipelineInstance.settings;
ScriptableRenderer renderer = pipelineInstance.renderer;
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);
RenderingData renderingData;
InitializeRenderingData(settings, ref cameraData, ref cullResults,
renderer.maxVisibleAdditionalLights, renderer.maxPerObjectAdditionalLights, 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 Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
CommandBuffer cmd = CommandBufferPool.Get(_kRenderOITTag);
using (new ProfilingSample(cmd, _kRenderOITTag))
{
cmd.GetTemporaryRT(_B0Handle.id, _DescriptorFloat);
cmd.GetTemporaryRT(_B1Handle.id, _DescriptorFloat4);
if (MomentsCount._8 == _MomentsCount)
{
cmd.GetTemporaryRT(_B2Handle.id, _DescriptorFloat4);
}
else if (MomentsCount._6 == _MomentsCount)
{
cmd.GetTemporaryRT(_B2Handle.id, _DescriptorFloat2);
}
CoreUtils.SetKeyword(cmd, "_MOMENT6", MomentsCount._6 == _MomentsCount);
CoreUtils.SetKeyword(cmd, "_MOMENT8", MomentsCount._8 == _MomentsCount);
CoreUtils.SetKeyword(cmd, "_MOMENT_HALF_PRECISION", FloatPrecision._Half == _MomentsPrecision);
CoreUtils.SetKeyword(cmd, "_TRIGONOMETRIC", _Trigonometric);
cmd.SetRenderTarget(_GMBinding);
cmd.ClearRenderTarget(false, true, Color.black);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
Vector2 logViewDepthMinDelta = new Vector2(Mathf.Log(_ViewDepthMinMax.x), Mathf.Log(_ViewDepthMinMax.y));
logViewDepthMinDelta.y = logViewDepthMinDelta.y - logViewDepthMinDelta.x;
cmd.SetGlobalVector("_LogViewDepthMinDelta", logViewDepthMinDelta);
//cmd.SetGlobalFloat("_Overestimation", 0.25f);
//cmd.SetGlobalFloat("_MomentBias", 0);
if (_Trigonometric)
{
Vector4 _WrappingZoneParameters = new Vector4();
_WrappingZoneParameters.x = 3.14f;
_WrappingZoneParameters.y = 3.14f - 0.5f * _WrappingZoneParameters.x;
float a = _WrappingZoneParameters.y * 2;
float x = Mathf.Cos(a);
float y = Mathf.Sin(a);
float r = Mathf.Abs(y) - Mathf.Abs(x);
r = (x < 0) ? (2.0f - r) : r;
r = (y < 0) ? (6.0f - r) : r;
_WrappingZoneParameters.z = 1 / (7 - r);
_WrappingZoneParameters.w = 1 - 7 * _WrappingZoneParameters.z;
cmd.SetGlobalVector("_WrappingZoneParameters", _WrappingZoneParameters);
}
Camera camera = renderingData.cameraData.camera;
var drawSettings = CreateDrawRendererSettings(camera, SortFlags.None, _RendererConfiguration, renderingData.supportsDynamicBatching);
context.DrawRenderers(renderingData.cullResults.visibleRenderers, ref drawSettings, _OITFilterSettings);
// Render objects that did not match any shader pass with error shader
renderer.RenderObjectsWithError(context, ref renderingData.cullResults, camera, _OITFilterSettings, SortFlags.None);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
cmd.GetTemporaryRT(_MOITHandle.id, _Descriptor);
if (renderingData.shadowData.supportsDeepShadowMaps)
{
cmd.GetTemporaryRT(_GIALHandle.id, _Descriptor);
cmd.SetRenderTarget(_RMBinding);
cmd.ClearRenderTarget(false, true, Color.black);
}
else
{
CoreUtils.SetRenderTarget(cmd,
_MOITHandle.Identifier(), RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store,
_DepthAttachmentHandle.Identifier(), RenderBufferLoadAction.Load, RenderBufferStoreAction.DontCare,
ClearFlag.Color, Color.black);
}
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
cmd.SetGlobalTexture("_b0", _B0Handle.id);
cmd.SetGlobalTexture("_b1", _B1Handle.id);
if (MomentsCount._4 != _MomentsCount)
{
cmd.SetGlobalTexture("_b2", _B2Handle.id);
}
drawSettings.SetShaderPassName(0, new ShaderPassName("ResolveMoments"));
context.DrawRenderers(renderingData.cullResults.visibleRenderers, ref drawSettings, _OITFilterSettings);
// Render objects that did not match any shader pass with error shader
renderer.RenderObjectsWithError(context, ref renderingData.cullResults, camera, _OITFilterSettings, SortFlags.None);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CoreUtils.SetRenderTarget(cmd,
_ColorAttachmentHandle.Identifier(), RenderBufferLoadAction.Load, RenderBufferStoreAction.Store,
ClearFlag.None);
cmd.Blit(_ColorAttachmentHandle.Identifier(), _ColorAttachmentHandle.Identifier(), renderer.GetMaterial(MaterialHandle.MomentOITComposite));
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
bool isLitView = true;
#if UNITY_EDITOR
if (renderingData.cameraData.isSceneViewCamera)
{
isLitView = UnityEditor.SceneView.currentDrawingSceneView.sceneLighting;
}
if (renderingData.cameraData.camera.cameraType == CameraType.Preview)
{
isLitView = false;
}
if (!Application.isPlaying)
{
s_SortingLayers = SortingLayer.layers;
}
#endif
Camera camera = renderingData.cameraData.camera;
FilteringSettings filterSettings = new FilteringSettings();
filterSettings.renderQueueRange = RenderQueueRange.all;
filterSettings.layerMask = -1;
filterSettings.renderingLayerMask = 0xFFFFFFFF;
filterSettings.sortingLayerRange = SortingLayerRange.all;
bool isSceneLit = Light2D.IsSceneLit(camera);
if (isSceneLit)
{
m_Renderer2DData.InitializeTransient();
CommandBuffer cmd = CommandBufferPool.Get();
cmd.Clear();
using (new ProfilingScope(cmd, m_ProfilingSampler))
{
this.CreateNormalMapRenderTexture(renderingData, cmd);
cmd.SetGlobalFloat("_HDREmulationScale", m_Renderer2DData.hdrEmulationScale);
cmd.SetGlobalFloat("_InverseHDREmulationScale", 1.0f / m_Renderer2DData.hdrEmulationScale);
cmd.SetGlobalFloat("_UseSceneLighting", isLitView ? 1.0f : 0.0f);
cmd.SetGlobalColor("_RendererColor", Color.white);
this.SetShapeLightShaderGlobals(cmd);
context.ExecuteCommandBuffer(cmd);
DrawingSettings combinedDrawSettings = CreateDrawingSettings(k_ShaderTags, ref renderingData, SortingCriteria.CommonTransparent);
DrawingSettings normalsDrawSettings = CreateDrawingSettings(k_NormalsRenderingPassName, ref renderingData, SortingCriteria.CommonTransparent);
SortingSettings sortSettings = combinedDrawSettings.sortingSettings;
GetTransparencySortingMode(camera, ref sortSettings);
combinedDrawSettings.sortingSettings = sortSettings;
normalsDrawSettings.sortingSettings = sortSettings;
var blendStylesCount = m_Renderer2DData.lightBlendStyles.Length;
for (var i = 0; i < s_SortingLayers.Length;)
{
var layerToRender = s_SortingLayers[i].id;
var lightStats = Light2D.GetLightStatsByLayer(layerToRender, camera);
cmd.Clear();
for (int blendStyleIndex = 0; blendStyleIndex < blendStylesCount; blendStyleIndex++)
{
uint blendStyleMask = (uint)(1 << blendStyleIndex);
bool blendStyleUsed = (lightStats.blendStylesUsed & blendStyleMask) > 0;
if (blendStyleUsed && !m_Renderer2DData.lightBlendStyles[blendStyleIndex].hasRenderTarget)
{
this.CreateBlendStyleRenderTexture(renderingData, cmd, blendStyleIndex);
}
RendererLighting.EnableBlendStyle(cmd, blendStyleIndex, blendStyleUsed);
}
context.ExecuteCommandBuffer(cmd);
// find the highest layer that share the same set of lights as this layer
var upperLayerInBatch = FindUpperBoundInBatch(i);
// Some renderers override their sorting layer value with short.MinValue or short.MaxValue.
// When drawing the first sorting layer, we should include the range from short.MinValue to layerValue.
// Similarly, when drawing the last sorting layer, include the range from layerValue to short.MaxValue.
var startLayerValue = (short)s_SortingLayers[i].value;
var lowerBound = (i == 0) ? short.MinValue : startLayerValue;
var endLayerValue = (short)s_SortingLayers[upperLayerInBatch].value;
var upperBound = (upperLayerInBatch == s_SortingLayers.Length - 1) ? short.MaxValue : endLayerValue;
// renderer within this range share the same set of lights so they should be rendered together
filterSettings.sortingLayerRange = new SortingLayerRange(lowerBound, upperBound);
// Start Rendering
if (lightStats.totalNormalMapUsage > 0)
{
this.RenderNormals(context, renderingData.cullResults, normalsDrawSettings, filterSettings, depthAttachment);
}
cmd.Clear();
if (lightStats.totalLights > 0)
{
this.RenderLights(renderingData, cmd, layerToRender, lightStats.blendStylesUsed);
}
else
{
this.ClearDirtyLighting(cmd, lightStats.blendStylesUsed);
}
CoreUtils.SetRenderTarget(cmd, colorAttachment, depthAttachment, ClearFlag.None, Color.white);
context.ExecuteCommandBuffer(cmd);
Profiler.BeginSample("RenderSpritesWithLighting - Draw Transparent Renderers");
context.DrawRenderers(renderingData.cullResults, ref combinedDrawSettings, ref filterSettings);
Profiler.EndSample();
if (lightStats.totalVolumetricUsage > 0)
{
cmd.Clear();
this.RenderLightVolumes(renderingData, cmd, layerToRender, colorAttachment, depthAttachment, lightStats.blendStylesUsed);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
}
// move on to the next one
i = upperLayerInBatch + 1;
}
cmd.Clear();
Profiler.BeginSample("RenderSpritesWithLighting - Release RenderTextures");
this.ReleaseRenderTextures(cmd);
Profiler.EndSample();
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
filterSettings.sortingLayerRange = SortingLayerRange.all;
RenderingUtils.RenderObjectsWithError(context, ref renderingData.cullResults, camera, filterSettings, SortingCriteria.None);
}
else
{
DrawingSettings unlitDrawSettings = CreateDrawingSettings(k_ShaderTags, ref renderingData,
SortingCriteria.CommonTransparent);
CommandBuffer cmd = CommandBufferPool.Get();
using (new ProfilingScope(cmd, m_ProfilingSamplerUnlit))
{
CoreUtils.SetRenderTarget(cmd, colorAttachment, depthAttachment, ClearFlag.None, Color.white);
cmd.SetGlobalTexture("_ShapeLightTexture0", Texture2D.blackTexture);
cmd.SetGlobalTexture("_ShapeLightTexture1", Texture2D.blackTexture);
cmd.SetGlobalTexture("_ShapeLightTexture2", Texture2D.blackTexture);
cmd.SetGlobalTexture("_ShapeLightTexture3", Texture2D.blackTexture);
cmd.SetGlobalFloat("_UseSceneLighting", isLitView ? 1.0f : 0.0f);
cmd.SetGlobalColor("_RendererColor", Color.white);
cmd.EnableShaderKeyword("USE_SHAPE_LIGHT_TYPE_0");
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
Profiler.BeginSample("Render Sprites Unlit");
context.DrawRenderers(renderingData.cullResults, ref unlitDrawSettings, ref filterSettings);
Profiler.EndSample();
RenderingUtils.RenderObjectsWithError(context, ref renderingData.cullResults, camera, filterSettings, SortingCriteria.None);
}
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
#if UNITY_EDITOR
if (!Application.isPlaying)
{
s_SortingLayers = SortingLayer.layers;
}
#endif
Camera camera = renderingData.cameraData.camera;
RendererLighting.Setup(m_RendererData);
CommandBuffer cmd = CommandBufferPool.Get("Render 2D Lighting");
Profiler.BeginSample("RenderSpritesWithLighting - Create Render Textures");
RendererLighting.CreateRenderTextures(cmd, camera);
Profiler.EndSample();
cmd.SetGlobalFloat("_LightIntensityScale", m_RendererData.lightIntensityScale);
cmd.SetGlobalFloat("_InverseLightIntensityScale", 1.0f / m_RendererData.lightIntensityScale);
RendererLighting.SetShapeLightShaderGlobals(cmd);
context.ExecuteCommandBuffer(cmd);
Profiler.BeginSample("RenderSpritesWithLighting - Prepare");
DrawingSettings drawSettings = CreateDrawingSettings(k_CombinedRenderingPassName, ref renderingData, SortingCriteria.CommonTransparent);
FilteringSettings filterSettings = new FilteringSettings();
filterSettings.renderQueueRange = RenderQueueRange.all;
filterSettings.layerMask = -1;
filterSettings.renderingLayerMask = 0xFFFFFFFF;
filterSettings.sortingLayerRange = SortingLayerRange.all;
Profiler.EndSample();
bool cleared = false;
for (int i = 0; i < s_SortingLayers.Length; i++)
{
short layerValue = (short)s_SortingLayers[i].value;
filterSettings.sortingLayerRange = new SortingLayerRange(layerValue, layerValue);
RendererLighting.RenderNormals(context, renderingData.cullResults, drawSettings, filterSettings);
cmd.Clear();
int layerToRender = s_SortingLayers[i].id;
RendererLighting.RenderLights(camera, cmd, layerToRender);
// This should have an optimization where I can determine if this needs to be called.
// And the clear is only needed if no previous pass has cleared the camera RT yet.
var clearFlag = cleared ? ClearFlag.None : ClearFlag.All;
var clearColor = renderingData.cameraData.camera.backgroundColor;
cleared = true;
SetRenderTarget(cmd, BuiltinRenderTextureType.CameraTarget, RenderBufferLoadAction.Load, RenderBufferStoreAction.Store, clearFlag, clearColor, TextureDimension.Tex2D);
context.ExecuteCommandBuffer(cmd);
Profiler.BeginSample("RenderSpritesWithLighting - Draw Renderers");
context.DrawRenderers(renderingData.cullResults, ref drawSettings, ref filterSettings);
Profiler.EndSample();
cmd.Clear();
RendererLighting.RenderLightVolumes(camera, cmd, layerToRender);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
}
Profiler.BeginSample("RenderSpritesWithLighting - Release RenderTextures");
RendererLighting.ReleaseRenderTextures(cmd);
Profiler.EndSample();
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
filterSettings.sortingLayerRange = SortingLayerRange.all;
RenderingUtils.RenderObjectsWithError(context, ref renderingData.cullResults, camera, filterSettings, SortingCriteria.None);
}
/// <summary>
/// Execute the custom post processing renderers
/// </summary>
/// <param name="context">The scriptable render context</param>
/// <param name="renderingData">Current rendering data</param>
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
// Copy camera target description for intermediate RTs. Disable multisampling and depth buffer for the intermediate targets.
m_IntermediateDesc = renderingData.cameraData.cameraTargetDescriptor;
m_IntermediateDesc.msaaSamples = 1;
m_IntermediateDesc.depthBufferBits = 0;
CommandBuffer cmd = CommandBufferPool.Get(m_PassName);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
int width = m_IntermediateDesc.width;
int height = m_IntermediateDesc.height;
cmd.SetGlobalVector("_ScreenSize", new Vector4(width, height, 1.0f / width, 1.0f / height));
// The variable will be true if the last renderer couldn't blit to destination.
// This happens if there is only 1 renderer and the source is the same as the destination.
bool requireBlitBack = false;
// The current intermediate RT to use as a source.
int intermediateIndex = 0;
for (int index = 0; index < m_ActivePostProcessRenderers.Count; ++index)
{
var rendererIndex = m_ActivePostProcessRenderers[index];
var renderer = m_PostProcessRenderers[rendererIndex];
RenderTargetIdentifier source, destination;
if (index == 0)
{
// If this is the first renderers then the source will be the external source (not intermediate).
source = m_Source;
if (m_ActivePostProcessRenderers.Count == 1)
{
// There is only one renderer, check if the source is the same as the destination
if (m_Source == m_Destination)
{
// Since we can't bind the same RT as a texture and a render target at the same time, we will blit to an intermediate RT.
destination = GetIntermediate(cmd, 0);
// Then we will blit back to the destination.
requireBlitBack = true;
}
else
{
// Otherwise, we can directly blit from source to destination.
destination = m_Destination;
}
}
else
{
// If there is more than one renderer, we will need to the intermediate RT anyway.
destination = GetIntermediate(cmd, intermediateIndex);
}
}
else
{
// If this is not the first renderer, we will want to the read from the intermediate RT.
source = GetIntermediate(cmd, intermediateIndex);
if (index == m_ActivePostProcessRenderers.Count - 1)
{
// If this is the last renderer, blit to the destination directly.
destination = m_Destination;
}
else
{
// Otherwise, flip the intermediate RT index and set as destination.
// This will act as a ping pong process between the 2 RT where color data keeps moving back and forth while being processed on each pass.
intermediateIndex = 1 - intermediateIndex;
destination = GetIntermediate(cmd, intermediateIndex);
}
}
using (new ProfilingScope(cmd, m_ProfilingSamplers[rendererIndex]))
{
// If the renderer was not already initialized, initialize it.
if (!renderer.Initialized)
{
renderer.InitializeInternal();
}
// Execute the renderer.
renderer.Render(cmd, source, destination, ref renderingData, injectionPoint);
}
}
// If blit back is needed, blit from the intermediate RT to the destination (see above for explanation)
if (requireBlitBack)
{
Blit(cmd, m_Intermediate[0].Identifier(), m_Destination);
}
// Release allocated Intermediate RTs.
CleanupIntermediate(cmd);
// Send command buffer for execution, then release it.
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (null == renderer)
{
throw new ArgumentException("renderer");
}
_MainLightFilteredSMDescriptor.width = renderingData.shadowData.mainLightShadowmapWidth;
_MainLightFilteredSMDescriptor.height = renderingData.shadowData.mainLightShadowmapHeight;
if (renderingData.shadowData.requiresScreenSpaceShadowResolve)
{
_MainLightFilteredSMDescriptor.autoGenerateMips = false;
_MainLightFilteredSMDescriptor.useMipMap = false;
}
CommandBuffer cmd = CommandBufferPool.Get(_FilterEVSM);
if (!CheckEnabled(ref renderingData))
{
foreach (var kvp in _TypeKeywords)
{
CoreUtils.SetKeyword(cmd, kvp.Value, false);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
return;
}
using (new ProfilingSample(cmd, _FilterEVSM))
{
foreach (var kvp in _TypeKeywords)
{
CoreUtils.SetKeyword(cmd, kvp.Value, kvp.Key == _ShadowMapsType);
}
CoreUtils.SetKeyword(cmd, _KeywordESMLogFilter, _LogFilterESM);
CoreUtils.SetKeyword(cmd, _KeywordShadowMapsPrecision, _ShadowMapsPrecision == ShadowMapsPrecision.Single);
cmd.SetGlobalVector(_UniformEVSMExponent, _EVSMExponent);
cmd.GetTemporaryRT(_FilteredMainLightSMHandle.id, _MainLightFilteredSMDescriptor, FilterMode.Bilinear);
cmd.GetTemporaryRT(_TmpMainLightSMHandle.id, _MainLightFilteredSMDescriptor, FilterMode.Bilinear);
RenderTargetIdentifier srti = _TmpMainLightSMHandle.Identifier();
RenderTargetIdentifier drti = _FilteredMainLightSMHandle.Identifier();
CoreUtils.SetKeyword(cmd, _KeywordFirstFilter, true);
cmd.SetGlobalVector(_UniformHorizontalVertical, Vector2.right);
SetRenderTarget(cmd, srti, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, ClearFlag.Color, Color.black, TextureDimension.Tex2D);
cmd.Blit(srti, srti, _Material);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CoreUtils.SetKeyword(cmd, _KeywordFirstFilter, false);
cmd.SetGlobalTexture(_UniformMainTex, srti);
cmd.SetGlobalVector(_UniformHorizontalVertical, Vector2.up);
SetRenderTarget(cmd, drti, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, ClearFlag.Color, Color.black, TextureDimension.Tex2D);
cmd.Blit(srti, drti, _Material);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
//for (int i = 1; i <= 1; i++)
//{
// int p = 1 << i;
// cmd.SetGlobalVector("_HorizontalVertical", Vector2.right * p);
// SetRenderTarget(cmd, srti, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, ClearFlag.Color, Color.black, TextureDimension.Tex2D);
// cmd.SetGlobalTexture("_MainTex", drti);
// cmd.Blit(drti, srti, _Material);
// context.ExecuteCommandBuffer(cmd);
// cmd.Clear();
// cmd.SetGlobalVector("_HorizontalVertical", Vector2.up * p);
// SetRenderTarget(cmd, drti, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, ClearFlag.Color, Color.black, TextureDimension.Tex2D);
// cmd.SetGlobalTexture("_MainTex", srti);
// cmd.Blit(srti, drti, _Material);
// context.ExecuteCommandBuffer(cmd);
// cmd.Clear();
//}
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
if (m_CopyDepthMaterial == null)
{
Debug.LogErrorFormat("Missing {0}. {1} render pass will not execute. Check for missing reference in the renderer resources.", m_CopyDepthMaterial, GetType().Name);
return;
}
CommandBuffer cmd = CommandBufferPool.Get();
using (new ProfilingScope(cmd, ProfilingSampler.Get(URPProfileId.CopyDepth)))
{
RenderTargetIdentifier depthSurface = source.Identifier();
RenderTargetIdentifier copyDepthSurface = destination.Identifier();
RenderTextureDescriptor descriptor = renderingData.cameraData.cameraTargetDescriptor;
int cameraSamples = descriptor.msaaSamples;
CameraData cameraData = renderingData.cameraData;
switch (cameraSamples)
{
case 8:
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa2);
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa4);
cmd.EnableShaderKeyword(ShaderKeywordStrings.DepthMsaa8);
break;
case 4:
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa2);
cmd.EnableShaderKeyword(ShaderKeywordStrings.DepthMsaa4);
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa8);
break;
case 2:
cmd.EnableShaderKeyword(ShaderKeywordStrings.DepthMsaa2);
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa4);
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa8);
break;
// MSAA disabled
default:
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa2);
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa4);
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa8);
break;
}
cmd.SetGlobalTexture("_CameraDepthAttachment", source.Identifier());
// Blit has logic to flip projection matrix when rendering to render texture.
// Currently the y-flip is handled in CopyDepthPass.hlsl by checking _ProjectionParams.x
// If you replace this Blit with a Draw* that sets projection matrix double check
// to also update shader.
// scaleBias.x = flipSign
// scaleBias.y = scale
// scaleBias.z = bias
// scaleBias.w = unused
float flipSign = (cameraData.IsCameraProjectionMatrixFlipped()) ? -1.0f : 1.0f;
Vector4 scaleBiasRt = (flipSign < 0.0f)
? new Vector4(flipSign, 1.0f, -1.0f, 1.0f)
: new Vector4(flipSign, 0.0f, 1.0f, 1.0f);
cmd.SetGlobalVector(ShaderPropertyId.scaleBiasRt, scaleBiasRt);
cmd.DrawMesh(RenderingUtils.fullscreenMesh, Matrix4x4.identity, m_CopyDepthMaterial);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public override void Render(ScriptableRenderContext context, Camera[] cameras)
{
if (m_IsCameraRendering)
{
Debug.LogWarning("Nested camera rendering is forbidden. If you are calling camera.Render inside OnWillRenderObject callback, use BeginCameraRender callback instead.");
return;
}
pipelineAsset.savedXRGraphicsConfig.renderScale = pipelineAsset.renderScale;
pipelineAsset.savedXRGraphicsConfig.viewportScale = 1.0f; // Placeholder until viewportScale is all hooked up
// Apply any changes to XRGConfig prior to this point
pipelineAsset.savedXRGraphicsConfig.SetConfig();
base.Render(context, cameras);
BeginFrameRendering(cameras);
GraphicsSettings.lightsUseLinearIntensity = true;
SetupPerFrameShaderConstants();
// Sort cameras array by camera depth
Array.Sort(cameras, m_CameraComparer);
foreach (Camera camera in cameras)
{
BeginCameraRendering(camera);
string renderCameraTag = "Render " + camera.name;
CommandBuffer cmd = CommandBufferPool.Get(renderCameraTag);
using (new ProfilingSample(cmd, renderCameraTag))
{
CameraData cameraData;
InitializeCameraData(camera, out cameraData);
SetupPerCameraShaderConstants(cameraData);
ScriptableCullingParameters cullingParameters;
if (!CullResults.GetCullingParameters(camera, cameraData.isStereoEnabled, out cullingParameters))
{
CommandBufferPool.Release(cmd);
continue;
}
cullingParameters.shadowDistance = Mathf.Min(cameraData.maxShadowDistance, camera.farClipPlane);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
#if UNITY_EDITOR
try
#endif
{
m_IsCameraRendering = true;
#if UNITY_EDITOR
// Emit scene view UI
if (cameraData.isSceneViewCamera)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
CullResults.Cull(ref cullingParameters, context, ref m_CullResults);
List <VisibleLight> visibleLights = m_CullResults.visibleLights;
RenderingData renderingData;
InitializeRenderingData(ref cameraData, visibleLights,
m_Renderer.maxSupportedLocalLightsPerPass, m_Renderer.maxSupportedVertexLights,
out renderingData);
var setup = cameraData.camera.GetComponent <IRendererSetup>();
if (setup == null)
{
setup = defaultRendererSetup;
}
setup.Setup(m_Renderer, ref context, ref m_CullResults, ref renderingData);
m_Renderer.Execute(ref context, ref m_CullResults, ref renderingData);
}
#if UNITY_EDITOR
catch (Exception)
{
CommandBufferPool.Release(cmd);
throw;
}
finally
#endif
{
m_IsCameraRendering = false;
}
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
context.Submit();
}
}
// Here you can implement the rendering logic.
// Use <c>ScriptableRenderContext</c> to issue drawing commands or execute command buffers
// https://docs.unity3d.com/ScriptReference/Rendering.ScriptableRenderContext.html
// You don't have to call ScriptableRenderContext.submit, the render pipeline will call it at specific points in the pipeline.
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
CommandBuffer cb = CommandBufferPool.Get("SSPR");
int dispatchThreadGroupXCount = GetRTWidth() / SHADER_NUMTHREAD_X; //divide by shader's numthreads.x
int dispatchThreadGroupYCount = GetRTHeight() / SHADER_NUMTHREAD_Y; //divide by shader's numthreads.y
int dispatchThreadGroupZCount = 1; //divide by shader's numthreads.z
if (settings.ShouldRenderSSPR)
{
cb.SetComputeVectorParam(cs, Shader.PropertyToID("_RTSize"), new Vector2(GetRTWidth(), GetRTHeight()));
cb.SetComputeFloatParam(cs, Shader.PropertyToID("_HorizontalPlaneHeightWS"), settings.HorizontalReflectionPlaneHeightWS);
cb.SetComputeFloatParam(cs, Shader.PropertyToID("_FadeOutScreenBorderWidthVerticle"), settings.FadeOutScreenBorderWidthVerticle);
cb.SetComputeFloatParam(cs, Shader.PropertyToID("_FadeOutScreenBorderWidthHorizontal"), settings.FadeOutScreenBorderWidthHorizontal);
cb.SetComputeVectorParam(cs, Shader.PropertyToID("_CameraDirection"), renderingData.cameraData.camera.transform.forward);
cb.SetComputeFloatParam(cs, Shader.PropertyToID("_ScreenLRStretchIntensity"), settings.ScreenLRStretchIntensity);
cb.SetComputeFloatParam(cs, Shader.PropertyToID("_ScreenLRStretchThreshold"), settings.ScreenLRStretchThreshold);
cb.SetComputeVectorParam(cs, Shader.PropertyToID("_FinalTintColor"), settings.TintColor);
if (ShouldUseSinglePassUnsafeAllowFlickeringDirectResolve())
{
////////////////////////////////////////////////
//Android Path
////////////////////////////////////////////////
//kernel MobilePathsinglePassColorRTDirectResolve
int kernel_MobilePathSinglePassColorRTDirectResolve = cs.FindKernel("MobilePathSinglePassColorRTDirectResolve");
cb.SetComputeTextureParam(cs, kernel_MobilePathSinglePassColorRTDirectResolve, "ColorRT", _SSPR_ColorRT_rti);
cb.SetComputeTextureParam(cs, kernel_MobilePathSinglePassColorRTDirectResolve, "PosWSyRT", _SSPR_PosWSyRT_rti);
cb.SetComputeTextureParam(cs, kernel_MobilePathSinglePassColorRTDirectResolve, "_CameraOpaqueTexture", new RenderTargetIdentifier("_CameraOpaqueTexture"));
cb.SetComputeTextureParam(cs, kernel_MobilePathSinglePassColorRTDirectResolve, "_CameraDepthTexture", new RenderTargetIdentifier("_CameraDepthTexture"));
cb.DispatchCompute(cs, kernel_MobilePathSinglePassColorRTDirectResolve, dispatchThreadGroupXCount, dispatchThreadGroupYCount, dispatchThreadGroupZCount);
}
else
{
////////////////////////////////////////////////
//Non-Android Path (PC/console..)
////////////////////////////////////////////////
//kernel NonMobilePathClear
int kernel_NonMobilePathClear = cs.FindKernel("NonMobilePathClear");
cb.SetComputeTextureParam(cs, kernel_NonMobilePathClear, "HashRT", _SSPR_PackedDataRT_rti);
cb.SetComputeTextureParam(cs, kernel_NonMobilePathClear, "ColorRT", _SSPR_ColorRT_rti);
cb.DispatchCompute(cs, kernel_NonMobilePathClear, dispatchThreadGroupXCount, dispatchThreadGroupYCount, dispatchThreadGroupZCount);
//kernel NonMobilePathRenderHashRT
int kernel_NonMobilePathRenderHashRT = cs.FindKernel("NonMobilePathRenderHashRT");
cb.SetComputeTextureParam(cs, kernel_NonMobilePathRenderHashRT, "HashRT", _SSPR_PackedDataRT_rti);
cb.SetComputeTextureParam(cs, kernel_NonMobilePathRenderHashRT, "_CameraDepthTexture", new RenderTargetIdentifier("_CameraDepthTexture"));
cb.DispatchCompute(cs, kernel_NonMobilePathRenderHashRT, dispatchThreadGroupXCount, dispatchThreadGroupYCount, dispatchThreadGroupZCount);
//resolve to ColorRT
int kernel_NonMobilePathResolveColorRT = cs.FindKernel("NonMobilePathResolveColorRT");
cb.SetComputeTextureParam(cs, kernel_NonMobilePathResolveColorRT, "_CameraOpaqueTexture", new RenderTargetIdentifier("_CameraOpaqueTexture"));
cb.SetComputeTextureParam(cs, kernel_NonMobilePathResolveColorRT, "ColorRT", _SSPR_ColorRT_rti);
cb.SetComputeTextureParam(cs, kernel_NonMobilePathResolveColorRT, "HashRT", _SSPR_PackedDataRT_rti);
cb.DispatchCompute(cs, kernel_NonMobilePathResolveColorRT, dispatchThreadGroupXCount, dispatchThreadGroupYCount, dispatchThreadGroupZCount);
}
//optional shared pass to improve result only: fill RT hole
if (settings.ApplyFillHoleFix)
{
int kernel_FillHoles = cs.FindKernel("FillHoles");
cb.SetComputeTextureParam(cs, kernel_FillHoles, "ColorRT", _SSPR_ColorRT_rti);
cb.SetComputeTextureParam(cs, kernel_FillHoles, "PackedDataRT", _SSPR_PackedDataRT_rti);
cb.DispatchCompute(cs, kernel_FillHoles, Mathf.CeilToInt(dispatchThreadGroupXCount / 2f), Mathf.CeilToInt(dispatchThreadGroupYCount / 2f), dispatchThreadGroupZCount);
}
//send out to global, for user's shader to sample reflection result RT (_MobileSSPR_ColorRT)
//where _MobileSSPR_ColorRT's rgb is reflection color, a is reflection usage 0~1 for user's shader to lerp with fallback reflection probe's rgb
cb.SetGlobalTexture(_SSPR_ColorRT_pid, _SSPR_ColorRT_rti);
cb.EnableShaderKeyword("_MobileSSPR");
}
else
{
//allow user to skip SSPR related code if disabled
cb.DisableShaderKeyword("_MobileSSPR");
}
context.ExecuteCommandBuffer(cb);
CommandBufferPool.Release(cb);
//======================================================================
//draw objects(e.g. reflective wet ground plane) with lightmode "MobileSSPR", which will sample _MobileSSPR_ColorRT
DrawingSettings drawingSettings = CreateDrawingSettings(lightMode_SSPR_sti, ref renderingData, SortingCriteria.CommonOpaque);
FilteringSettings filteringSettings = new FilteringSettings(RenderQueueRange.all);
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref filteringSettings);
}
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);
camera.depthTextureMode |= DepthTextureMode.MotionVectors | DepthTextureMode.Depth;
//Setup sort, filter, draw settings
var sortingSettings = new SortingSettings(camera);
var drawSettings = new DrawingSettings(m_StochasticColorPassName, sortingSettings);
drawSettings.perObjectData |= PerObjectData.MotionVectors;
var filterSettings = new FilteringSettings(RenderQueueRange.all);
filterSettings.excludeMotionVectorObjects = false;
InitializeFrameSettings();
// Render background
DrawSkybox(camera, context);
// Push constants
PushShadingConstants(camera, context, 0);
//------------------------------------------------------------------------------------
// STOCHASTIC TRANSPARENCY IMPLEMENTATION
//------------------------------------------------------------------------------------
{
//1.) Transmission Pass
RenderTransmission(sortingSettings, drawSettings, filterSettings, cull, context);
//2.) Stochastic Depths
RenderStochasticDepths(sortingSettings, drawSettings, filterSettings, cull, context);
//3.) Stochastic Colors
RenderStochasticColors(sortingSettings, drawSettings, filterSettings, cull, context);
//4.) Final Pass
RenderFinalPass(context, 0, camera);
}
//------------------------------------------------------------------------------------
CommandBuffer cmd = CommandBufferPool.Get("PostProcessing");
// Post Process
var postProcessLayer = camera.GetComponent <PostProcessLayer>();
if (postProcessLayer != null)
{
RenderPostProcess(postProcessLayer, cmd, camera);
}
// Flip to back buffer
cmd.Blit(m_ColorBuffer, BuiltinRenderTextureType.CameraTarget);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
context.Submit();
}
}
