/// <summary> /// Configure the pass /// </summary> /// <param name="baseDescriptor"></param> /// <param name="colorAttachmentHandle"></param> public void Setup(RenderTextureDescriptor baseDescriptor, RenderTargetHandle colorAttachmentHandle, bool requiresSRGConversion, bool killAlpha) { this.colorAttachmentHandle = colorAttachmentHandle; this.descriptor = baseDescriptor; this.requiresSRGConversion = requiresSRGConversion; this.killAlpha = killAlpha; }
/// <summary> /// Configure the pass /// </summary> public void Setup( RenderTextureDescriptor baseDescriptor, RenderTargetHandle colorAttachmentHandle, SampleCount samples) { this.colorAttachmentHandle = colorAttachmentHandle; this.samples = samples; descriptor = baseDescriptor; }
public bool Setup(RenderTargetHandle destination, ref RenderingData renderingData) { Clear(); this.destination = destination; int shadowLightIndex = renderingData.lightData.mainLightIndex; if (shadowLightIndex == -1) { return(false); } VisibleLight shadowLight = renderingData.lightData.visibleLights[shadowLightIndex]; Light light = shadowLight.light; if (light.shadows == LightShadows.None) { return(false); } if (shadowLight.lightType != LightType.Directional) { Debug.LogWarning("Only directional lights are supported as main light."); } Bounds bounds; if (!renderingData.cullResults.GetShadowCasterBounds(shadowLightIndex, out bounds)) { return(false); } m_ShadowCasterCascadesCount = renderingData.shadowData.mainLightShadowCascadesCount; int shadowResolution = ShadowUtils.GetMaxTileResolutionInAtlas(renderingData.shadowData.mainLightShadowmapWidth, renderingData.shadowData.mainLightShadowmapHeight, m_ShadowCasterCascadesCount); m_ShadowmapWidth = renderingData.shadowData.mainLightShadowmapWidth; m_ShadowmapHeight = (m_ShadowCasterCascadesCount == 2) ? renderingData.shadowData.mainLightShadowmapHeight >> 1 : renderingData.shadowData.mainLightShadowmapHeight; for (int cascadeIndex = 0; cascadeIndex < m_ShadowCasterCascadesCount; ++cascadeIndex) { bool success = ShadowUtils.ExtractDirectionalLightMatrix(ref renderingData.cullResults, ref renderingData.shadowData, shadowLightIndex, cascadeIndex, m_ShadowmapWidth, m_ShadowmapHeight, shadowResolution, light.shadowNearPlane, out m_CascadeSplitDistances[cascadeIndex], out m_CascadeSlices[cascadeIndex], out m_CascadeSlices[cascadeIndex].viewMatrix, out m_CascadeSlices[cascadeIndex].projectionMatrix); if (!success) { return(false); } } return(true); }
public void Setup( RenderTextureDescriptor baseDescriptor, RenderTargetHandle colorAttachmentHandle) { this.colorAttachmentHandle = colorAttachmentHandle; baseDescriptor.depthBufferBits = 0; baseDescriptor.colorFormat = m_ColorFormat; descriptor = baseDescriptor; }
/// <summary> /// Configure the pass before execution /// </summary> /// <param name="baseDescriptor">Current target descriptor</param> /// <param name="colorAttachmentHandle">Color attachment to render into</param> /// <param name="depthAttachmentHandle">Depth attachment to render into</param> /// <param name="configuration">Specific render configuration</param> public void Setup( RenderTextureDescriptor baseDescriptor, RenderTargetHandle colorAttachmentHandle, RenderTargetHandle depthAttachmentHandle, PerObjectData configuration) { this.colorAttachmentHandle = colorAttachmentHandle; this.depthAttachmentHandle = depthAttachmentHandle; descriptor = baseDescriptor; rendererConfiguration = configuration; }
/// <summary> /// Configure the pass /// </summary> public void Setup( RenderTextureDescriptor baseDescriptor, RenderTargetHandle depthAttachmentHandle) { this.depthAttachmentHandle = depthAttachmentHandle; baseDescriptor.colorFormat = RenderTextureFormat.Depth; baseDescriptor.depthBufferBits = kDepthBufferBits; // Depth-Only pass don't use MSAA baseDescriptor.msaaSamples = 1; descriptor = baseDescriptor; }
/// <inheritdoc/> public override void FrameCleanup(CommandBuffer cmd) { if (cmd == null) { throw new ArgumentNullException("cmd"); } if (destination != RenderTargetHandle.CameraTarget) { cmd.ReleaseTemporaryRT(destination.id); destination = RenderTargetHandle.CameraTarget; } }
/// <summary> /// Configure the pass before execution /// </summary> /// <param name="baseDescriptor">Current target descriptor</param> /// <param name="colorAttachmentHandle">Color attachment to render into</param> /// <param name="depthAttachmentHandle">Depth attachment to render into</param> /// <param name="clearFlag">Camera clear flag</param> /// <param name="clearColor">Camera clear color</param> /// <param name="configuration">Specific render configuration</param> public void Setup( RenderTextureDescriptor baseDescriptor, RenderTargetHandle colorAttachmentHandle, RenderTargetHandle depthAttachmentHandle, ClearFlag clearFlag, Color clearColor, PerObjectData configuration) { this.colorAttachmentHandle = colorAttachmentHandle; this.depthAttachmentHandle = depthAttachmentHandle; this.clearColor = CoreUtils.ConvertSRGBToActiveColorSpace(clearColor); this.clearFlag = clearFlag; descriptor = baseDescriptor; this.rendererConfiguration = configuration; }
/// <summary> /// Setup the pass /// </summary> /// <param name="baseDescriptor"></param> /// <param name="sourceHandle">Source of rendering to execute the post on</param> /// <param name="destinationHandle">Destination target for the final blit</param> public void Setup( RenderTextureDescriptor baseDescriptor, RenderTargetHandle sourceHandle, RenderTargetHandle destinationHandle, bool opaquePost, bool flip) { source = sourceHandle; destination = destinationHandle; descriptor = baseDescriptor; this.flip = flip; this.opaquePost = opaquePost; m_TemporaryColorTexture.Init("_TemporaryColorTexture"); m_ReleaseTemporaryRenderTexture = false; }
/// <summary> /// Configure the pass /// </summary> public void Setup( RenderTextureDescriptor baseDescriptor, RenderTargetHandle depthAttachmentHandle, SampleCount samples) { this.depthAttachmentHandle = depthAttachmentHandle; baseDescriptor.colorFormat = RenderTextureFormat.Depth; baseDescriptor.depthBufferBits = kDepthBufferBits; if ((int)samples > 1) { baseDescriptor.bindMS = false; baseDescriptor.msaaSamples = (int)samples; } descriptor = baseDescriptor; }
/// <summary> /// Setup the pass /// </summary> /// <param name="baseDescriptor"></param> /// <param name="sourceHandle">Source of rendering to execute the post on</param> /// <param name="destinationHandle">Destination target for the final blit</param> public void Setup( RenderTextureDescriptor baseDescriptor, RenderTargetHandle sourceHandle, RenderTargetHandle destinationHandle, bool opaquePost, bool flip) { if (sourceHandle == destinationHandle) { throw new InvalidOperationException($"{nameof(sourceHandle)} should not be the same as {nameof(destinationHandle)}"); } source = sourceHandle; destination = destinationHandle; descriptor = baseDescriptor; this.flip = flip; this.opaquePost = opaquePost; }
/// <summary> /// Configure the pass /// </summary> /// <param name="actions"></param> public bool Setup(RenderTargetHandle colorAttachmentHandle, IEnumerator <Action <RenderTargetIdentifier, CommandBuffer> > actions) { this.colorAttachmentHandle = colorAttachmentHandle; captureActions = actions; return(captureActions != null); }
public bool Equals(RenderTargetHandle other) { return(id == other.id); }
/// <summary> /// Configure the color and depth passes to use when rendering the skybox /// </summary> /// <param name="colorHandle">Color buffer to use</param> /// <param name="depthHandle">Depth buffer to use</param> public void Setup(RenderTargetHandle colorHandle, RenderTargetHandle depthHandle) { this.colorAttachmentHandle = colorHandle; this.depthAttachmentHandle = depthHandle; }
/// <summary> /// Configure the pass with the source and destination to execute on. /// </summary> /// <param name="source">Source Render Target</param> /// <param name="destination">Destination Render Targt</param> public void Setup(RenderTargetHandle source, RenderTargetHandle destination) { this.source = source; this.destination = destination; }
public void Setup(ScriptableRenderer renderer, ref RenderingData renderingData) { Init(); Camera camera = renderingData.cameraData.camera; renderer.SetupPerObjectLightIndices(ref renderingData.cullResults, ref renderingData.lightData); RenderTextureDescriptor baseDescriptor = ScriptableRenderer.CreateRenderTextureDescriptor(ref renderingData.cameraData); ClearFlag clearFlag = ScriptableRenderer.GetCameraClearFlag(renderingData.cameraData.camera); RenderTextureDescriptor shadowDescriptor = baseDescriptor; shadowDescriptor.dimension = TextureDimension.Tex2D; bool mainLightShadows = false; if (renderingData.shadowData.supportsMainLightShadows) { mainLightShadows = m_MainLightShadowCasterPass.Setup(m_MainLightShadowmap, ref renderingData); if (mainLightShadows) { renderer.EnqueuePass(m_MainLightShadowCasterPass); } } if (renderingData.shadowData.supportsAdditionalLightShadows) { bool additionalLightShadows = m_AdditionalLightsShadowCasterPass.Setup(m_AdditionalLightsShadowmap, ref renderingData, renderer.maxVisibleAdditionalLights); if (additionalLightShadows) { renderer.EnqueuePass(m_AdditionalLightsShadowCasterPass); } } bool resolveShadowsInScreenSpace = mainLightShadows && renderingData.shadowData.requiresScreenSpaceShadowResolve; // Depth prepass is generated in the following cases: // - We resolve shadows in screen space // - Scene view camera always requires a depth texture. We do a depth pre-pass to simplify it and it shouldn't matter much for editor. // - If game or offscreen camera requires it we check if we can copy the depth from the rendering opaques pass and use that instead. bool requiresDepthPrepass = resolveShadowsInScreenSpace || renderingData.cameraData.isSceneViewCamera || (renderingData.cameraData.requiresDepthTexture && (!CanCopyDepth(ref renderingData.cameraData))); // For now VR requires a depth prepass until we figure out how to properly resolve texture2DMS in stereo requiresDepthPrepass |= renderingData.cameraData.isStereoEnabled; renderer.EnqueuePass(m_SetupForwardRenderingPass); camera.GetComponents(m_BeforeRenderPasses); camera.GetComponents(m_AfterOpaquePasses); camera.GetComponents(m_AfterOpaquePostProcessPasses); camera.GetComponents(m_AfterSkyboxPasses); camera.GetComponents(m_AfterTransparentPasses); camera.GetComponents(m_AfterRenderPasses); bool createColorTexture = RequiresIntermediateColorTexture(ref renderingData, baseDescriptor) || m_BeforeRenderPasses.Count != 0 || m_AfterOpaquePasses.Count != 0 || m_AfterOpaquePostProcessPasses.Count != 0 || m_AfterSkyboxPasses.Count != 0 || m_AfterTransparentPasses.Count != 0 || m_AfterRenderPasses.Count != 0; // If camera requires depth and there's no depth pre-pass we create a depth texture that can be read // later by effect requiring it. bool createDepthTexture = renderingData.cameraData.requiresDepthTexture && !requiresDepthPrepass; RenderTargetHandle colorHandle = (createColorTexture) ? m_ColorAttachment : RenderTargetHandle.CameraTarget; RenderTargetHandle depthHandle = (createDepthTexture) ? m_DepthAttachment : RenderTargetHandle.CameraTarget; var sampleCount = (SampleCount)renderingData.cameraData.msaaSamples; if (createColorTexture || createDepthTexture) { m_CreateLightweightRenderTexturesPass.Setup(baseDescriptor, colorHandle, depthHandle, sampleCount); renderer.EnqueuePass(m_CreateLightweightRenderTexturesPass); } foreach (var pass in m_BeforeRenderPasses) { renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle, clearFlag)); } if (requiresDepthPrepass) { m_DepthOnlyPass.Setup(baseDescriptor, m_DepthTexture); renderer.EnqueuePass(m_DepthOnlyPass); } if (resolveShadowsInScreenSpace) { m_ScreenSpaceShadowResolvePass.Setup(baseDescriptor, m_ScreenSpaceShadowmap); renderer.EnqueuePass(m_ScreenSpaceShadowResolvePass); } if (renderingData.cameraData.isStereoEnabled) { renderer.EnqueuePass(m_BeginXrRenderingPass); } var perObjectFlags = ScriptableRenderer.GetPerObjectLightFlags(renderingData.lightData.mainLightIndex, renderingData.lightData.additionalLightsCount); m_SetupLightweightConstants.Setup(renderer.maxVisibleAdditionalLights, renderer.perObjectLightIndices); renderer.EnqueuePass(m_SetupLightweightConstants); // If a before all render pass executed we expect it to clear the color render target if (m_BeforeRenderPasses.Count != 0) { clearFlag = ClearFlag.None; } m_RenderOpaqueForwardPass.Setup(baseDescriptor, colorHandle, depthHandle, clearFlag, camera.backgroundColor, perObjectFlags); renderer.EnqueuePass(m_RenderOpaqueForwardPass); foreach (var pass in m_AfterOpaquePasses) { renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle)); } if (renderingData.cameraData.postProcessEnabled && renderingData.cameraData.postProcessLayer.HasOpaqueOnlyEffects(renderer.postProcessingContext)) { m_OpaquePostProcessPass.Setup(baseDescriptor, colorHandle, colorHandle, true, false); renderer.EnqueuePass(m_OpaquePostProcessPass); foreach (var pass in m_AfterOpaquePostProcessPasses) { renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle)); } } if (camera.clearFlags == CameraClearFlags.Skybox && RenderSettings.skybox != null) { // We can't combine skybox and render opaques passes if there's a custom render pass in between // them. Ideally we need a render graph here that each render pass declares inputs and output // attachments and their Load/Store action so we figure out properly if we can combine passes // and move to interleaved rendering with RenderPass API. bool combineWithRenderOpaquesPass = m_AfterOpaquePostProcessPasses.Count == 0; m_DrawSkyboxPass.Setup(baseDescriptor, colorHandle, depthHandle, combineWithRenderOpaquesPass); renderer.EnqueuePass(m_DrawSkyboxPass); } foreach (var pass in m_AfterSkyboxPasses) { renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle)); } // If a depth texture was created we necessarily need to copy it, otherwise we could have render it to a renderbuffer if (createDepthTexture) { m_CopyDepthPass.Setup(depthHandle, m_DepthTexture); renderer.EnqueuePass(m_CopyDepthPass); } if (renderingData.cameraData.requiresOpaqueTexture) { m_CopyColorPass.Setup(colorHandle, m_OpaqueColor); renderer.EnqueuePass(m_CopyColorPass); } m_RenderTransparentForwardPass.Setup(baseDescriptor, colorHandle, depthHandle, perObjectFlags); renderer.EnqueuePass(m_RenderTransparentForwardPass); foreach (var pass in m_AfterTransparentPasses) { renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle)); } #if UNITY_EDITOR m_LitGizmoRenderingPass.Setup(true); renderer.EnqueuePass(m_LitGizmoRenderingPass); #endif bool afterRenderExists = m_AfterRenderPasses.Count != 0; // if we have additional filters // we need to stay in a RT if (afterRenderExists) { // perform post with src / dest the same if (renderingData.cameraData.postProcessEnabled) { m_PostProcessPass.Setup(baseDescriptor, colorHandle, colorHandle, false, false); renderer.EnqueuePass(m_PostProcessPass); } //execute after passes foreach (var pass in m_AfterRenderPasses) { renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle)); } //now blit into the final target if (colorHandle != RenderTargetHandle.CameraTarget) { if (m_CapturePass.Setup(colorHandle, renderingData.cameraData.captureActions)) { renderer.EnqueuePass(m_CapturePass); } m_FinalBlitPass.Setup(baseDescriptor, colorHandle, Display.main.requiresSrgbBlitToBackbuffer, renderingData.killAlphaInFinalBlit); renderer.EnqueuePass(m_FinalBlitPass); } } else { if (renderingData.cameraData.postProcessEnabled) { m_PostProcessPass.Setup(baseDescriptor, colorHandle, RenderTargetHandle.CameraTarget, false, renderingData.cameraData.camera.targetTexture == null); renderer.EnqueuePass(m_PostProcessPass); } else if (colorHandle != RenderTargetHandle.CameraTarget) { if (m_CapturePass.Setup(colorHandle, renderingData.cameraData.captureActions)) { renderer.EnqueuePass(m_CapturePass); } m_FinalBlitPass.Setup(baseDescriptor, colorHandle, Display.main.requiresSrgbBlitToBackbuffer, renderingData.killAlphaInFinalBlit); renderer.EnqueuePass(m_FinalBlitPass); } } if (renderingData.cameraData.isStereoEnabled) { renderer.EnqueuePass(m_EndXrRenderingPass); } #if UNITY_EDITOR m_UnlitGizmoRenderingPass.Setup(false); renderer.EnqueuePass(m_UnlitGizmoRenderingPass); if (renderingData.cameraData.isSceneViewCamera) { m_SceneViewDepthCopyPass.Setup(m_DepthTexture); renderer.EnqueuePass(m_SceneViewDepthCopyPass); } #endif }
public void Setup(RenderTargetHandle source) { this.source = source; }
public void Setup(ScriptableRenderer renderer, ref RenderingData renderingData) { Init(); Camera camera = renderingData.cameraData.camera; renderer.SetupPerObjectLightIndices(ref renderingData.cullResults, ref renderingData.lightData); RenderTextureDescriptor baseDescriptor = ScriptableRenderer.CreateRenderTextureDescriptor(ref renderingData.cameraData); RenderTextureDescriptor shadowDescriptor = baseDescriptor; shadowDescriptor.dimension = TextureDimension.Tex2D; bool mainLightShadows = false; if (renderingData.shadowData.supportsMainLightShadows) { mainLightShadows = m_MainLightShadowCasterPass.Setup(m_MainLightShadowmap, ref renderingData); if (mainLightShadows) { renderer.EnqueuePass(m_MainLightShadowCasterPass); } } if (renderingData.shadowData.supportsAdditionalLightShadows) { bool additionalLightShadows = m_AdditionalLightsShadowCasterPass.Setup(m_AdditionalLightsShadowmap, ref renderingData, renderer.maxVisibleAdditionalLights); if (additionalLightShadows) { renderer.EnqueuePass(m_AdditionalLightsShadowCasterPass); } } bool resolveShadowsInScreenSpace = mainLightShadows && renderingData.shadowData.requiresScreenSpaceShadowResolve; bool requiresDepthPrepass = resolveShadowsInScreenSpace || renderingData.cameraData.isSceneViewCamera || (renderingData.cameraData.requiresDepthTexture && (!CanCopyDepth(ref renderingData.cameraData))); // For now VR requires a depth prepass until we figure out how to properly resolve texture2DMS in stereo requiresDepthPrepass |= renderingData.cameraData.isStereoEnabled; renderer.EnqueuePass(m_SetupForwardRenderingPass); camera.GetComponents(m_AfterDepthpasses); camera.GetComponents(m_AfterOpaquePasses); camera.GetComponents(m_AfterOpaquePostProcessPasses); camera.GetComponents(m_AfterSkyboxPasses); camera.GetComponents(m_AfterTransparentPasses); camera.GetComponents(m_AfterRenderPasses); if (requiresDepthPrepass) { m_DepthOnlyPass.Setup(baseDescriptor, m_DepthTexture, SampleCount.One); renderer.EnqueuePass(m_DepthOnlyPass); foreach (var pass in m_AfterDepthpasses) { renderer.EnqueuePass(pass.GetPassToEnqueue(m_DepthOnlyPass.descriptor, m_DepthTexture)); } } if (resolveShadowsInScreenSpace) { m_ScreenSpaceShadowResolvePass.Setup(baseDescriptor, m_ScreenSpaceShadowmap); renderer.EnqueuePass(m_ScreenSpaceShadowResolvePass); } bool requiresRenderToTexture = RequiresIntermediateColorTexture(ref renderingData.cameraData, baseDescriptor) || m_AfterDepthpasses.Count != 0 || m_AfterOpaquePasses.Count != 0 || m_AfterOpaquePostProcessPasses.Count != 0 || m_AfterSkyboxPasses.Count != 0 || m_AfterTransparentPasses.Count != 0 || m_AfterRenderPasses.Count != 0 || Display.main.requiresBlitToBackbuffer || renderingData.killAlphaInFinalBlit; RenderTargetHandle colorHandle = RenderTargetHandle.CameraTarget; RenderTargetHandle depthHandle = RenderTargetHandle.CameraTarget; var sampleCount = (SampleCount)renderingData.cameraData.msaaSamples; if (requiresRenderToTexture) { colorHandle = m_ColorAttachment; depthHandle = m_DepthAttachment; m_CreateLightweightRenderTexturesPass.Setup(baseDescriptor, colorHandle, depthHandle, sampleCount); renderer.EnqueuePass(m_CreateLightweightRenderTexturesPass); } if (renderingData.cameraData.isStereoEnabled) { renderer.EnqueuePass(m_BeginXrRenderingPass); } var perObjectFlags = ScriptableRenderer.GetPerObjectLightFlags(renderingData.lightData.mainLightIndex, renderingData.lightData.additionalLightsCount); m_SetupLightweightConstants.Setup(renderer.maxVisibleAdditionalLights, renderer.perObjectLightIndices); renderer.EnqueuePass(m_SetupLightweightConstants); m_RenderOpaqueForwardPass.Setup(baseDescriptor, colorHandle, depthHandle, ScriptableRenderer.GetCameraClearFlag(camera), camera.backgroundColor, perObjectFlags); renderer.EnqueuePass(m_RenderOpaqueForwardPass); foreach (var pass in m_AfterOpaquePasses) { renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle)); } if (renderingData.cameraData.postProcessEnabled && renderingData.cameraData.postProcessLayer.HasOpaqueOnlyEffects(renderer.postProcessingContext)) { m_CreatePostOpaqueColorPass.Setup(baseDescriptor, m_ColorAttachmentAfterOpaquePost, sampleCount); renderer.EnqueuePass(m_CreatePostOpaqueColorPass); m_OpaquePostProcessPass.Setup(baseDescriptor, colorHandle, m_ColorAttachmentAfterOpaquePost, true, false); renderer.EnqueuePass(m_OpaquePostProcessPass); colorHandle = m_ColorAttachmentAfterOpaquePost; foreach (var pass in m_AfterOpaquePostProcessPasses) { renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle)); } } if (camera.clearFlags == CameraClearFlags.Skybox) { m_DrawSkyboxPass.Setup(colorHandle, depthHandle); renderer.EnqueuePass(m_DrawSkyboxPass); } foreach (var pass in m_AfterSkyboxPasses) { renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle)); } if (renderingData.cameraData.requiresDepthTexture && !requiresDepthPrepass) { m_CopyDepthPass.Setup(depthHandle, m_DepthTexture); renderer.EnqueuePass(m_CopyDepthPass); } if (renderingData.cameraData.requiresOpaqueTexture) { m_CopyColorPass.Setup(colorHandle, m_OpaqueColor); renderer.EnqueuePass(m_CopyColorPass); } m_RenderTransparentForwardPass.Setup(baseDescriptor, colorHandle, depthHandle, perObjectFlags); renderer.EnqueuePass(m_RenderTransparentForwardPass); foreach (var pass in m_AfterTransparentPasses) { renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle)); } #if UNITY_EDITOR m_LitGizmoRenderingPass.Setup(true); renderer.EnqueuePass(m_LitGizmoRenderingPass); #endif bool afterRenderExists = m_AfterRenderPasses.Count != 0; // if we have additional filters // we need to stay in a RT if (afterRenderExists) { // perform post with src / dest the same if (renderingData.cameraData.postProcessEnabled) { m_CreatePostTransparentColorPass.Setup(baseDescriptor, m_ColorAttachmentAfterTransparentPost, sampleCount); renderer.EnqueuePass(m_CreatePostTransparentColorPass); m_PostProcessPass.Setup(baseDescriptor, colorHandle, m_ColorAttachmentAfterTransparentPost, false, false); renderer.EnqueuePass(m_PostProcessPass); colorHandle = m_ColorAttachmentAfterTransparentPost; } //execute after passes foreach (var pass in m_AfterRenderPasses) { renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle)); } //now blit into the final target if (colorHandle != RenderTargetHandle.CameraTarget) { if (m_CapturePass.Setup(colorHandle, renderingData.cameraData.captureActions)) { renderer.EnqueuePass(m_CapturePass); } m_FinalBlitPass.Setup(baseDescriptor, colorHandle, Display.main.requiresSrgbBlitToBackbuffer, renderingData.killAlphaInFinalBlit); renderer.EnqueuePass(m_FinalBlitPass); } } else { if (renderingData.cameraData.postProcessEnabled) { m_PostProcessPass.Setup(baseDescriptor, colorHandle, RenderTargetHandle.CameraTarget, false, renderingData.cameraData.camera.targetTexture == null); renderer.EnqueuePass(m_PostProcessPass); } else if (colorHandle != RenderTargetHandle.CameraTarget) { if (m_CapturePass.Setup(colorHandle, renderingData.cameraData.captureActions)) { renderer.EnqueuePass(m_CapturePass); } m_FinalBlitPass.Setup(baseDescriptor, colorHandle, Display.main.requiresSrgbBlitToBackbuffer, renderingData.killAlphaInFinalBlit); renderer.EnqueuePass(m_FinalBlitPass); } } if (renderingData.cameraData.isStereoEnabled) { renderer.EnqueuePass(m_EndXrRenderingPass); } #if UNITY_EDITOR m_UnlitGizmoRenderingPass.Setup(false); renderer.EnqueuePass(m_UnlitGizmoRenderingPass); if (renderingData.cameraData.isSceneViewCamera) { m_SceneViewDepthCopyPass.Setup(m_DepthTexture); renderer.EnqueuePass(m_SceneViewDepthCopyPass); } #endif }
/// <summary> /// Configure the pass /// </summary> /// <param name="baseDescriptor"></param> /// <param name="colorAttachmentHandle"></param> public void Setup(RenderTextureDescriptor baseDescriptor, RenderTargetHandle colorAttachmentHandle) { this.colorAttachmentHandle = colorAttachmentHandle; this.descriptor = baseDescriptor; }
/// <summary> /// Configure the color and depth passes to use when rendering the skybox /// </summary> /// <param name="colorHandle">Color buffer to use</param> /// <param name="depthHandle">Depth buffer to use</param> public void Setup(RenderTextureDescriptor baseDescriptor, RenderTargetHandle colorHandle, RenderTargetHandle depthHandle, bool combineWithRenderOpaquesPass) { descriptor = baseDescriptor; this.colorAttachmentHandle = colorHandle; this.depthAttachmentHandle = depthHandle; this.m_CombineWithRenderOpaquesPass = combineWithRenderOpaquesPass; }
public bool Setup(RenderTargetHandle destination, ref RenderingData renderingData, int maxVisibleAdditinalLights) { Clear(); this.destination = destination; if (m_AdditionalLightShadowMatrices.Length != maxVisibleAdditinalLights) { m_AdditionalLightShadowMatrices = new Matrix4x4[maxVisibleAdditinalLights]; m_AdditionalLightSlices = new ShadowSliceData[maxVisibleAdditinalLights]; m_AdditionalLightsShadowStrength = new float[maxVisibleAdditinalLights]; } m_AdditionalShadowCastingLightIndices.Clear(); Bounds bounds; var visibleLights = renderingData.lightData.visibleLights; int additionalLightsCount = renderingData.lightData.additionalLightsCount; for (int i = 0; i < visibleLights.Length && m_AdditionalShadowCastingLightIndices.Count < additionalLightsCount; ++i) { if (i == renderingData.lightData.mainLightIndex) { continue; } VisibleLight shadowLight = visibleLights[i]; Light light = shadowLight.light; if (shadowLight.lightType == LightType.Spot && light != null && light.shadows != LightShadows.None) { if (renderingData.cullResults.GetShadowCasterBounds(i, out bounds)) { m_AdditionalShadowCastingLightIndices.Add(i); } } } int shadowCastingLightsCount = m_AdditionalShadowCastingLightIndices.Count; if (shadowCastingLightsCount == 0) { return(false); } // TODO: Add support to point light shadows. We make a simplification here that only works // for spot lights and with max spot shadows per pass. int atlasWidth = renderingData.shadowData.additionalLightsShadowmapWidth; int atlasHeight = renderingData.shadowData.additionalLightsShadowmapHeight; int sliceResolution = ShadowUtils.GetMaxTileResolutionInAtlas(atlasWidth, atlasHeight, shadowCastingLightsCount); bool anyShadows = false; int shadowSlicesPerRow = (atlasWidth / sliceResolution); for (int i = 0; i < shadowCastingLightsCount; ++i) { int shadowLightIndex = m_AdditionalShadowCastingLightIndices[i]; VisibleLight shadowLight = visibleLights[shadowLightIndex]; // Currently Only Spot Lights are supported in additional lights Debug.Assert(shadowLight.lightType == LightType.Spot); Matrix4x4 shadowTransform; bool success = ShadowUtils.ExtractSpotLightMatrix(ref renderingData.cullResults, ref renderingData.shadowData, shadowLightIndex, out shadowTransform, out m_AdditionalLightSlices[i].viewMatrix, out m_AdditionalLightSlices[i].projectionMatrix); if (success) { // TODO: We need to pass bias and scale list to shader to be able to support multiple // shadow casting additional lights. m_AdditionalLightSlices[i].offsetX = (i % shadowSlicesPerRow) * sliceResolution; m_AdditionalLightSlices[i].offsetY = (i / shadowSlicesPerRow) * sliceResolution; m_AdditionalLightSlices[i].resolution = sliceResolution; m_AdditionalLightSlices[i].shadowTransform = shadowTransform; m_AdditionalLightsShadowStrength[i] = shadowLight.light.shadowStrength; anyShadows = true; } else { m_AdditionalShadowCastingLightIndices.RemoveAt(i--); } } return(anyShadows); }