Course overview

How to Design Graphics & Rendering Engines

53 modules
214 lessons
—
Part 1

Appendices

  1. Appendix A - Diagram Templates by StepSign in

  2. Appendix B - Mapping Concepts to Real-World APIs and EnginesSign in

  3. Appendix C - Readiness Checklists for Moving Up the Incremental LadderSign in

  4. Appendix D - Glossary of Canonical TermsSign in

Part 2

Course Setup and the Incremental Ladder

  1. Course Setup and the Incremental LadderSign in

  2. Why "Pixels to Photons": Rendering as an Integration ProblemSign in

  3. How to Use This Course: Modules as Rendering SlicesSign in

  4. The Incremental Ladder (Step 0 -> Step 7): Building Rendering Capability Without Losing BoundariesSign in

  5. The Course Lenses: Five Ways to Look at the Same FrameSign in

  6. Diagram Legend and Notation Types: Making Rendering Boundaries VisibleSign in

Part 3

What Is a Rendering Engine?

  1. What Is a Rendering Engine?Sign in

  2. Rendering Engines vs Game Engines vs UI/Compositing: Responsibilities and BoundariesSign in

  3. Core Responsibilities: Transforms -> Shading -> Composition -> Output as the Minimal Engine ContractSign in

  4. Real-Time vs Offline at a High Level: Budgets, Quality Targets, and Architectural ImplicationsSign in

Part 4

Pixels, Color, and Raster Images

  1. Pixels, Color, and Raster ImagesSign in

  2. Pixels, Resolution, Aspect: Sampling the World into a Grid and the Consequences for AliasingSign in

  3. Color Channels and Color Spaces: Linear vs Gamma Concepts, and Why Wrong Space Breaks LightingSign in

  4. Framebuffers and Presentation: Render Targets and Swap Chains as the Display Boundary (Conceptual)Sign in

Part 5

Coordinate Spaces

  1. Coordinate SpacesSign in

  2. Local, World, View, Clip, Screen: The Canonical Space Ladder and What Each Space Is ForSign in

  3. 2D vs 3D Coordinate Systems: Why the Same Math Underlies Both but Different Conventions MatterSign in

  4. Transform Stacks Conceptually: Translation/Rotation/Scale Composition as the Engine's Spatial ContractSign in

Part 6

The Modern GPU Pipeline

  1. The Modern GPU PipelineSign in

  2. Fixed-Function vs Programmable Stages: What Is Baked Into Hardware and What You ControlSign in

  3. Vertex to Fragment to Blend: The End-to-End Dataflow of a Draw CallSign in

  4. API-Agnostic Pipeline Thinking: Designing Around Concepts Rather Than a Specific Graphics APISign in

Part 7

Diagramming Rendering Systems

  1. Diagramming Rendering SystemsSign in

  2. Draw-Call Flow Diagrams: App -> Command Recording -> GPU Submission as the Execution BoundarySign in

  3. Transform Flow Along the Pipeline: How Coordinates Change at Each Stage and How to Debug MistakesSign in

  4. Layered Renderer Diagrams: Scene Representation, Culling, Passes, Post-Processing as Separable SubsystemsSign in

Part 8

Step 0 Drawing 2D Geometry

  1. Step 0 Drawing 2D GeometrySign in

  2. Lines, Triangles, Quads: The Primitive Vocabulary of Raster EnginesSign in

  3. Screen-Space vs World-Space Primitives: Choosing Coordinate Conventions for 2D ScenesSign in

  4. Textured Quads: Mapping Images to Geometry as the First Bridge to MaterialsSign in

Part 9

Step 0 Transforming Geometry

  1. Step 0 Transforming GeometrySign in

  2. Object -> World -> View -> Projection: Composing Transforms as the Canonical Render PathSign in

  3. Orthographic vs Perspective Projections: What Projection Choice Implies for Depth and ScaleSign in

  4. The Camera as "Moving the World": Debugging Camera Transforms and Common Sign ErrorsSign in

Part 10

Step 0 Rasterization and Sampling

  1. Step 0 Rasterization and SamplingSign in

  2. Triangles to Fragments: Rasterization as a Sampling ProcessSign in

  3. Depth and Visibility: Z-Buffer Intuition and Why Ordering Matters Less Than You ExpectSign in

  4. Texture Sampling Basics: How Fragment Shaders Look Up Texels and Where Aliasing BeginsSign in

Part 11

Step 0 Simple 2D Rendering Pipeline

  1. Step 0 Simple 2D Rendering PipelineSign in

  2. Sprites and UI Elements: Building a Minimal Retained Model or Immediate Draw LayerSign in

  3. Layering and Z-Order: Compositing Discipline for Predictable 2D ScenesSign in

  4. Alpha Blending: Transparency Basics and the First Encounter with Ordering ProblemsSign in

Part 12

Step 0 Minimal 3D Rendering Pipeline

  1. Step 0 Minimal 3D Rendering PipelineSign in

  2. Upload Mesh, Use Camera, Draw: The Smallest 3D Loop That Demonstrates the Full Transform ChainSign in

  3. Frame Lifecycle: Update -> Record -> Submit -> Present as the Core Engine HeartbeatSign in

  4. OS/Window Integration Boundary: The Platform Edge Where Rendering Meets PresentationSign in

Part 13

Step 1 Shaders as Programs on the GPU

  1. Step 1 Shaders as Programs on the GPUSign in

  2. Vertex and Fragment Shaders: Where Geometry Becomes PixelsSign in

  3. Shader Inputs: Attributes, Uniforms, Push Constants, Textures as Explicit Interface ContractsSign in

  4. Compilation and Linking: Managing Shader Build Artifacts as Part of the Engine ToolchainSign in

Part 14

Step 1 Materials and Parameterization

  1. Step 1 Materials and ParameterizationSign in

  2. Materials as Shader + Parameters: Separating "What Code Runs" from "What Values Drive It"Sign in

  3. Surface Parameters: Color, Roughness, Metalness-Like Concepts and Why They Reduce Content AmbiguitySign in

  4. Parameter Maps: Albedo/Normal/Roughness and How Texture Conventions Become Engine ContractsSign in

Part 15

Step 1 Texturing and Sampling

  1. Step 1 Texturing and SamplingSign in

  2. UVs and Texture Mapping: The Address System for Surface DetailSign in

  3. Filtering Concepts: Nearest vs Linear and Why Filtering Changes Perceived Material PropertiesSign in

  4. Mipmaps and Aliasing: Reducing Shimmering by Trading Detail for StabilitySign in

Part 16

Step 1 The Rendering Equation Without the Math Pain

  1. Step 1 The Rendering Equation Without the Math PainSign in

  2. Incoming Light to Outgoing Light: The Conceptual Inputs and Outputs of ShadingSign in

  3. BRDF Intuition: How the Surface Responds as a Programmable ModelSign in

  4. Integration as an Idea: Why Light Comes From Many Directions Even if You Approximate ItSign in

Part 17

Step 1 Material Systems in Engines

  1. Step 1 Material Systems in EnginesSign in

  2. Material Graphs vs Parameter Blocks: Flexibility Versus Predictability and PerformanceSign in

  3. Material Instances: Reusing a Base Material with Different Parameters as a Content-Scaling StrategySign in

  4. Multiple Shading Models: Supporting Variety Without Exploding Engine ComplexitySign in

Part 18

Step 1 Shader and Material Abstractions

  1. Step 1 Shader and Material AbstractionsSign in

  2. Decoupling Engine Logic from Shader Source: Maintaining Stable Interfaces Across RefactorsSign in

  3. Cross-Platform Shader Handling: API-Agnostic Strategies That Avoid Leaking Backend DetailsSign in

  4. Permutations and Variants: Controlling Combinatorial Growth in Features and Quality TiersSign in

Part 19

Step 2 Local Illumination Models

  1. Step 2 Local Illumination ModelsSign in

  2. Diffuse and Specular: Splitting Response into Conceptually Distinct LobesSign in

  3. Classic Models: Lambert and Simple Specular as the Baseline ApproximationsSign in

  4. Multiple Light Types: Directional, Point, Spot and How Each Changes Attenuation and CostSign in

Part 20

Step 2 Modern Shading Models (High-Level)

  1. Step 2 Modern Shading Models (High-Level)Sign in

  2. Energy Conservation and Roughness: Why "Physically Inspired" Reduces Content Tuning ChaosSign in

  3. Environment Lighting: Image-Based Lighting Concepts and the Content Dependencies It IntroducesSign in

  4. Consistency Across Scenes: Shading as an Engine-Wide Contract, Not Per-Asset ArtistrySign in

Part 21

Step 2 Shadows

  1. Step 2 ShadowsSign in

  2. Shadow Mapping Flow: Rendering Depth from Light and Using It at Shading Time (Conceptual)Sign in

  3. Partitioned Approaches: Cascaded and Partitioned Strategies as a Response to Scale and Resolution LimitsSign in

  4. Soft Shadows Conceptually: Penumbra, Filtering, and the Cost of PlausibilitySign in

Part 22

Step 2 Ambient and Indirect Lighting (Conceptual)

  1. Step 2 Ambient and Indirect Lighting (Conceptual)Sign in

  2. Ambient Terms: Why They Exist and Why They Are Often Visually Wrong but Operationally CheapSign in

  3. Indirect Lighting at a High Level: What Global Illumination Tries to Capture ConceptuallySign in

  4. Approximations and Baking: When You Precompute Light to Buy Back Frame TimeSign in

Part 23

Step 2 Normal Mapping and Detail

  1. Step 2 Normal Mapping and DetailSign in

  2. Normals as Shading Inputs: Why Surface Orientation Is the Core of LightingSign in

  3. Tangent-Space Normal Mapping: Adding Detail Without Adding TrianglesSign in

  4. Combining Geometry and Normal Detail: Avoiding Artifacts from Mismatched Scale and FilteringSign in

Part 24

Step 2 Lighting Architectures in Real-Time Engines

  1. Step 2 Lighting Architectures in Real-Time EnginesSign in

  2. Forward vs Deferred (Conceptual): Moving Cost Between Shading and CompositionSign in

  3. Many Lights at Scale: Managing Light Lists, Culling, and Shading Cost GrowthSign in

  4. Simplicity vs Flexibility vs Performance: Why Lighting Architecture Is an Engine Identity DecisionSign in

Part 25

Step 3 2D Rendering Models

  1. Step 3 2D Rendering ModelsSign in

  2. Immediate Mode: Draw-Per-Frame Simplicity and Why CPU Overhead Becomes the LimiterSign in

  3. Retained Mode: Scene Graphs and Retained Objects as a Batching and Tooling EnablerSign in

  4. Composition for UI/HUD: Layering Policies and the Interaction Between 2D and Post-ProcessingSign in

Part 26

Step 3 Sprites, Tilemaps, and Vector Graphics

  1. Step 3 Sprites, Tilemaps, and Vector GraphicsSign in

  2. Sprite Batching and Atlases: Reducing Draw Calls by Changing Content RepresentationSign in

  3. Tilemaps and Parallax: Organizing Large 2D Worlds as Repeated StructureSign in

  4. Vector Primitives Conceptually: Paths and Strokes and Why They Imply Different Tessellation StrategiesSign in

Part 27

Step 3 Text Rendering

  1. Step 3 Text RenderingSign in

  2. Glyphs and Atlases: Caching as the Difference Between Usable and Unusable Text SystemsSign in

  3. Hinting and Scaling Concepts: Why Text Quality Is a Sampling and Layout ProblemSign in

  4. Text in the Render Pipeline: Ordering, Blending, and Performance Interactions with UISign in

Part 28

Step 3 3D Scene Representation

  1. Step 3 3D Scene RepresentationSign in

  2. Scene Graphs vs Flat ECS-Style Lists: Hierarchy Benefits Versus Update and Traversal CostSign in

  3. Cameras, Lights, Meshes, Bounds: The Minimal 3D Scene VocabularySign in

  4. Spatial Partitioning Concepts: Grids and Trees as Visibility and Query AcceleratorsSign in

Part 29

Step 3 Visibility and Culling

  1. Step 3 Visibility and CullingSign in

  2. Frustum Culling: Removing Invisible Work Before It Becomes GPU CostSign in

  3. Backface and Occlusion Concepts: Visibility Pruning Trades Compute for BandwidthSign in

  4. Culling Complexity vs Wins: When the Cure Becomes Worse Than the DiseaseSign in

Part 30

Step 3 Combining 2D and 3D in One Engine

  1. Step 3 Combining 2D and 3D in One EngineSign in

  2. UI Overlays and HUDs: Compositing Boundaries and Render OrderingSign in

  3. 2D in 3D: Billboards and Screen-Space Effects as Hybrid RepresentationsSign in

  4. Render Order and Post: Managing Transparency, Post-Processing, and Composition ConsistencySign in

Part 31

Step 4 Real-Time Rendering Constraints

  1. Step 4 Real-Time Rendering ConstraintsSign in

  2. Frame Budgets: Stable Frame Time as a User-Facing ContractSign in

  3. Spikes vs Throughput: Why Occasional Stalls Feel Worse Than Slightly Lower Average QualitySign in

  4. Interactivity vs Quality: Making Approximation Choices Explicit Per FeatureSign in

Part 32

Step 4 Offline Rendering Characteristics

  1. Step 4 Offline Rendering CharacteristicsSign in

  2. Quality Without Hard Budgets: Trading Time for Accuracy and the Operational ImplicationsSign in

  3. Samples and GI Conceptually: Why Noise and Convergence Dominate Offline PipelinesSign in

  4. Render Farms and Batch Pipelines: Distributed Rendering as a Compute Orchestration Problem (Conceptual)Sign in

Part 33

Step 4 Baking and Precomputation

  1. Step 4 Baking and PrecomputationSign in

  2. Lightmaps and Probes: Precomputing Expensive Lighting into Textures and VolumesSign in

  3. Offloading Runtime Work: Shifting Computation from Frame Time to Build TimeSign in

  4. Dynamic vs Static Lighting: Splitting Content by Change Frequency as an Engine ConstraintSign in

Part 34

Step 4 Hybrid Pipelines

  1. Step 4 Hybrid PipelinesSign in

  2. Offline Precompute in Real-Time: Integrating Baked Data Without Losing FlexibilitySign in

  3. Real-Time Compositing of Offline Content: Layering Cinematics and High-Quality PassesSign in

  4. Cinematics vs Gameplay Rendering: Differing Quality Targets Inside One ProductSign in

Part 35

Step 4 Choosing Rendering Approaches Per Feature

  1. Step 4 Choosing Rendering Approaches Per FeatureSign in

  2. When to Accept Approximations: Cost-Benefit Decisions Under a Frame BudgetSign in

  3. Dynamic vs Static Splitting: Isolating Expensive Features to Avoid Global Budget CollapseSign in

  4. Feature-Level Decisions: Hair, Particles, and Water as Domain-Specific Trade SpacesSign in

Part 36

Step 5 Where Time Goes in Rendering

  1. Step 5 Where Time Goes in RenderingSign in

  2. CPU vs GPU Responsibilities: Submission, Culling, State Setup Versus Shading and BandwidthSign in

  3. Draw Calls and State Changes: Why "Too Many Small Things" Is a Common Failure ModeSign in

  4. GPU Bottleneck Taxonomy: Vertex, Fragment, Bandwidth and How Symptoms DifferSign in

Part 37

Step 5 Overdraw, Fill Rate, and Complexity

  1. Step 5 Overdraw, Fill Rate, and ComplexitySign in

  2. Overdraw Costs: Why Transparency and Layering Can Dominate Frame TimeSign in

  3. Depth Pre-Pass Philosophies: Reducing Wasted Shading by Paying Extra Passes (Conceptual)Sign in

  4. Resolution and MSAA-Like Costs: Trading Clarity for Bandwidth and Shading TimeSign in

Part 38

Step 5 Geometry Optimization

  1. Step 5 Geometry OptimizationSign in

  2. LOD Strategies: Reducing Geometry Cost Without Visible PoppingSign in

  3. Instancing: Amortizing Submission and State Across Repeated ObjectsSign in

  4. Mesh Optimization Concepts: Vertex Cache Behavior and Index Ordering as Hidden Performance LeversSign in

Part 39

Step 5 Texture and Memory Management

  1. Step 5 Texture and Memory ManagementSign in

  2. Texture Budgets and Streaming: Managing VRAM as a Constrained, Shared ResourceSign in

  3. Mip Control and Streaming Policies: Choosing What Stays Resident to Avoid ThrashSign in

  4. Texture Format Concepts: Block Compression Versus Uncompressed and the Quality/Performance TradeSign in

Part 40

Step 5 Resource Lifetime and Pools

  1. Step 5 Resource Lifetime and PoolsSign in

  2. Managing Buffers, Textures, Targets: Lifetime Discipline as the Antidote to Leaks and SpikesSign in

  3. Pools and Transient Allocations: Reducing Allocation Overhead and FragmentationSign in

  4. Fragmentation and Leaks: How Memory Failures Show Up as Stutters and InstabilitySign in

Part 41

Step 5 Profiling and Debugging Performance

  1. Step 5 Profiling and Debugging PerformanceSign in

  2. Profilers and Counters: Turning Frame Time Into EvidenceSign in

  3. CPU/GPU Sync and Pipeline Bubbles: Diagnosing Stalls as Boundary ProblemsSign in

  4. Building Internal Visualization Tools: Making Performance ExplainableSign in

Part 42

Step 6 Assets and Content as First-Class Citizens

  1. Step 6 Assets and Content as First-Class CitizensSign in

  2. Asset Types and Dependencies: Thinking in GraphsSign in

  3. Source vs Engine-Ready Formats: Conversion as a BoundarySign in

  4. Metadata and Versioning: Making Content ReproducibleSign in

Part 43

Step 6 Importers, Converters, and Build Pipelines

  1. Step 6 Importers, Converters, and Build PipelinesSign in

  2. Offline Conversion and Baking: Build-Time Work That Buys Runtime DeterminismSign in

  3. Re-Import and Change Detection: Keeping Iteration Fast Without Corrupting OutputsSign in

  4. Engine-Specific Formats: Optimized Representations Rather Than Raw ContentSign in

Part 44

Step 6 Material and Shader Authoring Tools

  1. Step 6 Material and Shader Authoring ToolsSign in

  2. Node-Based Material Editors: Enabling Artist Iteration While Preserving Engine ConstraintsSign in

  3. Shader Graph vs Hand-Written Code: Productivity Versus Control and Debugging BurdenSign in

  4. Live Preview and Iteration Loops: Shortening the Feedback Cycle Without Making Builds Non-ReproducibleSign in

Part 45

Step 6 Scene and Level Editors

  1. Step 6 Scene and Level EditorsSign in

  2. Editing Scenes In Context: Object Placement, Lights, Cameras, and the Need for Stable SerializationSign in

  3. Editing Materials and Post Effects: Authoring with Immediate Visual Feedback and Correct DefaultsSign in

  4. Saving, Loading, and Versioning Scenes: Avoiding Content Corruption in Collaborative WorkflowsSign in

Part 46

Step 6 Debugging and Visualization Tools

  1. Step 6 Debugging and Visualization ToolsSign in

  2. Diagnostic Views: Wireframe, Overdraw, Normals and What Each RevealsSign in

  3. Buffer Inspection Flows: Frame Capture and Pass Inspection (Conceptual)Sign in

  4. Visualizing Culling, LOD, and Light Complexity: Making Invisible Performance Costs VisibleSign in

Part 47

Step 6 Integrating Tools into the Engine Workflow

  1. Step 6 Integrating Tools into the Engine WorkflowSign in

  2. In-Editor vs External Tools: Choosing Integration Depth and Managing ComplexitySign in

  3. Asset CI and Build Pipelines: Treating Content as Build Artifacts with Tests and ReproducibilitySign in

  4. Collaboration Workflows: Artists, Tech Artists, Engineers and the Contracts that Keep Teams UnblockedSign in

Part 48

Step 7 Engine Architecture and Subsystems

  1. Step 7 Engine Architecture and SubsystemsSign in

  2. Core Subsystems: Resource Manager, Renderer, Scene System, Tools and Why Boundaries MatterSign in

  3. Platform Layer and API Abstraction: Isolating Backend Variability Without Hiding Essential ConstraintsSign in

  4. Game/App vs Renderer Boundary: Defining the Interface that Prevents Unbounded CouplingSign in

Part 49

Step 7 Render Graphs and Multi-Pass Rendering

  1. Step 7 Render Graphs and Multi-Pass RenderingSign in

  2. Render Pass Dependencies: Expressing Ordering and Resource Usage as an Explicit GraphSign in

  3. Render Graph as Description: Separating "What to Render" from "How to Schedule" (Conceptual)Sign in

  4. Post, G-Buffers, Offscreen: Composing Complex Pipelines Without Losing DebuggabilitySign in

Part 50

Step 7 Multi-Platform and Multi-API Rendering

  1. Step 7 Multi-Platform and Multi-API RenderingSign in

  2. Abstracting APIs Without Leaks: Deciding What Must Remain Backend-SpecificSign in

  3. Capability Differences: Designing Around Tiers Rather Than Assuming Uniform HardwareSign in

  4. Feature Detection and Quality Levels: Mapping Capabilities to Content and Shader PermutationsSign in

Part 51

Step 7 Extensibility and Plugin Architectures

  1. Step 7 Extensibility and Plugin ArchitecturesSign in

  2. Adding New Passes and Effects: Extension Points That Preserve Engine StabilitySign in

  3. Modularizing the Renderer: Isolating Experiments From the Stable CoreSign in

  4. Supporting Custom Pipelines: Enabling Variation Without Fragmenting the CodebaseSign in

Part 52

Step 7 Testing, Validation, and Stability

  1. Step 7 Testing, Validation, and StabilitySign in

  2. Visual Regression Testing: Golden Images and How to Manage Acceptable VariationSign in

  3. Performance Regression Testing: Preventing "Small Changes" From Breaking Frame BudgetsSign in

  4. Maintenance Over Time: Refactors, Deprecation, and Compatibility Across Hardware GenerationsSign in

Part 53

Step 7 Reference Architectures and Maturity

  1. Step 7 Reference Architectures and MaturitySign in

  2. Minimal Engine - A Stable Foundation You Can ShipSign in

  3. Intermediate Engine - Managing Growth Without Losing BoundariesSign in

  4. Advanced Engine - Explicit Policy, Capability Tiers, and Long-Term EvolutionSign in