330 terms from AABB to Z-fighting. Format: Term — Definition. (See: Ch N)
AABB (Axis-Aligned Bounding Box) — A rectangular box aligned with the coordinate axes that tightly encloses a geometric object. Used for fast intersection tests and spatial hierarchies. (See: Ch 47)
Acceleration Structure — A spatial data structure (BVH, k-d tree, grid) that speeds up ray-scene intersection tests by culling large portions of the scene. Without one, ray tracing is O(n) per ray. (See: Ch 23, Ch 47)
ADSR (Attack-Decay-Sustain-Release) — An envelope model describing how a value changes over time: ramps up (attack), drops (decay), holds (sustain), then fades (release). Used in animation and audio-driven graphics. (See: Ch 31)
Affine Transform — A transformation that preserves lines and parallelism: any combination of translation, rotation, scaling, and shearing. Representable as a matrix multiply plus a translation, or as a 4x4 matrix in homogeneous coordinates. (See: Ch 1)
Albedo — The base color of a surface without any lighting or shadowing applied. In PBR, the diffuse color (or "base color") before shading. (See: Ch 29)
Alembic — An open interchange file format for baked animation data (meshes, particles, curves per frame). Used in VFX pipelines for passing simulation results between tools. (See: Ch 48)
Aliasing — Staircase-like artifacts that appear when continuous geometry is sampled onto a discrete pixel grid. Caused by insufficient sampling of high-frequency detail. (See: Ch 12)
Alpha — The opacity component of a color, where 0 = fully transparent and 1 = fully opaque. Stored as the fourth channel in RGBA color. (See: Ch 6)
Alpha Blending — Compositing a semi-transparent surface over a background using the alpha channel. The standard formula: out = alpha * src + (1 - alpha) * dst. (See: Ch 6, Ch 13)
Alpha Test — Discarding fragments whose alpha value falls below a threshold, creating hard-edged transparency (e.g., foliage). Cheaper than alpha blending because discarded fragments skip blending entirely. (See: Ch 14)
Ambient — A constant, directionless lighting term that approximates indirect illumination. In the Phong model: I_ambient = k_a * I_a. A crude placeholder for global illumination. (See: Ch 17)
Ambient Occlusion (AO) — A shading technique that darkens creases, corners, and tight spaces where indirect light is occluded. Approximates soft global illumination. (See: Ch 30)
Animation Curve — A function (often a spline) that maps time to a value (position, rotation, opacity). Defined by keyframes and interpolation handles. The core data structure of keyframe animation. (See: Ch 31)
Anisotropic — Having different properties in different directions. Anisotropic filtering improves texture quality at oblique angles. Anisotropic shading models handle brushed metal and hair. (See: Ch 14, Ch 29)
Anti-Aliasing — Techniques that reduce aliasing artifacts. Includes MSAA (multi-sample), FXAA (post-process), TAA (temporal), and supersampling. (See: Ch 12)
Asset Pipeline — The workflow and toolchain that converts source art (models, textures, animations) into optimized runtime formats for an engine or application. Includes import, validation, compression, and packaging. (See: Ch 48)
Attenuation — The decrease in light intensity with distance. Point lights attenuate with the inverse square of distance: 1 / d^2. (See: Ch 16)
Attractor — A point or set in a dynamical system toward which nearby trajectories converge. Strange attractors (Lorenz, Rossler) produce fractal-like structures used in generative art. (See: Ch 38)
Backface Culling — Skipping triangles that face away from the camera (their normal points away). Reduces the number of triangles the GPU must shade by roughly half for closed meshes. (See: Ch 10)
Barycentric Coordinates — A coordinate system for points inside a triangle, expressed as three weights (u, v, w) that sum to 1. Used to interpolate vertex attributes across a triangle during rasterization. (See: Ch 9)
Basis Vector — One of the vectors that define a coordinate system. In 3D, the standard basis is i=(1,0,0), j=(0,1,0), k=(0,0,1). The columns of a rotation matrix are the transformed basis vectors. (See: Ch 0, Ch 1)
Batch Rendering — Grouping multiple draw calls into fewer, larger calls by combining geometry that shares the same material or shader state. Reduces CPU overhead from per-draw-call setup. (See: Ch 42)
Bernstein Polynomial — The polynomial basis functions that define Bezier curves. For degree n: B_{i,n}(t) = C(n,i) * t^i * (1-t)^(n-i). Each control point is weighted by one Bernstein polynomial. (See: Ch 46)
Bezier Curve — A parametric curve defined by control points, evaluated using the de Casteljau algorithm or Bernstein polynomials. Cubic Bezier (4 control points) is used in SVG, fonts, and animation. (See: Ch 46)
Bijection — A one-to-one and onto mapping between two sets, where every element in one set corresponds to exactly one element in the other. UV unwrapping seeks a bijection between 3D surface patches and 2D texture space. (See: Ch 14, Ch 1)
Bilinear Interpolation — Interpolating a value on a 2D grid by linearly blending in both U and V directions using the four nearest samples. Used in texture sampling, heightmaps, and image resizing. (See: Ch 14)
Binormal — See Bitangent.
Bitangent — The vector perpendicular to both the normal and tangent at a surface point. Together with the normal and tangent, it forms the tangent-space basis used for normal mapping. (See: Ch 19)
Blend Tree — A structure in an animation system that blends multiple animation clips based on parameters (speed, direction). Enables smooth transitions such as walk-to-run without abrupt pops. (See: Ch 31)
Blender Cycles — Blender's production path tracer, using unbiased Monte Carlo integration. Supports CPU and GPU rendering with BVH acceleration, PBR materials, and volumetrics. (See: Ch 43)
Blending — Combining fragment colors with the existing framebuffer content. Used for transparency, additive effects (fire, glow), and compositing. (See: Ch 13)
Bloom — A post-processing effect that makes bright areas glow by blurring pixels above a brightness threshold and adding them back. Simulates lens/eye behavior. (See: Ch 42)
BMP — A simple, uncompressed raster image format storing pixels as raw RGB data with a header. Large file sizes but trivial to parse, often used as a first format in graphics courses. (See: Ch 48)
Boid — A simulated agent in a flocking system, following three rules: separation (avoid crowding), alignment (match heading), and cohesion (steer toward center). Coined by Craig Reynolds. (See: Ch 33, Ch 38)
Bounding Box — A simple enclosing shape (axis-aligned or oriented) used to quickly reject objects from intersection tests. If a ray misses the bounding box, it cannot hit the contents. (See: Ch 23, Ch 47)
BRDF (Bidirectional Reflectance Distribution Function) — A function that defines how light is reflected at a surface point, given incoming and outgoing directions. The core of physically based shading. (See: Ch 26, Ch 29)
BSDF (Bidirectional Scattering Distribution Function) — A generalization of BRDF that includes both reflection and transmission (refraction). Describes how light scatters at a surface boundary. (See: Ch 24, Ch 26)
BSP Tree (Binary Space Partitioning) — A spatial data structure that recursively divides space using planes. Used in Doom's renderer for visibility ordering and in CSG operations. (See: Ch 47)
B-Spline — A piecewise polynomial curve with local control — moving one control point only affects the nearby curve. Generalization of Bezier curves with a knot vector. (See: Ch 46)
BTDF (Bidirectional Transmittance Distribution Function) — The transmissive component of a BSDF, describing how light passes through a surface (refraction, subsurface scattering). Complements the BRDF. (See: Ch 24, Ch 26)
Buffer — A block of GPU memory used to store vertex data, index data, uniform values, or other information. Types include vertex buffers, index buffers, uniform buffers, and storage buffers. (See: Ch 15, Ch 44)
Bump Map — A grayscale texture that perturbs surface normals to simulate small-scale surface detail without changing geometry. Predecessor to normal maps. (See: Ch 19)
BVH (Bounding Volume Hierarchy) — A tree of nested bounding boxes used to accelerate ray tracing, collision detection, and spatial queries. The most important spatial data structure in modern graphics. (See: Ch 47)
Canvas-Sketch — A JavaScript framework for creating generative art and creative coding sketches. Provides a structured setup for 2D canvas, WebGL, and animation loops with hot reloading. (See: Ch 38)
Catmull-Clark Subdivision — A subdivision scheme that converts any polygonal mesh into a smooth quad mesh. The production standard at Pixar and most film studios. (See: Ch 46)
Caustic — Bright patterns of concentrated light created when light refracts through or reflects off a curved surface (e.g., light through a wine glass, pool floor patterns). Difficult to render; requires photon mapping or specialized techniques. (See: Ch 30)
Cellular Automata — A grid of cells that evolve over discrete time steps according to local rules based on neighbor states. Conway's Game of Life is the classic example. Used in procedural generation and generative art. (See: Ch 38)
Chrome Skia — Skia is the 2D graphics library used by Chrome (and Android) for rendering text, shapes, and images. It sits below the browser's layout engine and rasterizes display lists to pixels. (See: Ch 41)
Circumscribed — A shape that encloses another shape by touching its outer boundary. A circumscribed circle passes through all vertices of a polygon. Used in Delaunay triangulation and spatial bounds. (See: Ch 0, Ch 47)
Clipping — Removing geometry that falls outside the view frustum. Happens after vertex shading and before rasterization in the graphics pipeline. (See: Ch 2, Ch 10)
Cloth Simulation — Simulating the draping and movement of fabric using mass-spring systems or position-based dynamics. Must handle self-collision and collision with body geometry. (See: Ch 35)
Cofactor — The signed minor of a matrix element, computed by removing its row and column and taking the determinant of the remaining submatrix, with an alternating sign. Used for computing matrix inverses and adjugates. (See: Ch 1)
Collision Detection — Determining when and where two or more objects intersect. Broad phase (AABB overlap) quickly eliminates non-colliding pairs; narrow phase (GJK, SAT) computes exact contact. (See: Ch 34)
Color Space — A mathematical model for representing colors. Common spaces: sRGB (display), linear (computation), HSL/HSB (artistic), ACES (film). (See: Ch 6)
Column-Major — A matrix storage order where consecutive memory addresses store elements of the same column. OpenGL and GLSL use column-major layout. Opposite of row-major (used by DirectX). (See: Ch 1)
Compositing — Combining multiple images or layers into a final image. Alpha compositing uses the "over" operator: C_out = C_src * alpha + C_dst * (1 - alpha). (See: Ch 6)
Compositor — The system component that assembles the final screen image from independently rendered layers (UI, video, 3D content). In browsers, the compositor thread handles scrolling and CSS transforms off the main thread. (See: Ch 41)
Compute Shader — A GPU program that runs general-purpose computation (not tied to the rendering pipeline). Used for physics, particle systems, post-processing, and more. (See: Ch 44)
Constraint — A rule that restricts the motion of simulated objects (e.g., distance constraint, hinge joint, collision). Solvers iteratively project positions to satisfy constraints. Central to PBD and ragdoll physics. (See: Ch 34, Ch 35)
Convex Hull — The smallest convex shape that contains a set of points. Bezier curves always lie within the convex hull of their control points. (See: Ch 46)
Convolution — A mathematical operation that blends each pixel with its neighbors using a kernel (weight matrix). Used for blur, sharpen, edge detection, and bloom. (See: Ch 8)
Cook-Torrance — A microfacet-based specular BRDF model widely used in PBR. Combines a normal distribution function (D), Fresnel term (F), and geometry/masking term (G): f = DFG / (4 * dot(N,L) * dot(N,V)). (See: Ch 29)
Creative Coding — Using programming as a medium for artistic expression rather than purely functional software. Tools include Processing, p5.js, canvas-sketch, and Shadertoy. (See: Ch 36, Ch 38)
Cross Product — An operation on two 3D vectors that produces a third vector perpendicular to both, with magnitude equal to the area of the parallelogram they span: a x b. Used for computing normals and winding order. (See: Ch 0)
Cubemap — A texture with six faces forming a cube, used to represent environments for reflection mapping, skyboxes, and image-based lighting. (See: Ch 29)
Culling — Eliminating geometry that doesn't contribute to the final image. Types: frustum culling (outside view), backface culling (facing away), occlusion culling (hidden behind other objects). (See: Ch 10, Ch 47)
Curl Noise — The curl of a potential field (often Perlin or simplex noise), producing a divergence-free velocity field. Particles advected through curl noise form smooth, swirling, fluid-like patterns without sinks or sources. (See: Ch 37, Ch 38)
Damping — A force proportional to velocity that removes energy from a simulation, preventing perpetual oscillation. Commonly applied as v *= (1 - damping * dt). (See: Ch 33, Ch 34)
De Casteljau Algorithm — A numerically stable recursive algorithm for evaluating Bezier curves through repeated linear interpolation. Also naturally subdivides the curve. (See: Ch 46)
Deferred Rendering — A rendering technique where geometry is first rendered into G-buffers (position, normal, albedo, etc.), then lighting is computed in a separate pass. Efficient for many lights. (See: Ch 42)
Depth Buffer (Z-Buffer) — A per-pixel buffer storing the depth of the closest rendered fragment. Used to resolve visibility — closer fragments overwrite farther ones. (See: Ch 13)
Depth of Field (DoF) — A camera effect where objects at certain distances are sharp while others are blurred. Simulates the limited focus range of real lenses. (See: Ch 25)
Depth Test — The per-fragment comparison of a new fragment's depth against the value in the depth buffer. If the fragment is closer (or passes the configured test), it overwrites; otherwise it is discarded. (See: Ch 13)
Determinant — A scalar value computed from a square matrix that encodes how much the transformation scales volume. A determinant of zero means the matrix is singular (non-invertible). For 2x2: ad - bc. (See: Ch 1)
Dielectric — A non-conducting material (glass, water, plastic) that both reflects and refracts light. The ratio of reflection to refraction is governed by the Fresnel equations. (See: Ch 22, Ch 24)
Diffuse — Light that scatters equally in all directions when hitting a rough surface. Computed using Lambert's cosine law: max(0, dot(N, L)). (See: Ch 16, Ch 17)
Diffuse Map — A texture that stores the base color (albedo) of a surface at each texel. The most basic texture type, applied before lighting calculations. Also called a "color map" or "base color map" in PBR. (See: Ch 14, Ch 19)
Displacement Mapping — Actually moving surface vertices based on a texture, creating real geometric detail. Unlike bump/normal maps, displacement changes the silhouette. (See: Ch 19)
Distance Field — See SDF.
Domain Warping — Feeding the output of one noise function into the input coordinates of another, producing complex, organic patterns that look like geological strata, marble, or alien landscapes. (See: Ch 37)
Dot Product — An operation on two vectors that produces a scalar: a . b = |a||b|cos(theta). Measures alignment between vectors. Fundamental to lighting (Lambert), projections, and angle calculations. (See: Ch 0)
Draw Call — A command from the CPU telling the GPU to render a batch of geometry. Minimizing draw calls is a key optimization — each one has CPU overhead. (See: Ch 42)
Early-Z — A GPU optimization that performs the depth test before the fragment shader runs, skipping shading for fragments that would fail. Requires opaque geometry sorted front-to-back. Breaks when the shader writes to gl_FragDepth or uses discard. (See: Ch 13, Ch 42)
Easing — Non-linear interpolation functions that make animation feel natural by varying speed over time. Common curves: ease-in (slow start), ease-out (slow end), ease-in-out. Mathematically, often power curves or cubic Beziers. (See: Ch 31)
Edge Function — A function that determines which side of a triangle edge a point is on. Three edge functions (one per edge) determine if a point is inside the triangle. Foundation of modern rasterization. (See: Ch 9)
Eigenvalue — A scalar lambda such that for a matrix A and non-zero vector v: Av = lambda * v. The eigenvectors and eigenvalues reveal a transform's principal axes and scale factors. Used in PCA, physics simulations, and mesh analysis. (See: Ch 1)
Emission (Emissive) — Light that a surface produces on its own, independent of external illumination. Used for screens, neon signs, lava, and other glowing objects. (See: Ch 26)
Environment Map — A texture that captures the lighting environment surrounding a scene, used for reflections and image-based lighting. Can be a cubemap or equirectangular image. (See: Ch 29)
Euler Angle — Representing 3D rotation as three sequential rotations around the X, Y, and Z axes (pitch, yaw, roll). Simple but suffer from gimbal lock. (See: Ch 1, Ch 31)
Euler Integration — The simplest numerical method for advancing a simulation: x += v * dt; v += a * dt. First-order, fast, but accumulates energy error over time. Improved by symplectic Euler or Verlet methods. (See: Ch 33, Ch 34)
EXR (OpenEXR) — A high-dynamic-range image format developed by ILM. Stores floating-point pixel data (16-bit or 32-bit per channel), supporting HDR, multiple layers, and lossless compression. The standard in VFX compositing. (See: Ch 48)
FABRIK (Forward And Backward Reaching Inverse Kinematics) — An iterative IK solver that alternately adjusts a chain from tip-to-root and root-to-tip. Simple, fast, and naturally handles constraints. (See: Ch 32)
Face Winding — See Winding Order.
fBm (Fractional Brownian Motion) — Layering multiple octaves of noise at increasing frequency and decreasing amplitude to create fractal-like detail. The standard technique for procedural terrains, clouds, and organic textures. (See: Ch 37)
FBO (Framebuffer Object) — An OpenGL/WebGL object that allows rendering to textures instead of the screen. Used for shadow maps, post-processing, deferred rendering, and off-screen rendering. (See: Ch 15, Ch 20)
FBX — Autodesk's proprietary binary 3D file format. Supports meshes, materials, animation, and scene hierarchy. Widely used for game engine import despite its closed specification. (See: Ch 48)
Fill Rate — The number of pixels (fragments) the GPU can shade per second. Limited by fragment shader complexity and the number of overdraw layers. (See: Ch 42)
FK (Forward Kinematics) — Computing the position of an end effector by applying joint rotations in sequence from root to tip. The inverse problem (given a target, find joint angles) is inverse kinematics (IK). (See: Ch 32)
Flat Shading — Shading an entire triangle with a single color computed from the face normal. Produces a faceted look. The simplest shading model, replaced by Gouraud and Phong for smooth surfaces. (See: Ch 17)
Flocking — Simulating the collective motion of groups (birds, fish, crowds) using simple per-agent rules: separation, alignment, and cohesion. Produces emergent group behavior from local interactions. (See: Ch 33, Ch 38)
Flow Field — A 2D or 3D vector field that defines a direction (and optionally speed) at every point in space. Particles follow the field to create patterns. Often generated from noise functions. (See: Ch 37, Ch 38)
Force — A vector that causes acceleration of a body according to Newton's second law: F = ma. In simulation, forces (gravity, springs, drag) are accumulated and integrated to update velocity. (See: Ch 33, Ch 34)
Forward Rendering — The traditional rendering approach: for each object, shade it with all affecting lights in a single pass. Simple but expensive with many lights. (See: Ch 42)
Fragment — A potential pixel generated during rasterization — includes position, interpolated attributes, and depth. A fragment becomes a pixel if it passes the depth test. (See: Ch 12)
Fragment Shader — A GPU program that runs once per fragment, computing its final color, depth, or other outputs. Also called "pixel shader" in DirectX terminology. (See: Ch 18, Ch 36)
Frame Budget — The maximum time allowed to render a single frame, determined by the target frame rate. At 60 fps, the budget is 16.67 ms; at 30 fps, 33.33 ms. Exceeding the budget causes dropped frames. (See: Ch 42)
Framebuffer — The GPU memory buffer that holds the final rendered image. Contains color, depth, and optionally stencil attachments. (See: Ch 10)
Fresnel Effect — The increase in reflectivity at grazing angles. All materials become more reflective when viewed at shallow angles. Modeled by Schlick's approximation: F0 + (1-F0)(1-cos(theta))^5. (See: Ch 22, Ch 29)
Friction — A contact force opposing relative sliding motion between surfaces. Static friction prevents motion below a threshold; kinetic friction slows ongoing motion. Essential for realistic rigid body simulation. (See: Ch 34)
Front Buffer / Back Buffer — The double-buffering scheme where rendering writes to the back buffer while the display reads from the front buffer. Swapping them presents the new frame without tearing. (See: Ch 10, Ch 42)
Frustum — The truncated pyramid that defines the visible volume of a perspective camera. Bounded by near, far, left, right, top, and bottom planes. (See: Ch 2, Ch 47)
G-Buffer — A collection of screen-space textures (position, normal, albedo, metallic, roughness) produced during the geometry pass of deferred rendering. (See: Ch 42)
Game Engine — An integrated software framework providing rendering, physics, audio, input, scripting, and asset management for interactive applications. Examples: Unity, Unreal Engine, Godot. (See: Ch 42)
Gamma — The nonlinear encoding applied to color values for display. sRGB uses approximately gamma 2.2. Linear-to-sRGB conversion: sRGB = linear^(1/2.2). (See: Ch 6)
Generative Art — Art created wholly or in part by an autonomous system, often code. The artist designs the process and rules; the system produces the output, frequently with randomness or emergence. (See: Ch 38)
Gerber — A standard 2D vector format used in PCB (printed circuit board) manufacturing. An example of computer graphics applied to industrial fabrication rather than visual display. (See: Ch 48)
GGX — A microfacet normal distribution function (NDF) with long tails, producing more realistic specular highlights than Blinn-Phong. The default NDF in most PBR implementations. Also known as Trowbridge-Reitz. (See: Ch 29)
GI (Global Illumination) — Lighting that accounts for indirect light — light that bounces off surfaces before reaching the camera. Includes radiosity, path tracing, photon mapping, and various approximations. (See: Ch 28, Ch 30)
Gimbal Lock — A loss of one degree of rotational freedom when using Euler angles, occurring when two rotation axes align. Solved by using quaternions. (See: Ch 1, Ch 31)
GJK (Gilbert-Johnson-Keerthi) — An algorithm for determining whether two convex shapes overlap, using Minkowski difference and simplex iteration. The standard narrow-phase collision detection algorithm for convex bodies. (See: Ch 34)
Glass — A dielectric material that both reflects and transmits light. Rendering glass requires handling Fresnel reflectance, Snell's law refraction, attenuation through the medium, and total internal reflection. (See: Ch 22, Ch 24)
GLSL (OpenGL Shading Language) — The shader programming language for OpenGL and WebGL. C-like syntax with built-in types for vectors, matrices, and textures. (See: Ch 18, Ch 36)
glTF — GL Transmission Format — the modern standard 3D file format by Khronos Group. Supports PBR materials, animation, and binary encoding. Called the "JPEG of 3D." (See: Ch 48)
Gouraud Shading — Computing lighting per vertex and interpolating the resulting colors across the triangle. Smoother than flat shading but misses specular highlights that fall between vertices. (See: Ch 17)
GPU (Graphics Processing Unit) — A massively parallel processor optimized for graphics workloads. Contains thousands of small cores executing the same shader on different data (SIMD/SIMT). (See: Ch 10, Ch 44)
GPU Process — In browser architecture, the dedicated process that communicates with the GPU driver, executes graphics commands, and composites layers. Isolates GPU crashes from the rest of the browser. (See: Ch 41)
Gradient — The vector of partial derivatives of a scalar field, pointing in the direction of steepest increase. In shading, the gradient of an SDF gives the surface normal. In calculus, gradients drive optimization. (See: Ch 4, Ch 40)
Halfedge — A data structure element in the halfedge mesh representation, consisting of a directed edge belonging to one face, with pointers to its twin, next halfedge, vertex, and face. Enables O(1) adjacency queries. (See: Ch 45)
Hash Function — A deterministic function mapping input to pseudo-random output. In shaders, integer hash functions replace true random number generators for procedural noise, texture bombing, and random seeding. (See: Ch 37)
HDR (High Dynamic Range) — Representing color values beyond the 0-1 range to capture the full range of real-world luminance. HDR images use floating-point formats (EXR, HDR). (See: Ch 26)
HDRP (High Definition Render Pipeline) — Unity's high-fidelity render pipeline targeting PC and consoles. Features ray tracing, volumetric fog, area lights, and a complete PBR material system. (See: Ch 42)
Heightmap — A grayscale texture where pixel values represent elevation. Used for terrain generation, displacement mapping, and parallax effects. (See: Ch 19)
Hermite — A form of cubic interpolation defined by two endpoints and two tangent vectors, producing a curve that passes through both points with specified derivatives. Used in animation curves and spline construction. (See: Ch 3, Ch 46)
Homogeneous Coordinates — A 4D representation of 3D points: (x, y, z, w), where the 3D point is (x/w, y/w, z/w). Enables perspective projection and translation to be expressed as matrix multiplication. (See: Ch 1, Ch 2)
IBL (Image-Based Lighting) — Lighting a scene using an environment map as a light source. Captures real-world lighting conditions. Split into diffuse irradiance and specular pre-filtered maps. (See: Ch 29)
IK (Inverse Kinematics) — Computing joint angles that place an end effector (e.g., a hand) at a desired position. The opposite of forward kinematics. Used in animation and robotics. (See: Ch 32)
Importance Sampling — A Monte Carlo technique that concentrates random samples in directions that contribute most to the integral (e.g., toward the light or along the BRDF lobe). Dramatically reduces noise compared to uniform sampling. (See: Ch 27)
Impulse — An instantaneous change in momentum applied during collision resolution: J = delta_p. Avoids interpenetration by directly adjusting velocities rather than applying forces over time. (See: Ch 34)
Index Buffer — A GPU buffer containing integer indices that reference vertices in a vertex buffer. Enables vertex sharing between triangles (indexed rendering). (See: Ch 45)
Inertia Tensor — A 3x3 matrix describing how an object's mass is distributed relative to its rotation axes. Determines how torque produces angular acceleration: tau = I * alpha. (See: Ch 34)
Instancing — Drawing multiple copies of the same geometry with different transforms using a single draw call. Essential for rendering forests, crowds, particles. (See: Ch 42)
Interpolation — Computing intermediate values between known values. Linear interpolation (lerp), bilinear, trilinear, and Hermite interpolation are used throughout graphics for smooth transitions. (See: Ch 3)
Intersection Test — An algorithm that determines whether (and where) a ray hits a geometric primitive (sphere, triangle, AABB). The inner loop of any ray tracer. (See: Ch 21)
Irradiance — The total incoming light power per unit area at a surface point, integrated over the hemisphere. Measured in watts per square meter. (See: Ch 26)
Jacobian — A matrix of all first-order partial derivatives of a vector-valued function. In graphics, Jacobians appear in IK solvers (mapping joint velocities to end-effector velocities), texture filtering, and deformation analysis. (See: Ch 4, Ch 32)
Jitter — Small random offsets added to sampling positions to convert aliasing patterns into less noticeable noise. Used in anti-aliasing, soft shadows, and ambient occlusion. (See: Ch 12, Ch 27)
Joint — A connection point in a skeletal hierarchy that defines a local coordinate frame. Joints store rotation (and sometimes translation/scale) relative to their parent. Vertices are skinned to joints via weights. (See: Ch 32)
JPEG — A lossy compressed image format using discrete cosine transform (DCT). Achieves high compression ratios but introduces block artifacts at low quality. Not suitable for textures requiring exact data (normals, masks). (See: Ch 48)
k-d Tree — A binary tree that recursively partitions space along alternating axes. Excellent for nearest-neighbor queries and used in photon mapping. (See: Ch 47)
Keyframe — A specific point in time where an animation value (position, rotation, scale) is explicitly defined. Values between keyframes are interpolated. (See: Ch 31)
Lambert (Lambertian) — A diffuse reflectance model where reflected light intensity depends only on the cosine of the angle between the surface normal and the light direction: I = max(0, dot(N, L)). (See: Ch 17)
Layer — In browser and game engine compositing, an independently rendered surface (texture) that is composited with others to form the final frame. Layers enable efficient partial updates and GPU-accelerated transforms. (See: Ch 41)
Lerp (Linear Interpolation) — The fundamental blending operation: lerp(a, b, t) = a + t * (b - a), where t ranges from 0 to 1. Used ubiquitously in graphics for mixing colors, positions, normals, and animation values. (See: Ch 3)
LFO (Low-Frequency Oscillator) — A periodic signal (sine, triangle, sawtooth) used to modulate parameters over time in creative coding and audio visualization. Produces rhythmic, pulsing effects. (See: Ch 38)
Live-Coding — Writing and modifying code in real time with immediate visual feedback, often in a performance context. Tools include Shadertoy, Hydra, and live-reload frameworks like canvas-sketch. (See: Ch 39)
LOD (Level of Detail) — Using simpler (fewer triangles) models for distant objects and detailed models for close objects. Reduces rendering cost without noticeable quality loss. (See: Ch 42, Ch 45)
L-System (Lindenmayer System) — A string-rewriting grammar that models branching growth. Rules like "F -> F[+F]F[-F]F" generate fractal trees, plants, and organic structures through recursive substitution and turtle graphics. (See: Ch 38)
Lumen — Unreal Engine 5's dynamic global illumination and reflections system. Combines software ray tracing, screen-space traces, and surface caches to deliver real-time indirect lighting without baked lightmaps. (See: Ch 42)
Magnitude — The length (Euclidean norm) of a vector: |v| = sqrt(x^2 + y^2 + z^2). A vector divided by its magnitude becomes a unit vector (normalization). (See: Ch 0)
Manifold — A mesh where every point on the surface has a neighborhood topologically equivalent to a disk (or half-disk on boundaries). Required by most mesh processing algorithms. (See: Ch 45)
Mass-Spring — A simulation model where a mesh of masses connected by springs approximates deformable objects (cloth, jelly). Each spring exerts force based on Hooke's law: F = -k * (x - rest_length). (See: Ch 35)
Material — A data structure combining shaders, textures, and parameters (albedo, roughness, metallic, normal map) that defines the visual appearance of a surface. (See: Ch 19, Ch 29)
Matrix — A rectangular array of numbers representing a linear transformation. In graphics, 4x4 matrices encode translation, rotation, scaling, projection, and their compositions. (See: Ch 1)
Mesh — A collection of vertices, edges, and faces that defines a 3D surface. Triangle meshes are the standard representation in real-time graphics. (See: Ch 45)
Metal — In PBR, a material category where the surface reflects light with a colored specular (no diffuse). Metals have high F0 values (0.5-1.0) and zero diffuse albedo. Also the name of Apple's GPU API. (See: Ch 24, Ch 29)
Metallic — A PBR material parameter (0 or 1, sometimes interpolated) indicating whether a surface is a metal or dielectric. Metals tint their reflections; dielectrics do not. (See: Ch 29)
Microfacet — A theoretical model of surface roughness where the surface is composed of tiny, perfectly flat mirrors ("microfacets") at varying orientations. The statistical distribution of orientations determines the BRDF. (See: Ch 29)
Mipmap — A precomputed pyramid of progressively smaller versions of a texture. The GPU selects the appropriate level based on screen-space pixel density, reducing aliasing and improving cache performance. (See: Ch 14)
Moller-Trumbore — A fast algorithm for computing ray-triangle intersections using Cramer's rule, avoiding precomputation of the triangle's plane equation. The most common ray-triangle test in ray tracers. (See: Ch 21)
Moment of Inertia — A scalar (for rotation about a single axis) or tensor (for arbitrary 3D rotation) measuring an object's resistance to angular acceleration. Depends on mass distribution relative to the rotation axis. (See: Ch 34)
Monte Carlo — A class of algorithms that use random sampling to estimate results. In graphics, used for path tracing, ambient occlusion, and any integration over complex domains. (See: Ch 27, Ch 28)
Morton Code — A space-filling curve encoding that interleaves the bits of multidimensional coordinates into a single integer. Used in LBVH construction to sort primitives spatially. (See: Ch 47)
MSAA (Multi-Sample Anti-Aliasing) — An anti-aliasing technique that samples each pixel at multiple positions but only runs the fragment shader once (using the polygon center). Cheaper than supersampling. (See: Ch 12)
MVP (Model-View-Projection) — The combined transformation matrix that converts a vertex from model space through world space, camera space, and into clip space. The fundamental transform chain in 3D graphics. (See: Ch 2)
Nanite — Unreal Engine 5's virtualized geometry system that streams and renders film-quality meshes in real time. Breaks meshes into clusters, builds a BVH, and uses software rasterization for small triangles. (See: Ch 42)
Navier-Stokes — The partial differential equations governing fluid motion, relating velocity, pressure, viscosity, and external forces. Exact real-time solutions are impractical; graphics uses simplified solvers (Eulerian grids, SPH, FLIP). (See: Ch 35)
NDC (Normalized Device Coordinates) — The coordinate space after perspective division, where visible geometry maps to [-1, 1] on all axes (OpenGL) or [0, 1] (some APIs). (See: Ch 2)
Noise — A pseudo-random function that produces coherent, smooth random values. Types include Perlin, simplex, value, Worley, and curl noise. The foundation of procedural content generation. (See: Ch 37)
Normal — See Normal Vector.
Normal Map — A texture storing per-pixel surface normals encoded as RGB colors, enabling detailed surface shading without additional geometry. Stored in tangent space. (See: Ch 19)
Normal Vector — A unit vector perpendicular to a surface at a given point. Defines which direction the surface faces. Essential for lighting calculations. (See: Ch 0, Ch 17)
Normalize — Dividing a vector by its magnitude to produce a unit vector (length = 1) pointing in the same direction. Required before dot-product-based lighting calculations. (See: Ch 0)
NURBS (Non-Uniform Rational B-Splines) — Weighted B-spline curves/surfaces that can exactly represent conic sections (circles, ellipses). The standard in CAD/engineering software. (See: Ch 46)
OBJ (Wavefront) — A simple, plain-text 3D file format from the 1980s. Stores vertex positions, normals, texture coordinates, and face indices. Easy to parse, limited features. (See: Ch 45, Ch 48)
Occlusion Culling — Skipping rendering of objects that are completely hidden behind other objects. More expensive than frustum culling but eliminates overdraw. (See: Ch 42)
Octave — In noise generation, a single layer of noise at a specific frequency and amplitude. Multiple octaves are summed in fBm to build fractal detail. (See: Ch 37)
Octree — A spatial data structure that recursively subdivides a cube into 8 equal sub-cubes. Used for voxel data, frustum culling, and spatial queries. (See: Ch 47)
ODE (Ordinary Differential Equation) — An equation relating a function to its derivatives. Physics simulation is fundamentally about solving ODEs: dx/dt = v, dv/dt = F/m. Solved numerically with Euler, Verlet, or RK4 methods. (See: Ch 33, Ch 34)
Orthogonal — Perpendicular; at 90 degrees. Two vectors are orthogonal when their dot product is zero. Orthogonal matrices preserve lengths and angles (rotations and reflections). (See: Ch 0, Ch 1)
Orthographic Projection — A projection where parallel lines remain parallel and objects do not shrink with distance. Used for 2D games, CAD, and isometric views. No perspective divide is needed. (See: Ch 2)
Overdraw — Rendering fragments that end up being covered by closer geometry. Wasted GPU work. Measured as the average number of times each pixel is shaded. (See: Ch 42)
Paint — In browser rendering, the stage where the layout tree is converted into a display list of draw commands (rectangles, text, images) for the rasterizer to execute. (See: Ch 41)
Parallax Mapping — A texture-based technique that offsets texture coordinates based on view angle and height, creating the illusion of depth. More convincing than normal maps, cheaper than displacement. (See: Ch 19)
Parametric — A representation where a curve or surface is defined by one or more parameters (t, u, v) that sweep out the shape. Bezier curves are parametric: P(t) for t in [0,1]. Contrasts with implicit representations. (See: Ch 3, Ch 46)
Path Tracing — A Monte Carlo rendering technique that traces rays from the camera, bouncing randomly at each surface according to the BRDF, accumulating light contributions. Produces physically correct images given enough samples. (See: Ch 28)
PBD (Position-Based Dynamics) — A simulation method that directly moves particle positions to satisfy constraints, rather than computing forces and integrating. Stable, controllable, and widely used for cloth, hair, and soft bodies. (See: Ch 35)
PBR (Physically Based Rendering) — A shading approach based on the physics of light interaction with materials. Uses BRDF models (Cook-Torrance), energy conservation, and Fresnel effects to produce realistic materials. (See: Ch 29)
PDF (Probability Density Function) — In Monte Carlo rendering, the probability distribution used to generate random samples. Importance sampling uses PDFs that match the integrand to reduce variance. (See: Ch 27)
Penumbra — The partially shadowed region at the edge of a shadow, caused by the finite size of the light source. Soft shadows have wide penumbrae; hard shadows have none. (See: Ch 20)
Perlin Noise — A gradient noise function that produces natural-looking random patterns. Used for terrain, clouds, fire, water, and procedural textures. Created by Ken Perlin in 1983. (See: Ch 37)
Persistence — In fBm noise, the factor by which amplitude decreases with each successive octave (typically 0.5). Higher persistence produces rougher, more detailed noise; lower persistence yields smoother results. (See: Ch 37)
Perspective Divide — Dividing clip-space coordinates (x, y, z) by the w component to produce NDC. This is the mathematical step that makes distant objects appear smaller. (See: Ch 2)
Perspective Projection — The projection that makes distant objects appear smaller, creating depth perception. Defined by field of view, aspect ratio, and near/far planes. (See: Ch 2)
Phong — Both a shading model (per-pixel normal interpolation for smooth shading) and a reflection model (ambient + diffuse + specular with a power exponent). (See: Ch 17)
Photon Mapping — A two-pass global illumination algorithm: first, photons are traced from lights and stored in a spatial structure; then, gathering queries estimate illumination. Excels at caustics. (See: Ch 30)
Physically-Based — Adhering to physical laws: energy conservation, reciprocity, and correct Fresnel behavior. Physically-based models produce consistent, realistic results across lighting environments. (See: Ch 29)
Pipeline (Graphics Pipeline) — The sequence of stages that transform 3D geometry into a 2D image: vertex processing, clipping, rasterization, fragment shading, and output merging. (See: Ch 10)
Pixel — A single picture element on screen. The final output of the rendering pipeline. (See: Ch 5)
Pixel Shader — See Fragment Shader.
PLY (Polygon File Format) — A file format for 3D scanned data, storing vertex positions, normals, colors, and custom per-vertex properties. Supports both ASCII and binary encoding. Common in point cloud data. (See: Ch 48)
PMJ (Progressive Multi-Jittered) — An advanced sampling pattern that distributes samples well across multiple dimensions simultaneously. Used in production renderers for anti-aliasing. (See: Ch 27)
PNG (Portable Network Graphics) — A lossless compressed raster image format supporting an alpha channel. Ideal for textures that require exact pixel values (normal maps, masks, sprites). (See: Ch 48)
Point Light — A light source that emits in all directions from a single point. Attenuates with distance squared. (See: Ch 16)
Polar Coordinates — A 2D coordinate system where a point is specified by a distance from the origin (r) and an angle (theta). Useful for circular patterns, spirals, and converting to/from Cartesian coordinates. (See: Ch 3)
PPM (Portable Pixmap) — The simplest image format: a plain-text header followed by RGB values. Trivial to write from code, making it popular for ray tracer output in tutorials. (See: Ch 48)
Primitive — The basic geometric element processed by the GPU: triangles, lines, or points. Triangles are by far the most common. (See: Ch 10)
Procedural — Content generated algorithmically rather than authored by hand. Procedural textures, terrain, and models use noise, math, and rules to create variety without storing large datasets. (See: Ch 37)
Projection — Transforming 3D coordinates into 2D screen space. Perspective projection provides depth cues; orthographic projection preserves parallel lines. (See: Ch 2)
Projection Matrix — A 4x4 matrix that transforms view-space coordinates into clip space. Encodes the camera's field of view, aspect ratio, and near/far planes. Perspective and orthographic projections have different matrix forms. (See: Ch 2)
Quad — A polygon with four vertices. Can be split into two triangles for rendering. Catmull-Clark subdivision produces quad-dominant meshes. (See: Ch 45, Ch 46)
Quaternion — A 4D number system used to represent 3D rotations without gimbal lock. Quaternions interpolate smoothly (slerp) and compose efficiently. (See: Ch 1, Ch 31)
Radians — The standard angular unit in graphics mathematics, where a full circle is 2*pi radians. All trigonometric functions in GLSL, C, and most math libraries expect radians, not degrees. (See: Ch 3)
Radiance — The light power per unit area per unit solid angle in a given direction. The fundamental quantity measured by cameras and computed by renderers. Measured in W/(m^2 * sr). (See: Ch 26)
Radiosity — A global illumination method that computes diffuse interreflection by solving a system of equations over surface patches. Produces soft, realistic indirect lighting for diffuse scenes. (See: Ch 30)
Ragdoll — A physics-driven character model where rigid body parts are connected by constrained joints. Used for death animations and rag-like character physics after active animation ends. (See: Ch 34)
Rasterization — Converting continuous geometric primitives (triangles) into discrete fragments (pixels). The core of real-time rendering pipelines. (See: Ch 12)
Ray — A half-line defined by an origin point and a direction vector: P(t) = O + t*D, where t >= 0. The fundamental primitive in ray tracing. (See: Ch 21)
Ray Marching — Stepping along a ray in small increments, testing for intersection at each step. Used for rendering SDFs, volumetric effects, and terrain. (See: Ch 40)
Ray Tracing — Computing visibility and lighting by shooting rays from the camera into the scene and tracing their interactions with surfaces. Naturally handles reflections, refractions, and shadows. (See: Ch 21, Ch 22)
Reaction-Diffusion — A system of PDEs where substances diffuse through space and react with each other, producing patterns (spots, stripes, spirals) resembling biological markings. The Gray-Scott model is the most common in creative coding. (See: Ch 38)
Recursion Depth — In recursive ray tracing, the maximum number of times a ray can bounce (reflect/refract) before termination. Higher depth allows more realistic caustics but increases computation. Typically capped at 4-10 bounces. (See: Ch 22)
Reflectance — The fraction of incident light that a surface reflects. Varies with angle (Fresnel), wavelength, and surface roughness. The F0 value is reflectance at normal incidence. (See: Ch 29)
Reflection — Light bouncing off a surface. Specular reflection follows the law of reflection (angle of incidence = angle of reflection). Computed as R = 2(dot(N,L))*N - L. (See: Ch 17, Ch 22)
Refraction — Light bending as it passes through a boundary between materials with different indices of refraction. Governed by Snell's law. (See: Ch 22, Ch 24)
Render Target — A texture or framebuffer attachment that receives rendering output. Used for off-screen rendering, shadow maps, G-buffers, and post-processing. (See: Ch 15, Ch 42)
Render Tree — In browser rendering, the combined result of the DOM and computed CSS styles, representing only visible elements with their layout properties. The render tree drives layout and paint. (See: Ch 41)
Resolution — The number of pixels in a rendered image (width x height). Higher resolution provides more detail but requires more computation. (See: Ch 5)
Restitution — The coefficient of restitution (0 to 1) determines how "bouncy" a collision is. 0 = perfectly inelastic (no bounce); 1 = perfectly elastic (full bounce). Applied during impulse-based collision resolution. (See: Ch 34)
Rigid Body — A simulation object that does not deform: it can only translate and rotate. Described by mass, center of mass, inertia tensor, linear velocity, and angular velocity. (See: Ch 34)
Roughness — A PBR material parameter (0 to 1) controlling how blurry reflections appear. Low roughness = mirror-like; high roughness = matte. Internally controls the width of the microfacet NDF. (See: Ch 29)
Row-Major — A matrix storage order where consecutive memory addresses store elements of the same row. DirectX/HLSL use row-major layout. Opposite of column-major (used by OpenGL/GLSL). (See: Ch 1)
Russian Roulette — A probabilistic technique in path tracing for unbiasedly terminating low-contribution ray paths. Each bounce has a probability of being killed, and surviving paths are weighted up to compensate. (See: Ch 28)
SAH (Surface Area Heuristic) — A method for building optimal BVH trees by minimizing the expected ray traversal cost, using the principle that the probability of a ray hitting a box is proportional to its surface area. (See: Ch 47)
Sampler — A GPU object that defines how textures are read: filtering mode (nearest, linear, anisotropic), wrapping mode (repeat, clamp, mirror), and mipmap selection. (See: Ch 14)
SAT (Separating Axis Theorem) — A collision detection method stating that two convex shapes do not overlap if and only if a separating axis exists between them. Test all face normals and edge cross products as candidate axes. (See: Ch 34)
Scalar — A single numerical value (as opposed to a vector or matrix). In shaders, float is the scalar type. The dot product maps two vectors to a scalar. (See: Ch 0)
Scanline — A single horizontal row of pixels. Scanline rasterization processes triangles one row at a time, computing the left and right intersection points and filling between them. (See: Ch 12)
Schlick Approximation — A fast polynomial approximation of the Fresnel equations: F = F0 + (1 - F0) * (1 - cos(theta))^5. Accurate enough for real-time PBR. (See: Ch 29)
Scissor Test — A per-fragment test that discards fragments outside a defined screen-space rectangle. Used to restrict rendering to a sub-region of the framebuffer. (See: Ch 13)
Screen Space — The 2D coordinate system of the final output pixels, typically with origin at the top-left or bottom-left of the window. Fragment positions, post-processing, and UI operate in screen space. (See: Ch 2, Ch 12)
SDF (Signed Distance Field) — A scalar field that stores the distance to the nearest surface, with sign indicating inside (negative) or outside (positive). Used for font rendering, CSG, and ray marching. (See: Ch 36, Ch 40)
Shader — A program that runs on the GPU. Vertex shaders transform vertices; fragment (pixel) shaders compute pixel colors; compute shaders do general computation. (See: Ch 18, Ch 36)
Shading — The process of computing the color of a surface point based on its material, geometry (normal), and lighting. Encompasses diffuse, specular, ambient, and emissive contributions. (See: Ch 17)
Shadow Map — A texture rendered from a light's perspective that stores depth values. Used to determine if a point is in shadow by comparing its depth to the shadow map. (See: Ch 20)
Shadow Ray — A ray cast from a surface point toward a light source to test for occlusion. If the ray is blocked, the point is in shadow. (See: Ch 21)
Shadertoy — A web-based platform for writing and sharing GLSL fragment shaders. Renders a fullscreen quad with per-pixel ray marching or 2D effects. A major hub for creative coding and shader art. (See: Ch 36, Ch 40)
Simplex Noise — An improved noise function by Ken Perlin that works in any number of dimensions with lower computational cost than classic Perlin noise. Uses a simplex grid instead of a hypercube grid. (See: Ch 37)
Simulation — Numerically advancing a physical system through time by integrating equations of motion. Encompasses particles, rigid bodies, cloth, fluids, and more. (See: Ch 33, Ch 34, Ch 35)
Skeletal Animation — Animating a mesh by manipulating an internal skeleton (hierarchy of joints/bones). The mesh is bound to the skeleton via skinning weights, so joint rotations deform the surface. (See: Ch 32)
Skinning — Deforming a mesh based on a skeleton of bones. Each vertex is influenced by multiple bones with different weights. Linear blend skinning (LBS) is the standard real-time approach. (See: Ch 32)
Slerp (Spherical Linear Interpolation) — Interpolation along the surface of a sphere, used for smooth rotation interpolation between quaternions. Maintains constant angular velocity. (See: Ch 1, Ch 31)
Smoothstep — A smooth interpolation function: smoothstep(a, b, t) = 3t^2 - 2t^3 (after clamping and remapping t). Produces an S-curve with zero derivatives at both endpoints. Ubiquitous in shader code for soft transitions. (See: Ch 3, Ch 36)
Snell's Law — The law governing refraction: n1 * sin(theta1) = n2 * sin(theta2), where n1, n2 are indices of refraction. (See: Ch 16, Ch 22)
Solid Angle — The 3D equivalent of an angle — the area a shape subtends on a unit sphere, measured in steradians. A full sphere subtends 4*pi steradians. (See: Ch 26)
Specular — Light reflected in a concentrated direction off a smooth surface. Creates highlights and reflections. Modeled by Phong, Blinn-Phong, or Cook-Torrance BRDF. (See: Ch 17, Ch 29)
Specular Map — A texture that stores per-texel specular intensity or color, controlling where and how strongly specular highlights appear on a surface. In PBR workflows, replaced by metallic and roughness maps. (See: Ch 19)
Sphere Tracing — A ray marching technique specific to SDFs: at each step, advance by the SDF value at the current point (the safe distance guaranteed to not pass through any surface). Converges quickly for smooth geometry. (See: Ch 40)
SPH (Smoothed Particle Hydrodynamics) — A particle-based fluid simulation method where fluid properties (density, pressure) are estimated by summing contributions from neighboring particles using a smoothing kernel. (See: Ch 35)
Spline — A piecewise polynomial curve. B-splines, Catmull-Rom splines, and Hermite splines are common types. (See: Ch 3, Ch 46)
Spring — A simulation element that exerts a force proportional to its displacement from a rest length: F = -k * (x - rest) (Hooke's law). The building block of mass-spring systems for cloth and soft body simulation. (See: Ch 33, Ch 35)
SRP (Scriptable Render Pipeline) — Unity's architecture allowing developers to define custom rendering pipelines in C#. URP and HDRP are built on SRP. (See: Ch 42)
SSAO (Screen-Space Ambient Occlusion) — An approximation of ambient occlusion computed from the depth buffer. Samples nearby depths to estimate occlusion without ray tracing. (See: Ch 30)
SSGI (Screen-Space Global Illumination) — A screen-space approximation of global illumination that traces short rays in screen space to gather indirect lighting from visible surfaces. (See: Ch 30)
SSS (Subsurface Scattering) — Light penetrating a translucent material, scattering internally, and exiting at a different point. Creates the soft, glowing look of skin, wax, marble, and milk. (See: Ch 24, Ch 29)
State Machine — In animation, a graph of states (idle, walk, run, jump) with transitions triggered by conditions (speed threshold, input). Manages which animation clip plays and blends between them. (See: Ch 31)
Steering Behavior — An algorithm that computes forces to guide an autonomous agent (seek, flee, arrive, wander, path-follow). Combined with flocking rules, steering behaviors produce lifelike AI movement. (See: Ch 33, Ch 38)
STL (Stereolithography) — A 3D file format storing a mesh as a list of unconnected triangles (no shared vertices). The standard format for 3D printing. Simple but redundant. (See: Ch 48)
Stencil Buffer — A per-pixel integer buffer used for masking operations: outlining, portals, mirrors, shadow volumes, and CSG rendering. (See: Ch 13)
Step Function — A function that returns 0 below a threshold and 1 above it: step(edge, x) = x < edge ? 0.0 : 1.0. Used in shaders for hard transitions. Smoothstep provides a soft version. (See: Ch 36)
Steradian (sr) — The SI unit of solid angle. A full sphere is 4*pi steradians. Used in radiometry to measure light per unit solid angle. (See: Ch 26)
Subdivision Surface — A smooth surface generated by repeatedly subdividing a coarse control mesh. Catmull-Clark (quads) and Loop (triangles) are the main schemes. The production standard for organic modeling. (See: Ch 46)
Sub-Pixel — Precision or effects finer than a single pixel. Sub-pixel rendering (e.g., ClearType) uses LCD sub-pixel color channels to increase effective resolution. Sub-pixel accuracy in rasterization prevents jittery edges. (See: Ch 12)
Supersampling — Rendering at a higher resolution than the display and averaging down to reduce aliasing. The brute-force approach to anti-aliasing — effective but expensive. (See: Ch 12)
Surface Normal — See Normal Vector.
Symplectic Euler — A variant of Euler integration that updates velocity before position: v += a * dt; x += v * dt. Conserves energy much better than standard Euler, making it the default for game physics. (See: Ch 33, Ch 34)
Tangent — A vector lying along a surface at a point, typically aligned with the U texture direction. Combined with the bitangent and normal, it forms the TBN matrix for normal mapping. (See: Ch 0, Ch 19)
Tangent Space — A per-vertex coordinate system defined by the tangent, bitangent, and normal vectors. Normal maps are stored in tangent space so they deform correctly with the mesh. (See: Ch 19)
TBN Matrix — The 3x3 matrix formed by the Tangent, Bitangent, and Normal vectors, used to transform normal map samples from tangent space to world space for lighting calculations. (See: Ch 19)
Tessellation — Subdividing geometry into smaller primitives, typically on the GPU. Used for adaptive detail, displacement mapping, and subdivision surfaces in real-time. (See: Ch 46)
Texel — A single element of a texture — the texture equivalent of a pixel. (See: Ch 14)
Texture — A 2D (or 3D) image applied to a surface to provide detail — color, normals, roughness, and more. Stored in GPU memory and sampled in shaders. (See: Ch 14)
Texture Filtering — Methods for sampling a texture when the texel grid does not align 1:1 with pixels. Nearest-neighbor (blocky), bilinear (smooth), trilinear (across mip levels), and anisotropic (at oblique angles). (See: Ch 14)
Thin Lens — A camera model that simulates defocus blur (depth of field) by sampling rays through a lens aperture rather than a pinhole. The aperture radius and focal distance control the blur amount. (See: Ch 25)
Three.js — A popular JavaScript library for 3D graphics in the browser, built on WebGL (and experimentally WebGPU). Provides scene graph, materials, lights, loaders, and post-processing out of the box. (See: Ch 39)
Tile-Based Rendering — A GPU architecture (common in mobile GPUs like ARM Mali and Apple GPU) that divides the screen into small tiles and renders each tile entirely in fast on-chip memory before writing to main memory. Reduces bandwidth. (See: Ch 42)
Tone Mapping — Converting HDR (high dynamic range) color values to the displayable LDR range [0, 1]. Operators: Reinhard, ACES, filmic, exposure-based. (See: Ch 26)
Torque — The rotational analog of force: tau = r x F. Causes angular acceleration proportional to the inverse of the inertia tensor. (See: Ch 34)
Transpose — Flipping a matrix over its diagonal, swapping rows and columns: M^T[i][j] = M[j][i]. The transpose of an orthogonal matrix is its inverse. Used in normal transformation and converting between row-major and column-major. (See: Ch 1)
Triangle — The fundamental polygon in computer graphics. Always planar, always convex, efficiently rasterized by GPUs. Every 3D mesh is ultimately made of triangles. (See: Ch 12, Ch 45)
Triangle Strip / Fan — Compact representations of connected triangles. A strip reuses the two most recent vertices for each new triangle; a fan shares a single central vertex. Reduces vertex data compared to independent triangles. (See: Ch 10, Ch 45)
Trigonometry — The branch of mathematics dealing with relationships between angles and sides of triangles. sin, cos, tan, and their inverses appear constantly in rotation, projection, lighting, and wave generation. (See: Ch 3)
Trilinear Filtering — Texture filtering that performs bilinear interpolation on two adjacent mipmap levels and linearly interpolates between them. Smooth transitions between mip levels. (See: Ch 14)
TSR / DLSS / FSR — Temporal upscaling technologies (Unreal TSR, NVIDIA DLSS, AMD FSR) that render at a lower resolution and use temporal history and/or neural networks to reconstruct a high-resolution output. (See: Ch 42)
Unit Vector — A vector with magnitude (length) of exactly 1. Normals, light directions, and view directions must be unit vectors for correct dot-product calculations. (See: Ch 0)
URP (Universal Render Pipeline) — Unity's performance-oriented render pipeline targeting mobile through console. Simpler than HDRP, with a single-pass forward renderer and 2D rendering support. (See: Ch 42)
USD (Universal Scene Description) — Pixar's open scene description format for exchanging and composing 3D scenes. Supports layering, referencing, and non-destructive overrides. Increasingly adopted beyond film. (See: Ch 48)
USDZ — A zero-compression, single-file packaging of USD assets for AR delivery (Apple AR Quick Look). Bundles geometry, materials, and textures into one file that can be viewed on iOS/visionOS devices. (See: Ch 48)
UV Coordinates — 2D texture coordinates (u, v) assigned to mesh vertices that map a 2D texture onto a 3D surface. The process of assigning them is called "UV unwrapping." (See: Ch 14)
Value Noise — A noise function that assigns random values to grid points and interpolates between them (as opposed to Perlin noise, which interpolates gradients). Simpler but more prone to axis-aligned artifacts. (See: Ch 37)
VAO (Vertex Array Object) — An OpenGL object that stores the configuration of vertex attribute pointers, binding vertex buffers and index buffers together for efficient draw calls. (See: Ch 15)
VBO (Vertex Buffer Object) — An OpenGL buffer for storing vertex data (positions, normals, UVs, etc.) in GPU memory. (See: Ch 15)
Verlet Integration — A numerical integration method that uses the current and previous positions (instead of velocity) to advance: x_new = 2*x - x_old + a*dt^2. Second-order accurate and naturally stable for constrained systems. (See: Ch 33, Ch 35)
Vertex — A point in space with associated attributes (position, normal, UV, color, bone weights). The fundamental building block of meshes. (See: Ch 45)
Vertex Shader — A GPU program that processes each vertex individually: applying transforms, computing per-vertex lighting, or deforming geometry. Runs once per vertex. (See: Ch 11, Ch 18)
View Matrix — The 4x4 matrix that transforms world-space coordinates into camera (eye) space. Computed as the inverse of the camera's model transform. Positions the entire world relative to the camera. (See: Ch 2)
Viewport — The rectangular region of the window where rendering output appears. The viewport transform maps NDC coordinates to pixel coordinates. (See: Ch 2)
Virtual Shadow Maps — A technique in Unreal Engine 5 that uses a large virtual texture to store high-resolution shadow data on demand, allocating physical pages only where needed. Replaces cascaded shadow maps for finer detail. (See: Ch 42)
Volumetric — Relating to effects that exist within a volume of space rather than on a surface — fog, smoke, clouds, light shafts (god rays). Requires ray marching or voxelization. (See: Ch 30, Ch 40)
Voronoi — A partitioning of space where each cell contains all points closest to a given seed. Produces organic, cell-like patterns used for cracks, scales, foam, and procedural textures. Also known as Worley noise when used as a distance function. (See: Ch 37)
Voxel — A volumetric pixel — a single element in a 3D grid. Used for volume rendering, voxel-based GI, and Minecraft-style worlds. (See: Ch 47)
WebGPU — The next-generation web graphics API, successor to WebGL. Provides compute shaders, better resource management, and a modern binding model inspired by Vulkan/Metal/D3D12. (See: Ch 44)
Weight Painting — The process of assigning per-vertex skinning weights to a skeleton, typically using a brush tool that "paints" influence values onto the mesh surface. Critical for quality skeletal deformation. (See: Ch 32)
WGSL (WebGPU Shading Language) — The shader language for WebGPU. Rust-influenced syntax with explicit memory management and type safety. Successor to GLSL for web graphics. (See: Ch 44)
Whitted Ray Tracing — Turner Whitted's 1980 recursive ray tracing algorithm that spawns reflection, refraction, and shadow rays at each intersection. The first ray tracing method to produce specular reflections and transparency. (See: Ch 22)
Winding Order — The direction (clockwise or counter-clockwise) in which a triangle's vertices are ordered. Determines which side is the "front" face. Convention: CCW = front. (See: Ch 12, Ch 45)
Wireframe — A rendering mode that draws only the edges of polygons, showing the mesh structure without filled faces. Useful for debugging and visualization. (See: Ch 5)
World Space — The global coordinate system where all objects, lights, and cameras have absolute positions and orientations. Objects are placed in world space by the model transform. (See: Ch 2)
Worley Noise — A noise function based on distances to randomly scattered feature points, producing cell-like patterns. Used for stone, scales, veins, and organic textures. Also called cellular noise or Voronoi noise. (See: Ch 37)
Z-Buffer — See Depth Buffer.
Z-Fighting — Flickering artifacts when two surfaces are nearly coplanar, causing their depth values to alternate being "closer." Solved by increasing near plane distance, using logarithmic depth, or separating the surfaces. (See: Ch 13)