I added a renderer feature for rendering outlines, using the method of expanding normals and rendering the backfaces of the model. For all objects with the OutlineRenderer component attached, it finds all visible renderers under them and uses cmd.DrawRenderer to draw the outlines. Everything works fine in the Editor, but when testing on the actual Quest device, only the outlined objects are rendered — everything else appears black. After capturing a frame with RenderDoc, I found that in the outline pass, the previous buffers were discarded and marked as STORE_DONT_CARE. The shader should be fine — did I miss something in the renderer feature?
Before rendering outline:
outline pass:
it shows STORDONTCARE:
render state:
i’m using unity 6000.0.41f1 with URP and testing on Quest3S and Quest3.
here’s my renderer feature code:
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;
using UnityEngine.Rendering.RenderGraphModule;
#if UNITY_EDITOR
using UnityEditor.SceneManagement;
#endif
public class OutlineRendererFeature : ScriptableRendererFeature
{
class OutlineRenderPass : ScriptableRenderPass
{
static Material m_Material;
static float m_MinScale;
static float m_MaxScale;
public OutlineRenderPass(Material material, float minScale, float maxScale)
{
m_Material = material;
m_MinScale = minScale;
m_MaxScale = maxScale;
}
private class PassData
{
internal Camera camera;
}
static Mesh GetMesh(Renderer renderer)
{
if (renderer is SkinnedMeshRenderer skinned)
{
return skinned.sharedMesh;
}
else
{
var filter = renderer.GetComponent<MeshFilter>();
return filter ? filter.sharedMesh : null;
}
}
static int GetSubMeshCount(Renderer renderer)
{
var mesh = GetMesh(renderer);
return mesh != null ? mesh.subMeshCount : 0;
}
// This static method is passed as the RenderFunc delegate to the RenderGraph render pass.
// It is used to execute draw commands.
static void ExecutePass(PassData data, RasterGraphContext context)
{
if (OutlineGlobal.outlineRendereList != null && OutlineGlobal.outlineRendereList.Count > 0)
{
foreach (var outlineRenderer in OutlineGlobal.outlineRendereList)
{
if (outlineRenderer)
{
if (outlineRenderer.material == null)
{
outlineRenderer.material = new Material(m_Material);
}
var rendererList = outlineRenderer.gameObject.GetComponentsInChildren<Renderer>();
if (rendererList != null && rendererList.Length > 0)
{
foreach (var renderer in rendererList)
{
if (renderer.isVisible)
{
int subMeshCount = GetSubMeshCount(renderer);
if (subMeshCount > 0)
{
for (int i = 0; i < subMeshCount; i++)
{
outlineRenderer.material.SetFloat("_OutlineWidth", outlineRenderer.outlineWidth);
outlineRenderer.material.SetColor("_OutlineColor", outlineRenderer.outlineColor);
outlineRenderer.material.SetFloat("_MinScale", m_MinScale);
outlineRenderer.material.SetFloat("_MaxScale", m_MaxScale);
int outlineShaderPassIndex = outlineRenderer.material.FindPass("Outline");
if (GeometryUtility.TestPlanesAABB(GeometryUtility.CalculateFrustumPlanes(data.camera), renderer.bounds))
{
context.cmd.DrawRenderer(renderer, outlineRenderer.material, i, outlineShaderPassIndex);
}
}
}
}
}
}
}
}
}
}
// RecordRenderGraph is where the RenderGraph handle can be accessed, through which render passes can be added to the graph.
// FrameData is a context container through which URP resources can be accessed and managed.
public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
{
const string passName = "Outline Pass";
// This adds a raster render pass to the graph, specifying the name and the data type that will be passed to the ExecutePass function.
using (var builder = renderGraph.AddRasterRenderPass<PassData>(passName, out var passData))
{
UniversalResourceData resourceData = frameData.Get<UniversalResourceData>();
UniversalCameraData cameraData = frameData.Get<UniversalCameraData>();
passData.camera = cameraData.camera;
// This sets the render target of the pass to the active color texture. Change it to your own render target as needed.
builder.SetRenderAttachment(resourceData.activeColorTexture, 0, AccessFlags.Write);
builder.SetRenderAttachmentDepth(resourceData.activeDepthTexture, AccessFlags.Read);
builder.AllowGlobalStateModification(true);
builder.AllowPassCulling(false);
// Assigns the ExecutePass function to the render pass delegate. This will be called by the render graph when executing the pass.
builder.SetRenderFunc((PassData data, RasterGraphContext context) => ExecutePass(data, context));
}
}
}
OutlineRenderPass m_OutlineRenderPass;
public Material material;
public float minScale = 1f;
public float maxScale = 500f;
/// <inheritdoc/>
public override void Create()
{
m_OutlineRenderPass = new OutlineRenderPass(material, minScale, maxScale);
// Configures where the render pass should be injected.
m_OutlineRenderPass.renderPassEvent = RenderPassEvent.AfterRenderingTransparent;
}
// Here you can inject one or multiple render passes in the renderer.
// This method is called when setting up the renderer once per-camera.
public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
{
#if UNITY_EDITOR
if (PrefabStageUtility.GetCurrentPrefabStage() != null)
{
return; // Skip in prefab view
}
#endif
if (renderingData.cameraData.cameraType == CameraType.SceneView || renderingData.cameraData.cameraType == CameraType.Game)
{
if (OutlineGlobal.renderOutline)
renderer.EnqueuePass(m_OutlineRenderPass);
}
}
}
