Computer Graphics

Attribute Contributions

Prerequisites

Overview

Computer graphics is the field of computer science and engineering concerned with generating, manipulating, and displaying visual content using computational methods. It underpins video games, visual effects, architectural visualization, scientific visualization, medical imaging, and user interface rendering. The field divides into real-time graphics (where frames must be generated fast enough for interactive experience, typically at sixty or more frames per second) and offline rendering (where photorealistic images can take seconds to hours per frame, as in visual effects and animated film).

The core technical areas are the rendering pipeline — the sequence of transformations from 3D scene geometry to 2D screen pixels — and the mathematical structures that support it: linear algebra (vectors, matrices, transformations), differential geometry (for smooth surfaces), and numerical methods. Shaders — programs that run on the GPU to determine the color and appearance of surfaces — are where artistic intent meets computational implementation, and shader programming is the practical interface between graphics theory and visual output.

Getting Started

Linear algebra is the mathematical foundation for virtually everything in computer graphics. Vectors (representing positions, directions, and colors), matrices (representing transformations), and their operations (dot product, cross product, matrix multiplication, inverse and transpose) appear in every graphics calculation. Understanding these mathematically — not just as syntactic operations but as geometric transformations — is the prerequisite that makes everything else interpretable rather than magical.

The rasterization pipeline — the sequence by which 3D geometry is transformed to screen coordinates and colored by shaders — is the standard model for real-time graphics and is implemented in APIs including OpenGL, Vulkan, DirectX, and Metal. Understanding the pipeline stages: vertex transformation (model → world → view → clip → NDC → screen space), primitive assembly, rasterization, and fragment shading — gives the framework within which GPU shader programming makes sense.

Writing your first shader in GLSL or HLSL — even a simple diffuse lighting model computing the dot product of the surface normal with a light direction — immediately demonstrates how GPU computation works and why the pipeline is structured as it is. Building up from simple diffuse to specular (Phong or Blinn-Phong) to texture mapping to normal mapping builds the shader vocabulary needed for practical graphics work.

Common Pitfalls

Skipping the mathematical foundations and working entirely through high-level abstractions limits understanding at the point where abstractions fail or need customization. A programmer who does not understand what a projection matrix actually does cannot debug the artifacts that appear when the matrix parameters are wrong. Building linear algebra intuition is an investment that pays off throughout all graphics work.

Confusing the coordinate spaces — model, world, view, and clip space — is a persistent source of subtle bugs. Forgetting which space a calculation is being performed in, or failing to transform normals correctly (using the inverse transpose of the model matrix, not the model matrix itself), produces shading artifacts that are difficult to diagnose without a clear mental model of the pipeline.

Underestimating the GPU's parallel execution model when writing shaders leads to poor performance. Shaders execute in parallel across thousands of cores simultaneously, with no shared state between threads; algorithms written for sequential CPU execution are often invalid or inefficient when translated directly to shader code.

Milestones

Rendering a lit 3D scene from scratch — loading geometry, implementing a vertex shader for transformations, and a fragment shader for diffuse and specular lighting — marks foundational pipeline competency. Implementing a shadow map — generating depth information from the light's perspective and testing against it in the main pass — marks understanding of multi-pass rendering. Implementing a real-time or offline ray tracer that produces correct reflections, refractions, and global illumination marks advanced rendering knowledge.

Advanced practitioners work with physically-based rendering, deferred rendering pipelines, ray tracing hardware acceleration (RTX), and compute shader applications beyond traditional rendering.

Where to Specialize

Real-time rendering focuses on game engine graphics systems, frame optimization, and GPU-driven rendering. Offline rendering develops path tracing and photon mapping algorithms for visual effects. Shader art applies mathematical creativity to procedural visual effects and visual demos. Scientific visualization renders complex data in forms that reveal structure. VR and AR rendering addresses the specific challenges of low-latency stereoscopic rendering.

Tips for Success

• Learn linear algebra properly before writing shaders — vectors, matrices, and transformations are the language every graphics calculation is written in.
• Understand which coordinate space each calculation operates in — model, world, view, or clip — before debugging any transformation artifact.
• Write your own rasterizer from scratch at least once — implementing the pipeline in software clarifies every stage better than working only through a GPU API.
• Visualize normals and intermediate values when debugging shaders — outputting values as colors makes invisible data visible and diagnoses problems quickly.
• Study the GPU's parallel execution model before optimizing shaders — sequential thinking applied to parallel hardware produces incorrect or inefficient code.
• Read PBRT (Physically Based Rendering book) even for real-time work — the rendering mathematics it establishes underlies both real-time and offline approaches.
• Start with OpenGL or Vulkan before using a game engine's material system — understanding the raw pipeline makes engine abstractions interpretable and debuggable.

Practice Quests

Suggested activities for building your Computer Graphics skill at different intensities.

Notable Practitioners

Learning Resources

Ready to start tracking Computer Graphics?