TL;DR
Thief: The Dark Project (1998) rendered its 3D world entirely in software; Sean Barrett was the primary author of the core renderer. The engine used a runtime portal-and-cell visibility system with bounding-octagon clipping to reduce overdraw, and later variants were adapted for hardware-accelerated builds used in other Looking Glass titles.
What happened
Released in 1998 as 3D hardware acceleration was emerging, Thief: The Dark Project shipped without GPU support and relied on a purely software rendering pipeline. Sean Barrett wrote the core rendering technology (excluding object and character renderers). The renderer implemented a portal-and-cell visibility scheme based on Seth Teller's 1992 dissertation: levels were split into convex cells connected by portals, and the engine performed a breadth-first traversal of portals from the viewpoint to determine visible cells at runtime. Each portal was transformed and projected; visibility contributions were represented as 2D "bounding octagons" (an axis-aligned box plus a 45-degree rotated box). Polygons were stored per-cell and clipped to these octagons, which reduced overdraw despite drawing geometry back-to-front. The same rendering core was later modified by others to run with 3D hardware acceleration for System Shock 2 and Thief 2.
Why it matters
- It preserved fully software-based 3D rendering late into the hardware-acceleration era, illustrating an alternative design path for complex indoor scenes.
- Runtime portal-and-cell traversal provided tighter, view-dependent culling than precomputed PVS lists used by some contemporaries.
- Bounding-octagon clipping offered a practical tradeoff to lower overdraw without full per-portal clipping.
- The renderer's architecture was flexible enough to be adapted later to hardware-accelerated versions used in other Looking Glass games.
Key facts
- Thief was released in 1998 and used only software rendering because its development predated widespread GPU use.
- Sean Barrett was the primary author of the engine's core rendering technology, but not the object/character renderers.
- The renderer employed a portal-and-cell visibility system, inspired by Seth Teller's 1992 dissertation.
- Portals and cells were precomputed, but Thief did not precompute a full PVS (potentially visible set); visibility was determined at runtime.
- Visibility through portals was represented as 2D "bounding octagons" (axis-aligned box + 45° rotated box) to quickly test and clip visible regions.
- World polygons were stored within cells and split where they crossed cell boundaries so they could be clipped by cell visibility octagons.
- Thief drew polygons back-to-front and reduced overdraw by clipping polygons to the visibility octagon for their cell.
- Texture coordinates used a 3D basis-vector approach (texture coordinates computed from basis vectors rather than per-vertex STs).
- Quake used precomputed PVS and span-buffering (edge-list) techniques; Thief's approach differed by using runtime portal traversal and octagon clipping.
- The same core renderer, later modified to use GPU acceleration, was used for System Shock 2 and Thief 2.
What to watch next
- The engine's full cell-and-portal analysis created overhead that became more apparent as polygon counts rose; this limited scalability when hardware-accelerated workflows were later applied.
- not confirmed in the source
- not confirmed in the source
Quick glossary
- Portal-and-cell: A level representation that divides space into convex cells connected by portals; visibility is determined by traversing portals between cells.
- PVS (Potentially Visible Set): A precomputed list of potentially visible regions or cells from a given location, used to speed up rendering by culling unseen geometry.
- Overdraw: Work done by the renderer when a pixel is drawn multiple times due to layered or overlapping geometry, increasing rendering cost.
- Bounding octagon: A conservative 2D visibility proxy combining an axis-aligned box and a 45-degree rotated box used to clip and cull geometry quickly.
- Span-buffering (edge list): A technique that draws surfaces front-to-back while tracking covered pixel spans so each pixel is shaded only once, reducing overdraw.
Reader FAQ
Was Thief hardware-accelerated when it shipped?
No. Thief shipped as a purely software-rendered game; hardware acceleration was not used in the released title.
Who developed the renderer?
Sean Barrett was the primary author of the core rendering technology; he did not write the object or character renderers.
Did Thief precompute visibility?
Thief precomputed portals and cells but did not precompute a full PVS; visibility was computed at runtime via portal traversal.
Was the Thief renderer ever adapted for GPUs?
Yes. The same rendering engine, modified by others to use 3D hardware acceleration, was used for System Shock 2 and Thief 2.
Did Thief use the same techniques as Quake?
Thief used ideas that overlapped with Quake (both used cell/portal concepts), but it differed in using runtime portal traversal, bounding-octagon clipping, and storing polygons per-cell rather than relying on Quake's precomputed PVS and span-buffering.
The 3D Software Rendering Technology of 1998's Thief: The Dark Project Sean Barrett 2011-09-19 In 1998 Looking Glass Studios released the stealth game Thief: The Dark Project. This was just…
Sources
- The 3D Software Rendering Technology of 1998's Thief: The Dark Project
- The 3D Software Rendering Technology of 1998's Thief
- The Dark Project (Project Diary)
- Thief: The Dark Project
Related posts
- What Is VO2 Max? The Cardiorespiratory Metric Linked to Longevity
- Five AirPods Pro 3 features Samsung and Google should adopt for flagship earbuds
- Documented NYC’s use of WeChat, WhatsApp and Nextdoor to reach immigrants