Interview with John Hendrikx

I think that would be in 1994, a few years after Wolfenstein and I think slightly before Doom was released. I remember seeing Doom, and being intrigued on how they achieved the floors and ceilings, and the illusion of staircases. I also remember rewriting big parts of the engine to incorporate these features (initially it was much more like Wolfenstein).

They were more concepts. I did not really focus much on the possibility of making a game out of the engine, I was primarily concerned with trying to get the most out of limited processing power and a graphics chip that was fundamentally unsuited for easy display of a fully rendered world (the same graphical layout of data that made the Amiga great at scrolling platformers, made it really hard to do texture mapped games requiring so called "chunky to planar" conversions which were very costly).

So in reality both games were just concepts which could possibly be built on the engine.

The idea was to construct the games with data files (let's say an early version of XML :)) -- in some releases of the demo one could see how we defined which textures to be loaded and how a level should look like. We never progressed much further than the concept of the games and so we hadn't looked into the possibility of specific customizations for the engine yet.

It basically worked by drawing walls that were specified in a 2d map. The walls in these maps had a texture associated with them, but also height information. A very low wall could be used to represent a step in a staircase for example, and by adding more of these walls in a neat row you could create the illusion of a stair case. In between wall segments, floors and ceilings could be drawn. The texture for a floor was associated with the walls that surrounded it, so in the map file itself floors and ceilings were just a feature of the appropriate wall segment, and not something you could specify directly.

Internally, the engine would basically cast a "ray of light" to each horizontal position on your screen (so for a screen of 320 pixels wide, it would cast 320 rays). It would then calculate which wall such a ray hits (depending on your position and direction you are viewing) and then draw the appropriate portion of wall on the screen. If that wall did not occupy the entire vertical line of space, the engine looked for the next wall and drew part of that, until the whole vertical line of screen was filled. This also included drawing floors and ceilings above and below the wall portions (floors and ceilings were nothing more than a texture associated with a specific wall). This procedure simply repeated until a screen was rendered, then shown to the user.

The goal was to scale with the power your Amiga had available. The lowest model it would work on though was the A1200, but the later versions of the engine could take advantage of better CPU's, more memory, higher resolutions and even 3rd party graphic cards.

Given how the Amiga market was, the target model would have been the A1200 even though it was not nearly powerful enough to do full-screen texture mapping at for example 320x256 resolution.

The engine was far from complete, as the main focus for me was always to get the most out of limited resources. For a full game we would still need to create AI for monsters, a point/click interface for picking up objects, weapons and so on. Overall I was pretty happy with the feature set we had, but disappointed that the Amiga platform was ill-equipped to do this kind of graphics rendering.

Plenty, the main challenge was always to get the most out of the Amiga systems available at the time. The main bottleneck for getting the fastest updates was always the AGA chipset which did not have a display mode that was suited for this kind of rendering. What we needed was a so-called "chunky" display, where one byte in memory represented one pixel on the screen. Instead on AGA we had to update 8 different locations just to modify one pixel on screen due the planar layout of screen information on Amigas -- the fastest solutions therefore always incorporated a chunky buffer in RAM to do the rendering, which was then subsequently converted to the Amiga's display format by a chunky to planar convertor. Obviously, having to convert an entire screen worth of data for each frame rendered was a major performance bottleneck.

Other solutions were possible, as other engines demonstrated, but always with big sacrifices in resolution.

Neither progressed very much beyond the conceptual phase. 10% complete at most, not counting the work on the engine itself -- I would not know how much of the total work the engine would have been.

For me, mostly because the Amiga platform was rapidly losing its edge to the PC as a gaming platform. The things possible on the PC due its different graphic layout and the higher processor power were opening up amazing new avenues in gaming. Games like Wolfenstein, Ultima Underworld, DOOM and Comanche (Voxel rendering) were simply incredibly hard to do on the Amigas.

So the primary reason is that we lost interest (or perhaps it was just me that lost interest seeing as I didn't really see much point in making a cool game with substandard graphics performance when compared to PC's of the same era).

No, nothing worth mentioning :) I was around 20 years old when I was working on TextDemo and it was the closest I came to ever creating a cool game :)

Poom I did try, and I kept track of other developments in that field (although most of those were on the PC). I tried a few others on the Amiga too but I must admit I donot remember their names.

I was myself pretty much a power user (see next question) at the time, having lots of harddisk space and files. The standard FFS filesystem would perform really bad in certain use cases (like 10000 files in a single directory). This got me interested in how file systems store files and how they could retrieve them so fast. Initially it was slow going as documentation on how to build a filesystem was pretty poor, until I bought the Amiga Guru Book from Ralph Babel which had detailed explanation on the API of filesystem handlers :)

Yes, I still own two. A pretty much striped Amiga 2000 with a harddisk card, and a A4000 with everything (68060 board, 50 MHz, with 96 MB of RAM, SCSI controller, a 3rd party graphics card (I forget who made it) and an Ariadne Ethernet card). I had an external case with several SCSI devices, two IDE harddisks, for a total space of 10 GB. So small now :)

The A4000 was extensively used during the development of both TextDemo and SFS.

The A2000 I haven't touched for atleast 10 years and is stored in its box. The A4000 I checked about 3 months ago. It still works, although the graphics card seems to have stopped working now, which means I had to connect it to a very old monitor to get it to display anything :/

Yes, I'm currently working as a freelance Java developer. Designing and developing software is still what I love to do most, and I've refused many opportunities for functions that would take me away from doing development work :)