Architecture

Assets/RCE/Runtime/
├── Bootstrap/          # RCEInstaller, service locator, startup
├── Core/               # Interfaces (ILoadoutManager, IDataPathProvider) and constants
├── Data/               # Enums & value types (ShapeType, ShapeData, GapMode, AnimationMode, etc.)
├── Loadout/            # LoadoutData, LayerData, CategoryData, TransitionSettings, serialization
├── Rendering/          # ReticleRenderer, LoadoutRendererBridge, GlobalFXBridge, GridRenderer
│   └──                # CategoryTransitionAnimator, ShapePropertyAnimator, CustomSDFGenerator
├── Tracers/            # TracerManager, TracerData, TracerSDF shader integration
├── Palettes/           # PaletteData, preset color palettes, palette serialization
├── Utilities/          # Easing, WaveformEvaluator, SDFEvaluator, UndoManager, MathHelpers
├── UI/                 # RCEEditorController, UXML layouts, USS stylesheets, theme files
├── Shaders/            # ReticleSDF.shader, ReticleSDFCore.hlsl, GridSDF, LayerConnectorLines, TracerSDF
├── Resources/          # ExactPolylineSDF.compute, materials, runtime-loaded assets
└── URP/                # RCERendererFeature.cs (separate assembly: RCE.Runtime.URP)

[StructLayout(LayoutKind.Sequential)]
public struct ShapeData
{
    public Vector4 color;           // 16 bytes — RGBA fill color
    public Vector4 outlineColor;    // 16 bytes — RGBA outline color (alpha > 0 enables outline)
    public Vector2 position;        //  8 bytes — UV-space position
    public Vector2 scale;           //  8 bytes — X/Y scale
    public float   rotation;        //  4 bytes — radians
    public float   glowIntensity;   //  4 bytes — glow brightness multiplier
    public float   glowSize;        //  4 bytes — glow distance falloff
    public float   feather;         //  4 bytes — edge softness (0 = hard)
    public int     shapeType;       //  4 bytes — ShapeType enum
    public int     gapMode;         //  4 bytes — bit-packed (see below)
    public int     gapShapeType;    //  4 bytes — bit-packed (see below)
    public int     groupShapeIndex; //  4 bytes — boolean group operand index
    public Vector4 shapeParams;     // 16 bytes — type-specific parameters
    public float   gapCount;        //  4 bytes
    public float   gapThickness;    //  4 bytes
    public float   gapRotation;     //  4 bytes
    public float   taperAmount;     //  4 bytes
    public int     isOutline;       //  4 bytes — true outline toggle
    public float   outlineThickness;//  4 bytes
    public int     customSDFIndex;  //  4 bytes — Texture2DArray slice index
    public int     _padding;        //  4 bytes — alignment padding
}                                    // Total: 144 bytes

// C# — Packing gapMode
int packed = (int)gapMode
          | (asSDF   ? 64  : 0)   // bit 6
          | (invert  ? 128 : 0);  // bit 7

// HLSL — Unpacking gapMode
int gapModeVal = shape.gapMode & 0x3F;       // bits 0-5
bool asSDF    = (shape.gapMode & 64) != 0;   // bit 6
bool invert   = (shape.gapMode & 128) != 0;  // bit 7

// C# — Packing gapShapeType for LineBurst
int packed = cutoutShape
          | (lineBurstRadial ? 256 : 0);  // bit 8

// C# — Packing gapShapeType for Stadia
int packed = markDirection
          | (capStyle << 2)
          | (symmetryMode << 4);

StructuredBuffer<ShapeData> _ShapeBuffer;
int _ShapeCount;
Texture2DArray _CustomSDFArray;

half4 FragReticle(Varyings input) : SV_Target
{
    float2 uv = input.uv;
    half4 result = 0;

    for (int i = 0; i < _ShapeCount; i++)
    {
        ShapeData shape = _ShapeBuffer[i];

        // Early-out for invisible shapes
        if (shape.color.a <= 0 && shape.glowIntensity <= 0) continue;

        // 1. Transform UV into shape-local space
        float2 localUV = TransformToLocal(uv, shape);

        // 2. Evaluate SDF for this shape type
        float dist = EvaluateSDF(localUV, shape);

        // 3. Apply gap mode (alpha mask or SDF boolean)
        dist = ApplyGaps(dist, localUV, shape);

        // 4. Boolean group compositing
        dist = ApplyBooleanGroup(dist, i, shape);

        // 5. Glow (exponential falloff from boundary)
        result += EvaluateGlow(dist, shape);

        // 6. Outline (band outside shape boundary)
        result += EvaluateOutline(dist, shape);

        // 7. Fill with feathering (fwidth-based AA)
        result = ComposeFill(result, dist, shape);
    }
    return result;
}

public class RCEEditorController : MonoBehaviour
{
    [SerializeField] private ReticleRenderer     _reticleRenderer;
    [SerializeField] private GridRenderer        _gridRenderer;
    [SerializeField] private LayerConnectorRenderer _layerConnectorRenderer;
    [SerializeField] private CategoryTransitionAnimator _transitionAnimator;
    [SerializeField] private TracerManager       _tracerManager;
}

public class GridRenderer : MonoBehaviour
{
    public static GridRenderer Instance { get; private set; }

    void OnEnable()  => Instance = this;
    void OnDisable() => Instance = null;
}

// Used by RCERendererFeature (ScriptableRendererFeature)
var grid = GridRenderer.Instance;
if (grid != null && grid.IsVisible)
    grid.EnqueuePass(context);

// Resolve transition animator from the same GameObject
if (!TryGetComponent(out _transitionAnimator))
    _transitionAnimator = null; // optional, transitions disabled

// Resolve or create shape property animator
var rendererGO = _reticleRenderer.gameObject;
if (!rendererGO.TryGetComponent(out _shapePropertyAnimator))
    _shapePropertyAnimator = rendererGO.AddComponent<ShapePropertyAnimator>();

// On-demand custom shape overlay (only when editing custom shapes)
_customShapeOverlayRenderer = gameObject.AddComponent<CustomShapeOverlayRenderer>();