Advanced Facilities for Real-Time Games
A practical course on the design and implementation of modern game engines and advanced facilities provided by these engines. Such facilities include systems for rendering 3D scenes; simulating physics; playing animations; game AI; and enabling multi-player games. Students will undertake a significant game development project.
Study notes
Independent, AI-drafted study guide · Public sources linked below · Added November 5, 2026
2026–27 calendar alignment with linked Winter 2021 public game-engine materials; independent design notes. Specific engine APIs and versions in historical materials are not presented as current requirements.
A game engine coordinates several time-sensitive systems
An engine organizes rendering, physics, animation, audio, input and gameplay state. These systems need explicit interfaces and update order because each can depend on another's output. Separate reusable engine mechanisms from game-specific rules. Data-oriented layouts and entity-component designs can improve iteration and memory access, but they are tools rather than requirements for every game. Profile the actual workload before replacing a clear design with a more elaborate architecture.
References: Carleton 4501 official calendar record · Anil Somayaji: Game Engines Winter 2021 public notes
Fixed simulation steps and variable rendering
Physics and gameplay updates often use a fixed time step for predictable numerical behaviour, while rendering runs at the display's available pace. An accumulator collects elapsed wall time and executes as many fixed simulation steps as needed. Rendering can interpolate between saved states. Cap catch-up work appropriately to avoid a spiral in which missed frames create more work than the engine can recover. Changing a time step also changes simulation behaviour and is not simply a visual setting.
References: Carleton 4501 official calendar record · Anil Somayaji: Game Engines Winter 2021 public notes
Rendering systems manage visibility and resources
A renderer selects visible objects, submits geometry and evaluates materials under lights and camera transforms. Frustum culling rejects objects outside the view before detailed drawing, while level of detail reduces distant complexity. Organizing draw calls can reduce expensive state changes, but overaggressive batching can prevent useful culling. Asset loading and GPU-resource lifetime are part of frame-time performance. Measure worst-frame spikes as well as average frame rate because pauses affect playability.
References: Carleton 4501 official calendar record · Anil Somayaji: Game Engines Winter 2021 public notes
Collision detection is distinct from response
A broad phase finds potentially colliding objects cheaply; a narrow phase determines actual contact geometry. The response then changes velocities or constraints according to the simulation model. Fast objects can pass through thin obstacles between discrete samples, motivating continuous collision detection or swept tests. Do not confuse a trigger event with a physically resolved contact. Stability depends on time step, integration method, constraint handling and scale conventions as well as collision geometry.
References: Carleton 4501 official calendar record · Anil Somayaji: Game Engines Winter 2021 public notes
Animation and decision systems share state carefully
Skeletal animation transforms a hierarchy of joints, and blending combines compatible poses over time. Gameplay events should align with meaningful animation moments rather than assuming every clip has the same duration. Behaviour trees or state machines can organize game AI; pathfinding supplies routes but does not by itself produce natural movement. Keep authoritative gameplay state separate from purely visual interpolation so a rendering delay does not silently change collision or combat outcomes.
References: Carleton 4501 official calendar record · Anil Somayaji: Game Engines Winter 2021 public notes
Multiplayer adds latency and authority decisions
A server-authoritative design controls important shared state and validates client requests. Clients can predict local movement for responsiveness and reconcile it when authoritative updates arrive. Remote entities are often interpolated from recent snapshots. These methods trade latency, smoothness and correction artifacts; they do not remove network uncertainty. Define which events can be replayed safely and how conflicting predictions are handled. Deterministic lockstep requires stronger simulation agreement than merely using the same game assets.
References: Carleton 4501 official calendar record · Anil Somayaji: Game Engines Winter 2021 public notes
Worked frame budget and project verification
At 60 displayed frames per second, one frame has approximately 16.7 milliseconds. If CPU simulation takes 8 ms and CPU submission takes 4 ms, adding a synchronous 10 ms asset load can exceed the CPU budget even when average performance looks adequate. GPU work can overlap CPU work, so summing all profiler times naively can mislead. Verify a complete gameplay loop and representative worst scenes, then prioritize the measured bottleneck rather than the most visually complex subsystem.
References: Carleton 4501 official calendar record · Anil Somayaji: Game Engines Winter 2021 public notes
Practice & worked answers
Original exercises for this guide.
1. If a physics step is 0.02 seconds and 0.05 seconds accumulates, how many steps can run and what remains?
Show worked answer
Run two steps, advancing simulation by 0.04 seconds, and retain 0.01 seconds in the accumulator for the next frame.
2. Does client prediction mean a client may decide the permanent multiplayer result?
Show worked answer
Not in a server-authoritative design. Prediction supplies temporary local responsiveness; authoritative state can correct it, and important requests still require validation.
Public notes & references
Course sources establish the scope above. Reference materials support the explanations; linked lecture notes and books remain with their authors.
2026
Topics
- Architecture of games and game engines.
- Advanced rendering techniques: deferred rendering, global illumination heuristics
- Animation: key-frame animation, mesh animation, character animation, locomotion.
- Rigid-body physics: collision detection, animation based on physical simulation.
- Shape modeling and acquisition.
- Networking, AI, pathfinding.
Readings
- Game engines: Jason Gregory, “Game Engine Architecture”, Second Edition, CRC Press, 2015.
- Computer graphics: Peter Shirley, Steve Marschner, “Fundamentals of Computer Graphics”, Third Edition, CRC Press, 2009.
- Real-time rendering, physically-based rendering: Tomas Akenine-Möller, Eric Haines, and Naty Hoffman, “Real-time rendering”, Third Edition, A. K. Peters, 2008.
- Animation: Rick Parent, “Computer Animation: Algorithms and Techniques”, Third Edition, Morgan Kaufmann, 2012.
- Gregory, “Game Engine Amazon, used CAD $142 Architecture” Shirley and Marschner, Amazon, used CAD $167 “Fundamentals of Computer Graphics” Akenine-Möller, Haines, and Amazon, used CAD $157
- Hoffman, “Real-time rendering” Parent, “Computer Animation: Amazon, used CAD $100 Algorithms and Techniques”
Prerequisites & course information
Prerequisite(s): COMP 3501 . Lectures three hours a week.