History of Computer Graphics
Computer graphics is the field concerned with generating, manipulating, and displaying images by computer. Its history extends from the experimental display systems of the 1950s and early 1960s to the photorealistic rendering and real-time interactive imagery that pervade modern life. Although the subject is filed here within the dawn of the Information Age, when graphics moved decisively onto the desktop, its full arc spans more than half a century of advances in display hardware, rendering algorithms, and specialized processors. Each of those advances enlarged what a computer could show and how quickly it could show it.
The growth of computer graphics was propelled by the steady advance of electronics. Early displays were constrained by the cost of memory and the speed of available circuits, and many fundamental techniques were devised precisely to economize on those scarce resources. As semiconductor memory grew cheaper and processors grew faster, the field progressed from drawing simple lines on a screen to simulating the behavior of light across complex three-dimensional scenes. The story of computer graphics is therefore inseparable from the broader story of computing hardware, even as it was shaped at every step by the ingenuity of the algorithms that ran on that hardware.
Early Vector Displays and Sketchpad
The earliest interactive computer graphics relied on vector displays, which drew images as line segments traced directly on the face of a cathode ray tube. An electron beam was steered from point to point by a pair of deflection amplifiers under program control, illuminating the phosphor along its path. Because the display drew only the lines that made up a figure, rather than scanning the entire screen, vector systems suited the line drawings of engineering and scientific work and required far less memory than later approaches. Their cost lay instead in refresh: the picture had to be redrawn dozens of times per second from a display list held in memory, so the number of lines a system could show without visible flicker set a hard limit on scene complexity.
The Whirlwind and SAGE
Among the first computers to display graphical information interactively was Whirlwind, developed at the Massachusetts Institute of Technology and operational in the early 1950s. Robert Everett devised for it a handheld light gun, the ancestor of the light pen, which let an operator point at a spot on the screen and have the computer identify what had been selected. These techniques were carried into the SAGE air defense system, built by IBM to a Lincoln Laboratory design and fully deployed by the early 1960s. SAGE consoles presented radar tracks on large circular displays, and an Air Force operator could touch a track with the light gun to obtain a report on a target's course and speed, or to instruct the system to follow it. SAGE demonstrated on a national scale that a computer could maintain a graphical picture of changing data and respond to direct operator input, establishing principles that interactive graphics would build upon.
Sketchpad
The decisive early milestone was Sketchpad, created by Ivan Sutherland at MIT's Lincoln Laboratory in 1963 as the subject of his doctoral research, running on the experimental TX-2 computer. Using a light pen and a vector display, a user could draw figures directly on the screen and manipulate them interactively. Sketchpad introduced ideas that remain central to computer graphics, including geometric constraints that the system solved automatically, the reuse of master drawings as instances so that editing a master updated every copy, and the internal representation of a picture as structured data rather than as a fixed grid of dots. It is widely regarded as the origin of interactive computer graphics and of computer-aided design, and it anticipated the object-oriented style of describing pictures that later graphics systems adopted.
Vector Graphics in Practice
Through the 1960s and into the 1970s, vector displays served the demanding applications of the day. Engineering workstations used them for design work, flight simulators for instrument and scene displays, and laboratories for the visualization of data. Specialized display processors, such as the picture systems built by Evans and Sutherland, offloaded the repetitive task of refreshing the picture from the main computer and performed transformation and clipping in hardware. A cheaper alternative was the direct-view storage tube, exemplified by Tektronix terminals of the early 1970s, which retained a drawn image on the phosphor without refresh and so brought graphics within reach of modest budgets, at the cost of being unable to erase anything selectively. Vector graphics dominated wherever crisp lines and interactive response mattered more than filled, shaded imagery, and they persisted in niches well after raster methods rose to prominence, including arcade games such as Asteroids and Battlezone at the turn of the 1980s.
The Rise of Raster Graphics
Raster graphics represents an image as a rectangular grid of individually addressable picture elements, or pixels, each holding a color or intensity value. The complete image is stored in a region of memory called the frame buffer and displayed by scanning the screen line by line, exactly as a television does. Raster displays can render filled areas, shaded surfaces, and photographic images that vector displays could not, and their cost is fixed by the size of the screen rather than by the complexity of the picture. The approach became practical only once memory grew inexpensive enough to store an entire screen of pixels.
The Frame Buffer
The practical frame buffer emerged in the early 1970s, notably in the work of Richard Shoup and others at the Xerox Palo Alto Research Center, whose SuperPaint system of 1972 and 1973 stored a full color image in memory and allowed it to be painted and edited. Memory was the binding constraint: a modest display of a few hundred lines demanded hundreds of kilobits of storage at a time when semiconductor memory was priced by the bit. Early systems economized by storing only a few bits per pixel and passing them through a color lookup table, a palette that mapped a small set of stored codes onto a much larger range of displayable colors. As memory prices fell through the decade, frame buffers grew from a handful of colors toward the twenty-four bits per pixel of full color at steadily increasing resolutions. The frame buffer became the foundation of nearly all subsequent display technology, the surface on which rendered images would be assembled.
Foundational Raster Algorithms
Raster graphics required new algorithms to convert geometric descriptions into arrays of pixels efficiently. Jack Bresenham, working at IBM, devised a line-drawing algorithm that used only integer addition and comparison, avoiding the division and rounding that a direct evaluation of the line equation would demand; it remains the textbook method and maps readily into hardware. Other work established the rest of the raster toolkit: methods to fill polygons by scanning across them one line at a time, John Warnock's recursive subdivision approach to hidden-surface removal, and the Sutherland and Hodgman algorithm for clipping polygons against the boundaries of a viewing region. Sampling a continuous shape onto a discrete grid also produced jagged, staircased edges, a defect addressed by antialiasing, which computes intermediate intensities for pixels that a shape only partly covers. These techniques, refined through the 1970s, established the computational core on which interactive raster graphics would depend.
Shading and Texture
Much of this work came from a single remarkable group at the University of Utah, founded by Ivan Sutherland and David Evans, whose students defined the shading and rendering methods of the era. To make surfaces appear solid and curved rather than faceted, researchers developed shading models that computed how light reflected from a surface. Henri Gouraud introduced smooth shading in 1971 by computing intensity at each vertex and interpolating it across a polygon. Bui Tuong Phong introduced a more refined model in his 1973 dissertation, interpolating the surface normal rather than the intensity and adding a specular term that produced convincing highlights. Edwin Catmull demonstrated texture mapping in 1974, wrapping a stored image onto a curved surface to add detail without adding geometry, and James Blinn extended the idea in 1978 with bump mapping, which perturbs the surface normal to simulate roughness on a geometrically smooth surface. The group also produced the standard test objects of the field, including Martin Newell's teapot of 1975, still used as a benchmark model. These advances gave rendered images a far greater sense of depth and material reality.
Color and Image Compositing
A rendered image is of little use unless the display reproduces its colors faithfully, and the numbers held in a frame buffer are related to the light a monitor emits only through a chain of conventions. Computer graphics therefore absorbed the science of colorimetry, developed for photography and television long before computers could generate pictures, and added to it the particular problems of limited palettes, nonlinear displays, and the combination of images computed separately. Color handling grew from an afterthought of the earliest frame buffers into a discipline with standards of its own.
Color Models and Colorimetry
Human color vision responds to light through three classes of cone cell, so a wide range of colors can be matched by a mixture of three suitably chosen primaries. The International Commission on Illumination formalized this in 1931 with a standard observer and a chromaticity diagram that assigned coordinates to every visible color, giving engineers a common language for specifying it. Display hardware works in the additive red, green, and blue primaries produced by its phosphors or emitters, and printing works in the subtractive cyan, magenta, yellow, and black inks, so the range of colors a device can reproduce, its gamut, differs from device to device and no device covers the whole diagram. Because red, green, and blue coordinates correspond poorly to the way people describe color, Alvy Ray Smith introduced the hue, saturation, and value model in 1978, giving artists axes that matched their vocabulary while converting readily to and from the primaries that the hardware required.
Gamma, Quantization, and Dithering
A cathode ray tube does not emit light in proportion to its input voltage; luminance rises roughly as the input raised to the power of 2.2. Images were therefore encoded with approximately the inverse of that curve, a practice known as gamma correction, which had the convenient effect of distributing the available code values in rough proportion to the sensitivity of the eye. Disagreement over where in the pipeline the correction belonged produced years of mismatched images between systems, and the sRGB specification, published by Hewlett-Packard and Microsoft in 1996, settled the matter for consumer equipment by fixing the primaries, the white point, and the transfer function. A second problem arose from frame buffers too shallow to hold full color. Reducing a photograph to the 256 entries of a palette required choosing those entries well, which Paul Heckbert accomplished in 1982 by repeatedly splitting the distribution of colors in the image, and it required disposing of the resulting error, which the error-diffusion method published by Robert Floyd and Louis Steinberg in 1976 did by pushing the rounding error of each pixel onto its unprocessed neighbors. The result traded visible banding for a fine texture that the eye readily forgives.
Compositing and the Alpha Channel
Complex images are rarely computed all at once. Film effects in particular combine elements rendered or photographed separately, and doing so requires knowing not only the color of each pixel in an element but also how much of that pixel the element covers. Edwin Catmull and Alvy Ray Smith introduced an additional channel to carry this coverage, called alpha, alongside the red, green, and blue values. Thomas Porter and Tom Duff placed the practice on a firm algebraic footing in 1984 by enumerating the operators for combining two images with alpha and showing that multiplying color by coverage in advance made those operators simple and associative. Their formulation underlies every layered image editor, every windowing system that draws translucent elements, and every effects pipeline that assembles a frame from dozens of separately rendered pieces.
Geometric Modeling and Curved Surfaces
Before a scene can be rendered, it must be described. The problem of representing shape inside a computer proved as deep as the problem of drawing it, and it was pressed forward by the automobile and aircraft industries, whose designers needed to define smooth surfaces precisely enough to cut dies and machine parts from them. The representations they developed, and the solid modeling that followed, gave computer graphics its vocabulary of curves, surfaces, and volumes.
Curves and Surfaces
Draftsmen had long drawn fair curves with flexible wooden splines held in place by weights, and the mathematical spline replaced them with piecewise polynomials joined so that their slopes and curvatures agree. Steven Coons at MIT described in 1967 how to define a surface patch from its four bounding curves, and the automobile industry produced the formulation that spread furthest: Pierre Bézier at Renault published a curve defined by a small set of control points that shape it without lying on it, developed for the UNISURF design system, while Paul de Casteljau had derived equivalent mathematics at Citroën several years earlier under conditions of commercial secrecy. B-splines generalized the idea with local control, so that moving one control point disturbs only a limited span of the curve, and the dissertation of Richard Riesenfeld in 1973 brought them into design practice. The rational form, in which each control point carries a weight, added the ability to represent circles and conic sections exactly. Kenneth Versprille formalized that form in 1975, and non-uniform rational B-splines, universally abbreviated NURBS, became the standard surface representation of computer-aided design and of the data-exchange formats built around it.
Solid and Polygonal Models
Curves and surfaces describe the skin of an object but say nothing about whether a point lies inside it, a distinction that matters for machining, for mass properties, and for checking whether two parts interfere. Solid modeling supplied the answer along two lines. Constructive solid geometry, developed by Herbert Voelcker and Aristides Requicha at the University of Rochester during the 1970s, built objects as Boolean combinations of primitive volumes such as blocks, cylinders, and spheres. Boundary representation, advanced by Ian Braid at Cambridge in the same decade, described a solid by its faces, edges, and vertices together with the topology that connects them. Rendering, meanwhile, generally reduced whatever representation a modeler used to a mesh of triangles, since a triangle is always planar, always convex, and cheap to process; the polygon mesh became the common currency between modeling and display. James Clark showed in 1976 how to organize such models hierarchically and to substitute simpler versions of distant objects, the technique of level of detail that remains essential to rendering large scenes.
Procedural and Subdivision Methods
Describing a mountain range or a forest control point by control point is impracticable, so researchers turned to procedures that generate detail from compact rules. The work of Benoit Mandelbrot on fractals suggested that natural terrain could be synthesized by recursive subdivision with random displacement, and Loren Carpenter demonstrated the result in his short film Vol Libre of 1980, which showed fractal mountains rendered in flight and brought him to Lucasfilm. The grammars that Aristid Lindenmayer devised in 1968 to describe plant growth for theoretical biology were adapted to generate trees and foliage. Subdivision surfaces took a different route to smoothness: rather than fitting a patch, they refine a coarse polygon mesh repeatedly toward a smooth limit surface. Edwin Catmull and James Clark, and independently Doo and Sabin, published the founding schemes in 1978, and subdivision later became the preferred representation for animated characters because it accommodates the arbitrary mesh topology that patches cannot.
Three-Dimensional Rendering Milestones
Rendering is the process of computing a two-dimensional image from a description of a three-dimensional scene. Over several decades, researchers devised rendering methods of increasing physical fidelity, each capturing more of the subtle behavior of light. These milestones progressively narrowed the gap between synthetic images and photographs, at a steadily rising cost in computation that advancing hardware was called upon to meet.
Hidden Surfaces and the Z-Buffer
A fundamental problem of three-dimensional rendering is determining which surfaces are visible and which are hidden behind others. Edwin Catmull described the depth buffer, or z-buffer, in his 1974 doctoral work, storing the distance to the nearest surface found so far at each pixel and overwriting a pixel only when a nearer surface is drawn; Wolfgang Straßer arrived at the same idea independently. The method dispenses with the sorting that earlier visibility algorithms required, handles intersecting and interpenetrating objects without special cases, and processes primitives in any order, at the price of one additional word of memory per pixel. That trade grew steadily more attractive as memory prices fell, and the z-buffer became the dominant method of visible-surface determination. It remains central to real-time graphics today, implemented directly in hardware in every modern graphics processor.
Ray Tracing
Ray tracing computes an image by following the paths of light rays through a scene. Arthur Appel proposed casting rays from the eye to determine visibility and shadows in 1968, and Turner Whitted made the method recursive in 1980, spawning new rays at each surface to follow reflection and refraction. His images of mirrored and glass spheres above a checkered plane produced accurate reflections, refractions, and sharp shadows, and their realism astonished contemporaries. The method was computationally expensive, far too slow for interactive use at the time, since the cost scales with the number of rays and each ray must be tested against the scene geometry. It nonetheless set a standard of optical accuracy toward which the field would steadily work, and dedicated ray-tracing hardware finally reached consumer graphics cards in 2018.
Global Illumination
Realistic images require accounting for light that reflects repeatedly among surfaces, softly illuminating areas that no direct light reaches. The radiosity method, introduced by Cindy Goral, Kenneth Torrance, Donald Greenberg, and Bennett Battaile at Cornell University in 1984, adapted techniques from thermal engineering to model this diffuse interreflection, solving a system of energy-balance equations among surface patches. It produced the gentle gradations and color bleeding seen in interiors, and the Cornell box built to validate it against physical measurement became a standard test scene. James Kajiya unified these strands in 1986 with the rendering equation, a single integral formulation of light transport, together with path tracing, a stochastic method for approximating it. Global illumination, the faithful simulation of all the light transport within a scene, would in time yield images difficult to distinguish from photographs.
Animation Techniques
A still image is a special case. Computer graphics acquired its cultural weight when it learned to move, and moving imagery raised problems that rendering alone does not address: how to specify motion, how to make it plausible, and how to produce it for hundreds of objects at once. The techniques that answered those questions came variously from traditional animation practice, from robotics, and from physics.
Keyframes and Articulated Figures
Traditional animation is built from key drawings by a senior artist, with intermediate frames filled in by assistants, and the earliest computer animation systems automated the second half of that division of labor. Nestor Burtnyk and Marceli Wein built such a system at the National Research Council of Canada in the early 1970s, and Peter Foldes used it for the short film Hunger of 1974, which earned an Academy Award nomination; the two researchers received an Academy Award for technical achievement in 1997. Applying the same idea to three-dimensional figures required interpolating positions and orientations rather than drawings, which made the mathematics of smooth interpolation, and of rotation in particular, a practical concern. Articulated characters introduced a further difficulty, since an animator who wants a hand to reach a doorknob prefers not to specify each joint angle along the arm. Inverse kinematics, borrowed from robotics, solves for the joint angles that place an end point where the animator asks, and it became a standard feature of character animation software.
Motion Capture
An alternative to specifying motion is to measure it. Systems that record the movement of a human performer and map it onto a synthetic figure were explored at MIT and elsewhere during the early and middle 1980s, first with instrumented harnesses and then with optical trackers that follow reflective markers using several cameras at once. Optical capture matured into commercial equipment during the 1990s, and it gave animation a fidelity to human movement that hand animation achieves only with great labor. It also imported the limitations of measurement: captured data carries noise, requires cleaning, and describes only the performer who was recorded, so retargeting it onto a figure of different proportions became a research problem in its own right.
Procedural and Physically Based Animation
Some motion is easier to compute than to specify. William Reeves developed particle systems at Lucasfilm to animate fire, explosions, and other phenomena with no definite surface, representing them as clouds of simple elements governed by simple rules; the technique produced the planet-forming sequence of Star Trek II: The Wrath of Khan in 1982, and Reeves published it the following year. Craig Reynolds applied the same philosophy to groups in 1987 with his flocking model, in which each simulated bird follows three local rules and the coordinated motion of the flock emerges without being scripted; the method animated the bats and penguins of Batman Returns in 1992. Physically based methods took the further step of integrating the equations of motion, simulating rigid bodies, cloth, deformable solids, and eventually fluids, so that the animator specifies conditions rather than movement. The noise function that Ken Perlin introduced in 1985, meanwhile, supplied controlled randomness for both surfaces and motion, letting a compact procedure generate marble, clouds, and irregular movement; he too received an Academy Award for technical achievement in 1997.
Graphics Standards and Programming Interfaces
As graphics hardware proliferated, software written for one machine rarely ran on another. Standard programming interfaces solved this by defining an abstract rendering model that any vendor could implement, letting applications outlive the hardware they were written for and letting hardware makers compete on speed rather than on captive software. The interface layer proved as consequential for the field as any single algorithm.
Early Standards
The first efforts at portability produced the Graphical Kernel System, adopted in the mid-1980s as the first international standard for computer graphics programming, and its successor PHIGS, the Programmer's Hierarchical Interactive Graphics System, which added a structured, editable database of the scene. Both were conceived in the era of vector and workstation displays, and both proved too general and too far removed from the underlying hardware to deliver the speed that interactive three-dimensional rendering demanded. Their lasting contribution was the principle rather than the interfaces themselves.
Device-Independent Page Description
Printing posed a parallel problem. Each printer accepted its own control codes, so a document that printed correctly on one machine could not simply be sent to another. John Warnock and Charles Geschke, who had worked on the question at the Xerox Palo Alto Research Center, founded Adobe Systems in 1982 and released PostScript in 1984 as a complete programming language for describing a page: text, vector artwork, and images alike were expressed as procedures that an interpreter inside the printer executed to produce marks. Apple licensed it for the LaserWriter of 1985, and the combination of that printer, a Macintosh, and page-layout software created desktop publishing. PostScript established the value of describing an image independently of any device and resolving it at the resolution of whatever device rendered it, a principle the Portable Document Format later carried to the screen.
OpenGL and Direct3D
Silicon Graphics had developed IRIS GL as the native interface to its workstations. In 1992 the company reworked it into OpenGL, an open specification that competitors could license, and placed it under an industry consortium, the OpenGL Architecture Review Board. OpenGL exposed the rendering pipeline directly and became the standard interface for professional graphics, scientific visualization, and, in time, portable game development. Microsoft answered with Direct3D, built on technology acquired from RenderMorphics in 1995 and first shipped as part of DirectX in 1996. The rivalry between the two interfaces shaped consumer graphics for a decade, since a feature had to be reachable through an interface before hardware makers had any reason to build it, and the interfaces in turn had to expose what the hardware could newly do.
The Rise of the Graphics Processor
As graphical demands grew, designers moved the work of generating images out of the general-purpose processor and into specialized hardware. Rendering is unusually well suited to this treatment: the same short calculation is applied to millions of independent pixels or vertices, so throughput matters far more than latency and the work parallelizes almost perfectly. Dedicated graphics circuits could therefore perform the repetitive operations of drawing and shading far faster than software, and their evolution culminated in the graphics processing unit, a highly parallel processor devoted to imagery.
Early Acceleration and Workstations
During the 1980s, dedicated graphics hardware appeared in high-end workstations, arcade machines, and the more ambitious home computers. Silicon Graphics, founded in 1982 around the Geometry Engine, a chip for rapid geometric transformation devised by James Clark, built workstations whose pipelines of specialized processors accelerated the transformation, clipping, and rendering of three-dimensional scenes. Such machines powered engineering, scientific visualization, and the emerging field of digital film effects, and they defined the state of the art for a decade. At the other end of the market, the Commodore Amiga of 1985 paired its processor with custom chips including a blitter for rapid block transfers of pixel data and a display coprocessor that could alter video parameters line by line, delivering graphical performance far beyond that of contemporary machines at a consumer price.
Graphics Reaches the Personal Computer
On personal computers, graphics capability advanced through a succession of display adapters. IBM's Color Graphics Adapter of 1981 offered a few colors at coarse resolution, the Enhanced Graphics Adapter of 1984 improved on it, and the Video Graphics Array of 1987 established the resolutions and the 256-color mode that would anchor personal computer graphics for years. These devices merely displayed a frame buffer; the processor did all the drawing. From about 1991, accelerator chips began performing common windowing operations such as block transfers, line drawing, and rectangle fills in hardware, which transformed the responsiveness of graphical interfaces. Three-dimensional acceleration followed in the second half of the decade, most decisively with the 3dfx Voodoo Graphics of 1996, a card devoted solely to three-dimensional rendering that passed the output of a separate two-dimensional card through to the monitor. By taking over texture mapping, depth testing, and pixel blending, such cards brought real-time three-dimensional rendering to ordinary desktop machines for the first time.
The Graphics Processing Unit
By the end of the 1990s, accelerators had begun to absorb the remainder of the rendering pipeline, including the geometric transformation and lighting stages still performed by the central processor. NVIDIA released the GeForce 256 in October 1999 with those stages implemented in silicon and marketed it as the first graphics processing unit, a term that quickly became general. Built from large numbers of parallel arithmetic units, the GPU proved exceptionally efficient at the highly repetitive calculations of rendering. Its fixed pipeline gave way to programmable shading in the early 2000s, and once the shading units became general enough, interfaces for general-purpose computation on the GPU followed later in the decade. That parallel power would go on to serve scientific computation and machine learning, but its origin lay in the relentless demand for faster and richer images.
Graphics in Film and Games
Two industries did more than any others to drive computer graphics forward and to bring it before the public: motion pictures and video games. Film demanded the highest possible image quality without regard to rendering time, since a frame could take hours on a render farm. Games demanded images generated within milliseconds in response to a player, and were willing to approximate almost anything to get them. Between them they pressed the field toward both photorealism and real-time performance, and the tension between their differing needs accelerated progress on every front.
Computer Graphics in Film
The film industry adopted computer graphics gradually and then decisively. Westworld used computer-processed imagery for an android's point of view in 1973, and its sequel Futureworld introduced three-dimensional computer-generated imagery to a feature film in 1976. Tron in 1982 and The Last Starfighter in 1984 built extended sequences on the technique, the latter rendered on a Cray supercomputer. The first fully computer-generated character in a feature appeared in Young Sherlock Holmes in 1985, animated by the Lucasfilm group that would become Pixar. The water creature in The Abyss of 1989 and the liquid metal figure in Terminator 2: Judgment Day of 1991 then demonstrated digital characters convincing enough to carry dramatic scenes. Jurassic Park, released in 1993, presented computer-generated dinosaurs of such realism that they persuaded audiences worldwide and effectively settled the question of whether the technique belonged in mainstream filmmaking. The first entirely computer-animated feature, Toy Story, appeared in 1995, proving that digital imagery could sustain a full-length narrative.
The Rise of Real-Time Game Graphics
Video games carried interactive graphics into homes and arcades and demanded ever-faster rendering. Early games used simple two-dimensional sprites moved across the screen by dedicated video circuitry, but through the 1980s and early 1990s designers pursued three-dimensional effects with increasingly clever approximations. Wolfenstein 3D in 1992 and Doom in 1993 built convincing interior spaces on constrained geometry and fast software rasterizers, and Quake in 1996 delivered fully three-dimensional worlds in software before being adapted to the new accelerator hardware. Home consoles released in the mid-1990s, including the Sony PlayStation, the Sega Saturn, and the Nintendo 64, incorporated dedicated three-dimensional hardware and brought real-time rendered worlds to a mass audience. The constant pressure for richer game graphics at interactive speeds became the principal force driving consumer graphics hardware, a role it retains.
Production Tools and Rendering Software
Behind both film and games stood a growing body of software for modeling, animation, and rendering. Pixar's RenderMan, whose interface specification was published in the late 1980s, defined a standard description of a scene and an efficient architecture for rendering it, and it produced many of Hollywood's effects for two decades. Modeling and animation packages from Wavefront, Alias, Softimage, and Autodesk brought capable three-dimensional tools first to workstations and then to personal computers, while Adobe Photoshop, released in 1990, did the same for the editing of raster images. These tools turned computer graphics from a research discipline into a practical craft with an established professional workflow, accessible to artists rather than only to programmers.
The Graphical User Interface and Visualization
Beyond entertainment and design, computer graphics transformed how people interacted with computers and how they understood data. The graphical user interface made the computer accessible to a general public, while scientific and information visualization turned the computer into an instrument for insight. Both depended on the same raster display technology that served film and games, and both extended the reach of graphics far beyond the production of pictures.
The Graphical User Interface
The graphical user interface, with its windows, icons, menus, and pointer, grew from research at the Xerox Palo Alto Research Center in the 1970s, embodied in the experimental Alto computer and the later Xerox Star. The Apple Macintosh of 1984 brought the approach to a wide market, the Amiga and the Atari ST followed in 1985, and the X Window System gave the technical workstation a network-transparent graphical environment over the same period. Microsoft Windows reached broad acceptance with its third version in 1990 and carried the interface to the majority of personal computers over the following decade. Each of these systems depended on a raster frame buffer and on fast block transfers of pixel data, which is why the graphical interface arrived only when it did. By representing files and commands as manipulable graphical objects, the interface made computing intelligible to people with no technical training and turned the display from a passive readout into the principal means of control.
Scientific and Information Visualization
Computer graphics gave scientists and engineers powerful means to comprehend complex data. Visualization techniques rendered the results of simulations, medical scans, and large datasets as images that revealed structure invisible in tables of numbers. Computed tomography, developed in the early 1970s, reconstructed cross sections of the body from scanner data, and the marching cubes algorithm published in 1987 provided a general way to extract a three-dimensional surface from such volumetric measurements. A National Science Foundation report of the same year named scientific visualization as a discipline and argued that supercomputers were producing data faster than researchers could interpret it. Visualization spread to flows, fields, molecular structures, and eventually to abstract and statistical data, and as datasets grew, the visual representation of information became an indispensable tool of research and analysis in its own right.
Research Centers and the Growth of the Field
Computer graphics advanced through an unusually concentrated set of laboratories and an unusually open literature. A subject that occupied a few dozen researchers in 1970 supported a global industry within twenty years, and the path from the one to the other ran through a small number of institutions whose alumni founded much of that industry.
Laboratories and Their Alumni
The University of Utah, where David Evans and Ivan Sutherland built a graphics program under funding from the Advanced Research Projects Agency, produced within a single decade the shading models of Gouraud and Phong, the texture mapping and depth buffer of Catmull, the hidden-surface work of Warnock, and the geometry hardware of Clark. Its graduates went on to found or to lead Adobe, Silicon Graphics, Pixar, and Netscape. Alexander Schure established the Computer Graphics Laboratory at the New York Institute of Technology in 1974 and hired Catmull to run it; much of that group moved to the computer division that Lucasfilm created in 1979, which was sold in 1986 and became Pixar. Donald Greenberg founded the Program of Computer Graphics at Cornell University in the same year as the New York laboratory, and it became the center of research into the physics of light transport, producing the radiosity method and the physical measurements against which rendering accuracy was checked.
Conferences, Textbooks, and Recognition
The Association for Computing Machinery established a special interest group for graphics in the late 1960s and held the first SIGGRAPH conference in 1974. Its proceedings became the principal record of the field, and a paper accepted there generally reached practitioners within a year rather than a decade, which is one reason techniques moved so quickly from research into products. Textbooks consolidated the results for a wider audience: William Newman and Robert Sproull published an early comprehensive treatment in 1973, and the volume by James Foley, Andries van Dam, and their coauthors, first issued in 1982 and substantially rewritten in 1990, taught a generation of practitioners. Recognition followed the practical influence of the work. The Academy of Motion Picture Arts and Sciences has given scientific and technical awards to the authors of rendering and animation methods for decades, and Edwin Catmull and Pat Hanrahan received the 2019 A.M. Turing Award for contributions to three-dimensional computer graphics and their effect on computer-generated imagery in filmmaking.
Summary
The history of computer graphics runs from the vector displays of the 1950s to the photorealistic and interactive imagery of the present. Sketchpad established interactive graphics and computer-aided design, and vector displays served engineering and simulation through the era of scarce memory. The frame buffer and the raster algorithms of the 1970s, together with the shading and texturing methods that accompanied them, made solid, shaded, and photographic imagery possible, while colorimetry, gamma correction, and the alpha channel governed how those images were reproduced and combined. Geometric modeling supplied the descriptions that rendering consumes, from Coons patches and NURBS through solid modeling to procedural and subdivision surfaces, and animation techniques from keyframe interpolation to particle systems and physical simulation set those descriptions in motion. Rendering milestones, from the z-buffer through ray tracing to the rendering equation, steadily closed the distance between synthetic images and photographs, while standard programming interfaces such as OpenGL and Direct3D let software and hardware advance independently.
Specialized hardware evolved from the display processors of the 1970s through the accelerators of the 1990s into the graphics processing unit, bringing rich real-time rendering to ordinary computers and, in a late turn, becoming the workhorse of scientific computation and machine learning. The film and game industries drove the field toward photorealism and real-time performance respectively, while the graphical user interface and the practice of visualization extended the influence of graphics into everyday computing and scientific research. A small group of laboratories and an open conference literature carried each advance from research into practice with unusual speed. At every stage the progress of computer graphics depended on advancing electronics, yet it was equally the product of the algorithms devised to make the most of the hardware of each era. The discipline that began with simple lines on a screen now renders worlds, and it underlies much of how people see and use computers today.