There are many approaches to understanding the type of 3D math used in video -games, modelling, ray-tracing, etc. The usual is through vector algebra, matrices, and -linear transformations and, while they are not completely necesary to understand -most of the aspects of 3D game programming (from the theorical point of view), they -provide a common language to communicate with other programmers or -engineers. -

This tutorial will focus on explaining all the basic concepts needed for a -programmer to understand how to develop 3D games without getting too deep into -algebra. Instead of a math-oriented language, code examples will be given instead -when possible. The reason for this is that. while programmers may have -different backgrounds or experience (be it scientific, engineering or self taught), -code is the most familiar language and the lowest common denominator for -understanding. -

1.2 Vectors

1.2.1 Brief Introduction

When writing 2D games, interfaces and other applications, the typical convention is -to define coordinates as an x,y pair, x representing the horizontal offset and y the -vertical one. In most cases, the unit for both is pixels. This makes sense given the -screen is just a rectangle in two dimensions. -

An x,y pair can be used for two purposes. It can be an absolute position (screen -cordinate in the previous case), or a relative direction, if we trace an arrow from the -origin (0,0 coordinates) to it’s position. -

When used as a direction, this pair is called a vector, and two properties can be -observed: The first is the magnitude or length , and the second is the direction. In -two dimensions, direction can be an angle. The magnitude or length can be computed -by simply using Pithagoras theorem: -

The direction can be an arbitrary angle from either the x or y axis, and could be -computed by using trigonometry, or just using the usual atan2 function present in -most math libraries. However, when dealing with 3D, the direction can’t be described -as an angle. To separate magnitude and direction, 3D uses the concept of normal -vectors. -

1.2.2 Implementation

Vectors are implemented in Godot Engine as a class named Vector3 for 3D, and as -both Vector2, Point2 or Size2 in 2D (they are all aliases). They are used for any -purpose where a pair of 2D or 3D values (described as x,y or x,y,z) is needed. This is -somewhat a standard in most libraries or engines. In the script API, they can be -instanced like this: - -

a = Vector3()
a = Vector2( 2.0, 3.4 ) -

Vectors also support the common operators +, -, / and * for addition, -substraction, multiplication and division. - -

a = Vector3(1,2,3)
b = Vector3(4,5,6)
c = Vector3()

// writing

c = a + b

// is the same as writing

c.x = a.x + b.x
c.y = a.y + b.y
c.z = a.z + b.z

// both will result in a vector containing (5,7,9).
// the same happens for the rest of the operators. -

Vectors also can perform a wide variety of built-in functions, their most common -usages will be explored next. -

1.2.3 Normal Vectors

Two points ago, it was mentioned that 3D vectors can’t describe their direction as an -agle (as 2D vectors can). Because of this, normal vectors become important for -separating a vector between direction and magnitude. -

A normal vector is a vector with a magnitude of 1. This means, no matter where -the vector is pointing to, it’s length is always 1. -

Normal vectors have endless uses in 3D graphics programming, so it’s -recommended to get familiar with them as much as possible. -

1.2.4 Normalization

Normalization is the process through which normal vectors are obtained -from regular vectors. In other words, normalization is used to reduce the -magnitude of any vector to 1. (except of course, unless the vector is (0,0,0) -). -

To normalize a vector, it must be divided by its magnitude (which should be -greater than zero): - -

// a custom vector is created
a = Vector3(4,5,6)
// ’l’ is a single real number (or scalar) containight the length
l = Math.sqrt( a.x*a.x + a.y*a.y + a.z*a.z )
// the vector ’a’ is divided by its length, by performing scalar divide
a = a / l
// which is the same as
a.x = a.x / l
a.y = a.y / l
a.z = a.z / l - -

a = Vector3(4,5,6)
a.normalize() // in-place normalization
b = a.normalized() // returns a copy of a, normalized -

1.2.5 Dot Product

The dot product is, pheraps, the most useful operation that can be applied to 3D -vectors. In the surface, it’s multiple usages are not very obvious, but in depth it can -provide very useful information between two vectors (be it direction or just points in -space). -

The dot product takes two vectors (a and b in the example) and returns a scalar -(single real number): -

a_xb_x + a_yb_y + a_zb_z -

a = Vector3(...)
b = Vector3(...)

c = a.x*b.x + a.y*b.y + a.z*b.z

// using built-in dot() function

c = a.dot(b) -

1.2.6 Cross Product

The cross product also takes two vectors a and b, but returns another vector c that is -orthogonal to the two previous ones. -

c_x = a_xb_z - a_zb_y -

c_y = a_zb_x - a_xb_z -

c_z = a_xb_y - a_yb_x -

a = Vector3(...)
b = Vector3(...)
c = Vector3(...)

c.x = a.x*b.z - a.z*b.y
c.y = a.z*b.x - a.x*b.z
c.z = a.x*b.y - a.y*b.x

// or using the built-in function

c = a.cross(b) -

1.3 Plane

1.3.1 Theory

A plane can be considered as an infinite, flat surface that splits space in two halves, -usually one named positive and one named negative. In regular mathematics, a plane -formula is described as: -

ax + by + cz + d -

However, in 3D programming, this form alone is often of little use. For planes to -become useful, they must be in normalized form. -

A normalized plane consists of a normal vector n and a distance d. To normalize -a plane, a vector n and distance d’ are created this way: -

In any case, normalizing planes is not often needed (this was mostly for -explanation purposes), and normalized planes are useful because they can be created -and used easily. -

A normalized plane could be visualized as a plane pointing towards normal n, -offseted by d in the direction of n. -

In other words, take n, multiply it by scalar d and the resulting point will be part -of the plane. This may need some thinking, so an example with a 2D normal vector -(z is 0, so plane is orthogonal to it) is provided: -

1.3.2 Implementation

//creates a plane with normal (0,1,0) and distance 5
p = Plane( Vector3(0,1,0), 5 )
// get the distance to a point
d = p.distance( Vector3(4,5,6) ) -

1.4 Matrices, Quaternions and Coordinate Systems

It is very often needed to store the location/rotation of something. In 2D, it is often -enough to store an x,y location and maybe an angle as the rotation, as that should -be enough to represent any posible position. -

In 3D this becomes a little more difficult, as there is nothing as simple as an angle -to store a 3-axis rotation. -

The first think that may come to mind is to use 3 angles, one for x, one for y and -one for z. However this suffers from the problem that it becomes very cumbersome to -use, as the individual rotations in each axis need to be performed one after another -(they can’t be performed at the same time), leading to a problem called “gimbal -lock”. Also, it becomes impossible to accumulate rotations (add a rotation to an -existing one). -

To solve this, there are two known diferent approaches that aid in solving -rotation, Quaternions and Oriented Coordinate Systems. -

1.4.1 Oriented Coordinate Systems

Oriented Coordinate Systems (OCS) are a way of representing a coordinate system -inside the cartesian coordinate system. They are mainly composed of 3 Vectors, one -for each axis. The first vector is the x axis, the second the y axis, and the third is the - -z axis. The OCS vectors can be rotated around freely as long as they are kept the -same length (as changing the length of an axis changes its cale), and as long as they -remain orthogonal to eachother (as in, the same as the default cartesian system, -with y pointing up, x pointing left and z pointing front, but all rotated -together). -

Oriented Coordinate Systems are represented in 3D programming as a 3x3 matrix, -where each row (or column, depending on the implementation) contains one of the -axis vectors. Transforming a Vector by a rotated OCS Matrix results in the rotation -being applied to the resulting vector. OCS Matrices can also be multiplied to -accumulate their transformations. -

//create a 3x3 matrix
m = Matrix3()
//rotate the matrix in the y axis, by 45 degrees
m.rotate( Vector3(0,1,0), Math.deg2rad(45) )
//transform a vector v (xform method is used)
v = Vector3(...)
result = m.xform( v ) -

However, in most usage cases, one wants to store a translation together with the -rotation. For this, an origin vector must be added to the OCS, thus transforming it -into a 3x4 (or 4x3, depending on preference) matrix. Godot engine implements this -functionality in the Transform class: - -

t = Transform()
//rotate the transform in the y axis, by 45 degrees
t.rotate( Vector3(0,1,0), Math.deg2rad(45) )
//translate the transform by 5 in the z axis
t.translate( Vector3( 0,0,5 ) )
//transform a vector v (xform method is used)
v = Vector3(...)
result = t.xform( v ) -

Transform contains internally a Matrix3 “basis” and a Vector3 “origin” (which can -be modified individually). -

1.4.2 Transform Internals

Internally, the xform() process is quite simple, to apply a 3x3 transform to a vector, -the transposed axis vectors are used (as using the regular axis vectors will result on -an inverse of the desired transform): - -

m = Matrix3(...)
v = Vector3(..)
result = Vector3(...)

x_axis = m.get_axis(0)
y_axis = m.get_axis(1)
z_axis = m.get_axis(2)

result.x = Vector3(x_axis.x, y_axis.x, z_axis.x).dot(v)
result.y = Vector3(x_axis.y, y_axis.y, z_axis.y).dot(v)
result.z = Vector3(x_axis.z, y_axis.z, z_axis.z).dot(v)

// is the same as doing

result = m.xform(v)

// if m this was a Transform(), the origin would be added
// like this:

result = result + t.get_origin() -

1.4.3 Using The Transform

So, it is often desired apply sucessive operations to a transformation. For example, -let’s a assume that there is a turtle sitting at the origin (the turtle is a logo reference, - -for those familiar with it). The y axis is up, and the the turtle’s nose is pointing -towards the z axis. -

The turtle (like many other animals, or vehicles!) can only walk towards the -direction it’s looking at. So, moving the turtle around a little should be something -like this: - -

// turtle at the origin
turtle = Transform()
// turtle will walk 5 units in z axis
turtle.translate( Vector3(0,0,5) )
// turtle eyes a lettuce 3 units away, will rotate 45 degrees right
turtle.rotate( Vector3(0,1,0), Math.deg2rad(45) )
// turtle approaches the lettuce
turtle.translate( Vector3(0,0,5) )
// happy turtle over lettuce is at
print(turtle.get_origin()) -

As can be seen, every new action the turtle takes is based on the previous one it -took. Had the order of actions been different and the turtle would have never reached -the lettuce. -

Transforms are just that, a mean of “accumulating” rotation, translation, scale, -etc. -

1.4.4 A Warning about Numerical Precision

Performing several actions over a transform will slowly and gradually lead to -precision loss (objects that draw according to a transform may get jittery, bigger, -smaller, skewed, etc). This happens due to the nature of floating point numbers. if -transforms/matrices are created from other kind of values (like a position and -some angular rotation) this is not needed, but if has been accumulating -transformations and was never recreated, it can be normalized by calling the -.orthonormalize() built-in function. This function has little cost and calling it every -now and then will avoid the effects from precision loss to become visible. - - - - - -- cgit v1.2.3

1 Introduction to 3D Math

1.1 Introduction