Geometry and Meshes

This section delves into the fundamental building blocks of 3D graphics: geometry and meshes. Understanding how to represent, manipulate, and render geometric data is crucial for creating any visual experience in 3D.

What is Geometry in 3D Graphics?

In computer graphics, geometry refers to the mathematical description of shapes and their positions in 3D space. The most common way to represent complex geometric objects is through meshes.

Meshes: Vertices, Edges, and Faces

A mesh is a collection of vertices, edges, and faces that define the shape of a 3D object.

Vertices: These are the fundamental points in 3D space, typically defined by their (x, y, z) coordinates.
Edges: These are the lines connecting pairs of vertices.
Faces (or Polygons): These are the surfaces formed by connecting three or more vertices (often triangles or quads). Faces define the visible surface of the object.

Mesh Data Structures

Efficiently storing and accessing mesh data is vital for performance. Common structures include:

Vertex Buffer Objects (VBOs): Store vertex attributes like position, normals, and texture coordinates on the GPU for fast access.
Index Buffer Objects (IBOs): Store indices that define the order in which vertices should be rendered to form primitives (triangles, lines). This avoids redundant vertex data.

Common Geometric Primitives

While complex meshes can be loaded from files, many applications start with basic primitives:

Points: A single vertex.
Lines: Two vertices connected by an edge.
Triangles: Three vertices connected by three edges, forming a face. This is the most fundamental primitive in modern graphics APIs like DirectX and OpenGL.
Quads: Four vertices forming a rectangular face. Often decomposed into two triangles.
Spheres, Cubes, Cylinders: These are often generated procedurally using algorithms that create a mesh of vertices and faces.

Mesh Manipulation

Once a mesh is defined, it can be transformed in various ways:

Translation: Moving the object in space.
Rotation: Turning the object around an axis.
Scaling: Resizing the object.
Skeletal Animation: Deforming the mesh based on a hierarchical skeleton.

Normals: Lighting and Shading

For realistic lighting, meshes need normals. A normal is a vector perpendicular to the surface at a given point.

Vertex Normals: A normal associated with each vertex, representing the average surface orientation. Used for smooth shading.
Face Normals: A single normal for each face, calculated from the face's vertices. Used for flat shading.

Example: A Simple Triangle Mesh

Here's a conceptual representation of a simple triangle:

// Using pseudocode for clarity
struct Vertex {
    float3 Position;
    float3 Normal;
    float2 TexCoords;
}

Vertex[] vertices = {
    { Position: float3(-1.0f, -1.0f, 0.0f), Normal: float3(0.0f, 0.0f, 1.0f), TexCoords: float2(0.0f, 0.0f) },
    { Position: float3( 1.0f, -1.0f, 0.0f), Normal: float3(0.0f, 0.0f, 1.0f), TexCoords: float2(1.0f, 0.0f) },
    { Position: float3( 0.0f,  1.0f, 0.0f), Normal: float3(0.0f, 0.0f, 1.0f), TexCoords: float2(0.5f, 1.0f) }
};

ushort[] indices = { 0, 1, 2 }; // Defines the order to draw the vertices as a triangle

Visual representation of the triangle described above.