CHAPTER 2

Real-World Mechanics

The player’s primary logic operates within the known possibilities of physics. Keep in mind gravity, weight, mass, density, force, buoyancy, elasticity, etc. Use this as the starting point, but do not be limited by it.

Matt Allmer

2.1    Introduction

An understanding of motion and the driving forces thereof is crucial in understanding games. Most objects in games move. That is what makes them dynamic. Whether it be a two-dimensional (2D) character such as the original Mario or a fully-fledged three-dimensional (3D) character such as Geralt in The Witcher 3, they and their game environments are in constant motion.

To grasp the concept of motion, especially with respect to computer games, a development of foundation knowledge in vector mathematics is required. Vectors are used extensively in game development for describing not only positions, speed, acceleration, and direction but also within 3D models to specify UV texturing, lighting properties, and other special effects.

Before leaping into the use of vectors in games for defining motion, a crash course in essential vector mathematics for game environments is presented in the next section.

2.2    Principles of Vectors

In Chapter 1, a vector was introduced as a line with a length (magnitude) and a direction (indicated by an arrow). Vectors can be used to represent measurements such as displacement, velocity, and acceleration. In 2D, a vector has x and y coordinates. In 3D, it has x, y, and z coordinates. In pure mathematics, a vector is not a point in space, but a set of changing coordinate instructions. It can be likened to the instructions on a fictional pirate’s treasure map; for example, take three steps to the west and seven steps to the south. As shown in Figure 2.1, the instructions three steps to the west could be interpreted as the vector (3,0), meaning move 3 in the positive x direction and nothing in the y direction. The instructions move seven steps to the south become the vector (0,−7), meaning move only 7 in a negative y direction.

To determine the final location, vector x and y values are added to the starting point x and y values. For example, in Figure 2.1, the pirate ship lands at (4,8), and moving (3,0) will place them at (4 + 3,8 + 0) = (7,8). Then moving (0,−7) will put them at (7 + 0,8 − 7) = (7,1). They can also take a shortcut by going directly in a straight line to the treasure. In this case, the two instruction vectors (3,0) and (0,−7) are added together and become (3,−7). By taking the starting location and adding this new vector, they will end up in the same location [i.e., (4 + 3,8 − 7) = (7,1)].

To travel from the treasure back to the ship, the pirates can follow the same line but in the opposite direction. This is achieved by flipping the vector such that all coordinate values are multiplied by −1. In this case, to get back to the ship, they follow the vector (−3,7).

FIG 2.1 A pirate’s treasure map illustrating the use of vectors.

It might also be useful for the pirates to know how far the treasure is from the ship. The length of a vector, v, called its magnitude and written |v|, is found using the Pythagorean theorem:

${|v|}_{}=\sqrt{{v.x}^2{+v.y}^2}$

(2.1)

For the pirates, it means that their journey is a length of 7.62 (kilometers, if the units being used are kilometers), that is, $\sqrt{3^2{+(-7)}^2}.$

Sometimes it is necessary to scale a vector, so that it has a length equal to 1. The process of scaling the length is called normalizing, and the resultant vector, which still points in the same direction, is called a unit vector. To find the unit vector, each coordinate of the vector is divided by the vector’s length. In the case of the pirate’s journey, this would equate to (3/7.62,−7/7.62) = (0.39,−0.92). If the pirate takes 0.39 steps to the west and 0.92 steps to the south, he will end up a distance of 1 from his starting position, right on the original vector, as shown in Figure 2.2. As can be seen, the vectors (3,−7) and (0.39,−0.92) are parallel and the magnitude of (0.39,−0.92) is 1.

The unit vectors for north, south, east, and west as they would be overlaid on a map of the earth* are (0,1), (0,−1), (−1,0), and (1,0).

Two further important calculations can be performed with vectors. These are the dot product and the cross product. The use of these in computer graphics and games programming will become overwhelmingly clear later. Among other things, the dot product can be used to calculate the angle between two vectors, and the cross product can be used to determine the direction.

FIG 2.2 A normalized vector has a length of 1.

FIG 2.3 A pirate facing (1, 0) and the vector to the treasure.

The dot product is calculated by taking two vectors, v and w, and multiplying their respective coordinates together and then adding them. The dot product results in a single value. It can be calculated using the following equation:

$v_{}.w_{}=v_x\times w_x+v_y\times w_y$

(2.2)

Given the vectors v= (1,0) and w= (3,−7), the direction the pirate is facing and the direction to the treasure (shown in Figure 2.3), the dot product will be 1 × 3 + 0 × −7 = 3.

But what does this mean? The most useful application of the dot product is working out the angle between two vectors. In a moment, we will work out the actual value of the angle, but for now, by just knowing the value of the dot product you can determine how the vectors sit in relation to each other. If the dot product is greater than zero, the vectors are less than 90° apart; if the dot product equals zero, then they are at right angles (perpendicular); and if the dot product is less than zero, then they are more than 90° apart.

To find out the exact angle the pirate must turn to face the treasure, the arccosine of the dot product of the unit vectors is calculated. The unit vector for (3,−7) is (0.39,−0.92) as already established and (1,0) is already a unit vector. This result for the angle between the vectors is therefore:

= arcos[(1,0).(0.39,0.92)]

= arcos[(1 × 0.39) + (0 × 0.92)]

= arcos(0.39)

= 67°

You can always check the result of your calculation by looking at a plot of the vectors and measuring them with a protractor. In this case, by taking a visual estimate, the angle is larger than 45° and less than 90°; therefore, the calculation appears to be correct.

Now imagine the pirate is told to turn 67° and walk for 7.62 km to get to the treasure. Which way does he turn? The image in Figure 2.3 shows that a decision needs to be made as whether to turn to the right or the left.

In computer graphics, a positive value for an angle always indicates a counterclockwise turn. A counterclockwise turn in this case would have the pirate facing away from the treasure. When calculating the angle between vectors using the dot product, the angle is always positive. Therefore, you need another method to determine the turn direction. This is where the cross product comes into play.

The cross product of two vectors results in another vector. The resulting vector is perpendicular (at 90°) to both the initial vectors. This sounds odd working in 2D as a vector at right angles to two vectors in 2D would come right out of the page. For this reason, the cross product is only defined for 3D. The formula to work out the cross product is a little obtuse and requires further knowledge of vector mathematics, but we will try to make it as painless as possible.

The cross product of two vectors, v and w, denoted v × w is shown in the following equation:

$v\times w=(v_y{w}_z-v_z{w}_y)(1,0,0)+(v_z{w}_x-v_x{w}_z)(0,1,0)+(v_x{w}_y-v_y{w}_x)(0,0,1)$

(2.3)

The equation is defined in terms of standard 3D unit vectors. These vectors are three unit-length vectors oriented in the directions of the x, y, and z axes. If you examine Equation 2.3 you will notice that there are three parts added together. The first part determines the value of the x coordinate of the vector, as the unit vector (1,0,0) only has a value for the x coordinate. The same occurs in the other two parts for the y and z coordinates.

To find the cross product of two 2D vectors, the vectors first need to be converted into 3D coordinates. This is as easy as adding a zero z value. For example, v= (1,0) will become v= (1,0,0) and w= (0.39,−0.92) will become w= (0.39,−0.92,0). The value of v × w would equate to (0 × 0 – 0 × −0.92)(1,0,0) + (0 × 0.39 –1 × 0)(0,1,0) + (1 × −0.92 –0 × 0.39)(0,0,1) = 0(1,0,0) + 0(0,1,0) + −0.92(0,0,1) = (0,0,0) + (0,0,0) + (0,0,−0.92) = (0,0,−0.92). This vector only has a z coordinate, so is directed along the z axis. It is therefore coming out of the page.

An interesting thing to note about the cross product is that if the order of the equation is reversed, the resulting vector is different. w × v would equal (0,0,0.92) (check this out!), which is a vector of the same length as the one produced by v × w, but traveling in the exact opposite direction. This differs from the calculation of the dot product that yields the same answer no matter what the order of the vectors.

How does this help the pirate determine the direction in which to turn?

If he starts by facing in the direction of v and wishes to turn to face w, we can calculate v × w. If we examine Figure 2.3, we can see that w would be on the pirate’s right and therefore would require a clockwise turn. We know from the previous example that a clockwise turn between two vectors produces a cross product result with a negative z value. The opposite is true for a counterclockwise turn. Therefore, we can say that if z is positive, it means a counterclockwise turn and if z is negative, a clockwise turn.

The pirate now knows to turn to his right 67° clockwise and travel 7.62 km in a straight line to reach the treasure.

This may all seem obvious by looking at the map. However, objects in a game environment that have no visual point of reference, such as artificially controlled bots or vehicles, require these very calculations in order to move around successfully in a virtual environment.

2.3    Defining 2D and 3D Space

Whether it is in 2D or 3D space, the principles of vectors are applied in the same way. As we explored with vectors, the difference between a 2D coordinate and a 3D coordinate is just another value. In 3D game engines, such as Unity, 2D games are created by ignoring one of the axes. In the rocket ship application shown in Section 2.4, all game objects are positioned in the same plane, having a y position value initially set to 0. All movements thereafter only move and rotate the objects in x and y. This is the same principle as moving objects around on a flat tabletop. In the rocket ship game, the camera is positioned directly above the game objects and perspective is removed to give the illusion of a truly 2D world.

The camera in a game is a critical component, as it presents the action to the player. It is literally the lens through which the game world is perceived. Understanding how the camera moves and how to set what it looks at is essential knowledge.

2.3.1    Cameras

The camera in a game defines the visible area on the screen. In addition to defining the height and width of the view, the camera also sets the depth of what can be seen. The entire space visible by a camera is called the view volume. If an object is not inside the view volume, it is not drawn on the screen. The shape of the view volume can be set to orthographic or perspective. Both views are constructed from an eye position (representing the viewers’ location), a near clipping plane, the screen, and a far clipping plane.

An orthographic camera projects all points of 3D objects between the clipping planes in parallel onto a screen plane, as shown in Figure 2.5. The screen plane is the view the player ends up seeing. The viewing volume of an orthographic camera is the shape of a rectangular prism.

A perspective camera projects all points of 3D objects between the clipping planes back to the eye, as shown in Figure 2.6. The near clipping plane becomes the screen. The viewing volume of a perspective camera is called the frustum, as it takes on the volume of a pyramid with the top cut off. The eye is located at the apex of the pyramid.

The result of using a perspective and orthographic camera on the same scene in Unity is illustrated in Figure 2.7. A perspective camera is used in Figure 2.7a. The way in which perspective projections best show depth is evident from the line of buildings getting smaller as they disappear into the distance. This is not the case for the orthographic camera shown in Figure 2.7b. Depth can only be determined by which objects are drawn in front. The buildings appear to be flattened with no size difference between buildings in the distance. Figure 2.7c and d illustrate the way in which the camera view volume is displayed in Unity’s Editor Scene. If an object is not inside the view volume in the Scene, it will not appear on the screen in the Game.

FIG 2.5 Orthographic projection.

FIG 2.6 Perspective projection.

FIG 2.7 A 3D scene in Unity using (a) a perspective camera and (b) an orthographic camera. (c) The perspective camera’s frustum as displayed in the Unity scene. (d) The orthographic camera’s frustum as displayed in the Unity scene.

While cameras can be used to create a number of different visual effects, they are also important for optimizing a game’s performance. For example, the camera’s view volume should not be considered a trivial setting. As mentioned previously, all objects inside the view volume get drawn to the screen. The more objects to be drawn, the slower the frames per second. Even objects behind other objects and not noticeably visible will be considered by the game engine as something to be drawn. So even though an object does not appear on the screen, if it is inside the camera’s view volume it will be processed. Therefore, if you have a narrow back street scene in a European city where the player will never see beyond the immediate buildings, the camera’s far plane can come forward to exclude other buildings that cannot be seen anyway.

Whether the camera is looking at an orthographic or a perspective view, the coordinate system within the game environment remains the same.

2.3.2    Local and World Coordinate Systems

There are two coordinate systems at work in game environments: local and world. The local system is relative to a single game object, and the world system specifies the orientation and coordinates for the entire world. It is like having a map for the local layout of a city versus the longitude and latitude system used for the entire earth.

A game object can move and rotate relative to its local coordinate system or the world. How it moves locally depends on the position of the origin, the (0,0,0) point, within the model. Figure 2.11a shows a 3D model in Blender with the origin situated at the tip of the head, and Figure 2.11b shows it in the center of the body. In Blender the default vertical axis is the z axis. The red and green lines in Figure 2.11a and b represent the x and y axes, respectively. When imported into Unity, the software automatically flips the z axis for you, making y the new vertical axis. As shown in Figure 2.11a and b, the origin of the model is carried across into Unity. When a model is selected, its origin is evident by the location of the translation handles used for moving the model around in the Scene. The location of the model’s central point becomes an issue in Unity when positioning and rotating it. In Figure 2.11e, both models are placed in the world at (0,0,0) as set by the Inspector. As you can see, the models are placed in differing positions relative to their own central points. Figure 2.11f demonstrates how rotation is also affected by the model’s origin. The model from Figure 2.11a rotates about the point in the center top of the head, whereas the model in Figure 2.11b rotates about its abdomen.

In Figure 2.12, the effect of rotations on local and world coordinate systems is illustrated. Any object at the world origin when rotated will be oriented in the same way around local and world axes. However, when the model is not at the world origin, a rotation in world coordinates will move as well as reorient the model. Local rotations are not affected by the model’s location in the world.

2.3.3    Translation, Rotation, and Scaling

Three transformations can be performed on an object whether it be in 2D or 3D: translation, rotation, and scaling.

Translation refers to moving an object and is specified by a vector in the same way the pirate in Section 2.2 moved across the island. A translation occurs whenever the x, y, or z values of an object are modified. They can be modified all at once with a vector or one at a time. To move an object in the x direction by 5, the Unity C# is:

FIG 2.11 The effect of transformations based on local coordinates. (a) A model in Blender with the origin at the center top, (b) a model in Blender with the origin in the abdomen, (c) translation axes positioned in Unity for the model in (a), (d) translation axes positioned in Unity for the model in (b), (e) both models positioned at the world origin in a Unity scene, and (f) both models rotated 90° about their local x axes.

FIG 2.12 Local and world rotations affected by a model’s position.

To move the object by 3 in the x, 5 in the y, and 8 in the z, in Unity C# it could be written as

Several examples of the Translate function are shown in Figure 2.13.

Rotation turns an object about a given axis by a specified number of degrees. An object can rotate about its x, y, or z axes or the world x, y, or z axes. Combined rotations are also possible. These cause an object to rotate around arbitrary axes defined by vector values. The Unity C# to rotate an object about 90° about the y axis is

To rotate 90° around the x axis, the script is

and to rotate 90° around the z axis, the script is

Some of these rotations are illustrated in Figure 2.14.

FIG 2.13 Using the translate function to modify the position of a game object.

FIG 2.14 Rotating a game object with the rotate function.

FIG 2.15 Scaling an object.

Finally, scaling changes the size of an object as shown in Figure 2.15. An object can be scaled along its x, y, or z axis. This can be achieved in C# at the same time using a vector, thus

Values for the scale are always multiplied against the original size of the object. Therefore, a scale of zero is illegal. If a negative scaling value is used, the object is flipped. For example, setting the y axis scale to −1 will turn the object upside down.

Taking some time to orient yourself with both 2D and 3D space is necessary to understanding how objects will move around within your game. Fortunately, Unity takes the hard mathematics and hides it behind many easy-to-use functions. However, when something goes wrong in your game, it’s nice to have some idea where to start looking.

2.3.4    Polygons and Normals

Chapter 1 introduced polygons as the small shapes, usually triangles and sometimes squares, that make up 2D and 3D meshes (or models). A polygon in a mesh also represents a plane. A plane is a 3D object that has a width and height but no depth. It is completely flat and can be oriented in any direction, but not twisted.

The sides of planes are defined by straight edges between vertices. Each vertex has an associated point in space. In addition, planes only have one side. This means that they can only be seen when viewed from above. To see this, open Unity and create a plane game object. Rotate the plane around to the other side. It will become invisible, but it will still be there.

In order to define the visible side of a plane, it has an associated vector called a normal. This is not to be confused with normalization of a vector into a unit vector. A normal is a vector that is orthogonal (90°) to the plane as shown in Figure 2.16.

Knowing the normal to a plane is critical in determining how textures and lighting affect a model. It is the side the normal comes out of that is visible and therefore textured and lit. When a model is created in a 3D modeling package such as Blender, the normals are usually facing outward from the object. Figure 2.17 shows a model in Blender with the normals for each plane shown in blue.

The angle that a normal makes with any rays from light sources is used to calculate the lighting effect on the plane. Figure 2.18 illustrates the vectors and normal used in calculating the effect of light on a plane. The closer the normal becomes to being parallel with the vector to the light source, the brighter the plane will be drawn. This lighting model is called Lambert shading and is used in computer graphics for diffuse lighting.

FIG 2.16 A plane and its normal.

FIG 2.17 A 3D model in Blender showing normals for each plane in blue. To turn this on, select the object and, in edit mode, click on Draw Normals in the mesh tools 1 panel.

FIG 2.18 Vectors used in calculating the strength of lighting on a plane; a vector to the viewer, the normal and a vector to the light source.

2.4    Two-Dimensional Games in a 3D Game Engine

Although 3D game engines are not often written to support 2D game creation, many developers use them for this purpose because (a) they are familiar with them, (b) they do not have to purchase software licenses for other development platforms, and (c) the engines provide support for multiple platforms and game types. As Unity added the feature to port from Android and iOS platforms in earlier versions, it became attractive to developers for the creation of 2D content. At the time, Unity was still strictly 3D and 2D had to be faked by ignoring one of the axes in the 3D world.

Now-a-days Unity supports 2D game creation by putting the camera into orthographic mode and looking straight down the z axis. This setup happens by default when a new project is created in 2D mode. The scene is still essentially 3D but all the action appears and operates in the X-Y plane.

2.4.1    Quaternions?

In 3D space there are three axes around which an object can rotate. These rotations are analogous with the rotational movements of an aircraft as shown in Figure 2.22 (a) a rotation about the x axis, (b) creates pitch, a rotation about the z axis, (c) creates roll, and a rotation about the y axis, (d) develops yaw.

The angles used to specify how far to rotate objects around these axes are called Euler angles. Euler angles are often used in 3D software and game engines because they are intuitive to use. For example, if someone asked you to rotate around your vertical axis by 180° you would know this meant to turn around and look in the opposite direction.

However, there is a fundamental flaw in using Euler angles for rotations in software that can cause unexpected rotational effects. These angles are applied one after the other and therefore have a mathematical compounding effect. This consequence is seen in the mechanical devices used to stabilize aircraft, ships and spacecraft; the gyroscope.

FIG 2.22 (a–d) Individual rotations about the x, y, and z axis in 3D space.

A simple gyroscope is illustrated in Figure 2.23. It consists of three discs attached to the outer structure of a vehicle (in this example, a plane) and attached to each other at pivot points each representing rotations around the x, y, and z axes. These rotating discs are called gimbals. As the plane yaws, pitches, and rolls, the gyroscope responds to the forces with the rotating of the discs at their pivot points. The idea is that a plate attached to the central, third gimbal always remains upright. Navigational systems attached to the gyroscope monitor this plate to determine the orientation of the vehicle. For example, if the vehicle were on autopilot, the objective would be to keep it upright and level to the ground, and any change in the gyroscope’s orientation assists with pitch, yaw, or roll corrections.

FIG 2.23 A simple gyroscope. (a) The gimbals and rotation points. (b) Attaching the gyroscope to a plane. (c) A clockwise yaw of the plane forces the first gimbal to move with it, as it is attached and has no freedom of movement in that direction, whereas the second gimbal is free to move in response in the opposite direction. (d) A 90° yaw will cause the first and second gimbals to align thereby entering a locked state. (e) After the first and second gimbals become locked, a pitch will retain the integrity of the third gimbal. (f) However, a roll can cause erratic behavior from gimbal 3.

A situation can occur in which two of the gimbals become aligned as shown in Figure 2.23d. This is called a gimbal lock. At this point, it can either be corrected with the right maneuver (e) or cause erratic behaviors. In Figure 2.23f, the third gimbal cannot rotate back such that the central plate is facing upward as its pivot points would not allow it. In some circumstances, alignment of the first and second gimbal can also cause the third gimbal to flip upside down, even if the vehicle itself is not upside down. When this occurs, the navigational system becomes very confused as it attempts to realign the vehicle.

While this is a simplistic examination of gimbals, the issue of gimbal lock is a reality. It is a mechanical reality that was experienced by the astronauts of the Apollo missions and it is a virtual reality when using Euler angles to rotation 3D objects. Just as the gyroscope compounds the rotations of the outer gimbal inward, multiplying x, y, and z angle rotations one after the other in software systems produces the same errors.

2.4.2    Quaternions to the Rescue

Quaternions are mathematical constructs that allow for rotations around the three axes to be calculated all at once in contrast to Euler angles that are calculated one after the other. A quaternion has an x, y, and z component as well as a rotation value.

In games using Euler angles, rotations can cause erratic orientations of objects. This is illustrated in Figure 2.24 where the rotations of two planes are compared. Each plane is continually rotated around the x, y, and z axes by 1°. The plane on the left in Figure 2.24 is rotated using Euler angles and the other uses quaternions. The movement of the quaternion plane is smoother.

FIG 2.24 Two planes rotated 1° around each axis every frame. One uses Euler angle calculations, the other quaternions. (a) Planes begin aligned, (b) planes remain aligned at first, (c) once the x angle becomes 90° for the Euler plane, its rotations go off course with respect to the quaternion plane, (d) even further in the simulation.

Quaternions are used throughout modern game engines, including Unity, as they do not suffer from gimbal lock.

Although the rotation value for the transform component of game objects appears as Euler x, y, and z values in the Inspector, Unity uses quaternions for storing orientations. The most used quaternion functions are LookRotation(), Angle(), and Slerp().

LookRotation() given a vector will calculate the equivalent quaternion to turn an object to look along the original vector. This means, this.transform.rotation = Quaternion. LookRotation(target.position–this.transform.position); achieves the same result as this.transform.LookAt(target.transform.position).

The Angle() function calculates the angle between two rotations. It might be used to determine if an enemy is directly facing toward or away from the player.

Slerp() takes a starting rotation and an ending rotation and cuts it up into small arcs. It is extremely effective in making rotating objects change from one direction to another in a smooth motion. Originally, the previously created rocket ship was flipping back and forth as it changed direction. This occurs when the objects goes from the original facing direction to the goal facing direction in one frame. Slerp() breaks this rotation up, so small parts of it occur with each frame instead of all in one go.

Now you have a little understanding of quaternions we can continue with the 2D game. It contains two quaternion functions: AngleAxis() and Slerp(). AngleAxis() takes an angle and a vector, and rotates and object by the angle around the vector. It is being used to determine how to rotate the rocket, so it faces the earth. This value is required by the Slerp() function that uses the rotation speed and the time between the drawing of frames (Time.deltaTime) to carve up the complete turn angle into smaller pieces, making the rocket ship turn smoothly.

2.5    The Laws of Physics

Game players bring their own experience of the real world to a game environment. They understand that gravity makes things drop, acceleration changes the speed of an object, and when an object hits another object, a reaction, such as bouncing or exploding, will occur based on the object’s composition.

These expectations within game environments are essential to establishing the player’s suspension of disbelief—a psychological state in which a player accepts the limitations of a medium in order to engage with the content. This can include anything from low-quality graphics to flying aliens. Anything that messes with the player’s suspension of disbelief causes them to disengage and lose interest, like being woken from a dream. A big part of ensuring a game environment is making the virtual world act and react like the real one.

The laws of physics are a set of complex rules that describe the physical nature of the universe. Adhering to these rules when creating a game is key to creating a believable environment in which the player interacts. Sometimes the laws are bent to suit narrative; however, they essentially remain static throughout. For example, players in a modern warfare game, taking place on the earth, would expect gravity to react for their character as it does for them in the real world. In the case of science fiction, the effects of gravity may be altered to fit the story.

Physics is a fundamental element in games as it controls the way in which objects interact with the environment and how they move.

Although physics covers topics such as Einstein’s theory of relativity and thermodynamics, the key ones used in game environments are Newton’s three laws of motion and the law of gravity.

2.5.1    The Law of Gravity

Although it is a myth that an apple fell on Newton’s head, he did devise his theory of gravity while watching an apple fall from a tree. In Newton’s publication the Principia, the force of gravity is defined thus:

Every particle of matter in the universe attracts every other particle with a force that is directly proportional to the product of the masses of the particles and inversely proportional to the square of the distance between them.

In short, this means the bigger an object, the more it attracts other objects and that this attraction gets stronger the closer it is. Kepler also used this law, a century later, to develop his laws of planetary motion.

In game environments, applying a downward velocity to an object simulates gravity. The y coordinate of the object’s position is updated with each game loop to make it move in a downward direction. If you were to code this in Unity, the C# would look something like this:

Unfortunately, the actual calculation for real gravity would be a little more complex than taking away one, as the effect of earth’s gravity is a downward acceleration of 9.8 meters per second. This means that the downward speed of an object gets faster by 9.8 meters per second with each second. An object starting with a speed of 0 after 1 second will be moving at 9.8 meters per second, after 2 seconds it will be moving at 19.6 meters per second, and after 3 seconds it will be moving at 29.4 meters per second.

In addition, a game loop may not take exactly 1 second to execute. This will throw out any calculations you attempt with each loop update on a second by second basis.

Fortunately, game engines take care of all the mathematics and allow you to set just one gravity value for your environment. Let us take a look at how Unity does it.

2.5.2    The First Law of Motion

Every body continues in its state of rest, or of uniform motion in a straight line, unless it is compelled to change that state by forces impressed upon it.

This means that an object will remain stationary and a moving object will keep moving in the same direction unless pushed or pulled. In the real world, a number of different forces act to move or slow objects. These include gravity and friction. In addition, objects colliding with each other will also act to change their movement.

2.5.3    The Second Law of Motion

The acceleration produced by a particular force acting on a body is directly proportional to the magnitude of the force and inversely proportional to the mass of the body.

This means that a larger force is required to move a heavier object. In addition, a heavier object with the same acceleration as a lighter object will cause more destruction when it hits something as the force will be greater. Imagine throwing a bowling ball and a tennis ball at a wall with the same acceleration. Which one is going to leave a bigger hole?

2.5.4    The Third Law of Motion

To every action there is always opposed an equal reaction; or, the mutual actions of two bodies upon each other are always equal, and directed to contrary parts.

This can be rephrased to the well-known adage for every action there is an equal and opposite reaction. When a truck hits a car, energy from the movement of the truck is transferred to the car and it is propelled away from the truck. If a car hits another car of a similar size, some of the energy is transferred to the second car, whereas some goes back into the first car. If a car hits a brick wall, chances are most of the energy will go back into the car. This energy needs to go somewhere. In the case of cars, specially designed crumple zones absorb the energy. For a tennis ball, some of the energy is absorbed by the rubbery nature of the ball and the rest is used to propel the ball away. In other words, collisions occurring in the real world have an effect on the environment as well as the object.

The examples thus far examined in Unity see energy from an initial force transferred or totally absorbed by the objects. For a heavy sphere, cubes are knocked over easily, whereas a light sphere hits the cubes and drops straight to the ground. This rarely happens in the real world where things tend to bounce, to some degree. In Unity, adding a physics material to an object can simulate these extra effects.

2.6    Physics and the Principles of Animation

In their 1981 book, The Illusion of Life, Disney animators Ollie Johnston and Frank Thomas introduced 12 rules to be applied when creating animated films. These are

Squash and stretch:The deformation of objects in reaction to the laws of physics; for example, a tennis ball hitting a wall squashes on collision.

Anticipation: Presenting short actions or hints to a viewer of what is about to happen; for example, a person about to jump in the air will bend their knees first.

Staging: Presenting an idea such that no mistake can be made as to what is happening; for example, viewing an angry person’s face gives a better impression of their mood than the back of their head.

Straight-ahead action and pose to pose: These are animation drawing methods. Straight-ahead action refers to drawing out a scene frame by frame. Pose to pose refers to drawing key frames or key moments in a scene and filling in the gaps later.

Follow-through and overlapping action: This is the way in which momentum acts on a moving object to cause extra motion even after the initial force has stopped; for example, a baseball pitcher’s arm does not stop moving the moment the ball leaves his hand. In addition, his legs and body also move in response to the action. Overlapping action occurs when secondary objects move with the main object.

Slow in and out: Natural movement in which there is a change in direction decelerates into the change and accelerates out; for example, a car turning a corner slows into the corner and accelerates out. A person jumping will slow into the impact with the ground and speed up as he pushes off the ground with his legs.

Arcs: Motion in animals and humans occurs along curved paths. This includes the rotation of limbs and the rise and fall of a body when walking. The same curved movement is also found in the trajectory of thrown objects.

Secondary actions: These animations support the principal animation. They give a scene more realism; for example, a person walking along the street would not just be moving his legs. His arms might swing, he may be talking, and his hair could be flowing with the breeze.

Timing: This refers to the speed of actions. It is essential for establishing mood and realism; for example, a fast-moving character will appear to be in a hurry, whereas a slow-moving character portrays lethargy or disinterest. For realism, the correct timing of actions with motion and sound is critical. Slow animated walking characters can look like they are slipping across the ground if their forward movement and leg cycles are not matched. A delay between an action and a sound, such as a bomb exploding and the associated sound effect, adds to suspension of disbelief.

Exaggeration: Perfect imitations of the real world in animation can appear dull and static. Often it is necessary to make things bigger, faster, and brighter to present them in an acceptable manner to a viewer. Overexaggeration is also used in the physical features of characters for the effects of physics; for example, in Warner Brothers’ coyote and roadrunner films, when the coyote is about to fall from a great height, the time he spends in the air realizing his predicament is exaggerated far beyond what normal gravity would allow.

Solid drawing: This is the term given to an animator’s ability to consider and draw a character with respect to anatomy, weight, balance, and shading in a 3D context. A character must have a presence in the environment, and being able to establish volume and weight in an animation is crucial to believing the character is actually in and part of the environment.

Appeal: This relates to an animator’s ability to bring a character to life. It must be able to appeal to an audience through physical form, personality, and actions.

All but a couple of the preceding principles of animation can be conveyed in a game environment through the physics system. They are consequences of physics acting in the real world. We subconsciously see and experience them every day, albeit not with as much exaggeration as a game, and come to expect them in the virtual environment.

In the following hands-on sections, you will get a chance to see how these principles can be applied in your own games.

2.6.1    Squash and Stretch

2D Boy’s two-dimensional adventure World of Goo features many moving balls of Goo. Each time Goo accelerates, it becomes elongated along the direction of movement, and it decelerates and squashes when it collides with another object. Such movement occurs in the real world and is explained by Newton’s laws.

While game-based physics engines do allow for the creation of bouncy objects, typically they do not provide real-time squashing and stretching algorithms for the actual game object. The rigid body attached to a game object to simulate physics by very definition remains rigid even though its movement suggests otherwise. In most cases, it is too processor intensive in 3D environments to squash and stretch all objects, but just for fun this hands-on session will show you how to do it in Unity.

2.6.2    Anticipation

A simple implementation of anticipation is seen in racing games. At the beginning of a race, a traffic light or countdown will display, giving the player a heads up to when the race is about to start. Another way to add anticipation is to have explosive devices with countdown timers. In Splinter Cell, for example, the lead character, Sam Fisher, may lay down explosive charges and then a countdown occurs before they explode.

2.6.3    Follow-Through

Follow-through refers to actions occurring after and as a result of another action. For example, in racing games, a common follow-through is when one car clips another car and it goes spinning out of control. In most games where you have to blow something up, there is bound to be a follow-through action that removes obstacles from the player’s game progression.

2.6.4    Secondary Motion

Secondary motion brings the game environment to life. The simplest of movements can hint at a dynamic realistic environment with a life of its own. For example, a swaying tree or moving grass provides the illusion of a light breeze, while also suggesting to the player that these are living things. How often have you been for a walk in a forest that does not move around you? Even in a still warehouse environment there is the opportunity to add secondary motion to add extra atmosphere to the scene.

FIG 2.46 Full setup for an interactive cloth.

2.7    2D and 3D Tricks for Optimizing Game Space

The real world is a big place. The dream of many a game designer is to recreate the real world in all its detailed glory and vastness. Unfortunately, modeling everything down to the last nut and bolt and putting it into a game engine for real-time processing is not possible. However, many games do fake the vastness of the outside world very effectively, fooling the player into believing that the environment outside the game play area goes on forever.

A game requires a high frame rate to provide the player with a seamless game-playing experience. Between each frame, the computer must process all game object behaviors, sounds, physics, and player interactions. The number of game objects in view of the game has a large effect on the frame rate, as they must be processed and rendered. Therefore, when designing a game level or environment, it is critical to keep in mind how many things will need to be drawn in a scene and reduce this to an absolute minimum while keeping the quality high. Having said this, it might not necessarily be the number of objects in a scene that need to be reduced but a reconsideration of how they are treated and drawn.

This section explores some common ways for optimizing 3D game worlds.

2.7.1    Reducing Polygons

Each polygon, being the smallest part of a mesh, adds to the processing of a scene. On high-end gaming machines, the polycount must increase dramatically to affect the frame rate. However, on mobile devices, simply adding a couple hundred polygons can bring a game to a halt. Here are some methods to reduce the polycount.

2.7.1.1  Use Only What You Need

When creating a model for a game, consider the number of superfluous polygons in the mesh and reduce. For example, the default plane object created by Unity is essentially a square. If you only ever use it as a square, such as for objects in the rocket ship game, this object is inefficient as it has many polygons. A simple square plane only requires two triangular polygons. In this case, create a square plane in Blender and import it instead.

2.7.1.2  Backface Culling

As discovered earlier, Unity does not show the reverse side of surfaces. This is called backface culling and is a common technique in computer graphics for not drawing the reverse side of a polygon. In some cases, however, as with the curtain in the warehouse example, it may be necessary to draw both sides. In the hands-on session, we used two cloths, one for either side. This is an inefficient way as it immediately doubles the number of polygons used for the curtain. A better way is to turn backface culling off.

To do this in Unity requires the writing of a shader. A shader is a piece of code the game engine interprets as a texturing treatment for the surface of a polygon. When you set a material to Diffuse or Transparent/Specular, you are using a prewritten shader.

To write your own shader requires extensive knowledge of the shader language and complex computer graphics principles; however, numerous shaders are available on the Unity website for you to try, so here are the steps required to add a custom shader.

2.7.1.3  Level of Detail

Level of detail (LOD) is a technique for providing multiple models and textures for a single object with reducing levels of detail. For example, you may have a high polycount, high-resolution textured model; a medium polycount, medium-resolution textured model; and a low polycount, low-resolution texture model for a single character. The model that gets drawn by the renderer will depend on the distance the camera is away from the character. If the character is close, the highest quality version is used. If the character is far in the distance, the lowest quality version is used.

This method not only mimics human vision-making objects in the distance less defined, but also allows for the drawing of more objects in a scene as the ones farther away take up less memory.

Note, since creating the next hands-on tutorial, Unity has added a new component to handle LODs. While the following tutorial will show you how to achieve LODs manually, you may also be interested in investigating https://docs.unity3d.com/Manual/class-LODGroup.html.

2.7.2    Fog

Another very (very) handy trick in reducing the visual size of a game environment is fog. In the previous examples, when the FPC was at a far enough distance from the buildings they would slide behind the far plane of the camera or snap out of view because of the LOD. By adding fog, these other rather too obvious techniques can be hidden. A layer of fog can be added just before the far plane of the camera or the farthest distance of the LOD.

2.7.3    Textures

Fine-detailed, high-quality textures are the best defense against high polycounts. There is far more detail in a photorealistic image of a real-world item than could possibly fit into the polycount restrictions of any real-time game engine. Chapter 1 examined briefly the use of normal and specular maps to give extra texturing to game objects. Here we discuss two more popular tricks.

2.7.3.1  Moving Textures

When creating materials in Unity you may have seen properties for x and y offsets. These values are used to adjust the alignment and location of a texture on a polygon’s surface. If these values are adjusted constantly with each game loop, the texture will appear animated. This is an effective way of creating an animation that does not involve modeling or extra polygons. It is often used in creating sky and water effects.

2.7.3.2  Blob Shadows

Shadows give a scene an extra dimension of depth and add to visual realism. Generating shadows is processor intensive. Although shadows in game environments are covered in Chapter 7, a quick and easy method for generating processor light shadows called Blob Shadows is introduced here.

Usually the game rendering system calculates shadows based on the position and intensity of lights and the position of game objects. When many real-time shadows need to be calculated, such as those of moving objects like characters, it can slow the frame rate considerably. This is a big problem for games on mobile devices where such shadowing is not practical.

2.7.4    Billboards

Billboarding is a technique that uses planes to fake a lot of background scenery. A billboard is a plane usually having a partially transparent texture applied to give it the appearance of being a shape other than a square. Common uses for billboards are grass, clouds, and distant trees.

To give the illusion that the billboard is viewable from all angles, the plane orientates itself constantly so that it is always facing the player.

More often than not, billboards are used on horizon lines and in the distance. Because they do not stand up under close scrutiny, you may want to use them en masse, but in areas of the game environment the player cannot quite reach.

2.8    Summary

This chapter covered a variety of techniques for replicating real-world mechanics in a game environment. These included movement with vectors and the physics system and optimization techniques that make the virtual world seem as extensive as the real world.

Most often satisfactory movement in a game environment can be achieved through knowledge of vector mathematics. Applying this first before jumping headlong into the physics system will optimize processing of the game environment. For example, in the rocket ship hands-on session, physics could have been employed to push the rocket ship around the planet. This would, however, have been overkill, as only a simple translation and slerping algorithm was required.

It is a common first-timer mistake when creating a game environment to make it detailed and vast without consideration for how game play will be affected as the frame rate drops. Few can understand how such top-quality AAA titles can run so fast with such intricate landscapes and mind-blowing special effects, and it is often the game engine that takes the blame. This is not the case, and this chapter has revealed some of the tricks employed by professionals to trick the player’s perception of the environment.

*  This is only for a land map. For 3D coordinates there are no such equivalents.