Computer Graphics

VAO (Vertex Array Object)

Acts as a state wrapper encapsulating the configuration settings for vertex data layouts, VBOs, and EBOs

VBO (Vertex Buffer Object)

Allocates raw GPU memory and uploads coordinate, color, or structural data directly to the graphics card

EBO (Element Buffer Object)

Implements indexed rendering, allowing geometry to reuse existing vertices to prevent duplication

Dot Product

Extensively used to calculate projections, vector lengths, and the cosine angles between rays

Cross Product

Returns a vector perpendicular to the plane formed by vectors $A$ and $B$. The magnitude of the resulting vector equals the geometric area of the parallelogram formed by the inputs

View Matrix (Camera Transform)

Built by calculating the mathematical inverse of the camera's translation and orientation matrices

Orthographic Projection

Creates a parallel view volume defined by width, height, near, and far clipping planes. It does not scale objects by distance and is used for 2D, isometric views, or directional light depth maps.

Perspective Projection

Replicates human vision by utilizing a field-of-view (FOV) angle, aspect ratio, and near/far clipping planes

Viewport Transform

Triggered via glViewport to map Normalized Device Coordinates (NDC) directly into the window's physical pixel grid

Phong Shading Model

Combines three core components: Ambient (base background color), Diffuse (directional illumination based on surface normals), and Specular (bright highlight reflections).

Gouraud Shading

Performs lighting math per-vertex in the vertex shader, causing pixel artifacts

Phong Shading

It executes calculations per-fragment in the fragment shader, creating smooth illumination

Z-Fighting

Visual artifacts occur when overlapping or near-identical polygon depth values conflict in the depth buffer

Buffer Masking

Disables writing data to the depth buffer while preserving depth reads, which is required for transparent or reflective geometry passes.

Stencil Buffer Masking

Implements pixel-level filtering by writing reference flags into an 8-bit stencil buffer to confine rendering to specific shapes, such as mirroring reflections inside a floor plane

Back-Face Culling

Eliminates geometry facing away from the camera based on triangle index winding orders, which are typically Counter-Clockwise (CCW)

Frustum Culling

Run on the CPU to check bounding volumes (Axis-Aligned Bounding Boxes or Bounding Spheres) against the camera's six frustum planes. This discards entire VAO draw calls before sending them to the GPU.

Occlusion Culling

Discards objects that are within the camera frustum but hidden behind larger, solid geometry.

Profiling

Tools like the Tracy Profiler provide synchronous tracking across CPU and GPU timelines to locate processing bottlenecks.

Driver Bottlenecks

Graphics performance is often bottlenecked by driver overhead rather than hardware limits. The CPU cost of managing a draw call is frequently more expensive than processing instructions within a shader.

PBR Foundations

Mimics light physics more accurately than empirical models like Blinn-Phong. To be considered PBR, a pipeline must satisfy three conditions:

1. Rely on a microscopic microfacet surface distribution framework.

2. Maintain strict energy conservation laws (reflected light cannot exceed incoming light intensity).

3. Implement a physically based Bidirectional Reflectance Distribution Function (BRDF) evaluated via the standard Reflectance Equation.

IBL Integration

Extends PBR by treating a full environment cubemap as a distributed light source rather than relying only on analytical light points. To avoid complex Riemann sum calculations, the reflection equation is split into separate diffuse irradiance and specular components.

Forward Shading

Processes lighting operations for every incoming polygon face, which can lead to unnecessary calculations on obscured fragments

Deferred Shading

Splits rendering into separate geometry and lighting stages

G-Buffer (Geometry Buffer)

The first pass renders scene geometry to multiple textures using Multiple Render Targets (MRT), storing position coordinates, normal vectors, and albedo/specular properties.

Lighting Pass

Shaders read properties from the G-Buffer textures and perform lighting calculations exactly once per screen pixel, reducing calculation overhead. This approach provides noticeable performance gains on compatible platforms (e.g., up to a 120% FPS improvement on the Nintendo Switch) but demands higher memory bandwidth.

Shadow Pass

Renders the scene from the light source's point of view (Light POV) to save distance values into a specialized Depth Map texture. Directional lights require an orthographic projection matrix to calculate coordinates inside light-space.

Color Pass

Renders the scene from the camera's point of view. It transforms fragment positions into light-space coordinates and compares their depth values against the depth map texture to determine shadow states.

Bloom Pipeline

Employs Multiple Render Targets (glDrawBuffers) to generate two color buffers simultaneously: the standard color scene and a bright-pass highlight map. The bright map is blurred using a convolution kernel and combined back with the standard color scene.

Cubemaps

A specialized texture comprised of six square images mapped onto the inside faces of a cube, which is sampled using a 3D direction vector instead of flat 2D coordinates. It is primarily used to simulate infinite backgrounds like skyboxes, or to calculate real-time environmental reflections and refractions.

Framebuffer

An offscreen memory canvas that bundles color, depth, and stencil buffers so developers can redirect rendering outputs away from the main monitor display. This allows a scene to be rendered directly into a texture, which serves as the foundation for multi-pass rendering and post-processing filters.

Instancing

A hardware-accelerated technique that renders thousands of duplicate geometric meshes simultaneously using a single CPU draw call. It dramatically improves performance by eliminating the heavy driver overhead associated with constantly changing CPU states for individual objects like foliage or particles

Normal Mapping

A shading trick that alters the lighting vectors on a per-fragment basis using a 2D texture map where colors represent surface directions. This allows a low-polygon model to simulate complex physical details like cracks, bumps, and crevices without adding any expensive vertex geometry.

High Dynamic Range (HDR)

A pipeline architecture that utilizes floating-point color buffers to process light intensities far brighter than the standard hardware limit of 1.0. Before rendering to a screen, a tone-mapping function compresses these extreme exposure values back down to a standard displayable range, preventing highlights from getting entirely washed out.

Shadow Mapping

A multi-pass technique where the scene is first rendered from the perspective of a light source to generate a depth-only map. During the final camera pass, the pipeline checks if a pixel is further away than the corresponding depth on the map; if it is, the pixel is flagged as occluded and rendered in shadow.

Screen Space Ambient Occlusion (SSAO)

A post-processing effect that approximates global ambient lighting attenuation by analyzing depth values directly on the screen rather than calculating complex scene geometry. It works by testing random sample points around a pixel inside a small hemisphere, darkening tight corners and crevices where fewer samples can "see" open space.

glClear

[Command] Clears the specified screen buffer or buffers (such as color or depth) to their preset clear values.

glBufferData

[Command] Allocates storage and copies data from the CPU into a specified graphics buffer object.

glViewport

[Command] Defines the rectangular dimensions of the viewport to map normalized device coordinates into window screen pixels

glEnable

[Command] Activates specific fixed-function or pipeline capabilities, such as depth testing or blending.

glDepthFunc

[Command] Specifies the mathematical comparison criteria used to pass or fail fragments during depth testing

glDepthMask

[Command] Enables or disables the pipeline's ability to write new data into the depth buffer.

glBlendFunc

[Command] Configures the pixel operation weighting factors for both the incoming source color and the existing destination color during alpha blending

glGenFramebuffers

[Command] Allocates and generates unique identifying names for custom framebuffer objects.

glBindFramebuffer

[Command] Binds a specified framebuffer object to act as the current active rendering or reading target.

glCheckFramebufferStatus

[Command] Validates the configuration of the currently bound framebuffer to ensure it is complete and ready for rendering operations.

glDrawArrays

[Command] Renders geometric primitives directly from sequentially ordered array vertices.

glGenTextures

[Command] Generates unique texture reference identification numbers.

glBindTexture

[Command] Binds a specific texture ID to a texture target, such as a 2D texture or a cubemap.

glTexImage2D

[Command] Specifies the dimensions, data format, and pixel information to construct or upload a two-dimensional texture image on the GPU.

glDrawArraysInstanced

[Command] Renders multiple duplicates of a geometric primitive from array data using a single hardware-accelerated CPU call.

glDrawElementsInstanced

[Command] Renders multiple duplicates of indexed geometric meshes using a single CPU draw call to save driver overhead

glDrawBuffers

[Command] Specifies an array of color attachments inside a framebuffer that the fragment shader will simultaneously output to.