Glossary of All Footnote Terms

.geo files- Horde3D's processed file for model and animations, optimized for more efficient rendering. The file is processed through the Horde3DUtil library and done prior to runtime. ↩

A*- pronounced "A star", this is an algorithm that is widely used in pathfinding and graph traversal. It is an extension of Dijkstra's algorithm that also uses heuristics to guide its search for better performance. ↩

Airlock- in games, this refers to an area in which loading of the next chunk/section of the map is being performed. Within this zone the next and previous sections can both be in memory, or with limited memory only the next is being loaded into memory. In the first case the player can enter both the previous and next zones (once loading completes), however in the latter the player can neither advance or backtrack their game's progress while the loading happens. ↩

Allocator- a data structure that encapsulates memory management and doles out memory on request. There are different types of allocators based on the needs (amount and lifetime) of the memory. ↩

Animation-blended system- a graph of multiple animations and transitions from an animation to another, i.e., a idle animation to a walking animation, and the blend system is how the animations are "mixed" together. It extrapolates from the starting animation to the ending animation. ↩

Application context- the context, the set of data required to interrupt and continue a task, of an application. ↩

Asynchronous- typically associated with parallel programming, this is when a task runs and completes separately from the main application/thread. ↩

Audio renderer- a system which plays/outputs spatialized sound, sound that is positioned in the world. ↩

Autodesk 3ds Max- formerly 3D Studio and 3D Studio Max, is a professional 3D computer graphics program for making 3D animations, models, games, and images. ↩

BINK- the defacto video codec for games created by Rad Tools.↩

Backface culling- the technique of performing visibility checks on a mesh to not render the back face (face not facing the camera). ↩

Batching- when many instances of graphics data are bundled together and handled by the GPU in a single draw call operation. Issuing draw calls can be expensive, so batching is a good technique to speed up a renderer. ↩

Big O notation- a mathematical notation that describes the limiting behavior of a function when its argument approaches a value, typically infinity. It's usually used to evaluate the performance of an algorithm. ↩

Binary files- files stored in binary format, a format that is easily computer-readable but not really human readable. These are more compact in size than human readable files. ↩

Binary size- the size of the binary files built from source code and other assets. ↩

BitSquid- more modernly known as Autodesk Stingray, is a discontinued game engine from Stockholm, Sweden. End of sale was announced for January 7, 2018, and afterward it became a plugin for Autodesk 3DS Max known as 3DS Max Interactive. ↩

Blender- an open-source 3D computer graphics software used in creating 3D models, animations, and interactive applications. ↩

Boilerplate code- a section of code that has to be included in many places with little to no alteration. ↩

Box2D- an open source C++ engine for simulating rigid bodies in 2D. Box2D is developed by Erin Catto and has the zlib license. ↩

Branching- hen the processor needs to evaluate something in order to determine what code to run next. It tends to be very wasteful of processing time because of the typical instruction pipeline on a computer.

Breadth-first search (BFS)- an algorithm for traversing or searching tree or graph data structures; it starts at the tree root and explores all neighbor nodes before looking at children nodes. ↩

Broad-phase detection- a physics simulation phase performed by constructing a tree of simple primitives (either sphere or box) where the complex collider shapes are simplified into these shapes. Then iterating through these checks to determine if the simple shapes are colliding (this is a quicker calculation). The narrow-phase happens after the broad phase by checking the exact shape of the collider which are typically more complex shapes, such as capsules and object-bounding boxes (obb). ↩

Build engineer- the engineer in charge of the infrastructure that builds a software application, as well as testing and troubleshooting code for before the software's release.↩

Build farm- a cluster/group of servers whose job is to compiler programs remotely, typically used in cross-platform development, testing, and speeding the compilation process. ↩

Builder- a tool used to process assets from their editable forms (files editable by external software) into a more compact, unreadable file to be used by the engine for a game. The file format is typically proprietary and specific to the engine, and engine metadata is stored within the file. ↩

Bullet Physics- a real-time physics simulation library, a physics engine, which simulate collisions for soft and rigid body dynamics. ↩

CDLOD- short for the paper titled Continuous Distance-Dependent Level of Detail Rendering Heightmaps. It describes a technique for GPU-based rendering of heightmap terrains. ↩

CMake- a cross-platform, open-source application for managing the build process of software in a compiler-independent way. ↩ ↩

Call stack- a stack data structure that stores the information about the active routines of a computer. It can be walked up/down into the callee functions and function definitions, respectively. ↩

Casey Muratori- a game engine developer and creator of Handmade Hero, a web series documenting his efforts in building a game engine from scratch. We interviewed him as part of this project, and his interview can currently be found here. ↩

Client-server model- in networking where there is one central server that all other machines (the "clients") connect to. This server is typically the authority on all important and possibly conflicting information. ↩

Cocoa- Apple's native object-oriented API for macOS. ↩

Compute shader- a shader stage that is used entirely for computing arbitrary information. While it can do rendering, it is generally used for tasks not directly related to drawing triangles and pixels. ↩

Construct On-Demand Technique- in the context of the singleton pattern, this means that the single instance is only constructed when first requested. We can utilize this nature to control initialization order by manually invoking the getter for the singletons in the right order. ↩

Core render loop- the loop where the rendering function is called. The way the rendering occurs/is called varies from engine to engine, but is usually performed at the end of the main game loop. ↩

Core- refers to a CPU in a multi-core processor, it is one of the processing units in the single computing component that read and execute machine instructions. ↩

Cross product- the 3D math operation where the input is two vectors and the output is one vector that's perpendicular to both input vectors. However, the direction of the output vector depends on whether the space is defined as left handed or right handed.↩

Culling- the early rejection of objects being passed through the render pipeline, because they don't contribute to the final image. ↩

DLL- a dynamic-linked library which is Microsoft shared library concept which can be transported around easier than a project and contains information about the compiled project. ↩

Data locality- essentially accessing data in as nearby of code as possible to utilize caches most effectively. Robert Nystrom covers it really well in this chapter from Game Programming Patterns. ↩

Decision tree- a graph/tree data structure that maps decisions and their possible outcomes. ↩

Defragmentation- the process of reducing fragmentation, where fragmentation is where memory is used inefficiently with lots of gaps in between used memory chunks. In this context, defragmentation is used in the sense of keeping the rooms fully utilized, not wasting space on a fairly empty room. ↩ ↩

Delimiter- a sequence of one or more characters used to specify the boundary between separate regions in text or other data streams. An example would be the comma character for comma-separated values. ↩

Dependencies- links that are required between programs, such that one program is reliant on another. ↩

Dependency injection- a technique where one object supplies the dependencies of another object. A dependency is something that one object needs to run correctly, and injection is the process of passing one object to another. ↩

Depth culling- the process of deciding which elements to render based on the distance from the camera and if it is being hidden by another element. ↩

Depth peeling- a method of order-independent transparency when rendering 3D geometry. It determines what should be drawn on top by rendering multiple passes of a scene and comparing depths.↩

Deterministic behaviour- a process whose resulting state is determined by the initial state and inputs. It is heavily reliant on having a fixed-time so each step is performing the same amount of "work". ↩

Dijkstra's algorithm- an algorithm for finding the shortest paths between nodes in a graph, which may represent, for example, road networks. It's most common variant finds the shortest path by accumulating distances between node pairs in the path. ↩

Direct memory access (DMA)- a technique of computer systems that allows certain hardware subsystems to access main system memory without taking up the CPU cycles. ↩

DirectX- a collection of application programming interfaces (APIs) for handling tasks related to multimedia, especially game programming, on Microsoft platforms, like Windows and Xbox. It is most known for Direct3D which is the graphics API used for creating windows and rendering, and serves similar purposes as OpenGL. ↩

Disassembly- the assembly language, translated from machine code, of a program; it is the compiler's version of the program. ↩

Disk I/O- read or write operations involving a physical disk. In general, to load an asset from the disk, the system will need to read it from the hard disk, write it into the memory (and possibly cache), which takes a lot of time. ↩

Distributed system- a system where the tasks are split between multiple coordinated, communicating networked computers whose actions aim to complete a common goal. ↩

Double buffer- the use of two buffers to hold data. By switching the buffers, the reader can see the complete version of data instead of a partially written one. ↩

Draw call- a command from CPU to GPU that contains all the information encapsulated by CPU about textures, states, shaders, rendering objects, buffers, etc. ↩

Dynamic memory pools- pools in which memory sizes are determined during runtime, and are changing per allocation rather than being fixed for all. ↩

Element buffers- hold additional information regarding the vertices, specifically what index the pertinent information is located within the vertex array. ↩

Engine abstraction- the part of the engine code which depends on the hardware/software platform that the engine runs on and will be different on each platform. For example, the code that talks to the operating system on macOS will be different from that on Windows. Engine developers usually tackle this problem by having an abstraction layer on top of operating system code. So the code above that layer still looks the same when you swap out the underlying operating system. ↩

Entity-Component-System (ECS) is an architectural pattern that follows composition over inheritance principle and is mostly used in games. ↩ ↩ ↩

FBX- a proprietary file format owned by Autodesk that is mostly commonly used for 3D model and animation data within the games industry. ↩

FLA- the file format for projects created by Adobe Animate, and can contain graphics, video, text, audio, and more. They are often saved as SWF files to be used on the web. ↩

FMOD- a a cross platform audio engine and authoring tool used throughout the game industry. It was used by over 2,000 games in the last 15 years.↩

Fill rate- the number of pixels a video card can read/write to the screen per second. ↩

findstr- a command for the Windows command prompt that searches files for a specified string, it has additional options for printing file names and line numbers among other options. ↩

Fixed memory pools- a data structure for dynamic allocation of fixed block-size memory chunks. ↩

Frame buffers- a portion of RAM containing a bitmap of the display, containing the data for that given frame on the video display. ↩

Free list- a memory management data structure that uses a linked list which points to successive free regions of memory that can be utilized for allocation individually.↩

Frostbite- EA's proprietary game engine used across most of their studios. ↩

Frustum- the portion of the world which is viewable by a camera. It is typically shaped like a pyramid with near and far planes clipping the volume. What is rendered is the volume between the 2 planes. ↩

Function templates- functions definitions that, at compile time, generate individual function definitions for any types used with the template. This can be very useful for cutting out duplicate code, but greatly increases compile time and code size. ↩

Function pointer- a 4/8 byte pointer, depending on your computer architecture, that points to a virtual table holding a reference to a function; instead of pointing to a variable the pointer points to a function. ↩

GLFW- a library utility for creating windows and receiving input from the window. ↩

Game development kit (devkit)- hardware different from the commercially available version of the hardware, specialized for development. It will have a way of booting with a development version of the game, and modern developer kits have debugging features for the developers. ↩

Geometry instancing- the practice of rendering multiple copies of the same mesh in a scene at once. This technique is primarily used for objects such as trees, grass, or buildings which can be represented as repeated geometry without appearing unduly repetitive. ↩

Gilbert-Johnson-Keerthi (GJK)- a distance algorithm method of determing the minimum distance between convex sets. It is used heavily in collision detection systems. Casey Muratori has a great blog on Implementing GJK. ↩

glTF(GL Transmission Format)- a royalty-free file format for 3D scenes and models using the JSON standard. ↩

GNU Compiler Collection (GCC)- a compiler system that supports a number of programming languages, including C++. ↩

Goal-oriented action planner (GOAP)- an artificial intelligence system for agents that allows them to plan a sequence of actions to satisfy a particular goal. For a detailed explanation, visit http://alumni.media.mit.edu/~jorkin/goap.html ↩

grep- a command for a Linux command line that will search specific files for a regular expression or string. When compared with Window's findstr it is much more flexible in its capabilities. ↩ ↩

Handshake in networking is an automated negotiation process for creating a connection between two machines, typically a client and a server. The process requires the machines to exchange special packets before the connection can be established. ↩

Hash- a structure that maps keys to values through a formula defined to convert structures into an index, typically the formula is constructed to avoid collisions between similar objects. The hash of the same object will always return the same value. ↩

Heads-up display (HUD)- overlay on the screen that presents important information to the player. ↩

Heightmap- a texture (rasterized image) where pixels have different meaning rather than representing color. One common usage of heightmap is to store surface elevation data. ↩

Heuristic- a technique for solving a problem more quickly, often utilized in optimization problems for computer science. ↩ ↩

Homogenous coordinates- differentiate points from vectors by expanding the traditional Vector3 to a Vector4 and placing a 0 in the 4^th element for vectors and 1 in the 4^th element for points. ↩

IMGUI- stands for immediate mode GUI which is a code-driven GUI system where on each rendering frame the application needs to issue the draw commands of the GUI (the GUI is not stored for multiple frames) ↩

Intellisense- an intelligent code completion feature in Microsoft Visual Studio that is capable of detailing information about the code and objects that the programmer is working with while coding. ↩ ↩

Internet Protocol version 4 (IPv4)- the fourth version of the Internet Protocol (IP). It is one of the core protocols of standards-based internetworking methods in the Internet, and does not guarantee delivery or proper sequencing. ↩

JAI- a language being developed by Jonathan Blow and his team at Thekla to address some of the issues game developers have with the current industry standard, C++. ↩

JavaScript Object Notation (JSON)- a lightweight data-interchange format that can be used for a database. It features a set of syntax that's both easy for human to understand and for machine to parse. ↩

Job control- the control of multiple tasks on a computer system that may be "in-flight" at the same time. It requires proper allocation of resources and locked access to prevent deadlocks and failures.↩

Key-value map- an abstract data type composed of a collection of (key, value) pairs. ↩

Least Recently Used cache scheme- a strategy for evicting data from a memory cache based on how recently the data has been accessed. ↩

Level scene graph- the scene graph corresponding to a level, similar to a level configuration file. It will contain the information (transformation, behavior, whether it is static, etc.) about the starting game objects. ↩

Level of detail (LOD)- the process of simplifying a model/mesh by removing vertices and detail. This typically occurs when the model is far enough such that the details are relatively insignificant compared to others in the viewport. ↩

Linter- a tool that flags code for errors, bugs, stylistic errors, and suspicious constructs. ↩

Localhost- an address in networking specifically, 127.0.0.1. Packets that are sent here are not technically sent anywhere, they're just sent up to the next layer for processing. ↩

Macros- a way of automatically substituting text for some other during the compiling process. In C++, they are defined as #define TEXT_IN_CODE TEXT_TO_COPY OVER. For example, if you define #define SPEED 5 and write mySpeed = SPEED, SPEED will be substituted by 5 during compile time and the compiler will actually see mySpeed = 5. ↩

Messaging buffer- a stream of pixel data, typically as four floating point numbers or integers representing red, green, blue, and opacity/alpha. ↩

Metal- a low-level, low-overhead hardware-accelerated 3D graphic and compute shader application programming interface (API) developed by Apple Inc. ↩

Microsoft Foundation Class Library- an object-oriented C++ library that contains useful macros for exceptions, run-time type identification, serialization, and more.

Microsoft Visual C++ (MSVC)- an integrated development environment (IDE) for writing and debugging C and C++ programming languages. ↩

Model-view matrix- the matrix which transforms a position in local space to world space, then to camera space. ↩

MonoBehaviour- the base class within Unity that all components which attach to GameObject must derive from, it has methods for start, update, and destroy, among a ton of others. ↩ ↩

Network authority- when a certain machine, typically the server, has the control (final decision) on the state of a variable/script/entity. ↩

Ninja- a small build system that is designed to run builds as fast as possible.↩

Node-based- when an interface is visual with components, "boxes", that are connected to each other with outputs connected to inputs. A node-based shader system means a shader is edited through nodes. ↩

Not A Number (NaN)- a numeric data type value that represents an undefined or unrepresentable value, especially in floating-point calculations. ↩

OSI- Open System Interconnection and is a standard for networking layers. ↩

Object composition- in Object Oriented Programming, this is a way to combine simple objects or data types into more complex ones. The Component pattern in Game Programming Patterns book describes this in detail. ↩

Object factory- a programming pattern where you decouple object creation and destruction with the actual usage of the object. An object factory typically creates objects based on passed parameters, which you would then receive and use. ↩

Open Dynamic Engine (ODE)- a free and open source physics engine written in C/C++ that can do both rigid body dynamics simulation and collision detection. ↩

Open world streaming- the the process of "streaming" (loading) the world/map (sections of the world) into memory while the player moves throughout the world. While the player moves the game decides which section of the map should be loaded into memory, the engine needs to manage memory and framerate during these times of loading. ↩

OpenAL- an audio library used for games, although it contains the word open it actually isn't open-sourced. Its open-source counterpart is OpenALSoft. ↩

OpenGL Mathematics (GLM)- a mathematics library based off of OpenGL specifications, that contains definitions for typical math constructs used in graphics. ↩

OpenGL- short for Open Graphics Library - a cross-language, cross-platform application programming interface (API) for rendering 2D and 3D vector graphics. The API is typically used to interact with a graphics processing unit (GPU), to achieve hardware-accelerated rendering. It's the underlying rendering library for many modern game engines.↩ ↩ ↩

Oracle- a computer technology corporation headquartered in Redwood Shores, California, who acquired Java from Sun Microsystems and is now maintaining it.

Packet queue- a queue of packets, which are small chunks of an original, bigger message. These are sent out in-batch because of packet size limitations over internet networks. ↩

Packet- formatted data that is sent over a network. Virtual objects are serialized and broken into these small chunks before being sent, and different protocols expect different formats for packets. ↩

Panda3D- a game engine, a framework for 3D rendering and game development for Python and C++ programs. It was originally developed by Disney and expanded by past ETC projects. ↩

Parallel programming- when code can be run on multiple threads rather than a linear process, therefore speeding up the execution. A parallel algorithm is an algorithm that can be executed as multiple pieces at a time, being split among multiple threads, then joined at the end to get the result. ↩

Pathfinding- an application which routes a computer actor between points/to a point, avoiding obstacles and using a heuristic to determine the path to take. ↩

Path tracing- a realistic lighting algorithm that simulates light bouncing around a scene. It uses the Monte Carlo method to give a faithful rendition of the global illumination of the scene. ↩

Peer-to-peer networking- where every machine communicates with one another, which requires more bandwidth per client and more complex data authority handling but avoids needing a dedicated server. Peer-to-peer is generally harder to implement than client-server. ↩ ↩

Persistent game data- Jason Gregory refers to this as "LSR" data, Load-and-Stay-Resident, as seen in Game Engine Architecture_section 15.4.2 ↩

PhyreEngine- Sony's game engine that is freely available for PlayStation developers. The engine is compatible with the PlayStation platforms of the last decade. ↩

Physics solver- a physics engine for games usually consists of two parts: collision detection and collision resolution, and solver refers to the resolution part. Collision detection detects what objects collide with each other first, and then the solver determines their correct physical response, like position, rotation, velocity, etc. ↩

PhysX- NVIDIA's real-time physics engine used by most commercially available game engines such as Unity, Unreal, and Lumberyard. ↩

Pivot- the local position of the model which is the zero position. When transforming the model in the world space, all changes are relative to this point. An offset pivot is when the pivot is placed in a position that isn't about the model, for example offset in X=100 from the model. ↩

Pixel stream- a stream of pixel data, typically as four floating point numbers or integers representing red, green, blue, and opacity/alpha. ↩

Platform-dependent- code refers to application code that is dependent on one operating system, and typically won't run on multiple. ↩

Programmable shader pipeline- allows the developer to customize some phases in the render pipeline (mostly the vertex processing phase and the fragment shader phase). It was introduced by OpenGL 3.2 in 2009. ↩

Protocol- a specific implementation of a layer of the network stack. ↩

Qt- a framework for creating retained GUI applications. ↩

Quadtree- a special type of tree data structure used in spatial partitioning. It recursively divides the whole space into four quads of the same size, and keeps doing it until each leaf quad contains a certain amount of actual spatial units (like polygons when used for rendering, and colliders when used for collision detection). If you are interested in learning more, refer to the Spatial Partitioning chapter in Game Programming Patterns. ↩

Ray tracing- a rendering technique for generating an image by tracing the path of light as pixels in an image plane and simulating the effects of its encounters with virtual objects. ↩

Regression testing- the process of testing changes in software to make sure functionality is not broken when updating the software. ↩

Remote procedure call (RPC)- a function that can be called on a computer by another computer across a network. ↩

Render paths- programs to affect the shading/rendering of lighting and shadow fidelity, along with other graphic details, with different performance characteristics. ↩

RenderWare- a game engine by Criterion Software that launched in 1993 and continued to regularly support games through 2010. It was known for providing an off-the-shelf solution to the difficulties of PS2 graphics programming. ↩

Retained GUI- also known as canvas/scene graph, is where GUI is registered once and is displayed, "retained", on screen until it removes itself from rendering. ↩

Retro compatibility- also known as backwards compatibility, is when a system is setup such that it works with legacy code/input. ↩

Ring buffer- (or circular buffer) is a FIFO data structure which is broadly used for transmitting data between asynchronous processes. ↩

Run-length encoding- a form of lossless data compression where data is stored as a single data value and count. ↩

Run-time type information/identification (RTTI)- in C++, this is information about an object's type that is available at runtime. ↩ ↩

Runtime or Dynamic Polymorphism- when an overridden class or method is determined at runtime as opposed to compile time. This allows for us to change some behavior of our program depending on the data type it's operating with. ↩

STL- standard library which is the C++ library containing most of the needed data structures. It is known to not be best for performance, however, will save us time not implementing them. ↩

SWF- short for Small Web Format, is an Adobe Flash file format used for multimedia, vector graphics and ActionScript. SWF files can contain animations or applets of varying degrees of interactivity and function.↩

Scaleform- a vector graphics rendering engine used to display Adobe Flash-based user interfaces and HUDs for video games. ↩

Scene graph- holds the entities and components (including transforms and parent hierarchies) of a level, also known as a scene. ↩

Scriptable Render Pipeline (SRP)- an alternative to the built-in rendering pipeline in Unity. With the SRP, developers can control and tailor rendering via C# scripts. This way, they can either slightly modify or completely build and customize the render pipeline to their needs. ↩ ↩

ScriptableObjects- scripts which cannot be attached to GameObjects but still store (serialize) user data. ↩

Seek- a programming concept related to file reading, where a program has a file pointer associated with a position and a seek moves the pointer to a specific position within that file. ↩

Seek-free loading- a system which is able to read a file "free" (without) "seeking", (searching) a file, for data/position within a file. Seeking causes disk activity which is generally slower than CPU performance. ↩

Serialization- the process of data being converted into a byte stream for easier storage and transfer, think of it as similar to a save and load system. ↩

Simple DirectMedia Layer (SDL)- a hardware abstraction layer for audio, input, and graphics across multiple platforms. ↩

Singleton pattern- a software design pattern that restricts the instantiation of a class to one object. This is useful when exactly one object is needed to coordinate actions across the system. ↩

Software developer kit (SDK)- a set of programs used in developing another program. ↩

Spatial partitioning- as defined by Bob Nystrom, a way to "efficiently locate objects by storing them in a data structure organized by their positions". If you are interested in learning more, refer to the Spatial Partitioning chapter in his Game Programming Patterns book. ↩

Spine- a 2D skeletal animation software for video games by Esoteric Software. ↩

Static allocations- the allocation of memory at compile time, therefore faster than dynamic because the computer doesn't need to switch into kernel mode to grab more memory. ↩

std::function- a container for lambda functions, see cppreference. We have renamed std::function to Action in our aliases for simpler calling. ↩

Std::iterator- a C++ type that can be used to iterate through collections of elements based on that collection. ↩

Steering behavior- a way of applying various forces to a unit's movement to generate realistic behaviors like chasing, fleeing, following, and more. ↩

Stencil buffer- an additional depth buffer to the depth and color buffers. ↩

Student T-Test- a statistic test to determine whether a sample set passes hypothesis, the chance the samples are the same or different. For more information see Elan's GDC talk. ↩

Sunset Overdrive- a game developed by Insomniac Games for the Xbox One. It is a fast-paced, open world action-adventure, third-person shooter. ↩

Synergistic Processing Unit (SPU)- the processing unit associated with the Cell architecture of the PS3. The PS3 had seven as part of its hardware, only six of which were usable by game developers. ↩ ↩ ↩

Test harnesses- a test framework which can ensure the progression of the software. In the Isetta Engine case, they will act as sample levels to demo features of the engine and as versioning happens to ensure old features aren't broken on accident.↩

The Demoscene- an international computer art subculture focused on producing demos, which are self-contained, sometimes extremely small, audio-visual computer programs. ↩

Thread-safe code- only manipulates shared data structures in a manner that ensures that all threads behave properly and fulfill their design specifications without unintended interaction. ↩

Transpose- when the entries on the diagonals are flipped about the center diagonal.↩

Trie- also known as a radix tree, digital tree, or prefix tree, this is a kind of search tree—an ordered tree data used to store a dynamic set or associative array where the keys are usually strings. ↩

Two-Level Segregate Fit (TLSF)- a memory allocation scheme meant for use in video games because of its fast and efficient memory usage. ↩

Type safety- when the compiler can check whether the written code is using the right types and whether the language prevents or discourages type errors, errors from mismatching types. ↩

Type trait- defines a compile-time templated-base interface to query or modify the properties of types, for more see type support. ↩

Typecasting- also known as type conversion, this is a method of changing one data type to another. It helps ensure that variables are processed correctly by functions, but can also be dangerous with the way they handle the conversion. ↩

Uncanny valley- an effect where non-human audio/visual simulations attempt to closely mimic humans that isn’t perfectly realistic or convincing, causing an unsettling feeling. ↩

UNIX- a family of multitasking, multiuser operating systems that derive from the original AT&T Unix, originally developed at Ken Thompson, Dennis Ritchie, and others at Bell Labs. It's main comparable is Microsoft's DOS, which is mono-task and monouser. ↩

Unified Modeling Language (UML)- used to visually represent a software system with its actors and roles so that a programmer can better understand and design said system. Sometimes, UML diagrams can end up as a "disaster situation".↩

Unified memory architecture- an architecture that uses a portion of a computer's RAM rather than dedicated graphics memory. It is a single memory address space accessible from any processor in a system. ↩

Union- a special class type in C++ that can hold only one of its non-static data members at a time. Similar to a struct, you can declare multiple variables in a union, but only one is available at the same time. Another distinction is that the size of a struct is the sum of all of its members, but the size of a union is the size of the biggest member. The way the author understands it is that union gives you different ways to interpret the same memory values. ↩

Unreal Material Editor- a node-based graph interface that enables you to create shaders. For more see the Unreal Documentation. ↩

Unreal's Blueprint Visual Scripting System- the node-based scripting in the Unreal Engine used for gameplay scripting. ↩

Variable-render- refers to the fact that rendering will be updated as fast as the CPU/GPU can allow, not being slowed by a frame rate. All other modules will then be updated with a fixed timestep since some of them dependent on the timestep and can become non-deterministic with a variable timestep. ↩

Vector field- an assignment of a vector to each point in a subset of space, such as a plan with a collection of arrows with a given magnitude and direction. Vector fields are often used to model the speed and direction of a moving fluid like a river. ↩

Vector unit architecture (VU)- the architecture for the Emotion Engine that was used in the Playstation 2 console. The two processing units were focused for 3D math and predecessor for the vertex shader pipelines. ↩

Vertex shader- a graphics program that alters information associated to the vertices, it is one of the first stages in the graphics pipeline. ↩

Vertex arrays and buffers- hold the vertex information such as vertex positions, normals, color, etc and are stored within the OpenGL state. ↩

Viewport- a region of a 2D rectangle that's used to project the 3D scene to a virtual camera and thus provide a way to view the 3D virtual world. ↩ ↩

Virtual memory- a memory management technique that abstracts uniformed memory space from different kind of storage device. ↩

Virtual table (vtable)- a lookup table of functions used to resolve function calls. It's mostly used in C++ inheritance. ↩

Volume-casting- when a volume's path is traced along a line/curve to test collisions with other objects. ↩

Vulkan- a low-overhead, cross-platform 3D graphics and compute API targeting high-performance realtime 3D graphics applications such as video games and interactive media across all platforms. ↩

Waterfall schedule- a linear schedule where each subsequent item is dependent on the previous components being completed, it is less iterative and flexible because the flow is usually mono-directional. ↩

Window handle- a GLFW construct can be passed to objects and functions to allow them to hook into a particular window from the operating system. ↩

Wrapper- a class that "wraps" around another class to hide/change/add functionality. This is usually done when using other people's libraries to ensure only your features are available. ↩

Z-buffer- also known as the depth buffer, contains information regarding the distance from the camera, the depth. Z-buffering can also refer to the technique in which pixels are culled from the frame, not rendered, because another pixel's depth is closer to the camera, therefore the pixel in the background is being covered. ↩