- What Is 3D Rendering?
- Supplying the Graphics Processor with Data
- The OpenGL ES Context
- The Geometry of a 3D Scene
- Summary

## The Geometry of a 3D Scene

Many kinds of data, such as lighting information and colors, can be optionally omitted when supplying data to the GPU. The one kind of data that OpenGL ES must have when rendering a scene is geometric data specifying the shapes to be rendered. Geometric data is defined relative to a 3D coordinate system.

### Coordinate System

Figure 1.6 depicts the OpenGL coordinate system. A coordinate system is an imaginary set of guides to help visualize the relationships between positions in space. Each arrow in Figure 1.6 is called an *axis*. OpenGL ES always starts with a rectangular Cartesian coordinate system. That means the angle between any two axes is 90 degrees. Each position in space is called a *vertex*, and each vertex is defined by its locations along each of three axes called X, Y, and Z.

Figure 1.6 X, Y, and Z axes define the OpenGL coordinate system.

Figure 1.7 shows the vertex at position `{1.5, 3.0, 0.0}` relative to the axes. The vertex is defined by its position, 1.5, along the X axis; its position, 3.0, along the Y axis; and its position, 0.0, along the Z axis. Dashed lines in Figure 1.7 show how the vertex aligns with the axes.

Figure 1.7 The vertex at position {1.5, 3.0, 0.0} relative to the axes.

The locations along each axis are called *coordinates*, and three coordinates are needed to specify a vertex for use with 3D graphics. Figure 1.8 illustrates more vertices and their relative positions within the OpenGL coordinate system. Dashed lines show how the vertices align with the axes.

Figure 1.8 The relative positions of vertices within a coordinate system.

OpenGL ES coordinates are best stored as floating-point numbers. Modern GPUs are optimized for floating point and will usually convert vertex coordinates into floating-point values even when vertices are specified with some other data type.

One of the keys to using and understanding the coordinate system is to remember that it’s merely an imaginary tool of mathematics. Chapter 5, “Changing Your Point of View,” explains the dramatic effects produced by changing the coordinate system. In a purely mathematic sense, lots of non-Cartesian coordinate systems are possible. For example, a polar coordinate system identifies positions in 3D space by imagining where a point falls on the surface of a sphere using two angles and a radius. Don’t worry about the math for non-Cartesian coordinate systems now. Embedded GPUs don’t support most non-Cartesian coordinate systems in hardware, and none of the book’s examples use non-Cartesian coordinate systems. If the need arises in your projects, positions expressed in any coordinate system can be converted into the OpenGL ES default coordinate system as needed.

The OpenGL ES coordinate system has no units. The distance between vertex `{1, 0, 0}` and `{2, 0, 0}` is 1 along the X axis, but ask yourself, “One what—is that one inch, or one millimeter, or one mile, or one light-year?” The answer is that it doesn’t matter; or more precisely, it’s up to you. You are free to imagine that a distance of 1 represents a centimeter or any other unit in your 3D scene.

### Vectors

*Vectors* are another math concept used frequently in graphics programming. In one sense, vectors are an alternative way of interpreting vertex data. A vector is a description of a direction and a distance. The distance is also called the magnitude. Every vertex can be defined by its direction and distance from the origin, `{0, 0, 0}`, in the OpenGL ES coordinate system. Figure 1.9 uses a solid arrow to depict the vector from the origin to the vertex at `{1.5, 3.0, -2.0}`. Dashed lines show how the vertex aligns with the axes.

Figure 1.9 A vector in the 3D coordinate system.

Calculating a vector between any two vertices is possible using the differences between the individual coordinates of each vertex. The vector between a vertex at `{1.5, 3.0, -2.0}` and the origin is `{1.5 – 0.0, 3.0 – 0.0, -2.0 – 0.0}`. The vector between vertex V1 and vertex V2 in Figure 1.10 equals `{V2.x – V1.x, V2.y – V1.y, V2.z – V1.z}`.

Figure 1.10 The vector between two vertices, V1 and V2.

Vectors can be added together to produce a new vector. The vector between the origin and any vertex is the sum of three axis-aligned vectors, as shown in Figure 1.11. Vectors A + B + C equal vector D (as shown in the following), which also defines the vertex at `{1.5, 3.0, -2.0}`.

D.x = A.x + B.x + C.x = 1.5 + 0.0 + 0.0 = 1.5 D.y = A.y + B.y + C.y = 0.0 + 3.0 + 0.0 = 3.0 D.z = A.z + B.z + C.z = 0.0 + 0.0 + -2.0 = -2.0

Figure 1.11 The sum of axis-aligned vectors.

Vectors are key to understanding modern GPUs because graphics processors are massively parallel vector processing engines. The GPU is able to manipulate multiple vectors simultaneously, and vector calculations define the results of rendering. Several critical vector operations besides addition and subtraction are explained as needed in later chapters. The OpenGL ES default coordinate system, vertices, and vectors provide enough math to get started specifying geometric data to be rendered.

### Points, Lines, and Triangles

OpenGL ES uses vertex data to specify *points*, *line segments*, and *triangles*. One vertex defines the position of a point in the coordinate system. Two vertices define a line segment. Three vertices define a triangle. OpenGL ES only renders points, line segments, and triangles, so every complex 3D scene is constructed from combinations of points, line segments, and triangles. Figure 1.12 shows how complex geometric objects are built using many triangles.

Figure 1.12 Vertex data rendered as line segments and triangles.