Glossary of Terms
Terms listed should ideally be language agnostic. If a term is specific to the language it should be noted after the term and before the definition.
When you do find a satisfactory explanation of the word, then please feel free to add you that explanation to this list in your own wording. That way the glossary list becomes more complete and others won't have to search elsewhere for words they couldn't find here.
- 3D Texture
- A texture with an extra dimension. Usually you load two or more 2D textures and you blend between (e.g. a heightmap).
- A* or A-star
- Pathfinding is the process of finding a path from one point to another. A* (a-star) is an algorithm that efficiently finds a shortest path in a graph. In many game-programming situations this is the best choice for pathfinding. A* also has significant applications beyond finding paths across terrain; it can 'pathfind' in abstract problem spaces like sets of actions to undertake in order to accomplish a goal just as easily, making it a powerful AI tool.
- A rating given to a top-of-the-line game. Usually a game with big budget and high production values from an established developer.
- Adaptive Learning
- An artificial intelligence system that can re-program itself based on environmental factors and influences.
- See Artificial intelligence.
- A method of cheating, often in multiplayer games. A separate external program or script will perform perfect targetting on other players.
- A step-by-step problem-solving procedure, especially an established, recursive computational procedure for solving a problem in a finite number of steps.
- The effect produced when a complex image is put onto a display with a limited resolution. This effect is a product of downsampling. Examples include jagged looking lines in lower resolutions. Temporal aliasing is the effect where motion appears stuttered due to a low frame rate (for the speed).
- The first stage of development for a game. (see Beta, Gold)
- Alpha Blending
- Assigning varying levels of translucency to graphical objects, allowing the creation of things such as glass, fog, and ghosts. This can be accomplished by using alpha channels, or other means. (see Alpha Channel)
- Alpha Channel
- In 32-bit color, 24-bits are used for the color, and the extra 8-bits represent an alpha value, or alpha channel. This value is used to determine the pixel's translucency level.
- Ambient Lighting
- In 3D graphics: A base amount of light that is added to every polygon, even if it receives no light from the defined light sources. Used to simulate the light that is refracting off objects around us in the real world.
- Amortized Complexity
- Average complexity over a large number of calls. For example, push_back on a std::vector is amortized O(1) because it occasionally needs an O(n) reallocation, but only once every n calls or so, with the rest being O(1). Since this means O(n) for n calls, the per-call complexity averages to O(1).
- The process of creating simulated motion or activity.
- Anisotropic Filtering
- The level past trilinear filtering, this uses samples from multiple Mip Maps to get the best approximation for a texture. Very heavy performance cost.
- This is the process that gets rid of the aliasing effect. A filtering process is normally used in the process that removes "jaggedness effect" produced by pixels. (see Aliasing)
- Application Programming Interface. A collection of functions that you can use to build programs. Your operating system has an API with which you can manipulate its workings.
- A section of a circle that is measured in degrees or radians.
- A series of characters and/or numbers defined in order in memory. Used in programming to store data, create matrices, and other. C++ Example: char array="Hello world";
- In graphics, persistent portions of images resulting from improper blitting operations.
- Artificial intelligence
- Programming of computers that attempts to mimic human intelligence. The main types of Artificial Intelligence used in games currently are State Machines, Expert Systems, Fuzzy Logic, Genetic Algorithms and Neural Networks.
- Aspect Ratio
- The aspect ratio of an image is the ratio of its width to its height. Aspect_Ratio = Width / Height See Pixel Ratio
- In Role-Playing Games, attributes are numbers that represents specific aspects in a character's stats. EX: Agility, Intelligence, Luck, Power, etc. are all attributes.
- An in-game representation of the player.
- Backface Culling
- Backface Culling can be considered part of the Hidden Surface Removal process of a Rendering Pipeline. Backface Culling is the process by which Polygons (usually triangles) that are not facing the Camera are removed from the Rendering Pipeline. This is done by comparing the Polygon's Surface Normal with the position of the Camera.
- the second stage in a game's development cycle. This stage is usually fairly feature complete, but may still have missing content and minor bugs.
- Big-O Notation
- Used to give a rough estimate of the complexity of algorithms.
- In 3D graphics: A flat image drawn in 3D space in such a way that it is always facing the viewer/camera. Common uses are for particles and to display more complex objects at a low level of detail.
- Binary Heap
- A binary heap is a useful data structure if you have a collection of objects to which you are adding random objects and need to remove the object with the highest (or lowest, or the extreme of some other ordering) value. You could use a dynamic array or a list, but then you'll have to compare all the elements each time you want to find the biggest one.
- Binary Space Partion (BSP)
- A bit represents a 1 or a 0. It's on -or- off. 8 bits make a Byte .
- Bit Block Transfer. A function in the Windows API that allows you to transfer a block of bits (A bitmap, for example) from one location to another on the screen. This can be used to move sprites around a screen, a prerequisite for making many types of games.
- In graphics: The process of mixing colors from different sources, usually using an alpha channel.
- Bounding box
- A rectangle or box (often aligned to the axes of the coordinate system) around an object to make culling and collision-detection faster.
- An empty variable/object that will hold information usually from a function. Buffers also hold information that still needs to be processed, like a map buffer holds parts of the map which might still need to be clipped or processed in some other way.
- A software defect usually resulting from incorrect or missing code.
- 8 bit data value, from 0 to 255, or 0 to FF in hexadecimal. 
- An object which describes the viewpoint of the player, from this the renderer has to calculate what parts of the map to display.
- Cell Shading
- A style of rendering done to give graphics a cartoony look. One example is XIII - 
- A data type typically 8-bit in size 
- In graphics: The process of removing parts of geometry that are outside the screen during drawing.
- 1: A computer only meant for gaming. EX. Xbox, Playstation. 2: A command-line interface, possibly inside of a game.
- In 3D graphics: The process of removing non-visible geometry before drawing it to increase efficiency.
- A set of API procedures that allow a programmer more direct access to the machine's hardware while still shielding him from a substantial amount of tedious machine specific coding. This is Microsoft's answer to the complaints of programmers that Windows was too slow to be a gaming platform. By allowing us access to the video, audio, and input devices directly Microsoft has succeeded in convincing developers that Windows is a viable platform for their games.
- Dynamic Link Library. DLL's contain procedures that can be dynamically or statically accessed by programs running in Windows. Generally more than one program can access a single DLL at a time. Many DLL's come packaged with Windows, others are created for the specific needs of a program. DLL's are useful since they reduce the need for redundant code within Windows programs since the most frequently used procedures are centralized within the DLL's that make up the Windows API.
- Dynamic Lighting
- In 3D graphics: Lighting adjusted in real time for changing light sources (and sometimes also for shadow casters).
- Byte order for integer values, system specific See Big Endian, Little Endian
- Code, usually grouped into one or more classes, that performs a specific function. Examples are graphics engine, combat engine, etc.
- A method of error handling that most programming languages support. An exception can be "thrown" when a special or general error occurs, and it is then possible to handle the error, either by correcting it, or by exiting the application gracefully.
- First Person Shooter
- Is a genre of games in which you view the world from the perspective of the character. These games are typically fast-paced, emphasising speed and accuracy and are considered one of the most complicated games to develop.
- "First in, first out." Refers to a type of programming stack.
- An abbreviation for "frames per second", or possibly "first person shooter."
- In animation: A single time step. Every frame objects in the animation are updated and the screen is updated with their new state. Frames per second are a common (although not always very objective) way to measure game performance.
- In 3D programming: A pyramid-like shape with its point at the 'camera', pointing in the direction that you are viewing, and the base representing the far clip plane. This geometric shape contains all objects that are visible.
- Frustum Culling
- The process of weeding out things that are outside the frustum before drawing. Helps performance because less has to be drawn.
- Game Genres
- A game genre is simply a specific type of game. For example, a game in which the player solves puzzles would fall into the "Puzzle Game" genre.
- See Game Genres
- Is the OpenGL Shading Language.
- A graph is a basic mathematic concept meaning a collection of points with lines between them. Graphs can have diverse meanings, but a common use of them is to represent points in space and the connections between them.
- Graphical APIs
- Is a library of functions that handle the interaction between the hardware (graphics card and monitor) and software components and makes less troublesome to draw graphics to the screen. Most modern graphical APIs include a vast number of features to ease the creation of complex rendering systems.
- Graphical Device Interface. This API is used by Microsoft Windows in order to maintain commonality of look and feel for all programs. The GDI defines how Windows are displayed, bitmaps are moved around, etc. There is a file called GDI32.DLL that houses all of the API calls required to handle these operations (such as BitBlt).
- Hash Table
- A hash table is in effect an array, but elements are not added from front to back. The array has a fixed size and some property of the element to add decides where it will be put.
- A map or table of what height the ground is at a certain coordinate. It is popular to use heightmaps in the format of a raster image, where one pixel represents a single height coordinate.
- Hidden Face Removal
- In 3D graphics: The process of making sure only the visible surfaces end up in the final image, and surfaces behind those visible surfaces are hidden.
- Inverse Kinetics (Inverse Kinematics)
- A method of animating models based on starting with the desired motion of, for example, a hand, and computing the required motions of connected elements (e.g. lower arm, elbow, upper arm, shoulder) from there. Generally regarded as producing results inferior to motion capture.
- Games are called isometric when their world maps are based on grids of tiles which are drawn to the screen without taking perspective into account (orthogonal). The game view is necessarily top-down in such games.
- Index Buffer
- Kinetics (Kinematics)
- Part of an animation technique wich uses data to set up "snapshots" (keyframes) of the object being animated. These "snapshots" are then interpolated (the in between frames are generated at runtime by knowing the last and the next keyframes) to create a smooth animation using a small amount of data. The keyframes can each contain an instance of the whole mesh of the 3D model (old style) or just information (position and rotation) about the object's joints (a.k.a. skeletal animation)
- Left Handed Coordinate System
- An orientation of axes in a three-dimensional coordinate system, as opposed to right-handed coordinate systems. When you look at the thumb, index finger, and middle finger of your left hand (holding them in orthogonal positions in the most straightforward way), you can determine the orientation of respectively the X, Y and Z axes.
- Level of detail (abbr. LOD)
- In computer graphics: To make drawing more efficient, a simpler form of objects that are farther away is drawn.
- "Last in, first out". LIFO is commonly used to describe a type of programming stack.
- Linear Interpolation
- Linear interpolation is the process of using two known values at two points to determine a third unknown value at a third point.
- Linked List
- A linked list is a data structure where every element contains both a 'value' and a link/reference/pointer to a 'next' element (and sometimes also one to a 'previous' element). The whole list is represented by a pointer/reference/link to the first element of the list (or a structure encapsulating this).
- A lossless compression algorithm (as opposed to a lossy algorithm) achieves its space savings without any loss in data integrity. The compression must be fully reversible, and uncompression must result in an exact copy of the original data.
- A lossy compression algorithm (as opposed to a lossless algorithm) achieves its space savings by sacrificing the least critical portions of data. A lossy compression algorithm is not fully revisible, and uncompression will not result in an exact copy of the original data.
- A rectangular grid of numbers. Used heavily in 3d programming for transforming points in space.
- Media Control Interface. A Windows API for controlling multimedia devices such as CD ROM drives.
- Memory leak
- A memory leak is a part of the systems RAM memory that isn't released properly. This is a common problem in software development.
- In 3D computer graphics texture filtering, MIP maps (also mipmaps) are pre-calculated, optimized collections of bitmap images that accompany a main texture, intended to increase rendering speed and reduce artifacts.
- Is an abbreviation of Massive Multi-Player Online Role Playing Game, which is a certain game genre.
- Multi-User Dungeon or Multi-User Dimension, a genre of RPG, usually text-based, commonly thought of as a precursor to MMORPGs.
- Uses two or more "texture units" on the graphics card to blend the textures in one pass.
- Nibble (also know as Nybble)
- Half a byte, or 4 bits. Nibbles rarely come up when programming modern computers.
- Short for nickname, used in multiplayer games, it's the name you pick yourself by which you are known (other than using your real name)
- A vector perpendicular to a surface. At the same time, the direction of this vector determines the orientation of the surface. In the case of polygons, this direction is usually determined by the right hand rule.
- See Big-O Notation
- Object-oriented programming
- This type of programming consists of treating data as groups or objects, where these objects can inherit from other objects. An example would be a human. You can have one a body, with multiple limbs, and a head. Again, each hand would inherit fingers, and so on. Object-oriented programming helps organize code and improve reliability. It is also slower to execute than standard individual-variable type programming.
- OLE Custom Control. A program module available to other programs within the Windows environment. Where a DLL provides pre-made functions to Windows programs, an OCX control provides pre-made controls complete with their own inherent functions and behaviors. OCX files act as containers to ActiveX controls.
- Object Linking and Embedding. Pronounced oh-lay. OLE allows you to create an object within one program and link or embed it into another, thus allowing easily standardized formats. An example of this is how you can insert an Excel Worksheet Element into a Word document, and have it retain its functionality.
- Used in occlusion culling. An object that sits in front of other objects, blocking them from view and thereby making it unnecessary to draw them.
- Occlusion culling
- Pre-processing the list of objects that have to be drawn to remove objects that are entirely behind other object.
- See Object-oriented programming.
- Particle system
- A set of routines concerned solely with the physics and display of small particle effects. Examples include explosion fragments, bubbles, engine exhaust, etc.
- Path finding
- The way games find a way to get an object from one point to another taking unwalkable tiles etc. into consideration. An absolutely necessary part of almost any game.
- Pixel is a abbreviation of Picture Element. It is the smallest element of a display.
- Postmortem literally means, "after death," and in the world of game development refers to the act of analyzing a game's development after completion. Postmortems provide insight into the world of game development, and often provide the reader with helpful tips on what to do, and what not to do when developing a game.
- Projection Matrix
- It specifies the field of view angle, aspect ratio and near/far clipping planes.
- A data tree-structure where each node has four branches. Usually used to partition space in a two-dimensional plane. The square area represented by a node is split into 4 equal squares and every branch represents one of those squares, which might be split itself in turn.
- RAII ( Resource Aquisition Is Initialisation )
- The C++ idiom that resources should be owned by objects such that they are automatically released by that object's destructor, making code simpler and safer in the face of exceptions.
- The process of turning polygons and other internally vector type graphics into raster graphics (made up of discrete pixels.)
- Right Handed Coordinated System
- See left handed coordinate system, except this time you use your right hand. More common than the left handed variety.
- 'Role-Playing Game'. Computer RPGs (CRPGs) are usually 'role-playing games' only by the most generous standards; in computer gaming, 'RPG' refers mainly to a character-building or stat-building game.
- In 3D graphics: A program that runs on the video card. Shaders can be run for every vertex or pixel drawn. Not necessarily related to shading only, can influence many aspects of the rendering process.
- Sky Box
- A skybox is a trick used in 3d graphics to display a horizon (or other far-away stuff) without rendering enormous amounts of geometry.
- A two dimensional image, often with transparent areas, that is drawn to the screen to represent some in-game object.
- A stack is a container that allows elements to be pushed in and popped out in LIFO (last in, first out) fashion. Depending on the implemenation, only the top element can be accessed or all elements can be accessed.
- Stencil buffer
- A stencil buffer is an extra buffer, in addition to the color buffer (pixel buffer) and depth buffer (z-buffering) found on modern computer graphics hardware. The buffer is per pixel, and works on integer values, usually with a depth of one byte per pixel. The depth buffer and stencil buffer often share the same area in the RAM of the graphics hardware.
- Tetris is a game in which various falling blocks are to be organized and arranged to form rows with no spaces. It is one of the most well-known video games ever made and has been the center of much legal dispute in the late 80's and early 90's.
- A single pixel on a texture image.
- A single section of image that is blitted along with other tiles to make up a larger picture on the screen. An example is a picture of a bush. It is drawn to the screen along with other pictures, maybe one of grass and one of a road, to make up a picture of a landscape on the screen.
- UV Mapping
- Technique used to apply a bitmap (called texture) to at least one polygon
- In mathematics: A 1xN array. N usually represents dimensions. Points on a 2D surface can be represented by 2 dimensional vectors, etc. In programming: The word vector is sometimes used to indicate an array. The C++ standard library contains a templated class called std::vector that implements dynamic arrays.
- Vector graphics
- Graphics made up of lines, curves or mathematical formulas, as opposed to raster graphics. Vector graphics can be scaled indefinitely and experience no loss in quality, where raster graphics lose some of their accuracy. Generally, all 3D graphics are internally vector graphics, and when drawn to screen (rasterization), they are converted to a raster format the monitor can display.
- Vertex (pl. Vertices)
- In 3D graphics: A point in 3D space. Usually used when the point is part of a model. Can have more information besides location associated with it, for example color, normal, or vertex coordinates.
- View cone
- See Frustum
- View Matrix
- A voxel (short for volume pixel) is basically the 3D counterpart of a two dimensional pixel. Where you can represent a pixel as a square, a voxel would be a cube. Voxels can be used to build 3D worlds, in a raster format (versus polygonal format which is vector.)
- A method of cheating where the player can look through walls and objects. This is mostly done in multiplayer games, where the cheating player is getting a significant advantage by seeing the through the walls. The wall-hack is often performed by replacing a graphics driver.
- A w-buffer is a type of depth buffer similar to a Z-buffer, except it is more accurate and generally produces better results.
- World Matrix
- In graphics, we use it to rotate, scale and translate objects in 3D space(world space) by modifying their vertices. All of these transformations will be performed about the origin(0,0,0).
- X (position)
- A position on the screen used in 2D and 3D. Width.
- Y (position)
- A position on the screen used in 2D and 3D. Height.
- Z (position)
- A position on screen used in 3D. Depth.
- In 3D graphics: An array with a current z-value for every pixel on the screen. Used for hidden face removal. A pixel is only drawn when its z-value is smaller than the current value in the buffer for that location. When it is drawn the z-buffer is updated. In a limited byte situation for Z-buffering, the depth resolution is more condensed toward to the near plane of view frustum compared to the w-buffering. That is, if you set the near plane too close to your eye (zero distance ), it will make primitives blinking easily especially when they have certain distance from your eyes.