Outline. Introduction to Game Programming Autumn Game architecture. The (classic) game loop. Fundamental concepts

Transcription

1 Introduction to Game Programming Autumn Game architecture [S. Madhav, 2014], Ch. 1. Game programming overview [J. Gregory, 2015], Ch Runtime object model architectures Juha Vihavainen University of Helsinki Outline Some fundamental concepts and terms Basic terms: "game", "game loop", "game engine, the management of time in games, and handling of updates of game objects Case: Gears of War (2006): illustrative statistics Game object model: inheritance hierarchies vs. composition Implementing the game loop On multithreading of rendering and updates of game world 2 The game loop ("tick") Fundamental concepts the basic loop that drives discrete-time simulation in games may also use multiple(nested) or multithreaded loops Representing time in games the difference between "real time" and "game time" how to make logic (updates) a function of delta time (the real time that has elapsed after the last update point) why/how to control display rate? (implement frame limiting and/or frame dropping) Game objects (also known as entities, actors) how to define different kinds/types of game objects need to integrate game objects into the game loop (to find them) The (classic) game loop Overall flow control for the entire game program: keeps looping around until the user quits out of the game Each iteration of the loop produces one frame (snapshot image) e.g., 60 FPS (frames per second): the loop completes 60 iterations in one second most common frequences are 30 (the delay being 33 ms) and 60 (the delay is 17 ms) Basic logical scheme while game is running do process inputs; (1) update game world; (2) generate outputs; (3) 3 4

2 (1) Process inputs Any input devices, including keyboard, mouse, joystick Other forms of input (stored or generated) include instant replay playback data: to watch a recorded sequence of game play (say, the last served ball in a game of tennis) for online games, need to receive and process data from network and propagate onward... on a mobile device, can include data from GPS (Global Positioning System), accelerometer, gyroscope, or real camera (for modified view of reality in augmented reality games) 5 (2) Updating the game world Iterate through (currently active) game objects in the world and update them (or letting them update () themselves) could include hundreds or thousands of objects (or more) we will cover this in more detail later (3) Generating outputs Most common and expensive is usually graphics (2D/3D) Also audio, including sound effects, music, and dialogue Controller rumble (force feedback) For multi-player online games, need to send data to network 6 (1-3) Hypothetical game loop example while player.lives > 0 do // a Pac-Man-style game JoystickData d:= grab raw data from joystick; // process inputs update player.position based on d; // update game world for each Ghost g in world if player collides with g then Note. No game engine, here. Logic/control is kind centralized. kill either player or g; else update AI for g based on player.position; // Pac-Man eats power pellets and..... // generate outputs draw graphics & update audio; Note. Procedural approach. The behavior is hard-coded; this kind of tailored solution does not necessarily scale up. "Multiple interactions within the program" Case: Gears of War (2006) When usingo-o game engines, thehiddengame loop uses some form of callbacks(virtual functions, methods, messages..) 7 8

3 Case: gameplay simulation in Gears of War Models the state of the game world as interacting objects that evolve over time About 1000 distinct gameplay classes have dynamic state and behavior (member functions) About 10,000 currently active gameplay objects each time a gameplay object is updated, it typically touches (affects) 5-10 other objects Gears of War a futuristic third-person shooter Epic Games, 2006 (dated but relevant) Unreal Engine made by Epic Games updates (frames) per second, attempting more or less "photorealistic" quality (3D scene, details, lighting, shadows) Written in C++ or a custom scripting language (textual/visual) high-level, object-oriented code imperative programming style UnrealScript (late) Kismet => Blueprints lots of dynamic objects to manage (created/updated/destroyed) 9 10 Game development: Gears of War (Epic Games) Initially for Xbox 360 (2006); a Windows version (2007) sold over three million copies in ten weeks online multiplayer features.. Resources Game is a repository for itsobjects; in Unity, a level / scene containsand owns its game objects. A general view of game architecture: about 10 programmers about 20 artists (!) about 24 month development cycle (not incl. the ready engine) about $ 10 million budget Software dependencies Note. A game object may be composed of many subcomponents to handle drawing, physics, scripting.. 3D model (plus more) one "middleware" game engine (its own Unreal Engine 3) about 20other support libraries graphics APIs, sound, input, etc. ~dpw/popl/06/tim-popl.ppt Additionally, objects strongly interact with each other (physically, or via game logic). Static assets (no state) are shared for efficiency These numbers given by Tim Sweeney (Epic Games)

4 A hypothetical architecture for a 3rd-person shooter potentially anything Notes on the sample game architecture All player characters and game objects are contained in a game level (possibly using non-owning aggregation) Game objects have position, rotation, and velocity: can be moved around and touch/collide with each other Both players and enemies are "game characters" can identify generalizations and specializations => class hierarchy Transform: pos, rotate, scale The scene includes parts such as crates, barrels, etc. that have geometry (i.e., shape), are animated, and simulated by physics: generalize them as a class "game dynamic objects" ("rigid bodies", in game physics) Game triggers have (only) volumes and locations in a level, and often provide health power-ups, coins, ammo, generate events, etc. A game camera may have its own logic, e.g., how to follow the player character or have "scripted" actions; so need a specific class Also, e.g. heads-up display (HUD) shows current status (health, ammo); often not part of the 3D level (but can) but a separate display layer Using different types of game objects (Madhav) (1) Drawn and updated any character, creature, or otherwise movable object that's also visible in the world in Super Mario Bros.: Mario, any enemies, all dynamic entities (2) Only-drawn static objects, such as buildings, mountains, sky in the background of a level/scene (3) Only-updated cameras (presuming no mirrors reflect the camera object) trigger volumes(for doors, hidden secret passageways, etc.) the whole game/level (depending on the game logic) Basic GameObject implementation (Madhav) Create a root GameObject class Create two interfaces: Drawable Updateable See(Madhav, pp ). The three types (1) - (3) of game objects each implement the right combination of the interfaces class UpdateableGO : GameObject, Updateable... class DrawableGO : GameObject, Drawable... Create separate lists of drawableand updateableobjects, and add to these lists as appropriate 15 16

5 ClassicO-O approach: In an Unrealgame, virtually all classes in the game inherit from a single, common base class (Actor) A sample of class hierarchy from UT 2004 Using (1) plain inheritance vs. (2) aggregation (1) (1) A hypothetical game-object class hierarchy (object-centric approach); possible overuse of inheritance. [Gregory, pp ] Implementation, e.g.: As usual, all common functionality exists at the root of the hierarchy, while subclasses add increasingly specific functionality Such monolithic class hierarchies may prove difficult to manage.. (2) The hierarchy, here refactored to favor composition over inheritance (property-centric); a GO actsasa container for properties (2) ~ Unity Real-time simulation: the main game loop The game loop (again, very simplified) A game is a kind of discrete-time simulation system thestateof thesystem is updatedand then a snapshotis displayed on thescreen, at some distinct successive points in time nothing happens between, only the simulation clock advances so, changesaredoneas onebatch, all at one simulated game-time point(compare with "atomic transactions : use the same global time) A main game loop runs repeatedly during each iteration of the loop, game systems calculate and update their state for this discrete-time step game logic, physics simulation, animations, game AI, etc. the results are displayed as a snapshot of the game world render graphics, emit sound, and possibly produce other outputs (such as force feedback on the joypad) 19 while true do process input; calculate game logic depending on state and input; render; Potential problems for this approach: may need to add a delay here to provide a steady frame rate note the dependence on CPU and rendering speeds runs at themaximum speed (may begood - ornot) game speed is determined by load and respective speeds of CPU/GPU => the game is updated at variable rate if the frame rate (fps) varies, it may cause problems if we don't take elapsed time into account when updating state 20

6 (1) Real time Real time vs. game time amount of time elapsed in the real world (for the player) note that frame rate(fps) is always expressed in this real time (2) Game time amount of time elapsed in the game world simulation if the game is paused, no game time passes (but still frames are displayed so the game loop needs to keep running) game time may be slower or faster than real time (for example, bullet time being slower; collision of galaxies being faster) games may even have game time go in reverse (~ time travel?) Animationsoften need to usetheir own separatetiming systems, can advance in various speeds(a runner must animate faster, too) 21 Game logic as a function of delta time Consider a classical 2D game where screen pixels are used as units The following code will run differently on different systems enemy.position.x += 5 // update per each frame (loop cycle) At 30 FPS, the enemy would move 150 pixels/sec (original) At 60 FPS, the enemy would move 300 pixels/sec (twice that) Instead, need to make the speed a function of delta time(the amount of elapsed real time since last frame/update) Say, need speed 150 pixels per second Multiply 150 by the elapsed portion of second enemy.position.x += 150 * deltatime; // e.g. 1/60 sec. (17 ms) // e.g., check 60 fps => per sec ~ 60 * 150 * 1/60 22 Game loop with delta time whilegame is running do realdeltatime := elapsed time since last frame/update; gamedeltatime := realdeltatime * gametimefactor; // process inputs... update game world with gamedeltatime; // render outputs... use to easily stretch (slow down) or quicken time Note. Game time is always calculated from real time. 23 Problems with "unsteady" frame rate Basic physics may have wildly different behavior based on frame rate physics requires high and steady rate of updates game characters may move inaccurately at lower frame rates online games may not work with variable local frame rates Solution (for the classic game loop) use frame limitingto lock down the frame rate to a specific value: pause to wait until the required delta time has elapsed (but this may unnecessarily steal time from potential calculations) Another potential problem when updates start lagging behind(updates take longer than given by the target delay time per frame) solution: framedropping: skip allgraphicsprocessingand frames' output part and proceed with only game logic calculations Advanced solution: use another loop to do physics at a faster, steady rate 24

7 On multi-threaded game loops Modern CPUs have multiple cores: can run multiple lines of execution (threads) at once, in a true parallel way games should take advantage of all available cores Most current AAA games and game engines actually use customized multithreaded systems of their own Note. GPUs are ultra parallel by hardware design for vector & matrix calculations, and typically do thesame calculationsfor allthedata values (vertices) of a 3D model One strategy: multithreaded "split" loop Graphics (rendering) runs on one thread Everything else runs on a second thread (logic, physics) If graphics takes 30 ms/frame and everything else takes 20 ms/frame: traditional loop takes 50 ms/frame ( 20 fps) "split" loop is as slow as the lowest of the two threads, so 30 ms/frame ( > 30 fps); see the picture, on the next slide "Split" loop: advantages & disadvantages The jump is delayed (at least one frame) due to input lag. One problem: input lag Amount of time it takes for a (player) action to have a visible effect on screen Rendering thread is at least one calculation step (frame) "behind" the gameplay thread The higher the input lag, the more sluggish (slow to react to controls) the game feels For some genres (such as highly-tuned combat games), a high input lag may be unacceptable Bad luck here: the processing of the press is postponed until the next frame. A similar problem may occur when delivering buffered messages/events between game subsystems and components 28

8 Finally : a (simplified) single-thread game loop A GE architecture(antti Hietasaari, 2016) simplified from GEA book while game is running var time := Game.Time; // the current real time var realdeltatime:= time - lasttime; lasttime:= time; var gamedeltatime := realdeltatime* Game.TimeFactor; // (1) process inputs... poll input and receive/deliver any messages/events... // (2) update game world for var obj: Updateable in Game.UpdateableObjects obj.update (gamedeltatime); // (3) generate output for var obj: Drawable in Game.DrawableObjects obj.draw(); if realdeltatime < Game.TargetDelay then // frame limiting Game.Sleep (Game.TargetDelay-realDeltaTime); (Utility subsystems) (Game-specific subsystems) (Game-engine subsystems) (Game-engine core systems) (Resource files: loading/unloading) (memorymgt, testing, math, strings, platform independence, 3rd-party llibraries) 29 30