A sprite is a two-dimensional (2D) bitmap graphic object that can be a static image or animation that is integrated into a larger scene. Sprites are used in games to collectively create a scene. Each sprite is used to represent each object. A "Sprite Sheet" is simply a collection of still images that progress. Once displayed sequentially it creates animation.
Sprites can be used for two-dimensional games, or pseudo-3D sprite-scaling (such as Super Scaler, Mode 7 and Ray Casting), or pre-rendered games.
Sprites can also be used for, and have been used in, three-dimensional games. The way that they are typically used within 3D games is through rendering or imitating a rendered frame from certain perspectives. This removes the computational overhead of rendering each position dynamically. Sprites are also often used in 3D games today to display grass and foliage, in the form of billboarding. Sprites can also be used in conjunction with cel-shading.
In recent years, sprites have been used beyond gaming, such as CSS sprites which are used in web design as a way to improve performance by combining numerous small images or icons into a larger image called a sprite sheet or tile set, and selecting which icon to show on the rendered page using Cascading Style Sheets.
Sprite Drawing Methods
The following are the two most common methods for drawing sprites.
Buffering / Blitting
Using the buffering method, or blitting method, the CPU (central processing unit) and/or GPU (graphics processing unit) modify a frame-buffer held in RAM (random-access memory), which requires more memory cycles to load and store the pixels and refresh the backgrounds behind moving objects. The sprites are usually processed through a display list. This method frequently requires double buffering to avoid flickering and tearing, but place fewer restrictions on the size and number of moving objects.
This method is ideal for systems with high processing power (a fast CPU and/or GPU), and/or a high amount of fast RAM memory. However, it was usually only arcade systems that were capable of using this method very effectively up until the early 1990s (such as Sega's Super Scaler systems), due to their expensive CPU, GPU and RAM technologies. A number of personal computers also used this method in the 1980s (such as the Amiga), as well as a few consoles (such as the Atari 7800), but due to limited processing power and memory at the time, these systems were often unable to match the quality of hardware sprites without suffering slowdowns. But as processors and memory technology improved, buffering/blitting became the most common method for drawing sprites in the mid-1990s, for both personal computers and home consoles (such as the Sega Saturn).
Hardware sprites, rather than being part of the bitmap data in the frame-buffer, instead float around on top without affecting the data in the frame-buffer below, much like a ghost or "sprite". Using this method, there is a defined limit to the number of sprites on screen and their sizes, but two-dimensional shapes could be moved around the screen horizontally and vertically with minimal software overhead. In other words, hardware sprites have very little impact on overall system performance.
This method was ideal for systems with limited processing power and RAM memory. It was the most commonly used method for classic home consoles in the 1980s and early 1990s (such as the Sega Mega Drive/Genesis and Super Nintendo Entertainment System), some arcade systems in the early 1980s (such as the Namco Pac-Man), the more advanced personal computers of the 1980s (such as the Sharp X68000), and handheld systems up until the 2000s (such as the Game Boy Advance). But as processing power and RAM memory improved, the use of hardware sprites eventually fell into disuse in the mid-1990s, though it continued for handhelds up until the 2000s.
The first video games did not use sprites. Pong, for example, when it released in 1972, used simple rectangular blocks and lines to display the ball, paddles and points. The use of sprites became possible with the use of ROM (read-only memory) for several arcade games in 1974.
Taito released the earliest video games with sprites in 1974. The first game to use sprites was Basketball, a sports game released in Japan by Taito in early 1974 and imported to North America by Midway as TV Basketball in February 1974. Basketball represented four basketball players as well as two baskets as sprite images. These basketball players were the first player characters and the first representation of humans in gaming history.
Speed Race, which was designed by Tomohiro Nishikado and ran on Taito Discrete Logic hardware, released shortly afterwards in 1974. It featured sprites with collision detection, moving along a vertical scrolling playfield (see Bill Loguidice & Matt Barton, Vintage games: an insider look at the history of Grand Theft Auto, Super Mario, and the most influential games of all time, page 197, 2009).
The Fujitsu MB14241 was used to accelerate the drawing and buffering of sprite graphics for various 1970s arcade games from Taito and Midway, such as Gun Fight (1975), Sea Wolf (1976) which ran on the Midway 8080 hardware (ref), and the blockbuster hit Space Invaders (1978). The Taito 8080 hardware engineered by Tomohiro Nishikado for Space Invaders, which also used the Fujitsu MB14241 (ref), could display up to 11 sprites per scanline (see here, here and here for more information).
In 1977, the Taito Z80 arcade system board used for Super Speed Race was capable of generating up to 16 sprites in hardware and display 4 sprites per scanline. Each sprite could have a size up to 32 pixels in width or height and display up to 15 colors (see references here, here and here).
The Namco Galaxian arcade system, developed by Namco for the 1979 arcade hit Galaxian, used specialized graphics hardware supporting RGB color, multi-colored sprites and tilemap backgrounds. It could display up to 15 hardware sprites across each scanline. Each sprite could be up to 16x16 pixels in size, with 3 colors each. The Namco Galaxian hardware was widely used during the golden age of arcade video games, by game companies such as Namco, Centuri,Gremlin, Irem, Konami, Midway, Nichibutsu, Sega and Taito (see references here and here).
1980s to 1990s
In the 1980s, sprite-scaling became a popular technique in arcade games to represent a three-dimensional perspective using 2D sprite graphics, i.e. pseudo-3D graphics.
Sega in particular was at the forefront of sprite-scaling graphics with its powerful custom Super Scaler graphics boards, which could quickly scale and rotate many large colourful sprites at high frame rates. Sega's Super Scaler hardware powered a string of 1980s arcade hits, such as Hang-On and Space Harrier in 1985, and Out Run in 1987. Sega introduced sprite rotation with After Burner in 1987, and went on to produce more hits, such as Galaxy Force, Power Drift and Last Survivor in 1988.
Other arcade manufacturers such as Namco, Capcom and SNK also relied on custom graphics processors in order to produce similarly advanced sprite graphics in the 1980s to early 1990s. Eventually, the Sega Saturn console, released in 1994, was able to rival the sprite graphics of the arcades. Along with its arcade counterpart, the Sega ST-V, the Saturn had the most advanced sprite capabilities of the 1990s.
Following the rise of true 3D polygon graphics in the early-mid-1990s, the sprite graphics, including the sprite-scaling technique, eventually declined in popularity.
This is a table listing the sprite capabilities of various classic gaming systems and/or graphics chips.
For the sprite scaling/zooming and rotation/mirroring capabilities of these systems and chips (the ones with hardware support for these features), see here. For a full detailed table of sprite capabilities, with references, see here.
Systems / Chips
|Year||Sprites on screen||Sprites on line||Texels on line||Texture width||Texture height||Colors per sprite||Back-ground|
|Fujitsu MB14241||1975||60||9||144||4 to 32||1 to 224||1||1 bitmap layer|
|Fairchild Channel F||1976||Display list (run by CPU)||9||56||4, 8||5, 8||1||1 bitmap layer|
|Atari 2600||1977||9 (5 multiplied by CPU)||9 (with triplication)||51 (with triplication)||1, 8||192||1||1 bitmap layer|
|Taito Z80||1977||7||7||224||32||16||15||1 tile or bitmap layer|
|Atari 8-Bit & 5200||1979||Display list||8||40||2, 8||128, 256||1, 3||1 bitmap layer|
|Namco Galaxian||1979||Display list||15||240||8, 16||8, 16||3||1 tile layer and 1 bitmap layer|
|ColecoVision, MSX, Sega SG-1000||1979||32||4||64||8, 16||8, 16||1||1 tile layer|
|Namco Pac‑Man||1980||8||8||128||16||16||3||2 tile layers|
|Sega G80||1981||64||32||256||8, 16||8, 16||3||2 tile layers|
|Sega VCO Object||1981||64||16||315||8 to 20||8 to 20||3, 7||1 tile layer and 1 bitmap layer|
|Commodore 64||1982||Display list (run by CPU)||8||96, 192||12, 24||21||1, 3||1 tile or bitmap layer|
|Namco Pole Position||1982||64||32||512||16, 32||16, 32||15||1 tile layer and 1 bitmap layer|
|Sega 315‑5011 & 315‑5012||1982||128||100||800||8 to 256||8 to 256||15||2 tile layers and 1 bitmap layer|
|Famicom / NES||1983||64||8||64||8||8, 16||3||1 tile layer|
|Atari 7800||1984||100 (without back-ground)||30 (without back-ground)||160||4 to 160||4, 8, 16||1, 3, 8||1 bitmap layer|
|Amiga (OCS)||1985||Display list||8||128||16||Up to 256||3, 15||2 bitmap layers|
|Sega Master System & Game Gear||1985||64||8||128||8, 16||8, 16||15||1 tile layer|
|MSX2||1985||32||8||128||8, 16||8, 16||1, 3, 7, 15 per line||1 tile or bitmap layer|
|Sega OutRun||1986||128||128||1600||8 to 512||8 to 256||15||2 tile layers and 1 bitmap layer|
|Namco System 2||1987||128||128||2081||8 to 64||8 to 64||255||7 tile layers and 1 bitmap layer|
|PC-Engine / TurboGrafx-16||1987||64||16||256||16, 32||16, 32, 64||15||1 tile layer|
|Sharp X68000||1987||512 (128 multiplied by raster interrupt)||32||512||16||16||15||1-2 tile layers and 1-4 bitmap layers|
|Sega X Board||1987||256||256||3200||8 to 512||8 to 256||15||4 tile layers and 1 bitmap layer|
|Taito Ninja Warriors||1987||128||108||1737||16||16||15||6 tile layers|
|Taito Z System||1987||512||108||1737||16 to 128||8 to 128||15 to 255||2-4 tile layers and 1 bitmap layer|
|Capcom CPS||1988||256||65||1048||16 to 256||16 to 256||15||3 tile layers and 2 bitmap layers|
|Sega System 24||1988||2048||512||4096||8 to 1024||8 to 1024||15 to 255||4 tile layers|
|Sega Y Board||1988||2176||400||3200||8 to 512||8 to 512||15 to 511||1 bitmap layer|
|Taito B System||1988||408||110||1768||16 to 256||16 to 256||15 to 63||2 tile layers and 1 bitmap layer|
|MSX2+ & MSX TurboR||1988||32||8||128||8, 16||8, 16||1, 3, 7, 15 per line||1 tile layer and 1 bitmap layer|
|Sega Mega Drive / Genesis||1988||80||20||320||8, 16, 24, 32||8, 16, 24, 32||15||2 tile layers|
|Fujitsu FM Towns||1989||1024||64||1024||16||16||15||1-2 bitmap layers|
|Game Boy||1989||40||10||80||8||8, 16||3||1 tile layer|
|SuperGrafx||1989||128||32||512||16, 32||16, 32, 64||15||2 tile layers|
|Amstrad Plus||1990||Display list (run by CPU)||16||256||16||16||15||1 bitmap layer|
|Neo Geo||1990||384||96||1536||16||16 to 512||15||1 tile layer|
|Sega System 32||1990||8192||512||4096||8 to 1024||8 to 1024||15 to 512||4 tile layers and 1 bitmap layer|
|Super Famicom & SNES||1990||128||34||272||8, 16, 32, 64||8, 16, 32, 64||15||1-4 tile layers or 1 affine mapped tile layer|
|Amiga (AGA)||1992||Display list||8||448||16, 32, 64||Up to 256||3, 15||2 bitmap layers|
Taito SZ System
|1992||1024||162||2604||16 to 128||8 to 128||15 to 255||4 tile layers and 1 bitmap layer|
|Atari Jaguar||1993||1000||90||720||8 to 360||Up to 220||Up to 255||1 bitmap layer|
|Capcom CPS2||1993||900||65||1048||16 to 256||16 to 256||15||3 tile layers and 2 bitmap layers|
|Sega Saturn & ST-V||1994||16,384||512||4096||8 to 504||1 to 255||15 to 32,768||3-6 tile layers and 1-4 bitmap layers|
|Sony PlayStation||1994||4000||128||1024||8, 16, 256||8, 16, 256||15, 255||1 bitmap layer|
|Capcom CPS3||1996||1024||482||3861||8, 16||8, 16||63, 255||4 tile layers|
|Data East MLC System||1996||614||176||2828||16||16||15 to 255||2 tile layers|
|Hyper Neo Geo 64||1997||1535||384||3072||16||16 to 512||15, 255||4 tile layers|
|Game Boy Advance||2001||128||128||1210||8, 16, 32, 64||8, 16, 32, 64||15, 255||2-4 layers or 1-2 affine layers|
|Nintendo DS||2004||256 (128 per screen)||128||1210||8, 16, 32, 64||8, 16, 32, 64||15 to 32,768||8 layers (4 per screen); each layer is independent|
|Systems / Chips||Year||Sprites on screen||Sprites on line||Texels on line||Texture width||Texture height||Colors||Back-ground|