How to Create New Vehicles

This document walks you through turning your own 3D vehicle model into a working RCC vehicle. The end result is a prefab that drives, brakes, steers, has lights, makes engine noise, and behaves exactly like the included demo vehicles.

There are two paths to creating a vehicle:

1. The Quick Vehicle Setup Wizard — recommended. Handles wheel collider creation, hierarchy setup, and component wiring automatically.
2. Manual setup — useful when you need precise control or when your model is unusual.

This guide covers both. We start with the wizard since it's what most users want.

What You Need Before You Start

Before you create an RCC vehicle, your 3D model needs to meet a few basic requirements:

• A car body mesh with a MeshRenderer and a MeshFilter. The body can be one mesh or many.
• Four wheel mesh transforms — the visible wheel models. They should be separate child GameObjects under the car, not merged into the body mesh.
• Pivot at the wheel center. Each wheel's pivot point must be at the wheel's center of rotation (not at the corner of the bounding box). This is the most common mistake: if your wheel rotates around the wrong point, the car will look broken in motion.
• Forward axis = +Z. The vehicle should face the positive Z direction in Unity. If your model points the wrong way, rotate the parent GameObject 180° before continuing.
• Reasonable scale. RCC is tuned for vehicles around 4–5 meters long. If your car is the size of a building or the size of a coin, scale it down or up first.

If your model came from Blender, Maya, 3ds Max, or Fusion 360, the axis convention may need adjusting. Drop the FBX into Unity and check that the forward axis points +Z and the up axis points +Y. If the wheels rotate around the wrong axis when you spin them in the Scene view, you'll fix that in the wizard.

Path 1: The Quick Vehicle Setup Wizard

The wizard is the recommended path. It does most of the boring wiring for you and explains each step inline.

Step 1 — Drop the Model into the Scene

In the Project window, find your vehicle model (the .fbx or .obj file). Drag it into the Hierarchy. The model appears at world origin.

In the Inspector, set its Scale to (1, 1, 1) and confirm it's facing +Z. If it's not, rotate it now.

If your model has the wheel meshes parented under the body, you may want to unparent the wheel transforms first so they sit as direct children of the root. The wizard works either way, but a clean hierarchy makes future edits easier:

MyCar/
├── Body (mesh)
├── FL_Wheel (mesh)
├── FR_Wheel (mesh)
├── RL_Wheel (mesh)
└── RR_Wheel (mesh)

Step 2 — Open the Wizard

In the menu bar, click Tools → BoneCracker Games → Realistic Car Controller → Quick Vehicle Setup Wizard.

A wizard window opens. It has fields for:

• Vehicle root — drag your car GameObject here.
• Front Left Wheel Transform — drag the FL wheel mesh.
• Front Right Wheel Transform — drag the FR wheel mesh.
• Rear Left Wheel Transform — drag the RL wheel mesh.
• Rear Right Wheel Transform — drag the RR wheel mesh.
• (Optional) Extra Rear Wheels — for multi-axle vehicles like trucks.

Fill these in. If you have a 6-wheel truck, add two extra rear-wheel slots and assign them.

Step 3 — Auto-Detect Possible Wheels (Optional)

If you're not sure which transforms are the wheels (for example, you imported a model with 200 children named "polySurface17"), use the Auto Detect Possible Wheels button. The wizard scans the model's hierarchy and proposes candidates based on naming patterns (wheel, tire, FL, FR, etc.) and on bounding-box shape (wheels tend to be flatter cylinders).

Review the proposed assignments and accept or override them.

Step 4 — Run the Setup

Click Create Vehicle. The wizard does the following automatically:

1. Adds an RCC_CarControllerV4 component to the root.
2. Adds a Rigidbody (RequireComponent ensures this).
3. Sets mass to 1500 kg, drag to 0.01, angular drag to 0.5 (from RCC_InitialSettings.asset).
4. Computes a center-of-mass placement based on the model's bounding box, places a COM child transform.
5. Creates a Wheel Colliders container child.
6. For each wheel, creates a child GameObject with a Unity WheelCollider and an RCC_WheelCollider, positioned at the wheel's transform.
7. Sets up the wheel collider radius and suspension distance based on the wheel mesh's bounding box.
8. Assigns the wheel mesh transforms and the wheel colliders to the corresponding fields on RCC_CarControllerV4.
9. Sets up default values for engine, gears, friction curves, anti-roll bars, brake torque.
10. Tags the GameObject Player so the SceneManager registers it automatically.

After the wizard finishes, your car is ready to drive.

Step 5 — Test

Make sure your scene has an RCC Scene Manager and an RCC Canvas (see 05 — Quick Start). Press Play. You should be able to drive your car.

If it doesn't drive correctly out of the box, the most likely issue is wheel positioning. See "Common Wheel Issues" below.

Path 2: Manual Setup

Use manual setup when:

• The wizard mis-detects your wheels.
• You need a non-standard configuration (e.g., motorcycle, monster truck with raised suspension).
• You're learning what the wizard does behind the scenes.

Manual Step 1 — Prepare the Hierarchy

Set up the GameObject hierarchy like this:

MyCar/                              ← gets RCC_CarControllerV4 + Rigidbody
├── Body                            ← the visible mesh
├── COM                             ← empty transform for center of mass
├── Wheel Colliders/                ← container
│   ├── WheelCollider_FL            ← gets WheelCollider + RCC_WheelCollider
│   ├── WheelCollider_FR
│   ├── WheelCollider_RL
│   └── WheelCollider_RR
├── FL                              ← the front-left wheel mesh
├── FR
├── RL
└── RR

The mesh transforms (FL, FR, RL, RR) and the collider transforms (under Wheel Colliders/) are separate. The mesh shows the visible wheel; the collider drives the physics.

Manual Step 2 — Add the Controller

Select the root GameObject. In the Inspector, click Add Component → RCC_CarControllerV4. Unity will add a Rigidbody automatically because of [RequireComponent(typeof(Rigidbody))].

Set the Rigidbody mass to 1500, drag to 0.01, angular drag to 0.5.

Manual Step 3 — Position the COM

Move the COM transform inside the vehicle to roughly where you'd expect the center of mass to be: about waist-height in the front seats, near the floor. This dramatically affects handling — too high and the car flips, too low and it understeers.

For a sports car, COM Y should be around 0.2–0.4 m above the ground. For an SUV, around 0.6 m.

In the RCC_CarControllerV4 inspector, assign the COM transform to the COM field.

Manual Step 4 — Set Up Wheel Colliders

For each wheel collider GameObject under Wheel Colliders/:

1. Position it at the wheel's center.
2. Add a Unity WheelCollider component.
3. Set its Radius to the wheel's actual radius (measure from the mesh's bounding box).
4. Set its Suspension Distance to about 0.2 m for a road car.
5. Set its Center to (0, 0, 0) — the collider is already positioned, so the center offset stays at zero.
6. Add an RCC_WheelCollider component.
7. Assign the wheel mesh transform (the visible wheel) to the Wheel Model field on RCC_WheelCollider.

Manual Step 5 — Wire Wheels to the Controller

On the root RCC_CarControllerV4:

• Assign the four wheel mesh transforms (FL, FR, RL, RR) to FrontLeftWheelTransform, FrontRightWheelTransform, RearLeftWheelTransform, RearRightWheelTransform.
• Assign the four RCC_WheelCollider components (NOT the wheel mesh transforms) to FrontLeftWheelCollider, FrontRightWheelCollider, RearLeftWheelCollider, RearRightWheelCollider.

For extra wheels (trucks, 6-wheelers), use the ExtraRearWheelsTransform and ExtraRearWheelsCollider arrays and set hasExtraWheels = true.

Manual Step 6 — Tag as Player

In the Inspector, set the GameObject's Tag to Player. The SceneManager will auto-register this vehicle on Start.

Manual Step 7 — Set Up the Engine and Gears

Default engine values are fine for a sports car. If you want to tune them:

• Max Engine Torque — peak torque in Newton-meters (default 300 Nm).
• Max Engine Torque At RPM — RPM at which torque peaks (default 5500).
• Min Engine RPM — idle RPM (default 800).
• Max Engine RPM — redline (default 7000).
• Total Gears — forward gears (default 6).
• Final Ratio — final drive ratio (default 3.23).

The engine torque curve is auto-generated from these values. If you uncheck Auto Generate Engine RPM Curve, you can hand-edit the curve.

For gear ratios, RCC auto-generates a sensible distribution from totalGears and finalRatio. To tune them by hand, expand the gears array and edit each gear's maxRatio, maxSpeed, and targetSpeedForNextGear.

Manual Step 8 — Test

Make sure your scene has a Scene Manager, a UI Canvas, and a ground plane. Press Play. Your car should now drive.

Adding Lights

The wizard does not add lights — you do that as a separate step.

Add Headlights

1. Position empty GameObjects at each headlight location on the car (front left, front right).
2. Use the menu Tools → BoneCracker Games → Realistic Car Controller → Create → Lights → Add Lights To Vehicle → HeadLight.
3. The selected GameObject gets a Light component, an RCC_Light component, a lens flare, and is configured as a headlight type.

Repeat for each light:

• Brake Light — place at the back of the car.
• Reverse Light — place near the brake lights, separate fixture.
• Indicator Light Left — place at front left and rear left.
• Indicator Light Right — place at front right and rear right.
• Interior Light — place inside the cabin.

See 14 — Lights System for full configuration.

Adding Exhaust Effects

For smoke and exhaust flame effects:

1. Create an empty GameObject behind the exhaust outlet, positioned at the tailpipe.
2. Add an RCC_Exhaust component.
3. The component will spawn a Particle System automatically using the exhaust gas prefab from RCC_Settings.

If your car has two exhausts, create two RCC_Exhaust GameObjects.

Adding Other Optional Components

Save as a Prefab

Once your vehicle works in the scene, drag the root GameObject from the Hierarchy into the Project window to create a prefab. From now on you can drag this prefab into any scene.

If you ever change something on the prefab and want to push it to existing scene instances, use Unity's standard Prefab → Apply All workflow.

Common Wheel Issues

Wheels Tilt Sideways (Camber Looks Wrong)

The wheel mesh's forward axis is wrong. RCC assumes the wheel's forward (rolling) direction is +Z and the up axis is +Y. If your wheels were modeled with +X as forward, they'll roll sideways.

Fix: open Tools → BoneCracker Games → Realistic Car Controller → Check Axis Orientation. The window lets you reorient wheels without re-exporting from your modeling software.

Wheels Look Sunken Into the Ground

The wheel collider radius is too small, or the suspension distance is too large. Increase the Radius on the WheelCollider component until the wheel mesh sits naturally on the ground.

Car Wobbles or Vibrates at Rest

The wheel colliders aren't symmetric — one wheel is slightly different radius or position. Make sure all four wheels have identical Radius, Suspension Distance, and Suspension Spring values. Differences cause the vehicle to constantly correct itself.

Also check the COM position. If COM is above the wheels' suspension target, the rigidbody can oscillate.

Car Flips Over Easily

COM is too high. Move the COM transform down. As a sanity check, a sports car COM should be at most 0.4 m above the ground; an SUV at most 0.7 m.

If COM is correct and it still flips, increase antiRollFrontHorizontal and antiRollRearHorizontal on the controller (default 1000 N — try 2000–5000 for heavier vehicles).

Car Understeers / Won't Turn

Friction curves are too forgiving on the front wheels. The behavior preset's sidewaysExtremumValue is the main lever. For a tighter-turning car:

• Try the Arcade behavior (RCC.SetBehavior(2)) — it has higher sideways grip.
• Or in RCC_Settings.asset, increase sidewaysExtremumValue in the active behavior preset (e.g., from 1.0 to 1.3).
• Or per-vehicle, enable overrideBehavior on RCC_CarControllerV4 and tune the wheel friction curves directly.

Car Oversteers / Tail Wags

Opposite problem — too little rear grip relative to front. Increase the rear wheels' sidewaysExtremumValue or decrease the front's.

Vehicle Tuning Sanity Checks

After your vehicle drives, run through this checklist:

If any of these look wrong, the behavior preset is probably the culprit. Try switching presets (10 — Behavior Presets) before tweaking individual fields.

Next Steps

• For a field-by-field walkthrough of the controller's Inspector: 08 — Vehicle Inspector Reference.
• To understand how WheelColliders actually compute friction: 09 — How WheelColliders Work.
• To pick a driving feel (drift / arcade / simulator): 10 — Behavior Presets.
• To add lights: 14 — Lights System.
• To add the customization system: 20 — Customization.