API Reference

Runtime look writes go to a private copy of the profile instead of the shared asset.

The master switch: whether the outline is drawn at all.

Main Outline switch: the rim drawn where the object is visible.

X-Ray Outline switch: the rim drawn where the object is hidden.

Main Fill switch: the tint over the visible body.

X-Ray Fill switch: the tint over the hidden body.

Rim colour of the pass being edited (Main Outline outside an edit scope).

Rim width of the pass being edited, in the profile's Width Mode units.

Opacity of the pass being edited, 0 to 1.

Whether the pass being edited pulses.

Whether an edit scope is open.

Whether the component is enabled on an active object.

Whether a pass's switch is on. Reads back what was set.

Whether a pass is on screen: component live, master switch on, pass switch on, slot filled and its Project Feature on.

Switch a pass on or off. Its profile stays in the slot.

The profile a pass draws with: the private copy if there is one, else the asset.

Put a profile in a pass's slot. Null empties the slot. Rebuilds.

Whether a pass wears styleProfile. With includeForks, a private copy made from it counts too.

The asset a pass returns to: the one its private copy was made from, or the one in the slot when there is no copy.

In play mode, give a pass a private copy of its profile and return it. Outside play mode, returns the asset itself.

Whether a pass is currently drawing with a private copy.

Drop every private copy and put the shared assets back.

Move a pass to another profile over time. Numbers and colours slide when the two profiles draw alike; otherwise the outline fades out, changes over and fades in. The shared assets are not edited, and at the end the profile itself is in the slot. Any other write to the pass ends the blend where it is.

outline.BlendTo(KeylinePassKind.MainOutline, hoverProfile, 0.25f);

True while BlendTo is moving this pass.

Jump a running blend to its end.

Stop a running blend where it is; the pass keeps the in-between look.

Set one pass's rim colour. Material write only.

Set one pass's rim width, in the profile's Width Mode units.

Set one pass's opacity, 0 to 1.

Set the style of the pass being edited (Main Outline outside an edit scope).

Start a batch of writes to one pass. Structural changes wait for the matching end.

End the batch opened by BeginPassStyleProfileEdit and apply it.

A batch of writes to one pass, closed by using.

using (outline.EditScope(KeylinePassKind.XRayOutline))
{
    outline.SetStyle(KeylineStyle.Neon);
    outline.Width = 0.03f;
}

Set up every hull pass from one description, with one rebuild.

World bounds the outline covers. False when there is nothing.

Rebuild the generated objects from the current profiles. Does nothing while disabled.

Re-apply the profiles to the materials without rebuilding.

Raised when OutlineEnabled actually changes.

Raised after a slot is given a different profile. Not raised for private copies.

Raised after a Rebuild finishes.

Whether this outline still exists. Use it instead of == null on an interface reference, which does not see destroyed components.

Whether this highlight target still exists. See the outline overload.

The outline that draws hit: on the object or a parent, resolved to the outline that controls the figure when the one found was generated or adopted.

if (Physics.Raycast(ray, out RaycastHit hit)
    && KeylineOutlineRef.TryGetFrom(hit.collider, out IKeylineOutline outline))
{
    outline.OutlineEnabled = true;
}

The outline on gameObject, adding one if there is none: Keyline Outline 2D on a sprite, Keyline Outline 3D otherwise. Null for a null object.

IKeylineOutline outline = KeylineOutlineRef.GetOrAdd(enemy);
outline.Configure(new KeylineSetup { MainOutline = hostileProfile, Enabled = true });

Set the master switch on every outline in the list.

Switch one pass on or off on every outline in the list.

Put one profile in one pass's slot on every outline in the list.

Set one pass's rim colour on every outline in the list.

Close the burst. Anything the writes deferred happens here, once.

The profile this setup names for a pass.

The style this setup names for a pass, or null when it names none.

Profile for the visible rim, or null to leave that slot empty.

Profile for the rim that shows through occluders.

Profile for the fill over the visible part.

Profile for the fill over the hidden part.

Style for the visible rim, or null to keep the profile's own.

Style for the X-Ray rim, or null to keep the profile's own.

Style for the fill over the visible part, or null to keep the profile's own.

Style for the fill over the hidden part, or null to keep the profile's own.

Whether the outline draws at all once configured, or null to leave that as it is.

True for the two Cutout Overlay passes, which only a mesh outline has.

Whether an overlay kind is the X-Ray one. Meaningless for the other four.

The pass's name as the inspector writes it on its card.

Whether Project Settings ▸ Keyline ▸ Features lets a pass draw on this kind of outline.

Whether a value is one of the defined passes.

The four passes every Keyline component has. The two overlays are extra.

Every pass a mesh outline can address.

True when this controller was created by a parent outline rather than by hand.

True when a parent outline claimed this one through AdoptChild rather than by growing a generated component.

The outline that currently claims this one — generated owner or adoptive parent — or null when this outline is independent.

The child outlines this one created. Empty unless it is splitting them.

Outlines claimed through AdoptChild. Empty until something asks.

Unity's own answer, surfaced on the interface.

Whether writes fork the slot instead of landing on the shared asset. Turning it off does not un-fork slots already forked — call RevertSharedPassStyleProfiles.

Which layer the mirrors are put on. MatchRenderer matches each mirror to its renderer's layer and rendering layers; Fixed keeps them all on layer 0 as 1.2.0 did.

In play mode, check every frame whether a renderer changed layer and move its mirrors. Off by default; SyncLayers does the same once, on request.

Stop drawing a renderer's outline while the renderer is switched off or its object is inactive. Renderers hidden by the Reveal recipe keep theirs.

The LOD level of a LOD Group whose renderers the outline is built from. Clamped to the group's levels. Changing it rebuilds.

Follow the source material's alpha cutout instead of the polygon edge — grass cards, foliage, decals.

Which faces draw this pass (not the interior stencil mask).

The look this profile draws.

Which program draws this pass: Full, or the cheap Solid-only Mobile Solid one.

Full-shader feature mask (ignored on Mobile Solid profile). Solid style is always allowed.

Main colour of the outline.

Second colour of the styles that use one.

How far the outline reaches out from the surface.

Overall transparency of the whole outline, on top of the colours' own alpha.

<inheritdoc/>

World keeps the outline in proportion to the object: it thins out with distance and goes away with the thing it is on.

Give detected sheets a shell, so a card still has an outline seen edge-on. Off leaves in-plane growth only.

Sheet detection: Thickness (one ray) or MultiRay (a cone of rays).

Sheet detection: neighbour flatness, read only when a thickness ray misses the face. Clamped to 0.5–0.995.

Sheet detection, MultiRay: rays per face, from 1 (the normal only) to 4.

Sheet detection, MultiRay: cone half-angle in degrees, 5–30. Read only when more than one ray is cast.

Sheet detection: smallest face island that may count as a sheet.

Smallest connected piece of the finished outline, in triangles, that is kept. Applies where the outline builds its own copy of the mesh. Changing it rebuilds.

Sheet detection: thickness in centimetres. Thinner than this counts as a sheet. Clamped to 0.01–1.

Sheet detection: gap in centimetres under which a border still counts as a hard edge of the volume. A flat piece farther off the surface is separate. Clamped to 0.01–2.

With Smooth Normals on: how far a hard edge may push its outline out to keep the same thickness as a curved one. 1 (default) adds nothing; 1.45 brings square edges to the full Width. Clamped to 1–8.

Sheet Solidify with one number for the shell: thickness and in-plane spread together, × Width. Reading it under Separate returns Thickness. Setting it writes Volume, Thickness and Lateral. 0–2.

Sheet Solidify: size the shell with Thickness and Lateral separately rather than the single Volume.

Sheet Solidify: how far the shell is pushed out to each side of the sheet, × Width (Separate). 0–2.

Sheet Solidify: shell growth within the sheet's plane, × Width (Separate). 0–2.

Sheet Solidify: push the shell towards one side of local X (+ = +X, − = −X). −2–2.

Sheet Solidify: push the shell towards one side of local Y (+ = +Y, − = −Y). −2–2.

Effective Solidify thickness (±N). Uniform uses Sheet Volume.

Effective Solidify in-plane scale. Uniform uses Sheet Volume.

True when Solidify topology should be active (enabled + either axis > 0).

Brightness multiplier for the styles that emit.

Neon / Frost / Water: how quickly the view-facing rim fades.

Sketch / Electric: how far the line is pushed around by the noise.

Sketch / Electric: how fast the noise re-rolls.

Frost: reach of the outer halo, in the same units as Width.

Frost: opacity of the outer halo relative to the core band.

Pattern: greyscale mask tiled along the outline.

Pattern: tiling of the mask.

Pattern: scroll speed of the mask along X and Y, in tiles per second.

Pattern: contrast applied to the mask before the threshold — sharpens soft artwork into a crisp stencil.

Pattern: mask level that separates visible from clipped.

Double: thickness of the inner ring, in the same units as Width.

Double: clear space between the two rings.

Double: thickness of the outer ring, drawn in the Secondary colour.

Rainbow: how tightly the spectrum repeats along the ramp.

Rainbow: how fast the bands travel.

Rainbow: colour purity, 1 full spectrum, 0 greyscale bands.

Rainbow: Vertical runs the bands down the screen; Circular orbits them around the object's centre.

Circular Rainbow: object-local X of orbit center (0 = pivot).

Circular Rainbow: object-local Y of orbit center (0 = pivot).

Rainbow, Vertical: sweep direction in degrees. 0 is the vertical axis, the same bands the style had before this existed.

Rainbow, Vertical: how far the sweep leans out of the style space's XY plane, in degrees. 0 stays in the plane. Meshes in Object or World space only.

Frost: density and brightness of the shimmering ice sparks.

Frost: how large a patch of plain ice is left where the surface faces the camera, 0 to 1. Zero shows the strata everywhere, pinwheel included.

Gradient: direction of the sweep in degrees. 0 sweeps bottom to top.

Gradient: how far the sweep leans out of the style space's XY plane, -90 to 90 degrees. Zero keeps it in the plane, where GradientAngle alone sets it. Read by Linear in Object and World space and by the Radial stretch axis.

Gradient: slides the ramp along its own direction, -1 to 1. The parameter a gauge drives: with a transparent colour at one end of the ramp and an opaque one at the other, this is where the boundary between them sits.

Gradient: width of the blend between the two colours. 0 is a hard edge.

Gradient: Linear ramps along the angle, Radial ramps outwards from GradientCenter.

Gradient, Radial only: the world point the ramp spreads from. World rather than local on purpose. A wave that several objects have to render in step needs one origin they all agree on, and a local point would give each of them their own.

Gradient, Radial only: how far from the centre the ramp spans, in metres.

Gradient: 0 is a ramp, above zero a travelling band of this half-width.

Gradient, Radial only: how far the ramp reaches along GradientAngle relative to across it. 1 is a sphere.

Gradient, Radial only: how far the ramp reaches along the Angle axis.

Halo: how many concentric layers the glow is built from. Structural, unlike the other Halo values: each layer is a mirror renderer, so changing the count builds or tears down geometry rather than re-tinting it.

Coordinate space the style's pattern, noise or gradient lives in. Object space rides with the object, world space stays put as it moves, screen space stays put as the camera moves, UV space follows the mesh's own layout.

Pulse: beats per second.

Pulse: how deep the swing goes, as a fraction of the resting width.

How the outline composites over the frame. Default lets the style decide, which is what every profile did before blend modes existed.

Paint each pixel once however many times the hull covers it — the overlap fence. Honoured only by the single-band styles; the layered ones (Halo, Frost, Double) are built out of stacking and ignore it, exactly as the inspector explains. 3D only: a sprite's outline is one quad and covers no pixel twice.

Screen-space fade on the active rim pass, in pixels. 0 is a hard edge. Interior Fill ignores the value. Needs the Soft Edge pass in the pipeline.

Cutout rim: how far the edge fades out, in screen pixels.

Cutout rim: how far the outline runs under the artwork, in screen pixels.

Lava: how far the crust has broken open, 0 solid to 1 all glow.

Lava: size of the crust cells.

Lava: how fast the molten core moves under the crust.

Lava: brightness of the hot core inside the cracks.

Lava: direction the flow runs, in degrees.

Lava: how much the flow curls instead of sliding straight.

Lava: how fast the glow breathes, in beats per second.

Lava: how deeply the pulse swings, as a fraction of the heat.

Smoke: how much of the cloud survives.

Smoke: size of the billows.

Smoke: how fast the cloud drifts.

Smoke: direction of the drift within the style space's XY plane, in degrees.

Smoke: how far the drift leans out of that plane, in degrees. Zero stays in it.

Smoke: how much the billows curl as they travel.

Smoke: how far along the drift the cloud reaches, as a fraction of the shape.

Smoke: how raggedly the cloud ends, once Height has decided where.

Crystal: size of the facets.

Crystal: direction of the light the facets catch, in degrees.

Crystal: how fast the light source orbits the stone.

Crystal: how much fire the stone has — how many facets catch the light.

Crystal: ceiling on how far a lit facet washes out towards white.

Crystal: how visible the cut edges between facets are.

Crystal: how evenly sized the facets are.

Crystal: depth shading of the facets.

Crystal: how far neighbouring facets split between the two colours.

Water: how fast the ripples travel.

Water: direction of the flow, in degrees.

Water: size of the ripples.

Water: brightness of the caustic crests.

Water: how much the ripples curl rather than scrolling straight.

Water: view-facing sheen on the crests.

Fire: how fast the tongues rise.

Fire: direction the flame rises within the style space's XY plane, in degrees.

Fire: how far the rise leans out of that plane, in degrees. Zero stays in it.

Fire: how far up the object the flame reaches.

Fire: how stretched the tongues are along the rise.

Fire: size of the tongues.

Fire: how much the tongues fold and curl as they rise.

Fire: brightness of the root, past the colour into white-hot.

Fire: how much the whole flame gutters over time.

Layers that do not hide this outline's Main Outline and Main Fill.

Judge the Main passes at the object's own depth rather than at the hull's.

How far past the object's own volume the contact test reaches, in metres.

Draw the children inside this outline's silhouette rather than beside it.

Share a silhouette with whatever this overlaps, if that one agrees too.

See _shareStencilWithOthers.

How many renderers were dropped for their type on the last collect.

One of the dropped renderers, for a message that can name something.

Persisted bakes currently assigned to this controller (read-only).

Whether the outline draws at all — the master switch above every pass.

Main Outline switch: the rim drawn where the object is visible.

Optional X-Ray Outline (through-walls) style profile. Use XRayOutlineEnabled to toggle without clearing.

X-Ray Outline switch: the rim drawn where the object is hidden.

Optional Main Fill style profile. Use MainFillEnabled to toggle without clearing.

Main Fill switch: the tint over the visible body.

Optional X-Ray Fill style profile. Independent of XRayOutlineStyleProfile. Use XRayFillEnabled to toggle.

X-Ray Fill switch: the tint over the hidden body.

Keep the soft X-Ray rim out of this object's silhouette, so X-Ray Fill reads cleanly underneath it.

Whether this object's visible outline stays off its own silhouette where something passes through the body.

Keep the X-Ray rim's soft glow outside the object's silhouette instead of letting it wash across the body.

Optional second draw of Main Outline. Hull (Cutout off) extrudes outside; Cutout traces alpha on the surface. Pair with MainOutlineStyleProfile.

When true and MainCutoutOverlayStyleProfile is set, the Main overlay draws.

Optional second draw of XRay Outline. Hull or Cutout, paired with XRayOutlineStyleProfile.

When true and XRayCutoutOverlayStyleProfile is set, the XRay overlay draws.

Whether writes are currently being held back by an open scope.

True when any rim slot on this object asks for a soft edge. Interior is ignored. Used by the inspector to warn when the pipeline pass is missing.

Layers this outline's X-Ray may be seen through.

True when the Main Outline slot holds a style profile.

Main Outline style profile. Null leaves Main Outline off; other slots stay independent.

KeylineStyleProfile mine = controller.ForkSlot(KeylinePassKind.MainOutline);
mine.color = Color.red;
mine.glowIntensity = 4f;
controller.RefreshAppearance();

True when the outline system is on for this object. Reads the primary pass directly, so it is correct no matter which pass is momentarily active.

The material every mirror of this outline is instanced from, or null for the one Keyline loads out of its own Resources folder.

True while the active PassState is the XRay (or XRay Interior) rim/fill.

True while the active PassState is an interior fill pass.

Active stencil ref for this pass (primary or occluded half).

The widest reach of any rim this component currently draws, in metres.

Draw the outline when the scene starts.

Average the normals of vertices that share a position before extruding the hull.

Whether hard corners of the hull get a bevel. Default Rounded.

Rounded, Sheet Solidify shells only. Sharpest corner, in degrees, that still gets a round. A tighter corner stays sharp. Default 0. Changing it rebuilds.

Rounded, Sheet Solidify shells only. Widest corner, in degrees, that still gets a round. A wider corner stays sharp. Default 120. Changing it rebuilds.

Rounded, Sheet Solidify shells only. 0 keeps a corner sharp, 1 pulls it into a full circular arc. Default 1. Changing it rebuilds.

Rounded, Sheet Solidify shells only. A corner is left sharp when the arc between its edges would be shorter than this, in the same units as the outline width. Default 0.015. Changing it rebuilds.

Rounded, Sheet Solidify shells only. A corner stays sharp when the planes around it fold by more than this many degrees, either way. 180 rounds those corners too. Default 15. Changing it rebuilds.

Simple only. How far a sharp corner may reach, as a multiple of the outline width, from 1 to 4. 1 keeps it short and the band narrows there. Default 1. Changing it rebuilds.

Also join vertices that only nearly meet — within JoinDistanceMm of each other — in the outline's copy of the mesh. On by default.

How close two vertices must be, in millimetres of mesh space, before the outline's copy joins them. Default 1, range 0 to MaxJoinDistanceMm. 0 joins only vertices on the same point, as Join Coincident Vertices off does. Changing it rebuilds.

Extra surface around a cutout's artwork for the rim to be drawn on, in metres.

How far the distance field beside each cutout texture describes the shape, in texels.

Whether padding is worked out from the field rather than set by hand.

Outline every renderer under this object, not only the ones on it.

Transforms skipped when IncludeChildren is on (the transform and all descendants).

Only renderers on these layers receive an outline. Changing it rebuilds.

Draw the outline in the Scene view while the game is not running.

True when mirrors should be shown right now (Play Mode or Edit Mode preview).

Rewrite the style when a part of this figure moves inside it.

Move a pass to styleProfile over seconds.

True while BlendTo is moving this pass.

Jump a running blend to its end: the target profile in the slot, now.

Stop a running blend where it is. The pass keeps the in-between look on its own copy.

Treat child as a child of this outline.

Stop treating child as a child of this outline.

Become a child of parent. Same as parent.AdoptChild(this).

Stop being an adopted child. Same as OutlineParent.ReleaseChild(this) when this outline was claimed through AdoptChild.

The field for a texture, or null when none has been generated.

Supply the field for a texture this object will draw with.

Supply the field and say what range it was built with.

Supply the field, its range and the threshold it was baked at.

The source meshes this component needs to read and cannot, or an empty list.

Source meshes whose Read/Write can be switched back off, because a runtime bake has already been taken and Keyline will never read them again.

Dump the real GPU-facing state of every pass. Reading the code cannot show which values actually reached the material, so this reports them directly.

True when this slot is running on a clone rather than on the shared asset.

The shared asset a slot was holding before it forked, or the current one if it has not. This is the look the object is meant to return to, which is what anything layering a temporary highlight on top needs to know.

Fork a slot now and return the clone the object owns. Useful when you are about to write a burst of properties and want the clone to exist before the first of them, or when you want to hand the instance profile to something else — a tween, a gauge — without going through the look properties one at a time.

Fork every assigned slot in one go.

Put the shared assets back in every forked slot and destroy the clones. This is the cheap way to undo everything gameplay did to an object's look: rather than tracking which of forty properties were touched, drop the clone and the original asset is the look again.

Put every mirror on the layer MirrorLayer asks for, now. Call it after changing an outlined object's layer from code when FollowLayerChanges is off. Cheap: one comparison per mirror, and a write only where something changed.

<inheritdoc/>

<inheritdoc/>

<inheritdoc/>

Retarget stored width fields (px ↔ meters) so visual thickness stays similar when switching KeylineWidthMode. Uses the active camera distance / FOV (same relationship as ConstantScreen in the shader). Falls back to 1px ≈ 1cm.

Re-apply the merge rules after the fields behind them were written directly.

What this outline resolved to, and the inputs it was resolved from.

Bake config hash used by mesh cache and persisted Bake for Runtime assets.

True when any outlined renderer (Include Children / layer) is a SkinnedMeshRenderer.

True when this mesh is used by a SkinnedMeshRenderer in the current outline collect set.

The one place that decides which renderer types Keyline can outline. It used to be a term buried in the filter above, next to the layer mask and the mirror marker, with no comment of its own — so from the code it was impossible to tell whether sprites were excluded on purpose or as the leftover of an abandoned attempt. Product decisions and housekeeping should not share a condition.

Number of renderers that will receive an outline with the current setup.

Mirror renderers currently alive across all passes (rough draw-call cost).

True when the active pass would run a CPU mesh bake for this source kind. Only these meshes are worth persisting via Bake for Runtime.

True when a persisted bake exists but no longer matches the current settings, so the runtime would silently fall back to CPU analysis (or skip the effect on non-readable meshes). The Inspector surfaces this as a "re-bake" warning.

True when a persisted bake was assigned but its asset is no longer there.

Drop all persisted bakes (the runtime falls back to CPU analysis).

Replace persisted outline mesh entries (Bake for Runtime).

Unique source meshes used by the current Include Children / Layer Mask setup.

Create the outline's prepared copy of a mesh (no cache / persisted lookup). Caller owns the mesh.

Switch a pass on or off for the parts named here.

Forget what this pass was told about individual parts.

Forget what every pass was told about individual parts.

Whether this pass draws on this part — the pass's own switch and what it was told about that part, together, which is the question the picture answers.

Point a Cutout Overlay slot at the same style profile as Main Outline (As Main).

Put a profile in a pass's slot. Null empties the slot. Assigning the profile already there does nothing; a different one rebuilds that pass.

Point a feature slot at the same style profile as Main Outline (As Main).

Whether a pass is switched on, addressed by kind rather than by one of four properties. Anything generic over the passes — a flash that can paint either fill, an editor tool, a save system — otherwise has to carry the same four-way switch, and each copy is a place to forget the fourth case.

<inheritdoc/>

Switch a pass on or off for the whole figure, addressed by kind.

The profile assigned to a pass, addressed by kind. Null when the slot is empty.

Whether this pass is wearing styleProfile.

Say that a burst of writes to kind is about to begin.

Close a burst opened by BeginPassStyleProfileEdit, and do the work it held back.

Open a burst of writes to one pass, closed by leaving the using block.

Set this outline up from one description, in a single build.

var outline = go.AddComponent<KeylineOutline>();
outline.Configure(new KeylineSetup { MainOutline = mainProfile, XRayOutline = xrayProfile });

The common case of Configure — profiles and nothing else.

Activate a Cutout Overlay so look writes and Bake for Runtime hash that draw. Always pair with EndPassStyleProfileEdit.

Re-read the cutout texture from the source materials. The resolved texture is cached against the source material's instance id, so swapping the whole material is noticed by itself. Writing a different texture into the *same* material is not — the id has not changed, and re-resolving on every appearance push would put a property lookup per renderer on a path that runs whenever anything moves. So the one case that needs telling is exactly this one: mat.SetTexture("_BaseMap", damaged) at runtime, on a material an outline is reading. Call this after it and the outline follows.

The keyword a style needs, or null for Solid — which is the absence of them all.

World AABB of outline sources, for the overlap rule. False when there is nothing.

Called when merge-group membership or group enable state changes.

Set JoinCoincidentVertices and, optionally, JoinDistanceMm together, with one rebuild.

var outline = enemy.AddComponent<KeylineOutline>();
outline.SetJoinCoincidentVertices(true, 2f); // join within 2 mm

Replace the ignore list and rebuild mirrors when the outline is built.

Build or tear down edit-mode preview mirrors.

Set the master switch. Same as setting OutlineEnabled.

Flip the master switch. See OutlineEnabled.

Rim colour of the pass being edited. The property form is Color.

Rim width of the pass being edited, in whatever unit WidthMode reads. The property form is Width.

<inheritdoc/>

Point Outline Material at the package material for the current profile's program, and rebuild the mirrors.

Which optional shader branches this profile is allowed to compile.

True when the Full-shader feature bit is enabled (always false on Mobile Solid profile).

Solid is always allowed; other styles require their Feature Mask bit (Full only).

Inspector helper after SerializedProperty edits to ActiveSettings.shaderFeatures.

Throw the generated objects away and make them again from the current profiles.

Push current values without rebuilding geometry. Prefer this over Rebuild when style topology is unchanged (e.g. Solid↔Sketch). SoftShell / DoubleRing changes still need Rebuild.

Copy this component's current look into a style profile (does not assign the slot).

Put a profile in a pass's slot. The four named properties in one call, for code that has a KeylinePassKind in hand rather than a slot in mind.

<inheritdoc/>

<inheritdoc/>

Resources path of the default outline material.

Resources path of the default Mobile Solid outline material.

Name of the full outline shader.

Name of the Mobile Solid outline shader.

Shader keyword for a rim cut from the texture's alpha (Cutout).

Shader keyword for the sheet variant: flat parts grown in their own plane and given a shell. The name is the one 1.2.0 shipped, kept so variant collections still match.

Compiles the X-Ray see-through-layers test in. Public so the variant stripper can name it — the value itself lives in KeylineShaderIds, beside the property it goes with.

Sprites only: compare this pass at a depth derived from the sorting order rather than from where its quad sits. Never enabled by the 3D controller — a mesh has a real depth buffer to work against, and the keyword costs the early depth test.

Shader keyword for the Neon style.

Shader keyword for the Halo style.

Shader keyword for the Sketch style.

Shader keyword for the Pattern style.

Shader keyword for the Double style.

Shader keyword for the Electric style.

Shader keyword for the Rainbow style.

Shader keyword for the Gradient style.

Shader keyword for the Frost style.

Shader keyword for the Lava style.

Shader keyword for the Smoke style.

Shader keyword for the Crystal style.

Shader keyword for the Water style.

Shader keyword for the Fire style.

Every style keyword, so nothing has to keep a second list of them.

Largest Join Distance, in millimetres.

Outline the sprites underneath this one as well.

True when this component was created by a parent outline rather than by hand.

True when a parent outline claimed this one through AdoptChild rather than by growing a generated component.

The outline that currently claims this one — generated owner or adoptive parent — or null when this outline is independent.

The child outlines this one created. Empty unless Include Children is on.

Outlines claimed through AdoptChild. Empty until something asks.

Unity's own answer, surfaced on the interface.

Whether writes fork the slot instead of landing on the shared asset. Turning it off does not un-fork slots already forked — call RevertSharedPassStyleProfiles.

<inheritdoc/>

<inheritdoc/>

<inheritdoc/>

<inheritdoc/>

Show the outline in the Scene view while not playing.

<inheritdoc/>

<inheritdoc/>

<inheritdoc/>

<inheritdoc/>

How far the widest rim this sprite draws stands outside those bounds, in metres.

Whether writes are currently being held back by an open scope.

Which layer the mirrors are put on. MatchRenderer matches them to the sprite's layer and rendering layers; Fixed keeps them on layer 0 as 1.2.0 did.

In play mode, check every frame whether the sprite changed layer and move the mirrors. Off by default; SyncLayers does the same once, on request.

Stop drawing the outline while the SpriteRenderer is switched off. A sprite hidden by the Reveal recipe keeps its outline.

The stencil value this outline stamps and rejects, or 0 when it is not in a group.

Whether this outline currently belongs to a group with a stencil value.

Draw the children inside this outline's silhouette rather than beside it.

Share a silhouette with whatever this overlaps, if that one agrees too.

See _shareStencilWithOthers.

Whether this outline is drawing anything worth merging.

What the field is measured with. Changing it needs the field rebuilt.

The metric the assigned field holds, whatever this component is asking for.

The texture the assigned field was built from, or null if the pairing is unknown.

Texels of empty ground the field holds around the artwork, on every side.

True while the rim is drawn on the texel grid — asked for, and actually available.

True when the component wants a pixel edge and the field cannot give one.

The distance field assigned to this sprite, or null.

Range the assigned field covers, in source texels.

Threshold the assigned field was baked at.

Whether the field records the same edge the sprite path draws at.

The scale ratio the assigned field was measured under. One for an ordinary field.

Whether this outline has a field to measure against. Without one there is no rim — only the artwork's own shape.

Whether the rim is measured against the distance field at all.

Layers this outline's X-Ray may be seen through.

<inheritdoc/>

Empty room around the sprite for the outline to occupy, in the sprite's own units.

How many sorting orders above the sprite the outline is drawn. One by default, which is the smallest value that puts it over its own sprite without claiming orders that belong to other sprites.

Whether either X-Ray pass has a profile, and so needs somewhere to be drawn.

Main Outline profile. Use MainOutlineEnabled to toggle without clearing.

Optional X-Ray profile. Use XRayOutlineEnabled to toggle without clearing.

Optional Main Interior fill profile. Use MainFillEnabled to toggle.

Optional X-Ray Interior fill profile. Use XRayFillEnabled to toggle.

Draw the outline when the scene starts. The sprite half of the mesh controller's property of the same name.

Move a pass to styleProfile over seconds.

True while BlendTo is moving this pass.

Jump a running blend to its end: the target profile in the slot, now.

Stop a running blend where it is. The pass keeps the in-between look on its own copy.

Treat child as a child of this outline.

Stop treating child as a child of this outline.

Become a child of parent. Same as parent.AdoptChild(this).

Stop being an adopted child. Same as OutlineParent.ReleaseChild(this) when this outline was claimed through AdoptChild.

What each pass resolved to, in one block.

The real GPU-facing values behind all four passes.

<inheritdoc/>

<inheritdoc/>

<inheritdoc/>

Change the style of the pass currently being edited, or of the visible rim, forking the profile first when Instance Override says so.

World bounds of what this outline covers, or false when there is nothing to measure.

Whether this pass is wearing styleProfile.

Aim the writes that follow at one pass.

Close a burst opened by BeginPassStyleProfileEdit, and do the work it held back.

Open a burst of writes to one pass, closed by leaving the using block.

Turn the whole outline on or off. The verb form of OutlineEnabled, spelled the way the mesh controller spells it so one script drives either component.

Set this outline up from one description, in a single build.

The common case of Configure — profiles and nothing else.

The shared asset a slot was holding before it forked, or the current one if it has not.

<inheritdoc/>

Has this slot been forked into a copy this object owns?

Fork every slot that holds a profile.

Put the shared assets back in every forked slot and drop the copies.

Colour of the pass being edited. Same as setting Color.

Width of the pass being edited. Same as setting Width.

Copy this object's current look into a profile asset.

Put the mirrors on the layer MirrorLayer asks for, now. Call it after changing the sprite's layer from code when FollowLayerChanges is off.

Called by KeylineMergeGroup when the group's allocation changes — it is taken on enable and given back on disable, and a member cannot see that happen.

Re-apply the merge rules after the fields behind them were written directly.

Hand this outline a field and say which sprite texture it was built from.

The width a pass may actually use, capped at what the field can describe.

Where the X-Ray passes will be drawn, or false when the scene declares no occluders — in which case they have nothing to draw anyway. For tooling; the value is derived, not set.

Profile for a pass. Null leaves that pass off, and null is also the answer for the two Cutout Overlay passes, which a sprite does not have — see KeylinePassKind.

Assign a profile to a pass and rebuild that pass.

Rebuild geometry and materials from the sprite as it is now.

Re-read the profiles without rebuilding geometry.

Is this pass drawn at all?

Turn a pass on or off without clearing the profile in its slot.

<inheritdoc/>

<inheritdoc/>

<inheritdoc/>

<inheritdoc/>

Shared stencil for primary (visible) outlines in this group.

Shared stencil for X-Ray / occluded companion outlines in this group.

Whether this group holds a pair the pool currently stands behind.

Whether membership comes from the hierarchy. False means the explicit list decides, and descendants are not members unless they are named.

Whether membership comes from the hierarchy. False means the explicit list decides, and descendants are not members unless they are named.

Is this object excused from the group and from automatic merging?

The outlines this group currently covers. Built fresh on request — for the inspector's readout and for anything that wants to know without guessing at the rules.

Push a stencil refresh to everything this group covers, and to everything it used to.

Whether this sprite is excused from occluding. True makes it an exception to whatever its sorting layer is declared as.

How opaque a pixel must be to occlude. 0 to 1.

Rebuild the proxy from the sprite as it is now.

The registry the scene is using, or null if there is none.

How many occluders this registry is currently holding proxies for.

The sorting layers declared as occluders, as written in the inspector.

Whether the scene is swept for occluders on its own.

Create a sorting layer of this name in the project if it does not already exist.

Declare the occluder layers from script, replacing whatever the inspector says.

Sweep the scene now. Worth calling after spawning occluders if the interval is long, or if it is zero because the scene is static.

Sweep every registry in the scene.

Claim one sprite as an occluder, without sweeping the scene.

Release one sprite, taking its proxy down with it.

The Draw Config in force: the first one enabled that is still enabled, or null.

Custom draw asset assigned to this host. Setting it on the active host raises PresenceChanged.

Assigned custom asset, or null to use the memory factory.

Raised when the Draw Config in force changes: a host is enabled or disabled, its asset is reassigned, or it is edited in the Inspector. Outline controllers listen to reapply their draw settings.

Which shader program this profile is authored for — decided by the asset's type, not by a field on it.

True when the Mobile Solid (cheap) shader profile is selected.

Style actually used for topology / rendering (disallowed → Solid).

Whether a rim wearing this profile is cut from the source material's alpha: authored on, and the project has not switched Alpha Cutout (3D) off.

Whether this profile is drawn by the cheap Mobile Solid program. False for an ordinary profile, and for a Mobile Solid one while the project has Mobile Solid Profiles off — it is then drawn as Solid by the Full program, which is in every build.

Whether the rim pulses: authored on, and Pulse not switched off in the project.

The blend the rim draws with. Default while the project has Blend Modes off.

Edge Softness as it will be drawn: zero for a rim cut from alpha — which has no hull to blur — and zero while the project has Soft Edge off.

Halo Occlusion as it will be drawn. Ignore Depth while the project has it off.

Whether a rim wearing this profile is blurred and that blur is cut against scene depth — the combination that finishes most of the intersection clip's work and leaves the rest to it.

The rim's full width, styles included, in whatever unit widthMode is counting in.

The most Pulse ever widens the rim, as a multiplier.

How far past an extruded hull's own surface this look reaches, in metres — 0 when the answer is not a length in metres at all.

Signature of everything that changes mirror topology or the baked outline mesh. Controllers compare it to decide Rebuild (expensive) vs RefreshAppearance (cheap).

Notify listeners that look values changed (call after editing fields from code).

Does style read this group at all? Mirrors the style branches in the shader, plus the mirror topology chosen on the CPU — Shell exists for Neon and Frost because those build a second hull, not because of anything in the fragment.

True when a Full-shader feature bit is enabled on this profile and the project has not switched the feature off (always false on Mobile Solid).

True when a Full-shader feature bit is enabled on this profile, whatever the project says. The authored answer, for validation.

Mobile Solid renders Solid only. Under Full every style is available. Styles used to be gated by the Feature Mask as well, which meant a profile could sit on a style whose bit was off and silently render as Solid — the trap that produced the Gradient bug. The mask no longer decides what may render; it only records which shader variant the build needs, and its style bits are derived from style.

Feature-mask bit a style cannot render without (None for Solid).

Is the cutout path a choice for this subject, or the only thing it does?

True when the style reads a spatial coordinate at all. Solid, Neon, Halo and Double are rim/width driven, so Style Space would be a no-op for them.

Not every style supports every space. Pattern and Gradient drop World: both measure along a single axis from the pivot, which for an object with no rotation is the same number in world space as in object space — a mode that behaved like a duplicate of its neighbour most of the time.

Space a style used before Style Space existed. Needed because the legacy behaviour differs per style, so no single default value can preserve every profile.

Alpha of one Halo layer.

Width of one Halo layer as a fraction of the full outline width.

Overwrite every serialised value of destination with the values of source, leaving the object identity alone. Used to reset a per-instance clone back to its shared profile without allocating a new clone: a highlight that swapped a colour in should be undoable in one call, and anything that hands out references to the settings object keeps working because the object is the same one. Goes through JsonUtility rather than a field-by-field copy on purpose — a hand-written copy silently misses fields added later, and this class gains fields regularly.

A private runtime copy of this profile, for edits that must not touch the asset.

KeylineStyleProfile alert = baseProfile.CloneForRuntime();
alert.color = Color.red;
outline.SetPassStyleProfile(KeylinePassKind.MainOutline, alert);

Clamp every field into its legal range and drop selections the current Shader Profile / Feature Mask cannot render. Safe to call at any time.

Raised after this asset validates itself. Controllers listen so that editing the asset in the Project window live-updates every scene object that references it.

The look this profile draws.

Main colour of the outline.

What this profile is drawn on, which decides the controls the inspector shows.

Second colour of the styles that use one.

How far the outline reaches out from the surface.

World-space halo on the outer rim.

Whether the soft edge stops where its rim stops.

World keeps the outline in proportion to the object: it thins out with distance and goes away with the thing it is on.

How the outline is composited over what is behind it.

Which program draws a pass using this profile. Written by validation from AuthoredShaderProfile, never chosen here — an ordinary profile is Full and a KeylineMobileSolidStyleProfile is Mobile Solid.

Full shader only: disable unused features to strip HLSL (Solid always on).

Coordinate space the style's pattern / noise / gradient lives in.

Let the transform's non-uniform scale stretch the style, stored as the opt-out.

Overall transparency of the whole outline, on top of the colours' own alpha.

Brightness multiplier for the styles that emit.

Neon / Frost / Water: how quickly the view-facing rim fades.

Frost: reach of the outer halo, in the same units as Width.

Frost: opacity of the outer halo relative to the core band.

Sketch / Electric: how far the line is pushed around by the noise.

Sketch / Electric: how fast the noise re-rolls.

Pattern: greyscale mask tiled along the outline.

Pattern: tiling of the mask.

Pattern: scroll speed of the mask along X and Y, in tiles per second.

Pattern: contrast applied to the mask before the threshold — sharpens soft artwork into a crisp stencil.

Pattern: mask level that separates visible from clipped.

Double: thickness of the inner ring, in the same units as Width.

Double: clear space between the two rings.

Double: thickness of the outer ring, drawn in the Secondary colour.

Rainbow: how tightly the spectrum repeats along the ramp.

Rainbow: how fast the bands travel.

Rainbow: colour purity.

Rainbow: Vertical sweeps the bands along the vertical axis of the active Style Space — the object's own on a new profile, the screen's under Screen Space.

Circular Rainbow: object-local X of orbit center (0 = pivot).

Circular Rainbow: object-local Y of orbit center (0 = pivot).

Rainbow, Vertical: sweep direction in degrees. 0 is the vertical axis this style always used, so a profile that leaves it there does not change.

Rainbow, Vertical: lean of that direction out of the style space's XY plane. Meshes in Object or World space. Screen, UV and sprites stay in the plane.

Gradient: how wide the blend between the two colours is.

Gradient: slide the ramp along its own direction.

Gradient: direction of the colour sweep in degrees.

Gradient: how far the direction set by gradientAngle leans out of the style space's XY plane, in degrees. Meshes, Linear in Object or World space and Radial.

Gradient: Linear ramps along the angle above; Radial ramps outwards from a point in world space.

Gradient, Radial and Planar: the world-space point the ramp is measured from.

Gradient, Planar only: which way the plane faces.

Gradient, Radial only: whether Radius is multiples of the object's size or metres.

Gradient, Radial only: where the boundary between the two colours sits.

Gradient: 0 leaves the ramp as it is.

Gradient, Radial only: how much further the ramp reaches along the Angle direction.

Halo: how many steps the falloff is built from.

Frost: density and brightness of the shimmering ice sparks.

How large a patch of plain ice is left where the surface turns to face the camera.

Breathe the outline's width and intensity over time.

Pulse: beats per second.

Pulse: how deep the swing goes, as a fraction of the resting width.

Pulse, pixel art only: how far the outline dims as it reaches full stretch.

Pulse: how much brighter the outline gets at the top of the swing.

Follow the source material's alpha cutout instead of the polygon edge — grass cards, foliage, decals.

How soft the outline's outer edge is, as a fraction of its own width.

How far the outline continues underneath the cutout artwork, in screen pixels.

How far the crust has broken open, from a solid dark shell to nothing but glow.

Size of the crust cells.

How fast the molten core moves under the crust.

Brightness of the hot core inside the cracks, over the outline's colour.

Direction the flow runs, in degrees.

How much the flow curls instead of sliding straight.

How fast the glow breathes, in beats per second.

How deeply the pulse swings, as a fraction of the heat.

How much of the cloud survives.

Size of the billows.

How fast the cloud drifts.

Which way it drifts within the style space's XY plane, in degrees.

How far the drift leans out of that plane, in degrees.

How hard the cloud rolls as it travels.

How far along the drift the cloud reaches, as a fraction of the shape.

How raggedly the cloud ends, once Height has decided where.

Size of the facets.

Where the light falls from, in degrees.

How fast the light turns around the stone, in turns per second.

How much fire the stone has.

How far towards white a lit facet is allowed to go.

Brightness of the cut edges between facets.

How even the facets are, and with it the smallest one you can get.

How much each facet darkens towards its own middle.

How far the facets split the colour between them.

How fast the surface flows.

Which way it flows, in degrees.

Size of the ripples.

Strength of the caustic streaks — the bright threads where the surface focuses light.

How much the flow curls rather than sliding straight.

Sheen along the ripple crests, where the surface turns towards the viewer.

How fast the tongues rise.

Which way they rise within the style space's XY plane, in degrees.

How far the rise leans out of that plane, in degrees.

How far up the tongues reach, as a fraction of the shape.

How many times longer the tongues are than they are wide.

Size of the tongues.

How much the flames writhe as they climb.

Brightness at the base of the flame, over the outline's colour.

How much the flame gutters — the whole of it breathing together, and its tongues dropping out of step with each other.

Which faces draw this pass (not the interior stencil mask).

Paint each pixel once, however many times the outline covers it.

Smallest rim width the API and the inspector accept, in the profile's units.

<inheritdoc />

Overwrite the look of target with the reference values for style. The Feature Mask is deliberately left alone: which variants a build compiles is a build-size decision, not a look. The one exception is the bit the restored style itself needs — without it validation would silently bounce the style back to Solid. Pattern Texture is also kept, since it is an asset the user picked. Shader Profile goes back to Full — see below for why it does not keep that company.

A Settings instance preloaded with the reference look for a style.

A new Mobile Solid profile at its reference look.

Feature-mask bit a style cannot render without (None for Solid).

Whether Single Layer means anything for this style.

Every row, in the order the inspector draws them.

The row for a field, if the table describes it.

Whether a control should be on screen at all for this style and subject.

Hold a value to its row's range.

True when this row wants a slider rather than a free field.

True when style reads this parameter, or when the row lists no styles.

True when the parameter is drawn on any of the given subjects.

Clamps value to the row's range; only the lower bound applies when the row is unbounded.

Serialized field name on KeylineStyleProfile.

Inspector label. Null uses Unity's own prettified field name.

Subjects the parameter is drawn on.

Styles that read it. Empty means every style does.

Lower bound of the usable range.

Upper bound, or float.PositiveInfinity when there is none.

Short explanation of what the parameter does, or null.

Creates a row. Pass float.PositiveInfinity as max when there is no upper bound.

Drawn on nothing.

Drawn on mesh outlines.

Drawn on sprite outlines.

Drawn on both mesh and sprite outlines.

A mesh, outlined by extruding a hull.

A sprite, outlined by widening the texture's alpha.

Glow intensity.

Soft falloff of the view-facing rim.

Width and opacity of the outer shell hull.

Secondary colour.

Sketch amount and speed, shared by Sketch and Electric.

Pattern texture, scale, scroll, contrast and threshold.

Double's inner width, gap and outer width.

Rainbow scale, speed, saturation, motion, centre, and the vertical sweep.

Gradient shape and its per-shape controls.

Halo layer count.

Frost sparkle and band fade.

Base colour.

Shared outline width.

Controls only Lava reads, such as crack, flow and heat.

Controls only Smoke reads, such as density, drift and dissolve.

Controls only Crystal reads, such as scale, glint and dispersion.

Controls only Water reads, such as flow, caustics and sheen.

Controls only Fire reads, such as rise, height and flicker.

Hold a state.

Release a state.

True while the state is held.

True when this component paints pass itself.

True from Play until the count runs out or Stop is called.

Highlight state the blink holds. Give it one of its own rather than borrowing Hover — otherwise the pointer passing over the object releases the state and cancels the cue.

Start blinking with the authored count.

Start blinking a given number of times. 0 blinks until stopped.

Stop and release the state.

Fires every time a run begins, including a run started by Play On Enable.

Fires when the run ends: the count ran out, Stop was called, or the object was disabled.

Currently selected objects or groups, oldest first.

How many objects may be selected at once. 1 is classic single selection, 0 is no limit. Lowering it below the current count drops the oldest selections immediately.

Adds target to the selection and holds the selection state on it, dropping the oldest entries when the limit is reached. Ignored if the target is gone or already selected.

Drop a target from the selection.

Deselects every target, releasing the selection state on those still alive.

True when target is in the current selection.

Fires when an object joins the selection. For a group, the argument is the group's GameObject, not the clicked member.