public override void Action(int instanceId, string pathName, string resourceFile) { var instance = CreateInstance <ForwardRendererData>(); instance.postProcessData = PostProcessData.GetDefaultPostProcessData(); AssetDatabase.CreateAsset(instance, pathName); ResourceReloader.ReloadAllNullIn(instance, UniversalRenderPipelineAsset.packagePath); Selection.activeObject = instance; }
public PostProcessPass(RenderPassEvent evt, PostProcessData data) { renderPassEvent = evt; m_Data = data; m_Materials = new MaterialLibrary(data); // Texture format pre-lookup if (SystemInfo.IsFormatSupported(GraphicsFormat.B10G11R11_UFloatPack32, FormatUsage.Linear | FormatUsage.Render)) { m_DefaultHDRFormat = GraphicsFormat.B10G11R11_UFloatPack32; m_UseRGBM = false; } else { m_DefaultHDRFormat = QualitySettings.activeColorSpace == ColorSpace.Linear ? GraphicsFormat.R8G8B8A8_SRGB : GraphicsFormat.R8G8B8A8_UNorm; m_UseRGBM = true; } if (SystemInfo.IsFormatSupported(GraphicsFormat.R16_UNorm, FormatUsage.Linear | FormatUsage.Render)) { m_GaussianCoCFormat = GraphicsFormat.R16_UNorm; } else if (SystemInfo.IsFormatSupported(GraphicsFormat.R16_SFloat, FormatUsage.Linear | FormatUsage.Render)) { m_GaussianCoCFormat = GraphicsFormat.R16_SFloat; } else // Expect CoC banding { m_GaussianCoCFormat = GraphicsFormat.R8_UNorm; } // Bloom pyramid shader ids - can't use a simple stackalloc in the bloom function as we // unfortunately need to allocate strings ShaderConstants._BloomMipUp = new int[k_MaxPyramidSize]; ShaderConstants._BloomMipDown = new int[k_MaxPyramidSize]; for (int i = 0; i < k_MaxPyramidSize; i++) { ShaderConstants._BloomMipUp[i] = Shader.PropertyToID("_BloomMipUp" + i); ShaderConstants._BloomMipDown[i] = Shader.PropertyToID("_BloomMipDown" + i); } m_MRT2 = new RenderTargetIdentifier[2]; m_ResetHistory = true; }
public ColorGradingLutPass(RenderPassEvent evt, PostProcessData data) { renderPassEvent = evt; overrideCameraTarget = true; Material Load(Shader shader) { if (shader == null) { Debug.LogErrorFormat($"Missing shader. {GetType().DeclaringType.Name} render pass will not execute. Check for missing reference in the renderer resources."); return(null); } return(CoreUtils.CreateEngineMaterial(shader)); } m_LutBuilderLdr = Load(data.shaders.lutBuilderLdrPS); m_LutBuilderHdr = Load(data.shaders.lutBuilderHdrPS); // Warm up lut format as IsFormatSupported adds GC pressure... const FormatUsage kFlags = FormatUsage.Linear | FormatUsage.Render; if (SystemInfo.IsFormatSupported(GraphicsFormat.R16G16B16A16_SFloat, kFlags)) { m_HdrLutFormat = GraphicsFormat.R16G16B16A16_SFloat; } else if (SystemInfo.IsFormatSupported(GraphicsFormat.B10G11R11_UFloatPack32, kFlags)) { m_HdrLutFormat = GraphicsFormat.B10G11R11_UFloatPack32; } else { // Obviously using this for log lut encoding is a very bad idea for precision but we // need it for compatibility reasons and avoid black screens on platforms that don't // support floating point formats. Expect banding and posterization artifact if this // ends up being used. m_HdrLutFormat = GraphicsFormat.R8G8B8A8_UNorm; } m_LdrLutFormat = GraphicsFormat.R8G8B8A8_UNorm; }
static ScriptableRendererData CreateRendererData(RendererType type) { switch (type) { case RendererType.UniversalRenderer: default: { var rendererData = CreateInstance <UniversalRendererData>(); rendererData.postProcessData = PostProcessData.GetDefaultPostProcessData(); return(rendererData); } // 2D renderer is experimental case RendererType._2DRenderer: { var rendererData = CreateInstance <Renderer2DData>(); rendererData.postProcessData = PostProcessData.GetDefaultPostProcessData(); return(rendererData); // Universal Renderer is the fallback renderer that works on all platforms } } }
public static UniversalRenderPipelineAsset Create(ScriptableRendererData rendererData = null) { // Create Universal RP Asset var instance = CreateInstance <UniversalRenderPipelineAsset>(); if (rendererData != null) { instance.m_RendererDataList[0] = rendererData; } else { instance.m_RendererDataList[0] = CreateInstance <ForwardRendererData>(); } // Initialize default Renderer instance.m_EditorResourcesAsset = instance.editorResources; // Set default post process data instance.m_PostProcessData = PostProcessData.GetDefaultPostProcessData(); return(instance); }
public ForwardRenderer(ForwardRendererData data) : base(data) { UniversalRenderPipelineAsset urpAsset = GraphicsSettings.renderPipelineAsset as UniversalRenderPipelineAsset; #if ENABLE_VR && ENABLE_XR_MODULE UniversalRenderPipeline.m_XRSystem.InitializeXRSystemData(data.xrSystemData); #endif m_BlitMaterial = CoreUtils.CreateEngineMaterial(data.shaders.blitPS); m_CopyDepthMaterial = CoreUtils.CreateEngineMaterial(data.shaders.copyDepthPS); m_SamplingMaterial = CoreUtils.CreateEngineMaterial(data.shaders.samplingPS); //m_TileDepthInfoMaterial = CoreUtils.CreateEngineMaterial(data.shaders.tileDepthInfoPS); //m_TileDeferredMaterial = CoreUtils.CreateEngineMaterial(data.shaders.tileDeferredPS); m_StencilDeferredMaterial = CoreUtils.CreateEngineMaterial(data.shaders.stencilDeferredPS); StencilStateData stencilData = data.defaultStencilState; m_DefaultStencilState = StencilState.defaultValue; m_DefaultStencilState.enabled = stencilData.overrideStencilState; m_DefaultStencilState.SetCompareFunction(stencilData.stencilCompareFunction); m_DefaultStencilState.SetPassOperation(stencilData.passOperation); m_DefaultStencilState.SetFailOperation(stencilData.failOperation); m_DefaultStencilState.SetZFailOperation(stencilData.zFailOperation); m_ForwardLights = new ForwardLights(); //m_DeferredLights.LightCulling = data.lightCulling; this.m_RenderingMode = data.renderingMode; // Note: Since all custom render passes inject first and we have stable sort, // we inject the builtin passes in the before events. m_MainLightShadowCasterPass = new MainLightShadowCasterPass(RenderPassEvent.BeforeRenderingShadows); m_AdditionalLightsShadowCasterPass = new AdditionalLightsShadowCasterPass(RenderPassEvent.BeforeRenderingShadows); #if ENABLE_VR && ENABLE_XR_MODULE m_XROcclusionMeshPass = new XROcclusionMeshPass(RenderPassEvent.BeforeRenderingOpaques); // Schedule XR copydepth right after m_FinalBlitPass(AfterRendering + 1) m_XRCopyDepthPass = new CopyDepthPass(RenderPassEvent.AfterRendering + 2, m_CopyDepthMaterial); #endif m_DepthPrepass = new DepthOnlyPass(RenderPassEvent.BeforeRenderingPrePasses, RenderQueueRange.opaque, data.opaqueLayerMask); m_DepthNormalPrepass = new DepthNormalOnlyPass(RenderPassEvent.BeforeRenderingPrePasses, RenderQueueRange.opaque, data.opaqueLayerMask); if (this.renderingMode == RenderingMode.Deferred) { m_DeferredLights = new DeferredLights(m_TileDepthInfoMaterial, m_TileDeferredMaterial, m_StencilDeferredMaterial); m_DeferredLights.AccurateGbufferNormals = data.accurateGbufferNormals; //m_DeferredLights.TiledDeferredShading = data.tiledDeferredShading; m_DeferredLights.TiledDeferredShading = false; m_GBufferPass = new GBufferPass(RenderPassEvent.BeforeRenderingOpaques, RenderQueueRange.opaque, data.opaqueLayerMask, m_DefaultStencilState, stencilData.stencilReference, m_DeferredLights); // Forward-only pass only runs if deferred renderer is enabled. // It allows specific materials to be rendered in a forward-like pass. // We render both gbuffer pass and forward-only pass before the deferred lighting pass so we can minimize copies of depth buffer and // benefits from some depth rejection. // - If a material can be rendered either forward or deferred, then it should declare a UniversalForward and a UniversalGBuffer pass. // - If a material cannot be lit in deferred (unlit, bakedLit, special material such as hair, skin shader), then it should declare UniversalForwardOnly pass // - Legacy materials have unamed pass, which is implicitely renamed as SRPDefaultUnlit. In that case, they are considered forward-only too. // TO declare a material with unnamed pass and UniversalForward/UniversalForwardOnly pass is an ERROR, as the material will be rendered twice. StencilState forwardOnlyStencilState = DeferredLights.OverwriteStencil(m_DefaultStencilState, (int)StencilUsage.MaterialMask); ShaderTagId[] forwardOnlyShaderTagIds = new ShaderTagId[] { new ShaderTagId("UniversalForwardOnly"), new ShaderTagId("SRPDefaultUnlit"), // Legacy shaders (do not have a gbuffer pass) are considered forward-only for backward compatibility new ShaderTagId("LightweightForward") // Legacy shaders (do not have a gbuffer pass) are considered forward-only for backward compatibility }; int forwardOnlyStencilRef = stencilData.stencilReference | (int)StencilUsage.MaterialUnlit; m_RenderOpaqueForwardOnlyPass = new DrawObjectsPass("Render Opaques Forward Only", forwardOnlyShaderTagIds, true, RenderPassEvent.BeforeRenderingOpaques + 1, RenderQueueRange.opaque, data.opaqueLayerMask, forwardOnlyStencilState, forwardOnlyStencilRef); m_GBufferCopyDepthPass = new CopyDepthPass(RenderPassEvent.BeforeRenderingOpaques + 2, m_CopyDepthMaterial); m_TileDepthRangePass = new TileDepthRangePass(RenderPassEvent.BeforeRenderingOpaques + 3, m_DeferredLights, 0); m_TileDepthRangeExtraPass = new TileDepthRangePass(RenderPassEvent.BeforeRenderingOpaques + 4, m_DeferredLights, 1); m_DeferredPass = new DeferredPass(RenderPassEvent.BeforeRenderingOpaques + 5, m_DeferredLights); } // Always create this pass even in deferred because we use it for wireframe rendering in the Editor or offscreen depth texture rendering. m_RenderOpaqueForwardPass = new DrawObjectsPass(URPProfileId.DrawOpaqueObjects, true, RenderPassEvent.BeforeRenderingOpaques, RenderQueueRange.opaque, data.opaqueLayerMask, m_DefaultStencilState, stencilData.stencilReference); m_CopyDepthPass = new CopyDepthPass(RenderPassEvent.AfterRenderingSkybox, m_CopyDepthMaterial); m_DrawSkyboxPass = new DrawSkyboxPass(RenderPassEvent.BeforeRenderingSkybox); m_CopyColorPass = new CopyColorPass(RenderPassEvent.AfterRenderingSkybox, m_SamplingMaterial, m_BlitMaterial); #if ADAPTIVE_PERFORMANCE_2_1_0_OR_NEWER if (!UniversalRenderPipeline.asset.useAdaptivePerformance || AdaptivePerformance.AdaptivePerformanceRenderSettings.SkipTransparentObjects == false) #endif { m_TransparentSettingsPass = new TransparentSettingsPass(RenderPassEvent.BeforeRenderingTransparents, data.shadowTransparentReceive); m_RenderTransparentForwardPass = new DrawObjectsPass(URPProfileId.DrawTransparentObjects, false, RenderPassEvent.BeforeRenderingTransparents, RenderQueueRange.transparent, data.transparentLayerMask, m_DefaultStencilState, stencilData.stencilReference); } m_OnRenderObjectCallbackPass = new InvokeOnRenderObjectCallbackPass(RenderPassEvent.BeforeRenderingPostProcessing); #pragma warning disable 618 // Obsolete warning PostProcessData postProcessData = data.postProcessData ? data.postProcessData : urpAsset.postProcessData; #pragma warning restore 618 // Obsolete warning if (postProcessData != null) { m_ColorGradingLutPass = new ColorGradingLutPass(RenderPassEvent.BeforeRenderingPrePasses, postProcessData); m_PostProcessPass = new PostProcessPass(RenderPassEvent.BeforeRenderingPostProcessing, postProcessData, m_BlitMaterial); m_FinalPostProcessPass = new PostProcessPass(RenderPassEvent.AfterRendering + 1, postProcessData, m_BlitMaterial); m_AfterPostProcessColor.Init("_AfterPostProcessTexture"); m_ColorGradingLut.Init("_InternalGradingLut"); } m_CapturePass = new CapturePass(RenderPassEvent.AfterRendering); m_FinalBlitPass = new FinalBlitPass(RenderPassEvent.AfterRendering + 1, m_BlitMaterial); #if UNITY_EDITOR m_SceneViewDepthCopyPass = new SceneViewDepthCopyPass(RenderPassEvent.AfterRendering + 9, m_CopyDepthMaterial); #endif // RenderTexture format depends on camera and pipeline (HDR, non HDR, etc) // Samples (MSAA) depend on camera and pipeline m_CameraColorAttachment.Init("_CameraColorTexture"); m_CameraDepthAttachment.Init("_CameraDepthAttachment"); m_DepthTexture.Init("_CameraDepthTexture"); m_NormalsTexture.Init("_CameraNormalsTexture"); if (this.renderingMode == RenderingMode.Deferred) { m_GBufferHandles = new RenderTargetHandle[(int)DeferredLights.GBufferHandles.Count]; m_GBufferHandles[(int)DeferredLights.GBufferHandles.DepthAsColor].Init("_GBufferDepthAsColor"); m_GBufferHandles[(int)DeferredLights.GBufferHandles.Albedo].Init("_GBuffer0"); m_GBufferHandles[(int)DeferredLights.GBufferHandles.SpecularMetallic].Init("_GBuffer1"); m_GBufferHandles[(int)DeferredLights.GBufferHandles.NormalSmoothness].Init("_GBuffer2"); m_GBufferHandles[(int)DeferredLights.GBufferHandles.Lighting] = new RenderTargetHandle(); m_GBufferHandles[(int)DeferredLights.GBufferHandles.ShadowMask].Init("_GBuffer4"); } m_OpaqueColor.Init("_CameraOpaqueTexture"); m_DepthInfoTexture.Init("_DepthInfoTexture"); m_TileDepthInfoTexture.Init("_TileDepthInfoTexture"); supportedRenderingFeatures = new RenderingFeatures() { cameraStacking = true, }; if (this.renderingMode == RenderingMode.Deferred) { // Deferred rendering does not support MSAA. this.supportedRenderingFeatures.msaa = false; // Avoid legacy platforms: use vulkan instead. unsupportedGraphicsDeviceTypes = new GraphicsDeviceType[] { GraphicsDeviceType.OpenGLCore, GraphicsDeviceType.OpenGLES2, GraphicsDeviceType.OpenGLES3 }; } }