Modifying universal render data at runtime

ScriptableRenderPipeline The object contains UniversalRenderData object , Can be set at run time UniversalRenderData Object to get a specific display result .

using UnityEngine;
using UnityEngine.Rendering.Universal;

public class SetUniversalRenderData : MonoBehaviour
{
	[SerializeField]
	UniversalRendererData renderData;

	void Update()
	{
		if (Input.GetKeyDown(KeyCode.Alpha0))
		{
			renderData.opaqueLayerMask = 0;
            // Set up renderData The opaque layer of is “Nothing”
		}

		if (Input.GetKeyDown(KeyCode.Alpha1))
		{
			renderData.opaqueLayerMask = ~0;
            // Set up renderData The opaque layer of is “Everything”
		}

		if (Input.GetKeyDown(KeyCode.Alpha2))
		{
			ScreenSpaceOutlines screenSpaceOutlines = renderData.rendererFeatures[0] as ScreenSpaceOutlines;
			if (screenSpaceOutlines != null)screenSpaceOutlines.SetColor(Color.blue);
            // By executing the first render feature Provided SetColor Method to modify the display effect .
		}

		if (Input.GetKeyDown(KeyCode.Alpha3))
		{
			ScreenSpaceOutlines screenSpaceOutlines = renderData.rendererFeatures[0] as ScreenSpaceOutlines;
			if (screenSpaceOutlines != null) screenSpaceOutlines.SetColor(Color.yellow);
            // By executing the first render feature Provided SetColor Method to modify the display effect .
		}

		if (Input.GetKeyDown(KeyCode.Alpha4))
		{
			renderData.rendererFeatures[0].SetActive(false);
            // Set up a render feature Is inactive 
		}

		if (Input.GetKeyDown(KeyCode.Alpha5))
		{
			renderData.rendererFeatures[0].SetActive(true);
            // Set up a render feature Is active 
		}
	}
}

The above code demonstrates how to switch by keyboard numbers RenderData attribute , perform RenderFeature Methods and changes RenderFeature state .

The following code snippet posts the above mentioned RenderFeature The content of , You can see what it contains SetColor Method .

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;

public class ScreenSpaceOutlines : ScriptableRendererFeature
{
	class ViewSpaceNormalsTexturePass : ScriptableRenderPass
	{
		readonly Material normalsMaterials;
		readonly List<ShaderTagId> shaderTagIdList;
		FilteringSettings filteringSettings;
		readonly RenderTargetHandle normals;
		public RenderTargetIdentifier identifier { get { return normals.Identifier(); } }
		LayerMask outlineLayerMask;
		int msaaSamples;

		public ViewSpaceNormalsTexturePass(LayerMask outlineLayerMask, int msaaSamples)
		{
			normalsMaterials = new Material(Shader.Find("Hidden/ViewSpaceNormals"));
			shaderTagIdList = new List<ShaderTagId>
			{
				new ShaderTagId("UniversalForward"),
				new ShaderTagId("UniversalForwardOnly"),
				new ShaderTagId("LightWeightForward"),
				new ShaderTagId("SRPDefaultUnlit")
			};

			renderPassEvent = RenderPassEvent.AfterRenderingSkybox;
			this.outlineLayerMask = outlineLayerMask;
			this.msaaSamples = msaaSamples;
			normals.Init("_SceneViewSpaceNormals");
		}

		public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
		{
			RenderTextureDescriptor renderTextureDescriptor = cameraTextureDescriptor;
			renderTextureDescriptor.msaaSamples = msaaSamples;
			cmd.GetTemporaryRT(normals.id, renderTextureDescriptor, FilterMode.Point);
			ConfigureTarget(identifier);
			ConfigureClear(ClearFlag.All, Color.clear);
		}

		public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
		{
			if (!normalsMaterials) return;
			DrawingSettings drawSettings = CreateDrawingSettings(shaderTagIdList, ref renderingData, renderingData.cameraData.defaultOpaqueSortFlags);
			drawSettings.overrideMaterial = normalsMaterials;
			filteringSettings = new FilteringSettings(RenderQueueRange.opaque, outlineLayerMask);
			context.DrawRenderers(renderingData.cullResults, ref drawSettings, ref filteringSettings);
		}
	}

	class ScreenSpaceOutlinePass : ScriptableRenderPass
	{
		Material screenSpaceOutlineMaterial;
		RenderTargetIdentifier cameraColorTarget;
		readonly RenderTargetIdentifier normalsIdentifier;

		Material CreateMaterial() { screenSpaceOutlineMaterial = new Material(Shader.Find("Hidden/ViewSpaceOutline")); return screenSpaceOutlineMaterial; }
		public void SetColor(Color color)
		{
			if (!screenSpaceOutlineMaterial) screenSpaceOutlineMaterial = CreateMaterial();
			screenSpaceOutlineMaterial.SetColor("_Color", color);
			screenSpaceOutlineMaterial.SetFloat("_Intensity", color.a);
		}

		public ScreenSpaceOutlinePass(RenderTargetIdentifier normalsIdentifier, Color color)
		{
			renderPassEvent = RenderPassEvent.AfterRenderingSkybox;
			this.normalsIdentifier = normalsIdentifier;
			screenSpaceOutlineMaterial = new Material(Shader.Find("Hidden/ViewSpaceOutline"));
			SetColor(color);
		}

		public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
		{
			cameraColorTarget = renderingData.cameraData.renderer.cameraColorTarget;
		}

		public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
		{
			if (!screenSpaceOutlineMaterial) return;
			CommandBuffer cmd = CommandBufferPool.Get();
			Blit(cmd, normalsIdentifier, cameraColorTarget, screenSpaceOutlineMaterial, 0);
			context.ExecuteCommandBuffer(cmd);
			CommandBufferPool.Release(cmd);
		}
	}

	ViewSpaceNormalsTexturePass viewSpaceNormalsTexturePass;
	ScreenSpaceOutlinePass screenSpaceOutlinePass;

	public override void Create()
	{
		viewSpaceNormalsTexturePass = new ViewSpaceNormalsTexturePass(outlineLayerMask, msaaSamples);
		screenSpaceOutlinePass = new ScreenSpaceOutlinePass(viewSpaceNormalsTexturePass.identifier, color);
	}

	public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
	{
		renderer.EnqueuePass(viewSpaceNormalsTexturePass);
		renderer.EnqueuePass(screenSpaceOutlinePass);
	}

	[SerializeField]
	LayerMask outlineLayerMask;
	[SerializeField]
	Color color = Color.yellow;
	[SerializeField]
	[Range(1, 16)]
	int msaaSamples = 2;

	public void SetColor(Color color)
	{
		if (screenSpaceOutlinePass != null) screenSpaceOutlinePass.SetColor(color);
	}

	public void SetMsaaSamples(int msaaSamples)
	{
		this.msaaSamples = Mathf.Clamp(msaaSamples, 1, 16);
	}

	public void SetLayerMask(LayerMask outlineLayerMask)
	{
		this.outlineLayerMask = outlineLayerMask;
	}
}