High-Level Car Physics System (C++)

Wheeled vehicles are widely used in various simulations. The high-level Car Physics system, implemented as a set of C++ components, is intended to simplify creation of realistic wheeled vehicles in UNIGINE. It minimizes efforts required to create virtually any wheeled vehicle, be it a 4WD SUV, an exploration rover, or a sophisticated multi-axle transporter.

The following features are available:

• Setting the engine power and resistance curves, as well as idle speed (RPM)
• Gearbox simulation (manual and automatic) enabling you to adjust throttle an speed values for shifting gears along with transition time, as well as to set the number of gears and configure gear ratios
• Mathematical wheel model for more realistic steering, enabling simulation of forces affecting the rotating wheel, along with an ability to adjust suspension travel distance, spring, and damping values
• Easy setup of steering and driving axes along with capability to turn the differential lock on and off
• A set of debug windows displaying information on all vehicle parameters in real time
• Switching between different views (driver's, external camera, etc.)
• Simulation of various surface conditions (such as dry, wet, snow-covered, or icy road, mud, and so on)

Instructions given below cover the process of creation of a wheeled vehicle using the Vehicle Sample from the SDK in a new empty project. The step-by-step guide will take you through the process of creating all necessary nodes and configuring component parameters you need to have a functional vehicle, assuming that you have a model of the vehicle's body and models of its wheels at your disposal.

See also#

First, we should prepare a project and get all necessary source files containing implementation of components from the sample. So, we perform the following actions:

1. Create a new C++ project.

   

2. Open your new project's source folder and create the new vehicle_components folder in it.
3. Then open the source/vehicle_sample folder and copy all the files it contains to the vehicle_components folder that you've just created.
4. Open your project in the IDE and add all source files from the vehicle_components folder to it.

5. Add initialization code for C++ Component System to the AppSystemLogic::init() method:

   Source code (C++)

   #include <UnigineComponentSystem.h>
   
   /* ... */
   
   int AppSystemLogic::init()
   {
   	/* ... */
   	
   	// initialize ComponentSystem and register all components
   	Unigine::ComponentSystem::get()->initialize();
   	
   	/* ... */
   }

6. Build and run your project to register all components and generate necessary properties. We are going to use these properties later to configure our vehicle. Meanwhile, we can proceed to the next step.

Next, we create a model representing the vehicle's body and a model for vehicle's wheels (or several models, depending on how many different types of wheels your vehicle has).

The Y axis of all models (including wheels) should be pointing forward. So, you can't just make a copy of a wheel and rotate it around the Z axis by 180 degrees.

The scale of all models should be equal to 1 along all axes, to ensure correct physics simulation.

In order for the system to work, your vehicle's hierarchy should be properly organized. The following hierarchy is recommended:

All nodes in the hierarchy, except for the vehicle's body and wheels, are Node Dummy. These Node Dummy serve only to organize the components logic and have an identity transform matrix, except for the center_of_mass, as its position defines the position of the vehicle's center of mass in the local coordinates of the vehicle's body (must have the body as parent).

Then, we should assign a rigid body to the object representing the vehicle's body and disable the Shape-Based option for it, to turn off automatic calculation as inertia, mass, and center of mass are specified in the component. Then, add necessary number of physical shapes to specify the geometry of the body.

At this stage we assign component properties generated at Step 1 and configure necessary parameters for the engine, transmission, wheels, etc.

Engine#

Gearbox#

Transfer Case#

Axles#

Wheels#

Configure Vehicle Body#

You can choose to use various types of input devices to control your vehicle, be it a joystick or a gamepad, a driving wheel or a keyboard. The following NodeDummy hierarchy is recommended to implement user input handling:

The car_input_manager component implements vehicle control and enables simultaneous handling of input events from several input devices. It contains an array of nodes (NodeDummy), each having the corresponding input component (car_keyboard_input, car_joystick_input, or car_gamepad_input) assigned. Each component implements input handling for the corresponding device.

Input events can be generated by either of the following:

• Button
• Axis - can be either a physical axis of the controller, or it can be imitated with buttons

So here we simply configure necessary buttons and axes. Several options are available for an axis:

• Full - full axis range: [-1, 1]
• Positive range - only the positive range of axis values is taken: [0, 1]
• Negative range - only the negative range of axis values is taken: [-1, 0]
• Full to positive - converts values in the full [-1, 1] range to values in the positive [0, 1] range
• Full to negative - converts values in the full [-1, 1] range to values in the negative [-1, 0] range

The NONE value for a button indicates that it's not used.

Convincing simulation of any vehicle requires fine-tuning. To simplify the process of adjusting parameters, a set of debug windows displaying various vehicle parameters (engine, transmission, wheels, etc.) is at your disposal.

In order to enable the debug option, you should create the following hierarchy of Node Dummy (they're just used to enable component logic) and assign the corresponding components to them as shown below:

You can switch between the driver's view and other custom views (e.g. external cameras, etc.). Suppose you have various cameras (players) added to the scene and placed at desired locations. To enable switching between them, simply add a Node Dummy to the scene and assign the camera_switcher component to it. Then, in the Input field, specify the node responsible for input handling, that we added at Step 6. And, finally, specify the number of cameras you want to use, and drag the corresponding Player nodes to the fields of the Cameras parameter. All available cameras will be switched in a looped sequence according to the order they are listed.

Driving simulation would be incomplete without the ability to set various surface conditions, such as dry, wet, snow-covered, or icy road, mud, etc. You can simulate various surface conditions by setting up friction coefficients and specifying masks to define areas of the Landscape Terrain for them.

To enable simulation of surface conditions add a Node Dummy to the scene and assign the friction_controller component to it. Then specify masks of Landscape Terrain defining the areas to which the values of longitudinal (forward) and lateral friction will be applied.

Now you can mark areas with different surface conditions on your terrain and fine-tune your vehicle using the debug windows to make your driving simulation as close to real conditions as possible.