Understanding Coordinate Systems: Concepts, Creation, and Placement

In this section, we'll cover the concept of coordinate systems -- an essential topic for creating dynamic 3D scenes -- as well as how to create and place them in a program.

The term coordinate system might sound intimidatingly mathematical, but VCSSL Graphics3D is designed to make working with coordinate systems intuitive and straightforward.

Sponsored Link

What Is a Coordinate System?

Coordinate Systems and Position Vectors

So far, when you've moved models or defined the positions of polygon vertices, you've specified a point in space using a set of three values: (X, Y, Z). This set of values is called a position vector, and the individual components are referred to as the X, Y, and Z components.

However, a position vector alone isn't enough to define a point in space -- it only gains meaning within the context of a coordinate system.

For example, the position vector (1, 2, 3) represents a point located by moving 1 unit in the X direction, 2 units in the Y direction, and 3 units in the Z direction from the origin -- that is, from the point (0, 0, 0). So in order to specify a point in 3D space, we need not just the X, Y, Z components of the vector, but also two reference elements: the position of the origin and the directions of the X, Y, and Z axes. Together, these form a coordinate system.

Position indicated by the vector (1, 2, 3)

The point (1, 2, 3) is reached by moving 1 unit along the X-axis, 2 units along the Y-axis, and 3 units along the Z-axis from the origin.

The Same Point Can Have Different Vectors in Different Coordinate Systems

A position vector that points to a particular location in space will have different component values depending on the coordinate system.

Take the position vector (1, 2, 3) in one coordinate system. In another system, that same physical location in space might be represented by a different vector -- say, (0, 5, 3).

The same point from different coordinate systems

The vector components differ depending on the coordinate system used to observe the same location in space.

This discrepancy arises for two main reasons. First, the origin is located differently in each system -- meaning (0, 0, 0) points to different locations. Second, the directions of the X, Y, and Z axes may also differ. Even if the origins were aligned, the vector components would still differ due to this directional mismatch.

How Coordinate Systems Enable Movement

Coordinate systems are especially useful when you want to animate or move 3D objects.

Let's say you place a model at the position (1, 2, 3) relative to a particular coordinate system. If you want to move the model, you don't need to modify its position directly -- you can just move the coordinate system itself. Since the model's position is defined *relative to the coordinate system*, the model will appear to move along with it.

Moving the coordinate system

When the coordinate system moves, the position indicated by the vector moves with it.

Similarly, if you want to rotate the model, you can simply rotate the coordinate system. Because the X, Y, and Z axes themselves rotate, the point (1, 2, 3) also rotates accordingly, and the model appears to rotate.

Rotating the coordinate system

When the coordinate system rotates, the position indicated by the vector rotates as well.

This is essentially an alternative to rewriting the position of the model directly -- instead, you move the reference frame itself.

Of course, it's still possible to move or rotate a model by directly modifying its position vector (1, 2, 3). In fact, that's exactly what the moveModel(...), movePolygon(...) and rotModel(...), rotPolygon(...) functions do internally.

However, if you want to move multiple models together, it's much easier to move a shared coordinate system than to update each model individually. For example, to move a "car," it would be tedious to move each component (wheels, body, driver) one by one. Instead, you can create a dedicated coordinate system for the car and place all its parts within it -- then just move the coordinate system to move the entire car.

Types of Coordinate Systems

Coordinate systems fall broadly into three categories:

View (and Screen) Coordinate System

The view coordinate system is a special coordinate system that stays fixed to the camera or "viewpoint" of the 3D scene. It's sometimes called the camera coordinate system.

Everything you see on the screen is a projection of 3D objects in the virtual space onto the XY plane of this view coordinate system, with perspective applied. This 2D projection plane is often referred to as the screen coordinate system.

From our real-world perspective, the view coordinate system can be thought of as one that's "stuck to your computer screen." In this sense, it's a bridge between the real world and the virtual one. Typically, the X-axis runs to the right, the Y-axis runs upward, and the Z-axis extends toward the viewer (although some systems use the opposite Z direction). This orientation remains constant even if the 3D world moves.

View coordinate system

A coordinate system fixed to the camera. From a real-world point of view, it can be seen as attached to the screen. X points right, Y points up, Z points toward the viewer.

World Coordinate System

In addition to the view coordinate system, there's another important one: the world coordinate system. As the name suggests, this serves as the foundation of the entire 3D world.

While you could place models directly into the view coordinate system, doing so makes it difficult to manage the relative positions and orientations of objects when the camera moves. Every change in viewpoint would require you to recalculate the position and rotation of each object manually.

Instead, you can insert a world coordinate system between the view coordinate system and your models. This lets you move the camera by simply adjusting the relationship between the view and world coordinate systems, making things much easier to manage.

World coordinate system

Typically, models aren't placed directly in the view coordinate system, but in the world coordinate system.

Another benefit of using the world coordinate system is that it allows you to define a consistent, camera-independent reference frame. This is especially useful in games or simulations where many moving objects must be coordinated. You can, for instance, define a ground-based reference for all movement and interactions.

Local Coordinate Systems

Aside from the view and world coordinate systems, there are coordinate systems that you, the programmer, can create and use freely. These are generally called local coordinate systems. Typical use cases include moving an object dynamically or grouping multiple objects together to move them as one.

Local coordinate systems are not required by default, so you can declare and use as many as needed, based on your program's structure.

For example, imagine a 3D virtual world representing a city. Immovable objects like mountains can be placed directly in the world coordinate system. On the other hand, for moving objects like trains, buses, or airplanes, it's more convenient to create a dedicated local coordinate system for each one and place them there.

Local Coordinate System

Unlike the view and world coordinate systems, local coordinate systems are defined and used freely by the programmer.

Creating Coordinate Systems

General Coordinate Systems (Local Coordinate Systems)

To create a general-purpose (local) coordinate system, use the "newCoordinate" function:

- Function Format -

This function creates a new coordinate system and returns a unique ID assigned to it.

Special Coordinate Systems (World and View Coordinate Systems)

Special coordinate systems like the world and view coordinate systems are automatically created and maintained by the renderer. These systems are also assigned IDs, which can be retrieved using the getWorldCoordinate(...) and getViewCoordinate(...) functions:

- Function Format -

The argument "rendererID" specifies the ID of the renderer.

The first function returns the ID of the world coordinate system, while the second returns the ID of the view coordinate system.

Mounting Coordinate Systems

In VCSSL, coordinate systems are used by mounting them on top of other coordinate systems. The system being mounted onto is called the parent coordinate system, and the one being mounted is called the child coordinate system.

Coordinate systems can be layered in multiple levels, but the chain of parent systems must eventually trace back to either the world or view coordinate system.

To mount a coordinate system onto another, use the "mountCoordinate" function. For example, to mount a system onto the world coordinate system, use the following form:

- Function Format -

Arguments:

• childID: The ID of the coordinate system (child) to mount.
• rendererID: The ID of the renderer.

To mount a coordinate system onto another arbitrary (non-world) system, include one additional argument to specify the parent system:

- Function Format -

Arguments:

• childID: The ID of the coordinate system (child) to mount.
• rendererID: The ID of the renderer.
• parentID: The ID of the coordinate system (parent) to mount onto.

Example Program

Let's try creating a local coordinate system and mounting it onto the world coordinate system. To make the difference visually clear, we'll place a small axis model on the local system, and a larger one on the world system. Try running the following code:

import graphics3d.Graphics3DFramework;
import Graphics3D;

// Function called at the beginning of the program
void onStart ( int rendererID ) {

	// Optional: Set the window size and background color
	setWindowSize( 800, 600 );
	setBackgroundColor( 0, 0, 0, 255 );


	// Create a local coordinate system
	int coord = newCoordinate( );

	// Mount the local coordinate system on the world coordinate system
	mountCoordinate( coord, rendererID );

	// Place a small axis model on the local coordinate system
	int axis1 = newAxisModel( 1.5, 1.5, 1.5 );
	mountModel( axis1, rendererID, coord );

	// Place a larger axis model on the world coordinate system
	int axis2 = newAxisModel( 3.0, 3.0, 3.0 );
	mountModel( axis2, rendererID );
}

When this program runs, you'll see two axis models on a black background. The smaller one is placed on the local coordinate system, while the larger one is placed on the world coordinate system.

Execution Result

Two axis models appear overlapped -- the smaller one mounted on a local coordinate system, the larger one on the world coordinate system.

Now, if you move or rotate the local coordinate system, the small axis model mounted on it will move or rotate along with it. We'll cover how to perform these transformations next.