Documentation

Getting Started

From import to rendering your first reticle in under five minutes. RCE works with both URP and HDRP out of the box.

Requirements

RequirementDetails
Unity VersionUnity 2022.3 LTS or later (including Unity 6)
Render PipelineUniversal Render Pipeline (URP) or High Definition Render Pipeline (HDRP)
PlatformWindows, macOS, Linux (editor & standalone). Console support is SDF-based — no platform-specific code.
Graphics APIDX11, DX12, Vulkan, Metal. Requires compute shader support for custom shapes.

Installation

1

Import from the Asset Store

Open the Unity Package Manager (Window → Package Manager), find Reactive Combat Engine in your purchased assets, and click Import. The package installs into Assets/RCE/.

2

Add the Renderer Feature (URP)

Select your Universal Renderer asset (usually under Assets/Settings/). In the Inspector, click Add Renderer Feature → RCE Renderer Feature. The default injection point (After Rendering Transparents) places reticles above game geometry but below UI.

3

Add the Custom Pass (HDRP)

If your project uses HDRP instead, add a Custom Pass Volume to your scene, set the injection point to After Transparent, then add the RCE custom pass. Enable Is Global if you want RCE on all cameras.

4

Enter Play Mode

Add the RCE prefab to your scene (or use the included sample scene). Press Play. You should see the default reticle rendering at the center of the screen. Open the editor UI to start customizing.

Tip

RCE auto-detects your render pipeline. If you have URP installed, RCE.Runtime.URP compiles automatically. Same for HDRP. You never need to add scripting define symbols manually.

Project Structure

After import, the RCE package creates the following directory structure:

Assets/RCE/
Assets/RCE/
├── Runtime/
│   ├── Core/              // Constants, configuration
│   ├── Data/              // ShapeData, ShapeType, enums
│   ├── Loadout/           // LoadoutData, LayerData, serialization
│   ├── Rendering/         // ReticleRenderer, bridges, animators
│   ├── Tracers/           // Tracer system
│   ├── Palettes/          // Color palette storage
│   ├── Utilities/         // Easing, SDF evaluator, undo
│   ├── UI/                // Editor controller, UXML, USS
│   ├── Shaders/           // ReticleSDF, GridSDF, TracerSDF
│   ├── Resources/         // Compute shaders
│   ├── Bootstrap/         // RCEInstaller, service locator
│   └── URP/               // RCERendererFeature (auto-compiled)
├── Editor/                // Build tools, theme generator
├── Samples~/              // Example scenes and bootstrap
└── RCE.Runtime.asmdef

Your First Integration

RCE's runtime API is intentionally minimal. To wire your game's input to the reticle system, you only need two things:

  1. Set the active combat state whenever your player's input changes
  2. Trigger GlobalFX layers for hit markers and transient effects
MinimalSetup.cs
using RCE.Runtime.Data;
using RCE.Runtime.Bootstrap;

public class MinimalSetup : MonoBehaviour
{
    private ILoadoutManager _loadout;

    void Start()
    {
        _loadout = RCEServices.Get<ILoadoutManager>();
    }

    void Update()
    {
        if (Input.GetButton("ADS"))
            _loadout.SetActiveState(LoadoutState.AimDownSight);
        else if (Input.GetButton("Fire"))
            _loadout.SetActiveState(LoadoutState.HipFire);
        else
            _loadout.SetActiveState(LoadoutState.SituationalAwareness);
    }
}

That's it. RCE handles the transition animations, shape property animations, and GPU rendering automatically. See the Integration Guide for advanced topics like custom storage paths and DI configuration.

What's Next