🚀 go-pugleaf

Hi,
I was reading the book The Masters of Doom the other day, which details the 
lives of the two Johns Carmack and Romero as well as their games like Wolf 
3D, Doom and Quake. In general the book deals with tech topics a little 
vaguely but managed to explain concepts like binary Space partitioning and 
surface caching adequately enough. However, there was one particular detail 
in the context of the Quake 2 engine that made me curious as a fan of FPS 
games and a recreational programmer.

Quote from the Masters of Doom:
February 1998, he got what he had been waiting for: the Quake II code. It 
was the stuff that would enable them to put the completion of Daikatana into 
high gear. But when Romero opened the file, he took one look at the code and 
froze. Oh my God, he thought, what had Carmack done? <big snippage> The 
engine was completely different than what he had expected. All this time 
he'd had his programmers preparing Daikatana in a way that would make it 
easy to switch over to what he assumed Carmack's new engine would require. 
But it turned out that Carmack had trashed his expected direction and 
instead produced a structure of code that caught Romero completely by 
surprise. It certainly wasn't done to dupe Romero into a delay, it was just 
Carmack making his own idiosyncratic, intuitive leap-a leap that, once 
again, cramped Romero's grand designs.
End quote.

The above was especially vague and left me wondering what was the big hurdle 
in the Quake 2 engine compared to Quake 1. I'm guessing it is something 
architectural if it lead to major problems. I know very little about 3D 
engines, per se, apart from gaming experience, Duke3D's build and con files 
plus FraggleScript in Doom Legacy, so this is guess work.

My number one guess would be that the engine was deeply and elegantly 
object-oriented as opposed to procedural. That might require a major 
architectural change. Particularly if it affected AI, that is in stead of a 
huge, explicit if, elseif, elseif, else control flow construct it woulde be 
done differently. That is writing callback functions for particular events 
that occur to the actors. Technically it could look more functional (a bunch 
of function pointers) or object-oriented namely inheriting a pure virtual 
base class to use the C[++] terms here.

Another vague guess would be that the graphics in Quake 2 were more agnostic 
in terms of the underlying rendering system making the code more abstract 
and harder to understand initially. After all, Quake only did software 
rendering originally. But Quake 2 supported, as far as I can remember, 
software rendering, a subset of Open GL called mini GL, and Direct3D and or 
glide considering Voodoo cards were around (I used to have one myself).

Well, hope someone here knows enough of the engine internals to answer this 
question. I could take a look at the source but its probably hard to get 
into and I might not find the answer after all if its something completely 
unexpected. So, thought I'd be lazy and ask here in stead, <smile>.

PS: Just noticed this group is moderated according to the description though 
a little silent. To the moderator: if this one needs a Semi OT or OT tag, 
just lemme know and I'll fix that.

-- 
With kind regards Veli-Pekka Tńtilń (vtatila@mail.student.oulu.fi)
Accessibility, game music, synthesizers and programming:
http://www.student.oulu.fi/~vtatila/