What Is Reality?
Reality was the name of our Wolfenstein 3D-style game engine, which became an umbrella term for anything related to that pursuit. The project aimed to create a fast and efficient first-person engine on a near-stock Amiga 1200 (020+FastRAM) in the mid-1990s. This archive contains the last known remaining compiled executables from my various attempts to achieve reasonable performance on the platform.
Originally, the Reality project was most active between 1994 and 1995. Apart from a few screenshots shared with close friends, it was never publicly released. The executables included here represent alpha-stage software—functional but far from stable. While they take over the system in as OS-friendly a manner as I knew at the time, modern systems may not handle them well.
About the Demos
Reality.exe - Ray Casting Experiment
This was the initial test of the engine, developed sometime in late 1993 or early 1994. The first major challenge was the chunky-to-planar (C2P) problem, where my initial attempts using unrolled bit sets failed spectacularly. While this approach might have worked for particle effects, it was a disaster for general-purpose rendering. However, after several iterations, I moved on to a bit-parallel rotation solution, which significantly improved performance.
This is the only version of Reality that employs a true ray-casting method. The scene is constructed by casting rays outward from the camera’s field of view, step by step, checking for wall collisions. Each map pixel represents a vertical wall strip, likely stored as 8-bit data, allowing for 256 unique wall textures.
Color depth was either 16 or 64 colors, which struck a balance between visual quality and conversion speed. This version laid the foundation for later advancements.
Map.exe - 64-Color 2D Polygon Walls
As development progressed, I re-evaluated the engine’s structure and opted for a different approach. Instead of a traditional grid-based map, I structured levels as a grid of evenly spaced vertices, where walls were formed by linking vertex pairs. This allowed for non-orthogonal walls and greater flexibility in map design.
Rendering involved rotating and projecting the sector vertices, which determined floor and ceiling heights. The scene was then processed polygon-by-polygon. For each wall, I interpolated across its top and bottom, computing its Z-depth and texture U-values. Instead of rendering strips immediately, the engine stored them in a Z-buffer, ensuring proper visibility sorting.
A unique optimization was that textures were stored rotated in memory, enabling rapid texel fetching using a simple 8-bit V-offset.
Project Reality - 256-Color Rendering & 3D Objects
By early 1994, the gaming world was in the grip of DOOM fever, and we ambitiously aimed to push Reality further. As Commodore's decline loomed, we set our sights on creating something akin to Blake Stone, but with even more complex environments and polygonal objects.
This demo showcases the most advanced features we implemented:
For polygonal objects, we experimented with a method where triangles were clipped against the depth buffer. The goal was to calculate the screen-space width of an object, scan across the depth buffer, and determine the visible clipping edges. This technique would have allowed objects to be properly occluded by walls while enabling partial visibility. While not perfect, it was an innovative approach at the time.
Unfortunately, time and talent ran out. By the time we reached this stage, the Amiga community had already embraced Fears, Gloom, Breathless, and Alien Breed 3D. The dream of completing Reality faded, but looking back, I still wish I had been able to bring my full vision to life on screen.
System Requirements
Final Thoughts
Reality remains a fascinating relic of my early game development journey. While it never reached a finished state, it reflects the passion and creativity that fueled many indie Amiga developers during the 1990s. This archive preserves those efforts—flawed but ambitious, a glimpse into what could have been.
