First Look — What You Got

This document gives you a guided tour of the RCC folder after import. You don't need to memorize all of it — just know enough that when you're looking for a wheel prefab, a settings asset, or a particular script, you know where to find it.

Everything that ships with RCC lives under a single folder:

Assets/RealisticCarControllerV4/

The asset will never write outside this folder during normal use. If you ever need to remove RCC from a project, deleting that folder is enough.

Folder Layout

Here is the top-level contents of Assets/RealisticCarControllerV4/:

RealisticCarControllerV4/
├── Demo Scenes/       (11 scenes that demonstrate every feature)
├── Documentation/     (HTML-format documentation that ships with the package)
├── Editor/            (custom inspectors, wizards, menu items — editor-only code)
├── Materials/         (default materials for vehicles, environments, UI)
├── Models/            (3D models for the demo cars, trailers, environments)
├── Prefabs/           (vehicle prefabs, wheel prefabs, UI canvas prefabs, crashers)
├── Resources/         (singleton ScriptableObjects loaded at runtime)
├── Scripts/           (runtime C# code — 125 files)
├── Settings/          (URP / HDRP profile assets shipped for those pipelines)
├── Sounds/            (engine, gear shift, crash, wind, exhaust audio clips)
├── Textures/          (vehicle albedo / normal / metallic maps, UI sprites)
└── Welcome/           (the welcome window opens this scene on first install)

The two most important folders to know are Prefabs/ (where the cars live) and Scripts/ (where the code lives). The rest you generally don't need to open unless you're customizing visuals.

Vehicles

Prefabs/Vehicles/

This is where the playable vehicle prefabs live. RCC ships 12 of them:

These are not just art — every one is fully configured: wheel colliders set up, lights wired, audio clips assigned, engine torque curves tuned, gear ratios chosen. You can drop any of them into a scene and it will drive immediately.

Prefabs/Wheels/

Seven wheel models (rim + tire) you can mix and match. The Customization system uses these to let the player swap wheels at runtime.

Prefabs/Crashers/

Eleven prefabs for crash testing and stunts: ramps, jumps, walls, breakaway props. Useful for demo scenes and for testing damage.

Prefabs/UI/

Four UI canvas prefabs:

Drop one of these into your scene to get a working HUD. The mobile canvas auto-detects platform — on desktop the touch buttons hide; on mobile they show.

Scripts

Scripts/

The root Scripts/ folder holds the main runtime classes. Some of the most important ones:

• RCC.cs — the static public API. This is the class you call from your game code (e.g., RCC.SpawnRCC(), RCC.SetBehavior()). See 23 — Scripting API.
• RCC_Core.cs — base class for every RCC component. Holds static accessors for RCC_Settings and RCC_GroundMaterials and a cached lookup of the parent vehicle controller.
• RCC_CarControllerV4.cs — the main vehicle controller, ~3,700 lines. Every car uses this. See 08 — Vehicle Inspector Reference.
• RCC_WheelCollider.cs — wraps Unity's WheelCollider to add friction curves, ground detection, audio, particle effects, and skidmarks. See 09 — How WheelColliders Work.
• RCC_Events.cs — static event hub. Subscribe to vehicle spawn, AI spawn, collision, indicator toggle, etc. See 24 — Events System.
• RCC_Light.cs — vehicle light component (headlight, brake, reverse, indicator). See 14 — Lights System.
• RCC_Damage.cs — mesh deformation, detachable parts, wheel damage. Embedded inside RCC_CarControllerV4, not a separate component.
• RCC_SceneManager.cs — singleton that tracks the active player vehicle, the active camera, and all RCC vehicles in the scene.
• RCC_Singleton.cs — base class for thread-safe singletons (used by RCC_SceneManager, RCC_InputManager, RCC_SkidmarksManager, and others).

Scripts/AI/

The waypoint AI system. Five files: RCC_AICarController, RCC_AIWaypointsContainer, RCC_AIBrakeZonesContainer, RCC_AIBrakeZone, RCC_Waypoint. See 19 — AI System.

Scripts/Camera/

Nine camera scripts. RCC_Camera is the main one (per-player follow camera with multiple modes). RCC_HoodCamera and RCC_WheelCamera attach to anchor points inside a vehicle prefab. RCC_FixedCamera and RCC_CinematicCamera are scene-wide singletons. See 13 — Camera System.

Scripts/Customization/

Twenty-five files covering paint, spoiler, wheel, decal, neon, siren, and upgrade managers. See 20 — Customization.

Scripts/Inputs/

Four input files:

• RCC_InputManager.cs — singleton that polls the Input System and exposes a RCC_Inputs struct each frame.
• RCC_InputActions.cs — auto-generated from RCC_InputActions.inputactions.
• RCC_MobileButtons.cs — static class storing the mobile UI's current input values.
• RCC_Inputs.cs — the input struct (throttle, brake, steer, clutch, etc.).

See 16 — Input System.

Scripts/ScriptableObjects/

Seven ScriptableObject classes. Their corresponding .asset files live under Resources/RCC Assets/. The most important is RCC_Settings — the master configuration file for the whole package. See 21 — RCC Settings Deep Dive.

Scripts/UI/

Twenty-three UI classes. Dashboard widgets, the steering wheel UI, joystick, touch buttons, color picker, telemetry overlay, customization UI panels. Most of these don't need direct interaction — they hook into a RCC_Canvas prefab and read from the active player vehicle automatically.

Scripts/Others/

Sixteen miscellaneous scripts:

• RCC_Demo.cs — used in the demo scenes to wire up buttons.
• RCC_AIO.cs — used by the "all-in-one" demo scene to enable every feature.
• RCC_APIExample.cs — example UI showing every public RCC API call.
• RCC_CarSelectionExample.cs — car selection menu example.
• RCC_OverrideInputsExample.cs — example of pumping custom inputs into a vehicle.
• RCC_LevelLoader.cs — loads scenes preserving the selected vehicle.
• RCC_Spawner.cs — places a vehicle at scene start.
• RCC_Teleporter.cs — trigger volume that teleports a vehicle.
• RCC_RepairStation.cs — trigger volume that repairs a vehicle's damage.
• RCC_FuelStation.cs — trigger volume that refuels a vehicle.
• RCC_CrashHammer.cs, RCC_CrashPress.cs, RCC_CrashShredder.cs — animated hazards for damage testing.
• RCC_CharacterController.cs — a very minimal third-person character used by some demos (not a full character system).
• RCC_Prop.cs — simple physics prop that vehicles can knock around.

Editor Code

Editor/Components/

Eight custom inspectors. Each one wraps a runtime component so that the Inspector shows clean, organized fields instead of Unity's raw default layout. For example, the RCC_CarControllerV4 inspector groups fields into Wheels, Engine, Gears, Steering, Audio, Damage, etc., with foldouts.

Editor/InitLoad/

Scripts that run on package import: layer setup, scripting symbol setup, input system check, install verification.

Editor/Windows/

Twelve editor windows. The ones you'll use most often:

• RCC_EditorWindows.cs — defines every menu item under Tools → BoneCracker Games → Realistic Car Controller.
• RCC_WelcomeWindow.cs — the welcome dialog that opens on first import.
• RCC_QuickVehicleSetupWizardWindow.cs — the wizard that turns a 3D model into a working RCC vehicle. See 07 — Creating New Vehicles.
• RCC_CreateNewVehicle.cs — utility for the wizard.
• RCC_RenderPipelineConverterWindow.cs — converts materials between Built-in / URP / HDRP. See 22 — URP & HDRP Conversion.

Resources

Resources/RCC Assets/

This is where all the ScriptableObject singletons live. RCC scripts load them at runtime using Resources.Load("RCC Assets/<name>"). Don't move or rename them.

Resources/RCC_WindowSkin.guiskin

A custom IMGUI skin used by the RCC editor windows and inspectors. Don't delete it — the editor tooling depends on it.

Documentation

Documentation/HTML/

In-package HTML documentation. RCC's Welcome window has an "Open Documentation" button that opens these in your default browser. The HTML is generated from the same Markdown source you're reading now (under Docs/Markdown/ at the project root, which is dev-side and not part of the shipped package).

Demo Scenes

Demo Scenes/

Eleven scenes covering every major feature. The full walkthrough is in 04 — Demo Scenes, but a quick summary:

What You Can Safely Modify

You can change any asset (textures, materials, models, sounds) freely — they're project files like any other.

You can change RCC_Settings.asset and RCC_GroundMaterials.asset to tune your game — but make a backup of the originals before doing so (Git is the easiest way), because updating RCC in the future will overwrite them.

You can change runtime scripts (the .cs files), but doing so makes updates messy because future RCC versions overwrite the scripts when you re-import. If you want to extend RCC behavior, prefer subscribing to RCC_Events from your own scripts instead of modifying RCC code directly. See 24 — Events System for the pattern.

Next Steps

You now know where everything lives. Continue with 04 — Demo Scenes to see RCC in action, or jump to 05 — Quick Start to drop a vehicle into your own scene.