Documentation

// Bordercraft - Selection Outline for URP · v1.0.0 · Unity 6 / URP 17+

How It Works

Bordercraft hooks into URP's RenderGraph pipeline and draws a screen-space outline — a soft blurred glow, or a cheap hard edge line — around whichever GameObjects are currently selected. Selection is driven by flipping a reserved bit on the object's own renderers, so there's no scene setup and no per-project Layer configuration.

The outline only runs for a channel while at least one GameObject is currently selected on it. A channel with nothing selected costs nothing. This is the one thing most screen-space outline effects get wrong — they run their full pass every frame the moment the Renderer Feature is enabled, whether or not anything is actually outlined.

Requirements

Quick Start

You can also create profiles directly via Assets → Create → Bordercraft → Outline Profile, or by clicking + Add Channel on the Outline Renderer Feature's Inspector to wire up a second channel with its own new profile in one click.

Demo Scene

Samples/Demo.unity walks through every feature with an on-screen button panel. The Samples folder is optional — nothing else in the package depends on it, so it is safe to delete.

The buttons write into the demo profile assets, so the last look you picked stays in those assets after you exit Play. Press Reset to return to the default Soft look.

Channels

The Renderer Feature's Inspector shows one row per configured channel, Channel 0 onward, plus a + Add Channel button (up to 4 total). By default only Channel 0 is filled in, so Outliner.SetSelected(go, true) — which defaults to channel 0 — is all most projects need.

To show a second, independently-styled outline at the same time (e.g. a different color for enemies vs interactables), click + Add Channel, then select those objects with Outliner.SetSelected(go, true, 1). Each channel is fully independent — its own profile, its own zero-cost-when-idle gating, its own scissor rect — so an empty or unused slot costs nothing even while others are active.

Outline Styles

Soft grows the silhouette (Dilate, only when Gap or Wave is non-zero), blurs it (separable Gaussian, 2 passes), then subtracts the original from the blurred result to get a ring. Hard skips the blur entirely and samples two rings of the raw silhouette per pixel (near/far taps) instead — cheaper, but the line can't use the same wave-driven thickness variation trick as Soft.

Additive vs Opaque

OutlineProfile.opaque controls how the outline's color blends onto the scene.

Visibility & Occlusion

OutlineProfile.visibility controls how the outline resolves against the depth of the rest of the scene. It is decided per pixel, not per object — a half-covered target is outlined on the covered half only.

Where Hidden is the "where did my character go" effect — the classic outline that tracks a character walking behind a wall. It needs no bookkeeping on your side to switch on and off: an unoccluded target simply produces an empty mask, so nothing is drawn.

Cost. Both Where modes bind the camera's real depth buffer, which forces the silhouette buffer to full camera resolution with matching MSAA; Always skips that entirely. Where Hidden additionally draws the target's renderers a second time (the erase) inside the same render pass — no extra pass and no extra render target. Note that none of this makes a channel free when nothing happens to be occluded: zero-cost-when-idle is about having no active target, and an active-but-unoccluded target still runs the pass chain and produces an empty result.

OutlineProfile

An OutlineProfile is a serializable asset describing an outline's look — style, color, radius, wave, etc. It contains no rendering plumbing; that lives entirely in the Renderer Feature.

Ways to create a profile: Assets → Create → Bordercraft → Outline Profile, click + Add Channel on the Outline Renderer Feature's Inspector, or let the Setup Wizard create and assign one automatically.

Parameters

OutlineTarget

OutlineTarget marks a GameObject (and its child renderers) to be drawn with the outline. Most projects never touch this directly — Outliner.SetSelected adds and toggles it automatically. For objects you want pre-wired in the Editor instead, add it directly and just toggle its enabled checkbox — this works both in Play mode and in the Editor outside Play mode.

If any of those renderers is a Skinned Mesh Renderer with Update When Offscreen off, the Inspector shows a warning with a button that turns it on. See Troubleshooting for why it matters.

Call outlineTarget.Refresh() after adding or removing renderers on the object at runtime, so the outline picks up the change instead of continuing to use a stale cached list.

Runtime API

using Bordercraft;

// Select on channel 0 (the default most projects use):
Outliner.SetSelected(myGameObject, true);
Outliner.SetSelected(myGameObject, false);

// Select on a specific channel (0-3), routing to a different profile/look:
Outliner.SetSelected(myGameObject, true, 1);

Calling SetSelected is safe on any GameObject, including one that was never previously selected — no scene setup or pre-placed component required.

Common Patterns

Swap channels for different object types

void Highlight(GameObject go, bool isEnemy)
{
    Outliner.SetSelected(go, true, isEnemy ? 1 : 0);
}

Clear a previous selection before selecting a new one

if (previousSelection != null)
    Outliner.SetSelected(previousSelection, false);

Outliner.SetSelected(newSelection, true);
previousSelection = newSelection;

Change a profile at runtime

Every profile field can be changed while the game runs and takes effect on the next frame. Two things to keep in mind:

Speed the outline up as the player gets close:

using Bordercraft;
using UnityEngine;

public class DangerPulse : MonoBehaviour
{
    [SerializeField] private OutlineProfile profile;   // the asset assigned to this object's channel
    [SerializeField] private Transform player;
    [SerializeField] private float dangerDistance = 5f;

    private float restSpeed;

    private void OnEnable() => restSpeed = profile.waveSpeed;

    private void Update()
    {
        float closeness = 1f - Mathf.Clamp01(Vector3.Distance(transform.position, player.position) / dangerDistance);
        profile.waveSpeed = Mathf.Lerp(restSpeed, restSpeed * 3f, closeness);
    }

    // Edits made in Play mode stay in the asset in the Editor, so put the value back.
    private void OnDisable() => profile.waveSpeed = restSpeed;
}

Switch a channel to a completely different look, and back:

using Bordercraft;
using UnityEngine;

public class AlertLook : MonoBehaviour
{
    [SerializeField] private OutlineProfile profile;   // the asset assigned to this object's channel

    private OutlineProfile original;

    // An in-memory copy of the starting look, used to restore it.
    private void OnEnable() => original = Instantiate(profile);

    public void SetAlert(bool alert)
    {
        if (alert) ApplyAlertLook();
        else Restore();
    }

    // Write every field, so nothing from the previous look is left behind.
    private void ApplyAlertLook()
    {
        profile.style = OutlineStyle.Hard;
        profile.color = new Color(3f, 0.15f, 0.1f, 1f);   // above 1 glows when Bloom is on
        profile.opaque = false;
        profile.radius = 3;
        profile.gap = 2;
        profile.waveAmplitude = 5f;
        profile.waveFrequency = 10f;
        profile.waveSpeed = 10f;
        profile.waveUpdateRate = 4f;
        profile.thicknessVariation = 1f;
        profile.visibility = OutlineVisibility.Always;
    }

    // Copies every serialized field back from the saved copy.
    private void Restore() => JsonUtility.FromJsonOverwrite(JsonUtility.ToJson(original), profile);

    private void OnDisable()
    {
        Restore();
        Destroy(original);
    }
}

Known Limitations

Scissor rect is one shared box per channel, not per object

Every currently-outlined object on a channel contributes to a single scissor rect spanning the union of all of them, not a separate shaded region per object. Fine for one-object-at-a-time selection; several outlined objects far apart on screen on the same channel will scissor a rect spanning all of them, growing the shaded (and therefore shaded draw cost) area accordingly.

Wave frequency and the wrap seam

The wave's phase is the angle around the object multiplied by Wave Frequency, and that angle wraps around somewhere along the outline — directly to the left of the object's screen-space centre. The two sides of the wrap only line up when Wave Frequency is a whole number, so a fractional value leaves a step there: a place where the wave jumps rather than flows.

It is worst at a half-step (0.5, 4.5) where the two sides are in full opposition, and it scales with Wave Amplitude — easy to miss at a small amplitude, and a visible notch cut out of the outline at a large one. 0, 1, 2, 3… are all seam-free, 0 included. The default of 4 is deliberately a whole number for this reason.

Wave is designed for one outlined object at a time per channel

The wave's phase is the angle around a single screen-space centre, and that centre is the middle of the same union rect the scissor uses — so with two objects far apart on one channel it lands in the empty space between them rather than inside either. Seen from there each object spans only a narrow range of angles, so the sine barely changes across it and the wave stops travelling around the perimeter: the whole outline pulses in and out together instead, with the two objects at an arbitrary relative phase.

It still animates and still looks deliberate, so this is a degraded effect rather than a broken one — but it is not the effect the parameter describes. A channel outlining one object at a time, which is the usual case and what the four channels exist to make easy, is unaffected. Leave Wave Amplitude at 0 on a channel that routinely holds several scattered targets.

The wave shrinks by one amount per channel

How much the wave shrinks for a distant object is measured from the largest outlined object on the channel. Several small, distant objects shrink correctly however far apart they are, but a distant object sharing a channel with a close one keeps the close one's full wave. Give distant objects their own channel if that matters.

Wave animation only advances in the Editor while the view repaints

Outside Play mode Unity only redraws a view when something happens in it, so a profile with Wave Amplitude set moves while you move the mouse over the Game view and holds still when you stop. In Play mode it animates continuously.

2D Renderer not supported

The render pass assumes the standard 3D forward/deferred pipeline (mesh silhouette draws, camera depth access for occlusion mode) and has not been tested against URP's 2D Renderer.

Rendering Layer Usage

This package permanently reserves the top 4 bits (28-31) of every GameObject's Rendering Layer Mask — not however many of the 4 channels you actually configure, all 4 are reserved the moment the package is present in the project, since they're a fixed constant in code rather than something that scales with use.

Troubleshooting

Nothing shows when I call Outliner.SetSelected

The outline is see-through even with a solid color

Part of an animated character's outline is missing

Setup Wizard shows no renderers

Outline works in the Editor but is missing in a Player Build