Demo Scenes

RCC ships with 11 demo scenes that show every major feature. Each one is a self-contained example that you can open, press Play, and drive. This document walks through each scene and explains what to look at, what to learn from it, and how the underlying setup works.

Every demo scene lives in:

Assets/RealisticCarControllerV4/Demo Scenes/

If you haven't yet, install RCC first — see 02 — How to Install RCC.

Default Controls

All demo scenes share the same default input bindings:

These bindings come from RCC_InputActions.inputactions. You can rebind them inside the Input Actions asset window — see 16 — Input System.

RCC_Blank — Empty Starter Scene

File: RCC_Blank.unity

This is the smallest possible RCC scene. It contains:

• A directional light and an environment skybox.
• An RCC Scene Manager GameObject that holds the RCC_SceneManager singleton.
• An RCC Canvas for the dashboard UI.
• A single demo vehicle, registered as the player.

Use it when: you want to start a new scene from scratch. Save a copy of this scene under your own name, drop your environment in, and you've got a working starting point.

What to look at: click the RCC Scene Manager in the Hierarchy. Notice that it has no per-vehicle configuration — it just discovers vehicles in the scene automatically. The active player vehicle is whatever was registered most recently.

RCC_Blank_API — Runtime API Demo

File: RCC_Blank_API.unity

This scene contains the RCC_Canvas (API) prefab, which has buttons for every public method on the static RCC class. Press Play and you can:

• Spawn Vehicle — instantiates a new vehicle prefab at runtime.
• Set Behavior — switches between Drift, Race, Simulator, Arcade modes live.
• Start / Stop Engine — toggles the engine running state.
• Set Controllable — disables/enables player input.
• Repair — instantly resets all damage.
• Transport — moves the vehicle to a target transform.
• Change Camera — cycles camera modes.
• Set Mobile Controller — toggles the mobile UI on or off.
• Start / Stop Record and Start / Stop Replay — records the current drive and plays it back.

Use it when: you want to learn the public API by clicking buttons before writing code. Each button in the UI is wired to a method in RCC_APIExample.cs — open that file to see how to call the API from your own game code.

Note: the buttons on RCC_Canvas (API) are wired to the RCC_API_Example scene object, not to anything inside the prefab itself. If you drag the prefab into your own scene, the buttons will do nothing until you add a RCC_APIExample component to the scene and re-assign it as the target of each button's OnClick event (or wire the buttons to your own scripts).

What to learn: look at Scripts/Others/RCC_APIExample.cs. Every public method maps one-to-one to a button in the UI. For example, the "Spawn Vehicle" button calls:

RCC.SpawnRCC(vehiclePrefab, spawnTransform.position, spawnTransform.rotation,
             registerAsPlayerVehicle: true, isControllable: true, isEngineRunning: true);

For the full API surface, see 23 — Scripting API.

RCC_Blank_Customization — Showroom Demo

File: RCC_Blank_Customization.unity

A vehicle is parked on a turntable surrounded by a UI panel that lets you customize:

• Paint — pick any RGB color.
• Spoiler — cycle through spoiler prefabs and remove option.
• Wheels — cycle through wheel rim prefabs.
• Decals — apply decals to four body locations (hood, sides, roof).
• Neon — apply underglow neon lighting in any color.
• Sirens — apply emergency vehicle siren styles.
• Upgrades — engine, brake, handling, and speed level upgrades (each visualized by a numeric level).

All changes save automatically through PlayerPrefs and persist across runs. The RCC_Customizer component on the vehicle hosts every sub-manager (PaintManager, SpoilerManager, WheelManager, etc.).

Use it when: building a garage / customization screen in your own game. Look at the prefab RCC_Customization Manager for the wiring, and 20 — Customization for the full API.

RCC_Blank_OverrideInputs — Custom Input Demo

File: RCC_Blank_OverrideInputs.unity

This scene shows how to drive a vehicle from your own code instead of player input. The RCC_OverrideInputsExample script in the scene generates a sinusoidal steering pattern and constant throttle — the car drives itself in a wavy line.

The relevant pattern is:

RCC_Inputs myInputs = new RCC_Inputs();
myInputs.throttleInput = 0.5f;
myInputs.steerInput = Mathf.Sin(Time.time);
carController.OverrideInputs(myInputs);

Use it when: building an AI driver, replay system, networked multiplayer, or scripted cinematic sequence. The same pattern is what RCC_AICarController uses internally — see 17 — Overriding Inputs.

RCC_City — The Main Playable Scene

File: RCC_City.unity

A small city block with buildings, streets, and traffic markings. A single vehicle is placed at the spawn point. This is the scene most users open first.

The scene contains:

• An RCC Scene Manager.
• A player vehicle (one of the 12 demo prefabs).
• An RCC Canvas for the dashboard.
• An RCC AI Waypoints Container (deactivated by default — activate it and add RCC AI Cars to see AI traffic).
• A small city environment.

Use it when: testing changes to vehicle physics. The city is small enough that loading is fast, but big enough that you have room to actually drive.

Tip: if you want to see AI traffic in this scene, drag any Skyline (AI Chaser).prefab instance into the scene, expand its inspector, and assign the RCC AI Waypoints Container to its Target Container field.

RCC_City_AIO — All-in-One Showcase

File: RCC_City_AIO.unity

This is the most complete demo scene. Every feature is turned on:

• Multiple drivable vehicles parked at spawn points.
• AI traffic following waypoint paths.
• Damage zones with crashers (hammers, presses, shredders).
• A car-customization station.
• A repair station and a fuel station.
• The full mobile UI canvas (with touch buttons + steering wheel + joystick visible).
• Telemetry overlay in the bottom-right corner.
• Camera cycling working through all six modes.

Use it when: showcasing RCC to a teammate, debugging a feature in isolation against a complex environment, or copying a scene structure into your own project.

What to look at: open the Hierarchy. Notice that the city environment is loaded as a single prefab. The vehicles, AI containers, and UI canvas are siblings under the scene root. This is the typical RCC scene structure — a vehicle hierarchy that lives next to the environment, not embedded inside it.

RCC_City_CarSelection — Car Selection Menu (Same Scene)

File: RCC_City_CarSelection.unity

This scene starts with a car-selection menu overlaid on top of the city. The user clicks left / right arrows to cycle through demo vehicles, sees a preview rotating on a showroom turntable, and clicks "Start" to begin driving.

The selection is driven by RCC_CameraCarSelection, which controls the showroom camera, and RCC_CarSelectionExample, which contains the selection logic.

The chosen vehicle is then spawned via:

RCC.SpawnRCC(selectedPrefab, spawnTransform.position, spawnTransform.rotation,
             registerAsPlayerVehicle: true, isControllable: true, isEngineRunning: true);

Use it when: building a "select your car" screen as part of your game's UI. The selection persists in PlayerPrefs so the next scene knows which vehicle was chosen.

RCC_City_CarSelectionWithLoadScene — Selection Then Load

File: RCC_City_CarSelectionWithLoadScene.unity

Similar to the previous scene but here the selection happens in a dedicated "menu scene" and then a separate gameplay scene is loaded via RCC_LevelLoader. The selected car prefab is preserved across the scene load using PlayerPrefs.

Use it when: you want a separation between "menu" and "gameplay" scenes (typical for production games). The pair of scenes shows the full handoff.

RCC_City_CarSelectionWithLoadedScene — Receiver Scene

File: RCC_City_CarSelectionWithLoadedScene.unity

This is the second half of the pair above — the gameplay scene that gets loaded after car selection. On scene start, it reads the saved car index from PlayerPrefs and spawns the right car at the level's spawn point.

Use it when: you want to see the receiving side of the menu → game handoff pattern. The relevant code is in RCC_Spawner.cs (or RCC_LevelLoader.cs).

RCC_Damage — Damage Test Arena

File: RCC_Damage.unity

A flat arena populated with crash hazards: crash hammers, presses, shredders, ramps, and walls. A vehicle is parked at the start.

Drive into things, drop the vehicle off ramps onto the crash press, or shred it through the shredder. Watch the mesh deform, parts fall off, lights break, and wheels deflate. Then drive into the repair station prefab to instantly fix everything.

Use it when: tuning damage parameters on your own vehicles. The damage system has many configurable thresholds — see 12 — Damage System — and this arena is a faster feedback loop than constantly driving into walls in the city scene.

RCC_Multiple_Terrain — Off-Road & Surface Switching

File: RCC_Multiple_Terrain.unity

A Unity Terrain with multiple painted surfaces: asphalt road, dirt path, grass, sand, snow patches. Each surface has different friction and produces different audio + particle effects.

Drive across the surfaces and notice:

• Each surface has different acceleration and braking distance.
• Tire audio changes pitch and texture per surface.
• Particle dust changes color per surface (grey on asphalt, brown on dirt, light on snow).
• Skidmarks change appearance per surface.

This is all driven by RCC_GroundMaterials.asset, which has both a PhysicMaterial-based path (for non-terrain meshes) and a terrain splatmap path (for terrain textures). See 11 — Ground Physics for how to add your own surfaces.

Use it when: building an off-road game, or any game with multiple distinct ground surfaces.

How the Demo Scenes Are Structured

Every demo scene follows the same pattern. Once you understand it, you can replicate the pattern in your own scenes:

1. RCC Scene Manager — one per scene. The singleton that tracks the active player vehicle and camera.
2. A player vehicle prefab — usually one of the 12 in Prefabs/Vehicles/, with RCC_CarControllerV4 at the root.
3. An RCC Canvas — the dashboard UI. Without this, you won't see the speedometer.
4. An environment — geometry to drive on. Has colliders with appropriate physic materials (asphalt, dirt, etc.) for ground material detection.
5. Optional AI traffic — RCC AI Waypoints Container with waypoints, plus AI vehicles whose Target Container field points to that container.
6. Optional features — repair stations, fuel stations, customization stations, teleporters, crashers, etc.

The minimum-viable RCC scene is items 1–4. Items 5–6 are additive — turn them on per scene as needed.

Next Steps

After you've driven a few demos and you have a feel for what RCC does, continue with 05 — Quick Start to put a vehicle into your own scene.