syltefar.com

Game Rendering Types

Date     : 2022-07-31
Entry ID : 16608

From the earliest video games in the 1960s to early 3D games in the 1990s, 4 basic types of rendering technology have been used: vector graphics, raster bar graphics, tiles and sprites, and framebuffer graphics. In modern game hardware (since the mid-1990s), framebuffer rendering with dedicated 3D hardware are ubiquitous, as this is a very flexible approach to both 2D and 3D graphics, but this approach was not always practical during the early decades of video game history, as memory was very expensive.

Types of Rendering

This article describes the foundational types of computer graphics rendering used by video games throughout the years, starting from the 1960s to the early 1990s.

The following terms are used:

• Bitmap: Spatially mapped pixel array, a sequence of pixels ordered in memory in a similar fashion to how they should be displayed.
• Framebuffer: Memory containing a bitmap, driving a video display

Vector Graphics

The very first games such as Steve Russel's Spacewar! (1962) controlled the electron beam of their cathode ray tube (CRT) displays directly, drawing lines of varying light intensity between points. This form of graphics is known as vector graphics.

Atari would create particularly famous examples of vector graphics rendering, including 'Lunar Lander' and 'Asteroids' from 1979, first-person shooter 'Battlezone' from 1980, and 'Star Wars' from 1983. In 1982, Los Angeles-based Smith Engineering released the Vectrex, a home console with a built-in vector display.

Vector displays have become rare, but it is highly recommended to try out original arcade games like Asteroids to see this type of display, the contrast and smoothness can look very different from a normal CRT display.

Raster Bar Graphics

In home TV screens, the electron beam would automatically scan the screen left-to-right, top-to-bottom, 50 or 60 times per second in a horizontal line pattern. This fixed pattern is called 'raster scanning'.
Atari's 'Pong' (1972) was designed to be compatible with this type of TV display, and instead of controlling the electron beam's position freely, the beam output intensity would be controlled as a function of the x- and y-position of the electron beam, which would create colored areas on the screen. This approach normally results in blocky graphics with right angles. We might call this 'Raster Bar Graphics'.

The approach of changing the beam color on the fly would be used extensively on the Atari 2600 home console, where incredibly simple graphics hardware forced developers to make very creative choices. Read Nick Montforts and Ian Bogost's 'Racing the Beam' ¹ for great stories about the challenges of Atari 2600 development.

Tiles and Sprites

Graphics in many video games from the 1980s and early 1990s with was implemented using a combination of tiles, tilemaps, and sprites. Tiles and sprites would defined using bitmaps, spatially mapped arrays of pixel color data, and tilemaps would map tiles to display positions in a fixed grid on the screen. Video controllers would take this representation of tiles and sprites and display it directly on the screen. We will refer to this type of graphics as tile-based graphics.

The benefit of tile-based graphics is lower memory usage, something absolutely critical during this era, as memory chips were prohibitively expensive. With tiles and tilemaps, full screens of graphics can be represented using a small set of tiles, repeated in the tilemap to form larger graphics. Essentially, it is a form of manual image compression.

A classic example of tile-based graphics is Namco's Pac-Man (1980), where the maze and dots are displayed using tiles. This rendering type would be ubiquitous in arcade games in the 1980s and 1990s, and several home consoles would be designed this way, including Nintendo's NES (1983) and of course, the SEGA Genesis (1988).

Framebuffer Rendering

Computers from this era would also have tiles and sprites, but would often require more flexibility to render application GUIs, graphs, word processing, and the like.

This would be accomplished by rendering graphics in software to a bitmap in memory, called a framebuffer, and then displayed. This approach required more memory, but enabled the ultimate rendering flexibility. First off, previously mentioned rendering techniques could be supported: vector graphics could be emulated in software and rendered to a framebuffer, and, tiles and sprites could be supported in hardware and rendered on top of a framebuffer, and raster bar graphics could be emulated by modifying the color palette during scanline rendering.

Besides emulating existing techniques, framebuffer rendering enabled new techniques such as filled polygon rendering or raycasting 3D graphics.

Changelog

2025-01-04: Copied article originally written for namelessalgorithm.com in 2022-07-31

References