Half Life 2 is considered as one of the most important games in history. When the delay last year was announced, analysts lowered their PC games growth forecasts.

According to Vivendi it will be on shelves November 16, just in time for the holiday season.

According to the PC Gamer November issue, Half Life 2 is a “must buy”. Maybe this is because the environment is leaned strongly towards Europe. The graphics engine may not have those spectacular light effects of a Doom 3, but at least most scenes are brightly lit and you don’t feel claustrophobic all the time. We hope that they still have duct tape in the not-too-far future Half Life 2 is settled in, so you don’t have to switch between flashlight and weapon, but instead can use both at a time.

It’s time for a new graphics card, since ATI Technologies Inc. and Nvidia Corp. have to sell their newest cards to someone. If there are still cards left over from the sales to Doom 3 players …

So the countdown starts for MIT graduate Gordon Freeman to shed some alien blood …

For an introduction take a look at id.sdk. It’s official information.

Have fun

Finally you can play your game of choice on your OS of choice. With a (win32) retail version of the game, you can now download the Linux version and play away.

Plus there is the standalone Linux demo available.

Links broken? Looking for a Doom 3 patch? http://www.3dgamers.com/games/doom3/downloads/

For those of who who’d like to build maps of their own, there is GTKRadiant available, based on QeRadiant, the official editor for Quake 2, on which the official Doom 3 editor is also based.

Further investigation showed that this is of course not a sex video, but nevertheless a very impressive video.

Some Mirrors:
Fileshack (looks like this server is overcrowded at the moment)

Mirrors:
Doom 3 Patch 1.1 Download

The moral of the story is that irrespective to all the hype about Half Life 2 preload, steam users won’t be playing the game any time earlier than ordinary buyers.

Half-Life 2 Special Edition at Gamespot.

At least Steam users won’t get to download the game until it is made available at retail.

And there are some more coming. Half-Life 2, Grand Theft Auto San Andreas.

With that order ATI is planning to bring the 9800 to market at price of under $200.

All the while Nvidia is announcing plans for a low-priced version of its GeForce FX5900-series in the fourth quarter.

The other 2 licensees so far are Troika Games with Vampire: The Masquerade-Bloodlines, and Arkane Studios, for an yet to be specified upcoming title.

Other Mirrors:
3D Gamers

One of the most promising mods is Team Fortress. The makers were interviewed by planetdoom recently.

Posts signed with johnc are original .plan file updates, all other posts were made by other people.

I have given my best (and still doing it) to conserve the exact time stamps of .plan updates to the second wherever possible. In most cases this is Central Standard Time.

It is hoped that Christopher Ryan Carmack will be a valuable addition for the next QuakeCons.

Mexico, U.K., Ireland, Spain, Portugal, France, Switzerland, Iceland, Belgium, Finland, Sweden, Norway, Denmark, Austria, Czech Republic, The Netherlands, Italy, New Zealand, and Australia.

Not all countries from Europe are in the list, I’m inclined to blame censorship for that.

I thought they did an excellent job of catering to the strengths of the
medium, and not attempting to make a game engine compete (poorly) as a
general purpose renderer. In watching the video, I did beat myself up a
bit over the visible popping artifacts on the environment mapping, which are
a direct result of the normal vector quantization in the md3 format. While it
isn’t the same issue (normals are full floating point already in Doom), it was
the final factor that pushed me to do the per-pixel environment mapping for
the new cards in the current engine.

The neat thing about the machinima aspect of the video is that they also have
a little game you can play with the same media assets used to create the
video. Not sure when it will be made available publicly.

At the moment, the NV30 is slightly faster on most scenes in Doom than the
R300, but I can still find some scenes where the R300 pulls a little bit
ahead. The issue is complicated because of the different ways the cards can
choose to run the game.

The R300 can run Doom in three different modes: ARB (minimum extensions, no
specular highlights, no vertex programs), R200 (full featured, almost always
single pass interaction rendering), ARB2 (floating point fragment shaders,
minor quality improvements, always single pass).

The NV30 can run DOOM in five different modes: ARB, NV10 (full featured, five
rendering passes, no vertex programs), NV20 (full featured, two or three
rendering passes), NV30 ( full featured, single pass), and ARB2.

The R200 path has a slight speed advantage over the ARB2 path on the R300, but
only by a small margin, so it defaults to using the ARB2 path for the quality
improvements. The NV30 runs the ARB2 path MUCH slower than the NV30 path.
Half the speed at the moment. This is unfortunate, because when you do an
exact, apples-to-apples comparison using exactly the same API, the R300 looks
twice as fast, but when you use the vendor-specific paths, the NV30 wins.

The reason for this is that ATI does everything at high precision all the
time, while Nvidia internally supports three different precisions with
different performances. To make it even more complicated, the exact
precision that ATI uses is in between the floating point precisions offered by
Nvidia, so when Nvidia runs fragment programs, they are at a higher precision
than ATI’s, which is some justification for the slower speed. Nvidia assures
me that there is a lot of room for improving the fragment program performance
with improved driver compiler technology.

The current NV30 cards do have some other disadvantages: They take up two
slots, and when the cooling fan fires up they are VERY LOUD. I’m not usually
one to care about fan noise, but the NV30 does annoy me.

I am using an NV30 in my primary work system now, largely so I can test more
of the rendering paths on one system, and because I feel Nvidia still has
somewhat better driver quality (ATI continues to improve, though). For a
typical consumer, I don’t think the decision is at all clear cut at the
moment.

For developers doing forward looking work, there is a different tradeoff –
the NV30 runs fragment programs much slower, but it has a huge maximum
instruction count. I have bumped into program limits on the R300 already.

As always, better cards are coming soon.

————-

Doom has dropped support for vendor-specific vertex programs
(NV_vertex_program and EXT_vertex_shader), in favor of using
ARB_vertex_program for all rendering paths. This has been a pleasant thing to
do, and both ATI and Nvidia supported the move. The standardization process
for ARB_vertex_program was pretty drawn out and arduous, but in the end, it is
a just-plain-better API than either of the vendor specific ones that it
replaced. I fretted for a while over whether I should leave in support for
the older APIs for broader driver compatibility, but the final decision was
that we are going to require a modern driver for the game to run in the
advanced modes. Older drivers can still fall back to either the ARB or NV10
paths.

The newly-ratified ARB_vertex_buffer_object extension will probably let me do
the same thing for NV_vertex_array_range and ATI_vertex_array_object.

Reasonable arguments can be made for and against the OpenGL or Direct-X style
of API evolution. With vendor extensions, you get immediate access to new
functionality, but then there is often a period of squabbling about exact
feature support from different vendors before an industry standard settles
down. With central planning, you can have “phasing problems” between
hardware and software releases, and there is a real danger of bad decisions
hampering the entire industry, but enforced commonality does make life easier
for developers. Trying to keep boneheaded-ideas-that-will-haunt-us-for-years
out of Direct-X is the primary reason I have been attending the Windows
Graphics Summit for the past three years, even though I still code for OpenGL.

The most significant functionality in the new crop of cards is the truly
flexible fragment programming, as exposed with ARB_fragment_program. Moving
from the “switches and dials” style of discrete functional graphics
programming to generally flexible programming with indirection and high
precision is what is going to enable the next major step in graphics engines.

It is going to require fairly deep, non-backwards-compatible modifications to
an engine to take real advantage of the new features, but working with
ARB_fragment_program is really a lot of fun, so I have added a few little
tweaks to the current codebase on the ARB2 path:

High dynamic color ranges are supported internally, rather than with
post-blending. This gives a few more bits of color precision in the final
image, but it isn’t something that you really notice.

Per-pixel environment mapping, rather than per-vertex. This fixes a pet-peeve
of mine, which is large panes of environment mapped glass that aren’t
tessellated enough, giving that awful warping-around-the-triangulation effect
as you move past them.

Light and view vectors normalized with math, rather than a cube map. On
future hardware this will likely be a performance improvement due to the
decrease in bandwidth, but current hardware has the computation and bandwidth
balanced such that it is pretty much a wash. What it does (in conjunction
with floating point math) give you is a perfectly smooth specular highlight,
instead of the pixelish blob that we get on older generations of cards.

There are some more things I am playing around with, that will probably remain
in the engine as novelties, but not supported features:

Per-pixel reflection vector calculations for specular, instead of an
interpolated half-angle. The only remaining effect that has any visual
dependency on the underlying geometry is the shape of the specular highlight.
Ideally, you want the same final image for a surface regardless of if it is
two giant triangles, or a mesh of 1024 triangles. This will not be true if
any calculation done at a vertex involves anything other than linear math
operations. The specular half-angle calculation involves normalizations, so
the interpolation across triangles on a surface will be dependent on exactly
where the vertexes are located. The most visible end result of this is that
on large, flat, shiny surfaces where you expect a clean highlight circle
moving across it, you wind up with a highlight that distorts into an L shape
around the triangulation line.

The extra instructions to implement this did have a noticeable performance
hit, and I was a little surprised to see that the highlights not only
stabilized in shape, but also sharpened up quite a bit, changing the scene
more than I expected. This probably isn’t a good tradeoff today for a gamer,
but it is nice for any kind of high-fidelity rendering.

Renormalization of surface normal map samples makes significant quality
improvements in magnified textures, turning tight, blurred corners into shiny,
smooth pockets, but it introduces a huge amount of aliasing on minimized
textures. Blending between the cases is possible with fragment programs, but
the performance overhead does start piling up, and it may require stashing
some information in the normal map alpha channel that varies with mip level.
Doing good filtering of a specularly lit normal map texture is a fairly
interesting problem, with lots of subtle issues.

Bump mapped ambient lighting will give much better looking outdoor and
well-lit scenes. This only became possible with dependent texture reads, and
it requires new designer and tool-chain support to implement well, so it isn’t
easy to test globally with the current Doom datasets, but isolated demos are
promising.

The future is in floating point framebuffers. One of the most noticeable
thing this will get you without fundamental algorithm changes is the ability
to use a correct display gamma ramp without destroying the dark color
precision. Unfortunately, using a floating point framebuffer on the current
generation of cards is pretty difficult, because no blending operations are
supported, and the primary thing we need to do is add light contributions
together in the framebuffer. The workaround is to copy the part of the
framebuffer you are going to reference to a texture, and have your fragment
program explicitly add that texture, instead of having the separate blend unit
do it. This is intrusive enough that I probably won’t hack up the current
codebase, instead playing around on a forked version.

Floating point framebuffers and complex fragment shaders will also allow much
better volumetric effects, like volumetric illumination of fogged areas with
shadows and additive/subtractive eddy currents.

John Carmack

I need to apologize to Matrox — their implementation of hardware displacement
mapping is NOT quad based. I was thinking about a certain other companies
proposed approach. Matrox’s implementation actually looks quite good, so even
if we don’t use it because of the geometry amplification issues, I think it
will serve the noble purpose of killing dead any proposal to implement a quad
based solution.

I got a 3Dlabs P10 card in last week, and yesterday I put it through its
paces. Because my time is fairly over committed, first impressions often
determine how much work I devote to a given card. I didn’t speak to ATI for
months after they gave me a beta 8500 board last year with drivers that
rendered the console incorrectly.

I was duly impressed when the P10 just popped right up with full functional
support for both the fallback ARB_ extension path (without specular
highlights), and the NV10 NVidia register combiners path. I only saw two
issues that were at all incorrect in any of our data, and one of them is
debatable. They don’t support NV_vertex_program_1_1, which I use for the NV20
path, and when I hacked my programs back to 1.0 support for testing, an
issue did show up, but still, this is the best showing from a new board from
any company other than Nvidia.

It is too early to tell what the performance is going to be like, because they
don’t yet support a vertex object extension, so the CPU is hand feeding all
the vertex data to the card at the moment. It was faster than I expected for
those circumstances.

Given the good first impression, I was willing to go ahead and write a new
back end that would let the card do the entire Doom interaction rendering in
a single pass. The most expedient sounding option was to just use the Nvidia
extensions that they implement, NV_vertex_program and NV_register_combiners,
with seven texture units instead of the four available on GF3/GF4. Instead, I
decided to try using the prototype OpenGL 2.0 extensions they provide.

The implementation went very smoothly, but I did run into the limits of their
current prototype compiler before the full feature set could be implemented.
I like it a lot. I am really looking forward to doing research work with this
programming model after the compiler matures a bit. While the shading
languages are the most critical aspects, and can be broken out as extensions
to current OpenGL, there are a lot of other subtle-but-important things that
are addressed in the full OpenGL 2.0 proposal.

I am now committed to supporting an OpenGL 2.0 renderer for Doom through all
the spec evolutions. If anything, I have been somewhat remiss in not pushing
the issues as hard as I could with all the vendors. Now really is the
critical time to start nailing things down, and the decisions may stay with
us for ten years.

A GL2 driver won’t give any theoretical advantage over the current back ends
optimized for cards with 7+ texture capability, but future research work will
almost certainly be moving away from the lower level coding practices, and if
some new vendor pops up (say, Rendition back from the dead) with a next-gen
card, I would strongly urge them to implement GL2 instead of proprietary
extensions.

I have not done a detailed comparison with Cg. There are a half dozen C-like
graphics languages floating around, and honestly, I don’t think there is a
hell of a lot of usability difference between them at the syntax level. They
are all a whole lot better than the current interfaces we are using, so I hope
syntax quibbles don’t get too religious. It won’t be too long before all real
work is done in one of these, and developers that stick with the lower level
interfaces will be regarded like people that write all-assembly PC
applications today. (I get some amusement from the all-assembly crowd, and it
can be impressive, but it is certainly not effective)

I do need to get up on a soapbox for a long discourse about why the upcoming
high level languages MUST NOT have fixed, queried resource limits if they are
going to reach their full potential. I will go into a lot of detail when I
get a chance, but drivers must have the right and responsibility to multipass
arbitrarily complex inputs to hardware with smaller limits. Get over it.

The executive summary is that the Parhelia will run Doom, but it is not
performance competitive with Nvidia or ATI.

Driver issue remain, so it is not perfect yet, but I am confident that Matrox
will resolve them.

The performance was really disappointing for the first 256 bit DDR card. I
tried to set up a “poster child” case that would stress the memory subsystem
above and beyond any driver or triangle level inefficiencies, but I was
unable to get it to ever approach the performance of a GF4.

The basic hardware support is good, with fragment flexibility better than GF4
(but not as good as ATI 8500), but it just doesn’t keep up in raw performance.
With a die shrink, this chip could probably be a contender, but there are
probably going to be other chips out by then that will completely eclipse
this generation of products.

None of the special features will be really useful for Doom:

The 10 bit color framebuffer is nice, but Doom needs more than 2 bits of
destination alpha when a card only has four texture units, so we can’t use it.

Anti aliasing features are nice, but it isn’t all that fast in minimum feature
mode, so nobody is going to be turning on AA. The same goes for “surround
gaming”. While the framerate wouldn’t be 1/3 the base, it would still
probably be cut in half.

Displacement mapping. Sigh. I am disappointed that the industry is still
pursuing any quad based approaches. Haven’t we learned from the stellar
success of 3DO, Saturn, and NV1 that quads really suck? In any case, we can’t
use any geometry amplification scheme (including ATI’s truform) in conjunction
with stencil shadow volumes.

http://developer.nvidia.com/view.asp?IO=robust_shadow_volumes

8:50 pm addendum: Mark Kilgard at Nvidia said that the current drivers already
support the vertex program option to be invarint with the fixed function path,
and that it turned out to be one instruction FASTER, not slower.

I had a pre-production board before Siggraph last year, and we were discussing
the possibility of letting ATI show a Doom demo behind closed doors on it. We
were all very busy at the time, but I took a shot at bringing up support over
a weekend. I hadn’t coded any of the support for the custom ATI extensions
yet, but I ran the game using only standard OpenGL calls (this is not a
supported path, because without bump mapping everything looks horrible) to see
how it would do. It didn’t even draw the console correctly, because they had
driver bugs with texGen. I thought the odds were very long against having all
the new, untested extensions working properly, so I pushed off working on it
until they had revved the drivers a few more times.

My judgment was colored by the experience of bringing up Doom on the original
Radeon card a year earlier, which involved chasing a lot of driver bugs. Note
that ATI was very responsive, working closely with me on it, and we were able
to get everything resolved, but I still had no expectation that things would
work correctly the first time.

Nvidia’s OpenGL drivers are my “gold standard”, and it has been quite a while
since I have had to report a problem to them, and even their brand new
extensions work as documented the first time I try them. When I have a
problem on an Nvidia, I assume that it is my fault. With anyone else’s
drivers, I assume it is their fault. This has turned out correct almost all
the time. I have heard more anecdotal reports of instability on some systems
with Nivida drivers recently, but I track stability separately from
correctness, because it can be influenced by so many outside factors.

ATI had been patiently pestering me about support for a few months, so last
month I finally took another stab at it. The standard OpenGL path worked
flawlessly, so I set about taking advantage of all the 8500 specific features.
As expected, I did run into more driver bugs, but ATI got me fixes rapidly,
and we soon had everything working properly. It is interesting to contrast
the Nvidia and ATI functionality:

The vertex program extensions provide almost the same functionality. The ATI
hardware is a little bit more capable, but not in any way that I care about.
The ATI extension interface is massively more painful to use than the text
parsing interface from nvidia. On the plus side, the ATI vertex programs are
invariant with the normal OpenGL vertex processing, which allowed me to reuse
a bunch of code. The Nvidia vertex programs can’t be used in multipass
algorithms with standard OpenGL passes, because they generate tiny differences
in depth values, forcing you to implement EVERYTHING with vertex programs.
Nvidia is planning on making this optional in the future, at a slight speed
cost.

I have mixed feelings about the vertex object / vertex array range extensions.
ATI’s extension seems more “right” in that it automatically handles
synchronization by default, and could be implemented as a wire protocol, but
there are advantages to the VAR extension being simply a hint. It is easy to
have a VAR program just fall back to normal virtual memory by not setting the
hint and using malloc, but ATI’s extension requires different function calls
for using vertex objects and normal vertex arrays.

The fragment level processing is clearly way better on the 8500 than on the
Nvidia products, including the latest GF4. You have six individual textures,
but you can access the textures twice, giving up to eleven possible texture
accesses in a single pass, and the dependent texture operation is much more
sensible. This wound up being a perfect fit for Doom, because the standard
path could be implemented with six unique textures, but required one texture
(a normalization cube map) to be accessed twice. The vast majority of Doom
light / surface interaction rendering will be a single pass on the 8500, in
contrast to two or three passes, depending on the number of color components
in a light, for GF3/GF4 (*note GF4 bitching later on).

Initial performance testing was interesting. I set up three extreme cases to
exercise different characteristics:

A test of the non-textured stencil shadow speed showed a GF3 about 20% faster
than the 8500. I believe that Nvidia has a slightly higher performance memory
architecture.

A test of light interaction speed initially had the 8500 significantly slower
than the GF3, which was shocking due to the difference in pass count. ATI
identified some driver issues, and the speed came around so that the 8500 was
faster in all combinations of texture attributes, in some cases 30+% more.
This was about what I expected, given the large savings in memory traffic by
doing everything in a single pass.

A high polygon count scene that was more representative of real game graphics
under heavy load gave a surprising result. I was expecting ATI to clobber
Nvidia here due to the much lower triangle count and MUCH lower state change
functional overhead from the single pass interaction rendering, but they came
out slower. ATI has identified an issue that is likely causing the unexpected
performance, but it may not be something that can be worked around on current
hardware.

I can set up scenes and parameters where either card can win, but I think that
current Nvidia cards are still a somewhat safer bet for consistent performance
and quality.

On the topic of current Nvidia cards:

Do not buy a GeForce4-MX for Doom.

Nvidia has really made a mess of the naming conventions here. I always
thought it was bad enough that GF2 was just a speed bumped GF1, while GF3 had
significant architectural improvements over GF2. I expected GF4 to be the
speed bumped GF3, but calling the NV17 GF4-MX really sucks.

GF4-MX will still run Doom properly, but it will be using the NV10 codepath
with only two texture units and no vertex shaders. A GF3 or 8500 will be
much better performers. The GF4-MX may still be the card of choice for many
people depending on pricing, especially considering that many games won’t use
four textures and vertex programs, but damn, I wish they had named it
something else.

As usual, there will be better cards available from both Nvidia and ATI by the
time we ship the game.

8:50 pm addendum: Mark Kilgard at Nvidia said that the current drivers already
support the vertex program option to be invarint with the fixed function path,
and that it turned out to be one instruction FASTER, not slower.

ftp://ftp.idsoftware.com/idstuff/source/quake2.zip

As with previous source code releases, the game data remains under the
original copyright and license, and cannot be freely distributed. If you
create a true total conversion, you can give (or sell) a complete package
away, as long as you abide by the GPL source code license. If your projects
use the original Quake 2 media, the media must come from a normal, purchased
copy of the game.

I’m sure I will catch some flack about increased cheating after the source
release, but there are plenty of Q2 cheats already out there, so you are
already in the position of having to trust the other players to a degree. The
problem is really only solvable by relying on the community to police itself,
because it is a fundamentally unwinnable technical battle to make a completely
cheat proof game of this type. Play with your friends.

There are many driver optimizations that are pure improvements in all cases,
with no negative effects. The difficult decisions come up when it comes to
“trades” of various kinds, where a change will give an increase in
performance, but at a cost.

Relative performance trades. Part of being a driver writer is being able to
say “I don’t care if stippled, anti-aliased points with texturing go slow”,
and optimizing accordingly. Some hardware features, like caches and
hierarchical buffers, may be advantages on some apps, and disadvantages on
others. Command buffer sizes often tune differently for different
applications.

Quality trades. There is a small amount of wiggle room in the specs for pixel
level variability, and some performance gains can be had by leaning towards
the minimums. Most quality trades would actually be conformance trades,
because the results are not exactly conformant, but they still do “roughly”
the right thing from a visual standpoint. Compressing textures automatically,
avoiding blending of very faint transparent pixels, using a 16 bit depth
buffer, etc. A good application will allow the user to make most of these
choices directly, but there is good call for having driver preference panels
to enable these types of changes on naive applications. Many drivers now
allow you to quality trade in an opposite manner — slowing application
performance by turning on anti-aliasing or anisotropic texture filtering.

Conformance trades. Most conformance trades that happen with drivers are
unintentional, where the slower, more general fallback case just didn’t get
called when it was supposed to, because the driver didn’t check for a certain
combination to exit some specially optimized path. However, there are
optimizations that can give performance improvements in ways that make it
impossible to remain conformant. For example, a driver could choose to skip
storing of a color value before it is passed on to the hardware, which would
save a few cycles, but make it impossible to correctly answer
glGetFloatv( GL_CURRENT_COLOR, buffer ).

Normally, driver writers will just pick their priorities and make the trades,
but sometimes there will be a desire to make different trades in different
circumstances, so as to get the best of both worlds.

Explicit application hints are a nice way to offer different performance
characteristics, but that requires cooperation from the application, so it
doesn’t help in an ongoing benchmark battle. OpenGL’s glHint() call is the
right thought, but not really set up as flexibly as you would like. Explicit
extensions are probably the right way to expose performance trades, but it
isn’t clear to me that any conformant trade will be a big enough difference
to add code for.

End-user selectable optimizations. Put a selection option in the driver
properties window to allow the user to choose which application class they
would like to be favored in some way. This has been done many times, and is a
reasonable way to do things. Most users would never touch the setting, so
some applications may be slightly faster or slower than in their “optimal
benchmark mode”.

Attempt to guess the application from app names, window strings, etc. Drivers
are sometimes forced to do this to work around bugs in established software,
and occasionally they will try to use this as a cue for certain optimizations.

My positions:

Making any automatic optimization based on a benchmark name is wrong. It
subverts the purpose of benchmarking, which is to gauge how a similar class of
applications will perform on a tested configuration, not just how the single
application chosen as representative performs.

It is never acceptable to have the driver automatically make a conformance
tradeoff, even if they are positive that it won’t make any difference. The
reason is that applications evolve, and there is no guarantee that a future
release won’t have different assumptions, causing the upgrade to misbehave.
We have seen this in practice with Quake3 and derivatives, where vendors
assumed something about what may or may not be enabled during a compiled
vertex array call. Most of these are just mistakes, or, occasionally,
laziness.

Allowing a driver to present a non-conformant option for the user to select is
an interesting question. I know that as a developer, I would get hate mail
from users when a point release breaks on their whiz-bang optimized driver,
just like I do with overclocked CPUs, and I would get the same “but it works
with everything else!” response when I tell them to put it back to normal. On
the other hand, being able to tweak around with that sort of think is fun for
technically inclined users. I lean towards frowning on it, because it is a
slippery slope from there down in to “cheating drivers” of the see-through-
walls variety.

Quality trades are here to stay, with anti-aliasing, anisotropic texture
filtering, and other options being positive trades that a user can make, and
allowing various texture memory optimizations can be a very nice thing for a
user trying to get some games to work well. However, it is still important
that it start from a completely conformant state by default. This is one area
where application naming can be used reasonably by the driver, to maintain
user selected per-application modifiers.

I’m not fanatical on any of this, because the overriding purpose of software
is to be useful, rather than correct, but the days of game-specific mini-
drivers that can just barely cut it are past, and we should demand more from
the remaining vendors.

Also, excessive optimization is the cause of quite a bit of ill user
experience with computers. Byzantine code paths extract costs as long as they
exist, not just as they are written.

We do run a bit better on a high end wintel system, but the Apple
performance is still quite good, especially considering the short amount
of time that the drivers had before the event.

It is still our intention to have a simultaneous release of the next
product on Windows, MacOS-X, and Linux.

Here is a dump on the GeForce 3 that I have been seriously working
with for a few weeks now:

The short answer is that the GeForce 3 is fantastic. I haven’t had such an
impression of raising the performance bar since the Voodoo 2 came out, and
there are a ton of new features for programmers to play with.

Graphics programmers should run out and get one at the earliest possible
time. For consumers, it will be a tougher call. There aren’t any
applications our right now that take proper advantage of it, but you should
still be quite a bit faster at everything than GF2, especially with
anti-aliasing. Balance that against whatever the price turns out to be.

While the Radeon is a good effort in many ways, it has enough shortfalls
that I still generally call the GeForce 2 ultra the best card you can buy
right now, so Nvidia is basically dethroning their own product.

It is somewhat unfortunate that it is labeled GeForce 3, because GeForce
2 was just a speed bump of GeForce, while GF3 is a major architectural
change. I wish they had called the GF2 something else.

The things that are good about it:

Lots of values have additional internal precision, like texture coordinates
and rasterization coordinates. There are only a few places where this
matters, but it is nice to be cleaning up. Rasterization precision is about
the last thing that the multi-thousand dollar workstation boards still do
any better than the consumer cards.

Adding more texture units and more register combiners is an obvious
evolutionary step.

An interesting technical aside: when I first changed something I was
doing with five single or dual texture passes on a GF to something that
only took two quad texture passes on a GF3, I got a surprisingly modest
speedup. It turned out that the texture filtering and bandwidth was the
dominant factor, not the frame buffer traffic that was saved with more
texture units. When I turned off anisotropic filtering and used
compressed textures, the GF3 version became twice as fast.

The 8x anisotropic filtering looks really nice, but it has a 30%+ speed
cost. For existing games where you have speed to burn, it is probably a
nice thing to force on, but it is a bit much for me to enable on the current
project. Radeon supports 16x aniso at a smaller speed cost, but not in
conjunction with trilinear, and something is broken in the chip that
makes the filtering jump around with triangular rasterization
dependencies.

The depth buffer optimizations are similar to what the Radeon provides,
giving almost everything some measure of speedup, and larger ones
available in some cases with some redesign.

3D textures are implemented with the full, complete generality. Radeon
offers 3D textures, but without mip mapping and in a non-orthogonal
manner (taking up two texture units).

Vertex programs are probably the most radical new feature, and, unlike
most “radical new features”, actually turn out to be pretty damn good.
The instruction language is clear and obvious, with wonderful features
like free arbitrary swizzle and negate on each operand, and the obvious
things you want for graphics like dot product instructions.

The vertex program instructions are what SSE should have been.

A complex setup for a four-texture rendering pass is way easier to
understand with a vertex program than with a ton of texgen/texture
matrix calls, and it lets you do things that you just couldn’t do hardware
accelerated at all before. Changing the model from fixed function data
like normals, colors, and texcoords to generalized attributes is very
important for future progress.

Here, I think Microsoft and DX8 are providing a very good benefit by
forcing a single vertex program interface down all the hardware
vendor’s throats.

This one is truly stunning: the drivers just worked for all the new
features that I tried. I have tested a lot of pre-production 3D cards, and it
has never been this smooth.

The things that are indifferent:

I’m still not a big believer in hardware accelerated curve tessellation.
I’m not going to go over all the reasons again, but I would have rather
seen the features left off and ended up with a cheaper part.

The shadow map support is good to get in, but I am still unconvinced
that a fully general engine can be produced with acceptable quality using
shadow maps for point lights. I spent a while working with shadow
buffers last year, and I couldn’t get satisfactory results. I will revisit
that work now that I have GeForce 3 cards, and directly compare it with my
current approach.

At high triangle rates, the index bandwidth can get to be a significant
thing. Other cards that allow static index buffers as well as static vertex
buffers will have situations where they provide higher application speed.
Still, we do get great throughput on the GF3 using vertex array range
and glDrawElements.

The things that are bad about it:

Vertex programs aren’t invariant with the fixed function geometry paths.
That means that you can’t mix vertex program passes with normal
passes in a multipass algorithm. This is annoying, and shouldn’t have
happened.

Now we come to the pixel shaders, where I have the most serious issues.
I can just ignore this most of the time, but the way the pixel shader
functionality turned out is painfully limited, and not what it should have
been.

DX8 tries to pretend that pixel shaders live on hardware that is a lot
more general than the reality.

Nvidia’s OpenGL extensions expose things much more the way they
actually are: the existing register combiners functionality extended to
eight stages with a couple tweaks, and the texture lookup engine is
configurable to interact between textures in a list of specific ways.

I’m sure it started out as a better design, but it apparently got cut and cut
until it really looks like the old BumpEnvMap feature writ large: it does
a few specific special effects that were deemed important, at the expense
of a properly general solution.

Yes, it does full bumpy cubic environment mapping, but you still can’t
just do some math ops and look the result up in a texture. I was
disappointed on this count with the Radeon as well, which was just
slightly too hardwired to the DX BumpEnvMap capabilities to allow
more general dependent texture use.

Enshrining the capabilities of this mess in DX8 sucks. Other companies
had potentially better approaches, but they are now forced to dumb them
down to the level of the GF3 for the sake of compatibility. Hopefully
we can still see some of the extra flexibility in OpenGL extensions.

The future:

I think things are going to really clean up in the next couple years. All
of my advocacy is focused on making sure that there will be a
completely clean and flexible interface for me to target in the engine
after DOOM, and I think it is going to happen.

The market may have shrunk to just ATI and Nvidia as significant
players. Matrox, 3D labs, or one of the dormant companies may surprise
us all, but the pace is pretty frantic.

I think I would be a little more comfortable if there was a third major
player competing, but I can’t fault Nvidia’s path to success.

Most of this is not really public business, but if some things aren’t stated
explicitly, it will reflect unfairly on someone.

As many people have heard discussed, there was quite a desire to remake DOOM
as our next project after Q3. Discussing it brought an almost palpable thrill
to most of the employees, but Adrian had a strong enough dislike for the idea
that it was shot down over and over again.

Design work on an alternate game has been going on in parallel with the
mission pack development and my research work.

Several factors, including a general lack of enthusiasm for the proposed plan,
the warmth that Wolfenstien was met with at E3, and excitement about what
we can do with the latest rendering technology were making it seem more and
more like we weren’t going down the right path.

I discussed it with some of the other guys, and we decided that it was
important enough to drag the company through an unpleasant fight over it.

An ultimatum was issued to Kevin and Adrian(who control >50% of the company):
We are working on DOOM for the next project unless you fire us.

Obviously no fun for anyone involved, but the project direction was changed,
new hires have been expedited, and the design work has begun.

It wasn’t planned to announce this soon, but here it is: We are working on a
new DOOM game, focusing on the single player game experience, and using brand
new technology in almost every aspect of it. That is all we are prepared to
say about the game for quite some time, so don’t push for interviews. We
will talk about it when things are actually built, to avoid giving
misleading comments.

It went smoother than expected, but the other shoe dropped yesterday.

Kevin and Adrian fired Paul Steed in retaliation, over my opposition.

Paul has certainly done things in the past that could be grounds for
dismissal, but this was retaliatory for him being among the “conspirators”.

I happen to think Paul was damn good at his job, and that he was going to be
one of the most valuable contributors to DOOM.

We need to hire two new modeler/animator/cinematic director types. If you
have a significant commercial track record in all three areas, and consider
yourself at the top of your field, send your resume to Kevin Cloud.

Nvidia
Marketing silliness: saying “seven operations on a pixel” for a dual texture
chip. Yes, I like NV_register_combiners a lot, but come on…

The DDR GeForce is the reining champ of 3D cards. Of the shipping boards, it
is basically better than everyone at every aspect of 3D graphics, and
pioneered some features that are going to be very important: signed pixel
math, dot product blending, and cubic environment maps.

The GeForce2 is just a speed bumped GeForce with a few tweaks, but that’s not
a bad thing. Nvidia will have far and away the tightest drivers for quite
some time, and that often means more than a lot of new features in the real
world.

The nvidia register combiners are highly programmable, and can often save a
rendering pass or allow a somewhat higher quality calculation, but on the
whole, I would take ATI’s third texture for flexibility.

Nvidia will probably continue to hit the best framerates in benchmarks at low
resolution, because they have flexible hardware with geometry acceleration
and well-tuned drivers.

GeForce is my baseline for current rendering work, so I can wholeheartedly
recommend it.

ATI
Marketing silliness: “charisma engine” and “pixel tapestry” are silly names
for vertex and pixel processing that are straightforward improvements over
existing methods. Sony is probably to blame for starting that.

The Radeon has the best feature set available, with several advantages over
GeForce:

A third texture unit per pixel
Three dimensional textures
Dependent texture reads (bump env map)
Greater internal color precision.
User clip planes orthogonal to all rasterization modes.
More powerful vertex blending operations.
The shadow id map support may be useful, but my work with shadow buffers have
shown them to have significant limitations for global use in a game.

On paper, it is better than GeForce in almost every way except that it is
limited to a maximum of two pixels per clock while GeForce can do four. This
comes into play when the pixels don’t do as much memory access, for example
when just drawing shadow planes to the depth/stencil buffer, or when drawing
in roughly front to back order and many of the later pixels depth fail,
avoiding the color buffer writes.

Depending on the application and algorithm, this can be anywhere from
basically no benefit when doing 32 bit blended multi-pass, dual texture
rendering to nearly double the performance for 16 bit rendering with
compressed textures. In any case, a similarly clocked GeForce(2) should
somewhat outperform a Radeon on today’s games when fill rate limited. Future
games that do a significant number of rendering passes on the entire world
may go back in ATI’s favor if they can use the third texture unit, but I doubt
it will be all that common.

The real issue is how quickly ATI can deliver fully clocked production boards,
bring up stable drivers, and wring all the performance out of the hardware.
This is a very different beast than the Rage128. I would definitely recommend
waiting on some consumer reviews to check for teething problems before
upgrading to a Radeon, but if things go well, ATI may give nvidia a serious
run for their money this year.

3DFX
Marketing silliness: Implying that a voodoo 5 is of a different class than a
voodoo 4 isn’t right. Voodoo 4 max / ultra / SLI / dual / quad or something
would have been more forthright.

Rasterization feature wise, voodoo4 is just catching up to the original TNT.
We finally have 32 bit color and stencil. Yeah.

There aren’t any geometry features.

The T buffer is really nothing more than an accumulation buffer that is
averaged together during video scanout. This same combining of separate
buffers can be done by any modern graphics card if they are set up for it
(although they will lose two bits of color precision in the process). At
around 60 fps there is a slight performance win by doing it at video scannout
time, but at 30 fps it is actually less memory traffic to do it explicitly.
Video scan tricks also usually don’t work in windowed modes.

The real unique feature of the voodoo5 is subpixel jittering during
rasterization, which can’t reasonably be emulated by other hardware. This
does indeed improve the quality of anti-aliasing, although I think 3dfx might
be pushing it a bit by saying their 4 sample jittering is as good as 16
sample unjittered.

The saving grace of the voodoo5 is the scalability. Because it only uses SDR
ram, a dual chip Voodoo5 isn’t all that much faster than some other single
chip cards, but the quad chip card has over twice the pixel fill rate of the
nearest competitor. That is a huge increment. Voodoo5 6000 should win every
benchmark that becomes fill rate limited.

I haven’t been able to honestly recommend a voodoo3 to people for a long
time, unless they had a favorite glide game or wanted early linux Xfree 4.0
3D support. Now (well, soon), a Voodoo5 6000 should make all of today’s
games look better than any other card. You can get over twice as many pixel
samples, and have them jittered and blended together for anti-aliasing.

It won’t be able to hit Q3 frame rates as high as GeForce, but if you have a
high end processor there really may not be all that much difference for you
between 100fps and 80fps unless you are playing hardcore competitive and
can’t stand the occasional drop below 60fps.

There are two drawbacks: it’s expensive, and it won’t take advantage of the
new rasterization features coming in future games. It probably wouldn’t be
wise to buy a voodoo5 if you plan on keeping it for two years.

It is interesting how similar the activity is around an experimental rocket
launch, going to a race track with an experimental car, and putting out a
beta version of new software is. Lots of “twenty more minutes!”, and lots
of well-wishers waiting around while the people on the critical path sweat
over what they are doing.

Mere minutes before we absolutely, positively needed to leave to catch our
plane flight, they started the countdown. The rocket launched impressively,
but broke apart at a relatively low altitude. Ouch. It was a hybrid, so
there wasn’t really an explosion, but watching the debris rain down wasn’t
very heartening. Times like that, I definitely appreciate working in
software. “Run it again, with a breakpoint!”

Note to self: pasty-skinned programmers ought not stand out in the Mojave
desert for multiple hours.

http://www.space-frontier.org/Events/CATSPRIZE_1/
http://www.energyrs.com/sorac/sorac.htm
http://www.jpaerospace.com/

Thanks to the QuakeForge team for doing the grunt work of the preparation.

I have been pushing for a couple more bits of range for several years now,
but I now extend that to wanting full 16 bit floating point colors throughout
the graphics pipeline. A sign bit, ten bits of mantissa, and five bits of
exponent (possibly trading a bit or two between the mantissa and exponent).
Even that isn’t all you could want, but it is the rational step.

It is turning out that I need a destination alpha channel for a lot of the
new rendering algorithms, so intermediate solutions like 10/12/10 RGB
formats aren’t a good idea. Higher internal precision with dithering to 32
bit pixels would have some benefit, but dithered intermediate results can
easily start piling up the errors when passed over many times, as we have
seen with 5/6/5 rendering.

Eight bits of precision isn’t enough even for full range static image
display. Images with a wide range usually come out fine, but restricted
range images can easily show banding on a 24-bit display. Digital television
specifies 10 bits of precision, and many printing operations are performed
with 12 bits of precision.

The situation becomes much worse when you consider the losses after multiple
operations. As a trivial case, consider having multiple lights on a wall,
with their contribution to a pixel determined by a texture lookup. A single
light will fall off towards 0 some distance away, and if it covers a large
area, it will have visible bands as the light adds one unit, two units, etc.
Each additional light from the same relative distance stacks its contribution
on top of the earlier ones, which magnifies the amount of the step between
bands: instead of going 0,1,2, it goes 0,2,4, etc. Pile a few lights up like
this and look towards the dimmer area of the falloff, and you can believe you
are back in 256-color land.

There are other more subtle issues, like the loss of potential result values
from repeated squarings of input values, and clamping issues when you sum up
multiple incident lights before modulating down by a material.

Range is even more clear cut. There are some values that have intrinsic
ranges of 0.0 to 1.0, like factors of reflection and filtering. Normalized
vectors have a range of -1.0 to 1.0. However, the most central quantity in
rendering, light, is completely unbounded. We want a LOT more than a 0.0 to
1.0 range. Q3 hacks the gamma tables to sacrifice a bit of precision to get
a 0.0 to 2.0 range, but I wanted more than that for even primitive rendering
techniques. To accurately model the full human sensable range of light
values, you would need more than even a five bit exponent.

This wasn’t much of an issue even a year ago, when we were happy to just
cover the screen a couple times at a high framerate, but realtime graphics
is moving away from just “putting up wallpaper” to calculating complex
illumination equations at each pixel. It is not at all unreasonable to
consider having twenty textures contribute to the final value of a pixel.
Range and precision matter.

A few common responses to this pitch:

“64 bits per pixel??? Are you crazy???” Remember, it is exactly the same
relative step as we made from 16 bit to 32 bit, which didn’t take all
that long.

Yes, it will be slower. That’s ok. This is an important point: we can’t
continue to usefully use vastly greater fill rate without an increase in
precision. You can always crank the resolution and multisample anti-alaising
up higher, but that starts to have diminishing returns well before you use of
the couple gigatexels of fill rate we are expected to have next year. The
cool and interesting things to do with all that fill rate involves many
passes composited into less pixels, making precision important.

“Can we just put it in the texture combiners and leave the framebuffer at 32
bits?” No. There are always going to be shade trees that overflow a given
number of texture units, and they are going to be the ones that need the
extra precision. Scales and biases between the framebuffer and the higher
precision internal calculations can get you some mileage (assuming you can
bring the blend color into your combiners, which current cards can’t), but
its still not what you want. There are also passes which fundamentally
aren’t part of a single surface, but still combine to the same pixels, as
with all forms of translucency, and many atmospheric effects.

“Do we need it in textures as well?” Not for most image textures, but it
still needs to be supported for textures that are used as function look
up tables.

“Do we need it in the front buffer?” Probably not. Going to a 64 bit front
buffer would probably play hell with all sorts of other parts of the system.
It is probably reasonable to stay with 32 bit front buffers with a blit from
the 64 bit back buffer performing a lookup or scale and bias operation before
dithering down to 32 bit. Dynamic light adaptation can also be done during
this copy. Dithering can work quite well as long as you are only performing
a single pass.

I used to be pitching this in an abstract “you probably should be doing this”
form, but two significant things have happened that have moved this up my hit
list to something that I am fairly positive about.

Mark Peercy of SGI has shown, quite surprisingly, that all Renderman surface
shaders can be decomposed into multi-pass graphics operations if two
extensions are provided over basic OpenGL: the existing pixel texture
extension, which allows dependent texture lookups (matrox already supports a
form of this, and most vendors will over the next year), and signed, floating
point colors through the graphics pipeline. It also makes heavy use of the
existing, but rarely optimized, copyTexSubImage2D functionality for
temporaries.

This is a truly striking result. In retrospect, it seems obvious that with
adds, multiplies, table lookups, and stencil tests that you can perform any
computation, but most people were working under the assumption that there
were fundamentally different limitations for “realtime” renderers vs offline
renderers. It may take hundreds or thousands of passes, but it clearly
defines an approach with no fundamental limits. This is very important.
I am looking forward to his Siggraph paper this year.

Once I set down and started writing new renderers targeted at GeForce level
performance, the precision issue has started to bite me personally. There
are quite a few times where I have gotten visible banding after a set of
passes, or have had to worry about ordering operations to avoid clamping.
There is nothing like actually dealing with problems that were mostly
theoretical before…

64 bit pixels. It is The Right Thing to do. Hardware vendors: don’t you be
the company that is the last to make the transition.

I was skimming through Jim Blinn’s “A Trip Down The Graphics Pipeline”
tonight, and I wound up laughing out loud twice.

From the book:

P73: I then empirically found that I had to scale by -1 in x instead of in z,
and also to scale the xa and xf values by -1. (Basically I just put in enough
minus signs after the fact to make it work.) Al Barr refers to this technique
as “making sure you have made an even number of sign errors.”

P131: The only lines that generate w=0 after clipping are those that pass
through the z axis, the valley of the trough. These lines are lines that
pass exactly through the eyepoint. After which you are dead and don’t care
about divide-by-zero errors.

If you laughed, you are a graphics geek.

My first recollection of a Jim Blinn article many years ago was my skimming
over it and thinking “My god, what ridiculously picky minutia.” Over the last
couple years, I found myself haranguing people over some fairly picky issues,
like the LSB errors with cpu vs rasterizer face culling and screen edge
clipping with guard band bit tests. After one of those pitches, I quite
distinctly thought to myself “My god, I’m turning into Jim Blinn!”

There was a young man with Hodgkin’s Lymphoma that, instead of wanting to go
to Disneyland or other traditional wishes, wanted to visit Id and talk with
me about programming.

It turned out that Seumas McNally was already an accomplished developer.
His family company, Longbow Digital Arts (www.longbowdigitalarts.com), had
been doing quite respectably selling small games directly over the internet.
It bore a strong resemblance to the early shareware days of Apogee and Id.

We spent the evening talking about graphics programmer things — the relative
merits of voxels and triangles, procedurally generated media, level of detail
management, API and platforms.

We talked at length about the balance between technology and design, and all
the pitfalls that lie in the way of shipping a modern product.

We also took a dash out in my ferrari, thinking “this is going to be the best
excuse a cop will ever hear if we get pulled over”.

Longbow continued to be successful, and eventually the entire family was
working full time on “Treadmarks”, their new 3D tank game.

Over email about finishing the technology in Treadmarks, Seumas once said
“I hope I can make it”. Not “be a huge success” or “beat the competition”.
Just “make it”.

That is a yardstick to measure oneself by.

It is all too easy to lose your focus or give up with just the ordinary
distractions and disappointments that life brings. This wasn’t ordinary.
Seumas had cancer. Whatever problems you may be dealing with in your life,
they pale before having problems drawing your next breath.

He made it.

Treadmarks started shipping a couple months ago, and was entered in the
Independent Games Festival at the Game Developer’s Conference this last month.
It came away with the awards for technical excellence, game design, and the
grand prize.

I went out to dinner with the McNally family the next day, and had the
opportunity to introduce Anna to them. One of the projects at Anna’s new
company, Fountainhead Entertainment (www.fountainheadent.com), is a
documentary covering gaming, and she had been looking forward to meeting
Seumas after hearing me tell his story a few times. The McNallys invited
her to bring a film crew up to Canada and talk with everyone whenever she
could.

Seumas died the next week.

I am proud to have been considered an influence in Seumas’ work, and I think
his story should be a good example for others. Through talent and
determination, he took something he loved and made a success out of it in
many dimensions.

http://www.gamedev.net/community/memorial/seumas/ for more information.

First, the statement:

Virtualized video card local memory is The Right Thing.

Now, the argument (and a whole bunch of tertiary information):

If you had all the texture density in the world, how much texture
memory would be needed on each frame?

For directly viewed textures, mip mapping keeps the amount of
referenced texels between one and one quarter of the drawn pixels.
When anisotropic viewing angles and upper level clamping are taken into
account, the number gets smaller. Take 1/3 as a conservative estimate.

Given a fairly aggressive six texture passes over the entire screen,
that equates to needing twice as many texels as pixels. At 1024×768
resolution, well under two million texels will be referenced, no matter
what the finest level of detail is. This is the worst case, assuming
completely unique texturing with no repeating. More commonly, less
than one million texels are actually needed.

As anyone who has tried to run certain Quake 3 levels in high quality
texture mode on an eight or sixteen meg card knows, it doesn’t work out
that way in practice. There is a fixable part and some more
fundamental parts to the fall-over-dead-with-too-many-textures problem.

The fixable part is that almost all drivers perform pure LRU (least
recently used) memory management. This works correctly as long as the
total amount of textures needed for a given frame fits in the card’s
memory after they have been loaded. As soon as you need a tiny bit
more memory than fits on the card, you fall off of a performance cliff.
If you need 14 megs of textures to render a frame, and your graphics
card has 12 megs available after its frame buffers, you wind up loading
14 megs of texture data over the bus every frame, instead of just the 2
megs that don’t fit. Having the cpu generate 14 megs of command
traffic can drop you way into the single digit frame rates on most
drivers.

If an application makes reasonable effort to group rendering by
texture, and there is some degree of coherence in the order of texture
references between frames, much better performance can be gotten with a
swapping algorithm that changes its behavior instead of going into a
full thrash:

While ( memory allocation for new texture fails )
Find the least recently used texture.
If the LRU texture was not needed in the previous frame,
Free it
Else
Free the most recently used texture that isn’t bound to an
active texture unit

Freeing the MRU texture seems counterintuitive, but what it does is
cause the driver to use the last bit of memory as a sort of scratchpad
that gets constantly overwritten when there isn’t enough space. Pure
LRU plows over all the other textures that are very likely going to be
needed at the beginning of the next frame, which will then plow over
all the textures that were loaded on top of them.

If an application uses textures in a completely random order, any given
replacement policy has the some effect…

Texture priority for swapping is a non-feature. There is NO benefit to
attempting to statically prioritize textures for swapping. Either a
texture is going to be referenced in the next frame, or it isn’t.
There aren’t any useful gradations in between. The only hint that
would be useful would be a notice that a given texture is not going to
be in the next frame, and that just doesn’t come up very often or cover
very many texels.

With the MRU-on-thrash texture swapping policy, things degrade
gracefully as the total amount of textures increase but due to several
issues, the total amount of textures calculated and swapped is far
larger than the actual amount of texels referenced to draw pixels.

The primary problem is that textures are loaded as a complete unit,
from the smallest mip map level all the way up to potentially a 2048 by
2048 top level image. Even if you are only seeing 16 pixels of it off
in the distance, the entire 12 meg stack might need to be loaded.

Packing can also cause some amount of wasted texture memory. When you
want to load a two meg texture, it is likely going to require a lot
more than just two megs of free texture memory, because a lot of it is
going to be scattered around in 8k to 64k blocks. At the pathological
limit, this can waste half your texture memory, but more reasonably it
is only going to be 10% or so, and cause a few extra texture swap outs.

On a frame at a time basis, there are often significant amounts of
texels even in referenced mip levels that are not seen. The back sides
of characters, and large textures on floors can often have less than
50% of their texels used during a frame. This is only an issue as they
are being swapped in, because they will very likely be needed within
the next few frames. The result is one big hitch instead of a steady
loading.

There are schemes that can help with these problems, but they have
costs.

Packing losses can be addressed with compaction, but that has rarely
proven to be worthwhile in the history of memory management. A 128-bit
graphics accelerator could compact and sort 10 megs of texture memory
in about 10 msec if desired.

The problems with large textures can be solved by just not using large
textures. Both packing losses, and non- referenced texels can be
reduced by chopping everything up into 64×64 or 128×128 textures. This
requires preprocessing, adds geometry, and requires messy overlap of
the textures to avoid seaming problems.

It is possible to estimate which mip levels will actually be needed and
only swap those in. An application can’t calculate exactly the mip
map levels that will be referenced by the hardware, because there are
slight variations between chips and the slope calculation would add
significant processing overhead. A conservative upper bound can be
taken by looking at the minimum normal distance of any vertex
referencing a given texture in a frame. This will overestimate the
required textures by 2x or so and still leave a big hit when the top
mip level loads for big textures, but it can allow giant cathedral
style scenes to render without swapping.

Clever programmers can always work harder to overcome obstacles, but in
this case, there is a clear hardware solution that gives better
performance than anything possible with software and just makes
everyone’s lives easier: virtualize the card’s view of its local
memory.

With page tables, address fragmentation isn’t an issue, and with the
graphics rasterizer only causing a page load when something from that
exact 4k block is needed, the mip level problems and hidden texture
problems just go away. Nothing sneaky has to be done by the
application or driver, you just manage page indexes.

The hardware requirements are not very heavy. You need translation
lookaside buffers (TLB) on the graphics chip, the ability to
automatically load the TLB from a page table set up in local memory,
and the ability to move a page from AGP or PCI into graphics memory and
update the page tables and reference counts. You don’t even need that
many TLB, because graphics access patterns don’t hop all over the place
like CPU access can. Even with only a single TLB for each texture
bilerp unit, reloads would only account for about 1/32 of the memory
access if the textures were 4k blocked. All you would really want at
the upper limit would be enough TLB for each texture unit to cover the
texels referenced on a typical rasterization scan line.

Some programmers will say “I don’t want the system to manage the
textures, I want full control!” There are a couple responses to that.
First, a page level management scheme has flexibility that you just
can’t get with a software only scheme, so it is a set of brand new
capabilities. Second, you can still just choose to treat it as a fixed
size texture buffer and manage everything yourself with updates.
Third, even if it WAS slower than the craftiest possible software
scheme (and I seriously doubt it), so much of development is about
willingly trading theoretical efficiency for quicker, more robust
development. We don’t code overlays in assembly language any more…

Some hardware designers will say something along the lines of “But
the graphics engine goes idle when you are pulling the page over from
AGP!” Sure, you are always better off to just have enough texture
memory and never swap, and this feature wouldn’t let you claim any more
megapixels or megatris, but every card winds up not having enough
memory at some point. Ignoring those real world cases isn’t helping
your customers. In any case, it goes idle a hell of a lot less than if
you were loading the entire texture over the command fifo.

3Dlabs is supposed to have some form of virtual memory management in
the permedia 3, but I am not familiar with the details (if anyone from
3dlabs wants to send me the latest register specs, I would appreciate
it!).

A mouse controlled first person shooter is fairly unique in how quickly
it can change the texture composition of a scene. A 180-degree snap
turn can conceivably bring in a completely different set of textures on
a subsequent frame. Almost all other graphics applications bring
textures in at a much steadier pace.

So, given that 180-degree snap turn to a completely different and
uniquely textured scene, what would be the worst case performance? An
AGP 2x bus is theoretically supposed to have over 500 mb/sec of
bandwidth. It doesn’t get that high in practice, but linear 4k block
reads would give it the best possible conditions, and even at 300
mb/sec, reloading the entire texture working set would only take 10
msec.

Rendering is not likely to be buffered sufficiently to overlap
appreciably with page loading, and the command transport for a complex
scene will take significant time by itself, so it shows that a worst
case scene will often not be able to be rendered in 1/60th of a second.

This is roughly the same lower bound that you get from a chip texturing
directly from AGP memory. A direct AGP texture gains the benefit of
fine-grained rendering overlap, but loses the benefit of subsequent
references being in faster memory (outside of small on-chip caches).
A direct AGP texture engine doesn’t have the higher upper bounds of a
cached texture engine, though. It’s best and worst case are similar
(generally a good thing), but the cached system can bring several times
more bandwidth to bear when it isn’t forced to swap anything in.

The important point is that the lower performance bound is almost an
order of magnitude faster than swapping in the textures as a unit by
the driver.

If you just positively couldn’t deal with the chance of that much worst
case delay, some form of mip level biasing could be made to kick in, or
you could try and do pre-touching, but I don’t think it would ever be
worth it. The worst imaginable case is acceptable, and you just won’t
hit that case very often.

Unless a truly large number of TLB are provided, the textures would
need to be blocked. The reason is that with a linear texture, a 4k
page maps to only a couple scan lines on very large textures. If you
are going with the grain you get great reuse, but if you go across it,
you wind up referencing a new page every couple texel accesses. What
is wanted is an addressing mechanism that converts a 4k page into a
square area in the texture, so the page access is roughly constant for
all orientations. There is also a benefit from having a 128 bit access
also map to a square block of pixels, which several existing cards
already do. The same interleaving-of-low-order-bits approach can just
be extended a few more bits.

Dealing with blocked texture patterns is a hassle for a driver writer,
but most graphics chips have a host blit capability that should let the
chip deal with changing a linear blit into blocked writes. Application
developers should never know about it, in any case.

There are some other interesting things that could be done if the page
tables could trigger a cpu interrupt in addition to being automatically
backed by AGP or PCI memory. Textures could be paged in directly from
disk for truly huge settings, or decompressed from jpeg blocks, or even
procedurally generated. Even the size limits of the AGP aperture could
usefully be avoided if the driver wanted to manage each page’s
allocation.

Aside from all the basic swapping issue, there are a couple of other
hardware trends that push things this way.

Embedded dram should be a driving force. It is possible to put several
megs of extremely high bandwidth dram on a chip or die with a video
controller, but won’t be possible (for a while) to cram a 64 meg
geforce in. With virtualized texturing, the major pressure on memory
is drastically reduced. Even an 8mb card would be sufficient for 16
bit 1024×768 or 32 bit 800×600 gaming, no matter what the texture load.

The only thing that prevents a geometry processor based card from
turning almost any set of commands in a display list into a single
static dma buffer is the fact that textures may be swapped in and out,
causing the register programming in the buffer to be wrong. With
virtual texture addressing, a texture’s address never changes, and an
arbitrarily complex model can be described in a static dma buffer.

The idea isn’t to punish anyone, it is to have them comply with the license
and continue to contribute. QuakeLives has quite a few happy users, and it
is in everyone’s best interest to have development continue. It just has to
be by the rules.

I see both sides of this. Your goals are positive, and I understand the issues
and the difficulties that your project has to work under because of the GPL.
I have also seen some GPL zealots acting petty and immature towards you very
early on (while it is within everyone’s rights to DEMAND code under the GPL, it
isn’t necessarily the best attitude to take), which probably colors some of your
views on the subject.

We discussed several possible legal solutions to the issues.

This isn’t one of them.

While I doubt your “give up your rights” click through would hold up in court,
I am positive that you are required to give the source to anyone that asks for
it that got a binary from someone else. This doesn’t provide the obscurity
needed for a gaming level of security.

I cut you a lot of slack because I honestly thought you intended to properly
follow through with the requirements of the GPL, and you were just trying to
get something fun out ASAP. It looks like I was wrong.

If you can’t stand to work under the GPL, you should release the code to your
last binary and give up your project. I would prefer that you continue your
work, but abide by the GPL.

If necessary, I will pay whatever lawyer the Free Software Foundation
reccomends to pursue this.

http://www.students.tut.fi/~zibbo/qizmo/

I finally found a case of the stuck-at-awaiting-gamestate problem that
turned out to be a continuous case of a fragment of the gamestate getting
dropped. I have changed the net code to space out the sending of the
fragments based on rate.

Note that there have been a few different things that result in stuck
at gamestate or stuck at snapshot problems. We have fixed a few of them,
but there may well still be other things that we haven’t found yet.

You can still have a fun game on a 28.8 modem. It is a significant
disadvantage, no question about it, but you can still have a good game if
you play smart. If there is someone that knows what they are doing on a
server with a ping in the low 100s, there won’t usually be much you can
do, but a skilled modem player can still beat up on unskilled T1 players…

Make sure your modem rate is set correctly. If you have it set too high,
large amounts of data can get buffered up and you can wind up with multiple
seconds of screwed up delays.

Only play on servers with good pings. My connection gives me a couple dozen
servers with mid 200 pings. 56k modems often see servers with sub 200 pings.
If you ignore the ping and just look for your favorite map, you will probably
have a crappy game.

If you have a good basic connection to the server, the thing that will mess
up your game is too much visible activity. This is a characteristic of the
number of players, the openness of the level, and the weapons in use.

Don’t play on madhouse levels with tons of players. None of the normal Q3
maps were really designed for more than eight players, and many were only
designed for four.

Don’t play in the wide open maps unless there are only a couple other
players. Four very active players in a wide open area are enough to bog
down a modem connection.

I just implemented “sv_minPing” / “sv_maxPing” options so servers can restrict
themselves to only low ping or high ping players. This is done based on the
ping of the challenge response packet, rather than any in-game pings. There
are a few issues with that — a LPB may occasionally get into a HPB server
if they happen to get a network hiccup at just the right time, and the number
used as a gate will be closer to the number shown in the server list, rather
than the number seen in gameplay. I would reccomend “sv_minPing 200″ as a
reasonable breakpoint.

There will be a sorting out period as people figure out what directions
the Quake1 world is going to go in with the new capabilities, but it
will still be possible to have cheat free games after a few things get
worked out.

Here’s what needs to be done:

You have to assume the server is trusted. Because of the wau quake
mods work, It has always been possible to have server side cheats
along the lines of “if name == mine, scale damage by 75%”. You have
to trust the server operator.

So, the problem then becomes a matter of making sure the clients are
all playing with an acceptable version before allowing them to connect
to the server. You obviously can’t just ask the client, because if it
is hacked it can just tell you what you want to hear. Because of the
nature of the GPL, you can’t just have a hidden part of the code to do
verification.

What needs to be done is to create two closed source programs that act
as executable loaders / verifiers and communication proxies for the
client and server. These would need to be produced for each platform
the game runs on. Some modifications will need to be done to the
open source code to allow it to (optionally) communicate with these
proxies.

These programs would perform a robust binary digest of the programs they
are loading and communicate with their peer in a complex encrypted
protocol before allowing the game connection to start. It may be
possible to bypass the proxy for normal packets to avoid adding any
scheduling or latency issues, but it will need to be involved to some
degree to prevent a cheater from hijacking the connection once it is
created.

The server operator would determine which versions of the game are to
be allowed to connect to their server if they wish to enforce proxy
protection. The part of the community that wants to be competetive
will have to agree to some reasonable schedule of adoption of new
versions.

Nothing in online games is cheat-proof (there is allways the device
driver level of things to hack on), but that would actually be more
secure than the game as it originally shipped, because hex edited patches
wouldn’t work any more. Someone could still in theory hack the closed
source programs, but that is the same situation everyone was in with
the original game.

People can start working on this immediately. There is some prior art
in various unix games that would probably be helpfull. It would also
be a good idea to find some crypto hackers to review proposed proxy
communication strategies.

We still have a Christmas present for the coders, though:

http://www.idsoftware.com/q1source/

Happy holidays!

It wasn’t generally discussed during her time at Id, but we had been going
out when she joined the company, and we were engaged earlier this year.
We are getting married next month, and honeymooning in Hawaii. At her
thoughtful suggestion, we are shipping a workstation out with us, so I don’t
fall into some programming-deprivation state. How great is that?

Now that Q3A has shipped, the official winner of her Id Software figurine
chess set contest is Rowan Crawford for his prose and art.

An honorable mention goes to Reine Hogberg and Peder Hardings for their Q3A
Blair Witch Project. They will receive silver Q3A medallions.

I think there is a strong need for a proactive, vendor-neutral
OpenGL watchdog, or even a small group, especially in the linux space.

I have been working on the utah-GLX team for quite a while now, and while
I have been very pleased with the results, I would like to see more effort
spent on doing things as right as possible. Because the developers (me
included) are basically just doing the work in their spare time, testing
usually only consists of running their favorite OpenGL application, and a
few of the mesa demos, or some of the xscreensaver hacks.

Recently I did the initial bringup of a RagePro driver on linux, and I was
much more conscious of the large untested feature space, and the tunnel
vision I was using to get it to the point of running Q3.

What we need is someone, or a group of someones, who can really exercise
different implementations through all corners of the OpenGL specification
and provide detailed lists of faults with minimal test cases to reproduce
the behavior.

In most cases, the bugs could then be fixed, but even if it is decided that
the incorrect behavior is going to stay (to avoid a software fallback in a
common accelerated case), there would be clear documentation of it.

I consider performance on the matrox driver right now to be “good enough”.
There is definately more performance oriented work going on, but given a
choice of tasks to work on, I would rather improve quality and coverage
instead of kicking a few more fps out of Q3.

One of Alex St. John’s valid points was that “The drivers are always broken”.
There are a lot of factors that contribute to it, including fierce
benchmarking competition causing driver writers to do some debatable things
and diminish focus on quality. With open source drivers, some of those
factors go away. Sure, it is nice to beat windows drivers on some benchmarks,
but I wouldn’t let pursuit of that goal introduce dumb things into the code.

Some of the windows IHVs have good testing proceedures and high quality
drivers, but even there, it would be nice to have someone hounding them about
things beyond how well quake releated games run.

The same goes for Apple, especially now that there is both ATI and 3dfx
support.

Conformance would be my primary interest, but characterizing the performance
of different drivers would also be usefull, especially for edge cases that may
or may not be accelerated, like glDrawPixels.

On linux right now, we have:

The traditional fullscreen 3dfx mesa driver
The DRI-GLX based banshee/voodoo3 driver
The utah-GLX matrox G200/G400 driver
The temporary utah-GLX nvidia driver
The newly born utah-GLX ATI Rage Pro driver

If anyone is interested, join the developer list off of:
http://glx.on.openprojects.net/

Doing a proper job would require a really good knowledge of the OpenGL
specification, and a meticulous style, but it wouldn’t require hardcore
registers-and-dma driver writing skills, only basic glut programming.

If someone does wind up developing a good suite of tools and procedures and
gives one of the drivers a really good set of feedback, I would be happy to
provide extra video cards so they could beat up all the implementations.

Ahhhh….

I am very happy with how Q3 turned out. Probably more than any
game we have done before, it’s final form was very close to its
initial envisioning.

I will be getting all the Q3 code we are going to release together
over the next week or so. I will write some overview documentation
to give a little context, and since you can do game mods without
needing a commercial compiler now, I will write a brief step-by-step
to modifying the game code.

I’m looking forward to what comes out of the community with Q3.

The rough outline of what I am going to be working on now:

We will be supporting Q3 for quite some time. Any problems
we have will get fixed, and some new features my sneak in.

I have two rendering technologies that I intend to write research
engines for.

I am going to spend some time on computer vision problems. I think
the cheap little web cams have some interesting possibilities.

I am going to explore some possibilities with generalizing 3D game
engines into more powerful environments with broader uses. I think
that a lot of trends are coming to the point where a “cyberspace” as
it is often imagined is begining to be feasible.

I am going to spend more time on some Free Software projects. I have
been stealing a few hours here and there to work on the matrox glx
project for a while now, and it has been pretty rewarding.
People with an interest in the guts of a 3D driver might want to look
at the project archives at http://glx.on.openprojects.net/.
The web pages aren’t very up to date, but the mailing list covers some
good techie information.

* shrink zone, grow hunk
* flush memory on an error
* fixed crash pasting from clipboard
* test all compiler optimizations — 5% speedup
* fixed major slowdown in team games with large
numbers of players and location markers

The mac version going out has the executable fixes that we
have made in the last couple days, but most of the fixes
have been in code that runs in the virtual machine, and we
can’t update that without making it incomptable with the
pc version.

The game remains very marginal in playability on 266mhz imacs
and iBooks.

A 333mhz imac should be playable for a casual gamer if the
graphics options are turned down to the “fastest” setting.

There is still a lot of room for improvement on ATI’s side
with the RagePro drivers. Almost all the effort so far
has been on the Rage128 drivers.

The G3 systems run fine, but a little slower than a pc of
equal mhz

The rage128 cards in the G3s are only clocked at 75mhz, so
you can’t run too high of a resolution, but you can get
very nice image quality. I usually play with these settings:
r_mode 2 // 512*284 res
r_colorbits 32 // 32 bit color
r_texturemode gl_linear_mipmap_linear // trilinear filtering

I haven’t played on one of the new iMacs or G4’s but they
both use the rage128 driver, which is fairly high quality
now, so they should perform well.

We found a fairly significant problem with inputSprockets and
mouse control (motion is dropped after 40msec). I have done a
little working around it, so mouse control should be somewhat
better in this version, but it will hopefully be fixed
properly by Apple in the next IS rev. It isn’t an issue if
your framerate is high enough, but iMacs never see that
framerate on their very best days…

Linux version tomorrow night, if nothing horrible happens.

Some advance warning about something that is sure to stir
up some argument:

We should be handing off the masters for all three platforms
within a day or two of each other, but they aren’t going to
show up in stores at the same time. Publishers, distributers,
and stores are willing to go out of their way to expedite the
arrival of the pc version, but they just won’t go to the
same amount of trouble for mac and linux boxes.

THE EXECUTABLES FOR ALL PLATFORMS WILL NOT BE AVAILABLE FOR
DOWNLOAD UNTIL AFTER CHRISTMAS. This means that if you want
to play on the mac or linux, don’t pick up a copy of the pc
version and expect to download the other executables.

Our first update to the game will be for all platforms, and
will allow any version to be converted into any other, but
we intend to hold that off for a little while.

We are doing this at the request of the distributors. The
fear is that everyone will just grab a windows version,
and the separate boxes will be ignored.

A lot of companies are going to be watching the sales
figures for the mac and linux versions of Q3 to see if
the platforms are actually worth supporting. If everyone
bought a windows version and the other boxes sold like crap
in comparison, that would be plenty of evidence for most
executives to can any cross platform development.

I know there are a lot of people that play in both windows
and linux, and this may be a bit of an inconvenience in
the short term, but this is an ideal time to cast a vote
as a consumer.

Its all the same to Id (I like hybrid CD’s), and our continued
support of linux and mac (OS X for the next title) is basically
a foregone conclusion, but the results will probably influence
other companies.

* fixed getting your own dropped / kicked message
* added developer print for all file open write’s
* fixed occasional bad color on connecting background
* fixed occasional telefrag at start of skirmish game
* fix not being able to ready at intermission if
you were following a bot
* never timelimit during tourney warmup
* fixed local timer on map_restart
* offset sorlag’s head model for status bar
* added g_gametype to the votable commands:
map, map_restart, kick, g_gametype
* changed sound registration sequence to fix losing
default sound
* “sv_floodProtect 0″ to turn off flood protection
* converted sequenced messages to static arrays
* fixed custom skin reassignment on all LOD

Clients are only allowed to make one command a second of any kind.
This prevents excessive flooding by chats, model / name changes,
and any other command that could possibly be exploited. The
command streams are stalled, so it doesn’t have any effect on
processing order or reliability.

This means that if you issue two commands immediately after one
another, there will be a one second stall before the second
command and all movement clears. You see this on the lagometer
as yellow spiking up for a second, then dropping away.

Hitting tab for the scoreboard sends a command, so you trigger
the flood protection if you bang tab a couple times. This has
been fixed so that the scoreboard will never send more than
one update request every two seconds, but you will need to
watch out for it in the existing demo.

The defered model loading has also caused some confusion, but
that is a feature, not a bug.

In previous tests, you hitched for a second or two whenever a
client with a new model or skin joined a game.

In the demo, when a client joins the game they will be given
the model and skin of someone else temporarily, so there is
no hitch. The only time it will hitch on entry is if it is
a team game and there isn’t anyone on the team they join. I
make sure the skin color is correct, even if the model isn’t.

These “defered” clients will be loaded when you bring up the
scoreboard. You can do this directly by hitting tab, or you
can have it happen for you when you die.

The point is: you died BEFORE it hitched, not as a result of
the hitch.

The scoreboard header is up, but it is still a bit easy to miss.

* fixed high server idle cpu usage
(it was spinning in place until maxfps was used!)
* fixed g_password, which is crashing in the demo
* moved svs.snapshotEntities to the hunk
* enable lagometer whenever running a non-local game
* cg_drawTeamOverlay cvar, set to 0 by default
* finished authorize work
* better reporting of unused highwater memory

Xian added some chrome and energy effects to parts of q3tourney2,
which changed them from two pass to three pass shaders. We felt
that that 50% increase on those polygons was justified in normal
play, but as people have pointed out, when you are playing with
vertex lighting, that three passes stays three passes instead
of collapsing to a single pass, resulting in a 300% increase
on those polygons over the way it was before. Still faster than
lightmap mode, but a large variance over other parts of the level.

Today I wrote new code to address that, and improve on top of it.

Now when r_vertexlight is on, I force every single shader to a
single pass. In the cases where it isn’t a simple light*texture
case, I try and intelligently pick the most representative pass
and do some fixups on the shader modulations.

This works our great, and brings the graphics load down to the
minimum we can do with the data sets.

Performance is still going to be down a couple msec a frame due to
using dynamic compilation instead of dll’s for the cgame, but that
is an intentional tradeoff. You can obviously slow things down by
running a lot of bots, but that is to be expected.

I am still investigating the high idle dedicated server cpu utilization
and a few other issues. The server cpu time will definately be
higher than 1.08 due to the dynamic compiler, but again, that is
an intentional tradeoff.

A set of go-fast-and-look-ugly options:
r_mode 2
r_colorbits 16
r_texturemode GL_LINEAR_MIPMAP_NEAREST
r_vertexlighting 1
r_subdivisions 999
r_lodbias 2
cg_gibs 0
cg_draw3dicons 0
cg_brassTime 0
cg_marks 0
cg_shadows 0
cg_simpleitems 1
cg_drawAttacker 0

* icons for bot skills on scoreboard
* r_vertexlight is now “force single pass” for all shaders
* modified cd key check to be fire and forget on the client
* file handle debugging info in path command
* network address type of NA_BAD for failed resolves
* better command line variable overriding
* cache scoreboard for two seconds
* sync sound system before starting cinematics
* fixed many escapes disconnect from server exiting the game
* fixed shotgun pellets underwater expending all temp entities

Mac and linux builds won’t be out tonight.

* clear SVF_BOT when exiting follow mode
* render temp memory
* new mac GL initialization code
* no zone memory use in music thread
* added check for trash past zone block
* explicitly flush journal data file after a write
* added FS_Flush

We have hired Robert Duffy as a full time employee, starting in
December.

He has been maintaining the level editor since the release of Q2,
but a number of things have convinced me it is time to have a
full time tool-guy at id.

The original QE4 editor was my very first ever Win32 program, and
while Robert has done a good job of keeping it on life support
through necessary extensions and evolutions, it really is past
its designated lifespan.

I want to take a shot at making the level editor cross platform,
so it can be used on linux and mac systems. I’m not exactly
confident that it will work out, but I want to try.

Many of the content creation tasks seem to be fairly stabilized
over the last several years, and our next product is going to be
pretty content directed, so I can justify more engineering
effort on writing better tools.

It is time for a re-think of the relationships between editor,
utilities, and game. I am still an opponent of in-game editors,
but I want to rearrange a lot of things so that some subsystems
can be shared.

All of that added up to more than I was going to be able to do
in the time left after the various research, graphics, and
networking things I want to pursue.

* added r_speeds timing info to cinematic texture uploads
* fixed loop sounds on movers
* new bfg sound
* “sv_pure 1″ as default, requires clients to only get data from
pk3 files the server is using
* fixed fog pass on inside of textured fog surfaces
* properly fog sprites
* graphics for scoreboard headers
* show colored names on attacker display and scoreboard
* made “no such frame” a developer only warning
* count a disconnect while losing in tournement mode as a win
for the other player
* fixed running with jump held down runs slow
* draw “connection problems” in center of screen in addition
to phone jack icon
* cut marks properly on non-convex faces
* fixed bug with command completion partial match and case sensitivity
* fixed console dropping on level start
* fixed frags left feedback after restarts
* fog after dlight
* removed fogged stages from shader, dynamically generate
* removed fogonly shader keyword, infer from surfaceparm
* removed uneeded reinit of shader system on vid_restart

The timing just didn’t work out right for another test before we
complete the game.

We plan on releasing the demo after code freeze, when the entire
game is in final testing, which will give us a few days time to
fix any last minute problems that show up before golden master.

No, I don’t have an actual date when that will be.

—

I got an iBook in on friday. It is sort of neat (I need to go
buy an AirPort, then it will definately be neat), but it is
currently way too slow to play Q3 on.

Apple’s high end G3 and G4 systems with rage128/rage128pro cards
and latest drivers are just about as fast as equivelant wintel systems,
but the rest of the product line is still suffering a noticable
speed disadvantage.

The new iMac has a rage128, but it is only an 8mb/64bit version. Still,
with agp texturing it is a solid platform with performance that is
certainly good enough to play the game well on.

Existing iMacs have 6mb ragePro video. ATI’s windows drivers for
the pro have come a long ways, and Q3 is plenty playbale on
windows with a rage pro (ugly, but playable). On apple systems
(iMacs and beige G3’s), the performance is sometimes as low as HALF
the windows platform. The lack of AGP contributes some to this, but
it is mostly just a case of the drivers not being optimzed yet. The
focus has been on the rage128 so far.

The iBook is also ragePro based, but it is an ultra-cheap 32 bit
version. It does texture over AGP, but it is slooooow. I suspect it
is still driver issues, because it is still very slow even at 320×240,
so that leaves hope that it can be improved.

Another issue with the Apple systems is that Apple 16 bit color is
actually 15 bit. I never used to think it made much difference, but
I have been doing a lot of side by side comparying, and it does turn
out to be a noticable loss of quality.

* new lg splash
* added channel number for local sounds so feedbacks
don’t override announcers
* remvoed scoreup feedback sound
* expand score tabs as needed for large scores
* fixed bfg obit
* fixed swimming off floors
* fixed swim animation when jumping in shallow water
* fixed first weapopn switch problem
* convert all joystick axis to button events (twist is now bindable)

Q3test, and later the full commercial Quake3: Arena, will be simultaniously
released on windows, mac, and linux platforms.

I think Apple is doing a lot of things right. A lot of what they are
doing now is catch-up to wintel, but if they can keep it up for the next
year, they may start making a really significant impact.

I still can’t give the mac an enthusiastic reccomendation for sophisticated
users right now because of the operating system issues, but they are working
towards correcting that with MacOS X.

The scoop on the new G3 mac hardware:

Basically, its a great system, but Apple has oversold its
performance reletive to intel systems. In terms of timedemo scores,
the new G3 systems should be near the head of the pack, but there
will be intel systems outperforming them to some degree. The mac has
not instantly become a “better” platform for games than wintel, it
has just made a giant leap from the back of the pack to near the
front.

I wish Apple would stop quoting “Bytemarks”. I need to actually
look at the contents of that benchmark and see how it can be so
misleading. It is pretty funny listening to mac evangelist types
try to say that an iMac is faster than a pentium II-400. Nope.
Not even close.

From all of my tests and experiments, the new mac systems are
basically as fast as the latest pentium II systems for general
cpu and memory performance. This is plenty good, but it doesn’t
make the intel processors look like slugs.

Sure, an in-cache, single precision, multiply-accumulate loop could
run twice as fast as a pentium II of the same clock rate, but
conversly, a double precision add loop would run twice as fast
on the pentium II.

Spec95 is a set of valid benchmarks in my opinion, and I doubt the
PPC systems significantly (if at all) outperform the intel systems.

The IO system gets mixed marks. The 66 mhz video slot is a good step
up from 33 mhz pci in previous products, but that’s still half the
bandwidth of AGP 2X, and it can’t texture from main memory. This
will have a small effect on 3D gaming, but not enough to push it
out of its class.

The 64 bit pci slots are a good thing for network and storage cards,
but the memory controller doesn’t come close to getting peak
utilization out of it. Better than normal pci, though.

The video card is almost exactly what you will be able to get on
the pc side: a 16 mb rage-128. Running on a 66mhz pci bus, it’s
theoretical peak performance will be midway between the pci and
agp models on pc systems for command traffic limited scenes. Note
that current games are not actually command traffic limited, so the
effect will be significantly smaller. The fill rates will be identical.

The early systems are running the card at 75 mhz, which does put
it at a slight disadvantage to the TNT, but faster versions are
expected later. As far as I can tell, the rage-128 is as perfect
as the TNT feature-wise. The 32 mb option is a feature ATI can
hold over TNT.

Firewire is cool.

Its a simple thing, but the aspect of the new G3 systems that
struck me the most was the new case design. Not the flashy plastic
exterior, but the functional structure of it. The side of the
system just pops open, even with the power on, and lays the
motherboard and cards down flat while the disks and power supply
stay in the encloser. It really is a great design, and the benefits
were driven home yesterday when I had to scavenge some ram out of old
wintel systems yesterday — most case designs suck really bad.

—

I could gripe a bit about the story of our (lack of) involvement
with Apple over the last four years or so, but I’m calling that
water under the bridge now.

After all the past fiascos, I had been basically planning on ignoring Apple
until MacOS X (rhapsody) shipped, which would then turn it into a platform
that I was actually interested in.

Recently, Apple made a strategic corporate decision that games were a
fundamental part of a consumer oriented product line (duh). To help that
out, Apple began an evaluation of what it needed to do to help game
developers.

My first thought was “throw out MacOS”, but they are already in the process
of doing that, and its just not going to be completed overnight.

Apple has decent APIs for 2D graphics, input, sound, and networking,
but they didn’t have a solid 3D graphics strategy.

Rave was sort of ok. Underspecified and with no growth path, but
sort of ok. Pursuing a proprietary api that wasn’t competetive with
other offerings would have been a Very Bad Idea. They could have tried
to make it better, or even invent a brand new api, but Apple doesn’t have
much credebility in 3D programming.

For a while, it was looking like Apple might do something stupid,
like license DirectX from microsoft and be put into a guaranteed
trailing edge position behind wintel.

OpenGL was an obvious direction, but there were significant issues with
the licensing and implementation that would need to be resolved.

I spent a day at apple with the various engineering teams and executives,
laying out all the issues.

The first meeting didn’t seem like it went all that well, and there wasn’t
a clear direction visible for the next two months. Finally, I got the all
clear signal that OpenGL was a go and that apple would be getting both the
sgi codebase and the conix codebease and team (the best possible arrangement).

So, I got a mac and started developing on it. My first weekend of
effort had QuakeArena limping along while held together with duct
tape, but weekend number two had it properly playable, and weekend
number three had it brought up to full feature compatability. I
still need to do some platform specific things with odd configurations
like multi monitor and addon controlers, but basically now its
just a matter of compiling on the mac to bring it up to date.

This was important to me, because I felt that Quake2 had slipped a bit in
portability because it had been natively developed on windows. I like the
discipline of simultanious portable development.

After 150 hours or so of concentrated mac development, I learned a
lot about the platform.

CodeWarrior is pretty good. I was comfortable devloping there
almost immediately. I would definately say VC++ 6.0 is a more powerful
overall tool, but CW has some nice little aspects that I like. I
am definately looking forward to CW for linux. Unix purists may
be aghast, but I have allways liked gui dev environments more than
a bunch of xterms running vi and gdb.

The hardware (even the previous generation stuff) is pretty good.

The OpenGL performance is pretty good. There is a lot of work
underway to bring the OpenGL performance to the head of the pack,
but the existing stuff works fine for development.

The low level operating systems SUCKS SO BAD it is hard to believe.

The first order problem is lack of memory management / protection.

It took me a while to figure out that the zen of mac development is
“be at peace while rebooting”. I rebooted my mac system more times
the first weekend than I have rebooted all the WinNT systems I
have ever owned. True, it has gotten better now that I know my
way around a bit more, and the codebase is fully stable, but there
is just no excuse for an operating system in this day and age to
act like it doesn’t have access to memory protection.

The first thing that bit me was the static memory allocation for
the program. Modern operating systems just figure out how much
memory you need, but because the mac was originally dsigned for
systems without memory management, significant things have to be
laid out ahead of time.

Porting a win32 game to the mac will probably involve more work
dealing with memory than any other aspect. Graphics, sound, and
networking have reasonable analogues, but you just can’t rely
on being able to malloc() whatever you want on the mac.

Sure, game developers can manage their own memory, but an operating
system that has proper virtual memory will let you develop
a lot faster.

The lack of memory protection is the worst aspect of mac development.
You can just merrily write all over other programs, the development
environment, and the operating system from any application.

I remember that. From dos 3.3 in 1990.

Guard pages will help catch simple overruns, but it won’t do anything
for all sorts of other problems.

The second order problem is lack of preemptive multitasking.

The general responsiveness while working with multiple apps
is significantly worse than windows, and you often run into
completely modal dialogs that don’t let you do anything else at all.

A third order problem is that a lot of the interfaces are fairly
clunky.

There are still many aspects of the mac that clearly show design
decisions based on a 128k 68000 based machine. Wintel has grown
a lot more than the mac platform did. It may have been because the
intel architecture didn’t evolve gracefully and that forced the
software to reevaluate itself more fully, or it may just be that
microsoft pushed harder.

Carbon sanitizes the worst of the crap, but it doesn’t turn it
into anything particularly good looking.

MacOS X nails all these problems, but thats still a ways away.

I did figure one thing out — I was always a little curious why
the early BeOS advocates were so enthusiastic. Coming from a
NEXTSTEP background, BeOS looked to me like a fairly interesting
little system, but nothing special. To a mac developer, it must
have looked like the promised land…

However, Gregory Maxwell pointed out that it wouldn’t work cross platform
with 64 bit pointer environments like linux alpha. That is a killer, so
I will be forced to do everything the hard way. Its probably for the
best, from a design standpoint anyway, but it will take a little more effort.

I am considering allowing the interpreted code to live in the global address
space, instead of a private 0 based address space of its own. Store
instructions from the VM would be confined to the interpreter’s address
space, but loads could access any structures.

On the positive side:

This would allow full speed (well, full interpreted speed) access to variables
shared between the main code and the interpreted modules. This allows system
calls to return pointers, instead of filling in allocated space in the
interpreter’s address space.

For most things, this is just a convenience that will cut some development
time. Most of the shared accesses could be recast as “get” system calls,
and it is certainly arguable that that would be a more robust programming
style.

The most prevelent change this would prevent is all the cvar_t uses. Things
could stay in the same style as Q2, where cvar accesses are free and
transparantly updated. If the interpreter lives only in its own address
space, then cvar access would have to be like Q1, where looking up a
variable is a potentially time consuming operation, and you wind up adding
lots of little cvar caches that are updated every from or restart.

On the negative side:

A client game module with a bug could cause a bus error, which would not be
possible with a pure local address space interpreter.

I can’t think of any exploitable security problems that read only access to
the entire address space opens, but if anyone thinks of something, let me
know.

The way the QA game architecture has been developed so far has been as two
seperate binary dll’s: one for the server side game logic, and one for the
client side presentation logic.

While it was easiest to begin development like that, there are two crucial
problems with shipping the game that way: security and portability.

It’s one thing to ask the people who run dedicated servers to make informed
decisions about the safety of a given mod, but its a completely different
matter to auto-download a binary image to a first time user connecting to a
server they found.

The quake 2 server crashing attacks have certainly proven that there are
hackers that enjoy attacking games, and shipping around binary code would
be a very tempting opening for them to do some very nasty things.

With quake and Quake 2, all game modifications were strictly server side,
so any port of the game could connect to any server without problems.
With Quake 2’s binary server dll’s not all ports could necessarily run a
server, but they could all play.

With significant chunks of code now running on the client side, if we stuck
with binary dll’s then the less popular systems would find that they could
not connect to new servers because the mod code hadn’t been ported. I
considered having things set up in such a way that client game dll’s could
be sort of forwards-compatable, where they could always connect and play,
but new commands and entity types just might now show up. We could also
GPL the game code to force mod authors to release source with the binaries,
but that would still be inconvenient to deal with all the porting.

Related both issues is client side cheating. Certain cheats are easy to do
if you can hack the code, so the server will need to verify which code the
client is running. With multiple ported versions, it wouldn’t be possible
to do any binary verification.

If we were willing to wed ourselves completely to the windows platform, we
might have pushed ahead with some attempt at binary verification of dlls,
but I ruled that option out. I want QuakeArena running on every platform
that has hardware accelerated OpenGL and an internet connection.

The only real solution to these problems is to use an interpreted language
like Quake 1 did. I have reached the conclusion that the benefits of a
standard language outweigh the benefits of a custom language for our
purposes. I would not go back and extend QC, because tThat stretches the
effort from simply system and interpreter design to include language design,
and there is already plenty to do.

I had been working under the assumption that Java was the right way to go,
but recently I reached a better conclusion.

The programming language for QuakeArena mods is interpreted ANSI C. (well,
I am dropping the double data type, but otherwise it should be pretty
conformant)

The game will have an interpreter for a virtual RISC-like CPU. This should
have a minor speed benefit over a byte-coded, stack based java interpreter.
Loads and stores are confined to a preset block of memory, and access to all
external system facilities is done with system traps to the main game code,
so it is completely secure.

The tools necessary for building mods will all be freely available: a
modified version of LCC and a new program called q3asm. LCC is a wonderful
project — a cross platform, cross compiling ANSI C compiler done in under
20K lines of code. Anyone interested in compilers should pick up a copy of
“A retargetable C compiler: design and implementation” by Fraser and Hanson.

You can’t link against any libraries, so every function must be resolved.
Things like strcmp, memcpy, rand, etc. must all be implemented directly. I
have code for all the ones I use, but some people may have to modify their
coding styles or provide implementations for other functions.

It is a fair amount of work to restructure all the interfaces to not share
pointers between the system and the games, but it is a whole lot easier
than porting everything to a new language. The client game code is about
10k lines, and the server game code is about 20k lines.

The drawback is performance. It will probably perform somewhat like QC.
Most of the heavy lifting is still done in the builtin functions for path
tracing and world sampling, but you could still hurt yourself by looping
over tons of objects every frame. Yes, this does mean more load on servers,
but I am making some improvements in other parts that I hope will balance
things to about the way Q2 was on previous generation hardware.

There is also the amusing avenue of writing hand tuned virtual assembly
assembly language for critical functions…

I think this is The Right Thing.

I wanted to do a .plan about my evolving thoughts on code quality
and lessons learned through quake and quake 2, but in the interest
of actually completing an update, I decided to focus on one change
that was intended to just clean things up, but had a surprising
number of positive side effects.

Since DOOM, our games have been defined with portability in mind.
Porting to a new platform involves having a way to display output,
and having the platform tell you about the various relevant inputs.
There are four principle inputs to a game: keystrokes, mouse moves,
network packets, and time. (If you don’t consider time an input
value, think about it until you do — it is an important concept)

These inputs were taken in separate places, as seemed logical at the
time. A function named Sys_SendKeyEvents() was called once a
frame that would rummage through whatever it needed to on a
system level, and call back into game functions like Key_Event( key,
down ) and IN_MouseMoved( dx, dy ). The network system
dropped into system specific code to check for the arrival of packets.
Calls to Sys_Milliseconds() were littered all over the code for
various reasons.

I felt that I had slipped a bit on the portability front with Q2 because
I had been developing natively on windows NT instead of cross
developing from NEXTSTEP, so I was reevaluating all of the system
interfaces for Q3.

I settled on combining all forms of input into a single system event
queue, similar to the windows message queue. My original intention
was to just rigorously define where certain functions were called and
cut down the number of required system entry points, but it turned
out to have much stronger benefits.

With all events coming through one point (The return values from
system calls, including the filesystem contents, are “hidden” inputs
that I make no attempt at capturing, ), it was easy to set up a
journalling system that recorded everything the game received. This
is very different than demo recording, which just simulates a network
level connection and lets time move at its own rate. Realtime
applications have a number of unique development difficulties
because of the interaction of time with inputs and outputs.

Transient flaw debugging. If a bug can be reproduced, it can be
fixed. The nasty bugs are the ones that only happen every once in a
while after playing randomly, like occasionally getting stuck on a
corner. Often when you break in and investigate it, you find that
something important happened the frame before the event, and you
have no way of backing up. Even worse are realtime smoothness
issues — was that jerk of his arm a bad animation frame, a network
interpolation error, or my imagination?

Accurate profiling. Using an intrusive profiler on Q2 doesn’t give
accurate results because of the realtime nature of the simulation. If
the program is running half as fast as normal due to the
instrumentation, it has to do twice as much server simulation as it
would if it wasn’t instrumented, which also goes slower, which
compounds the problem. Aggressive instrumentation can slow it
down to the point of being completely unplayable.

Realistic bounds checker runs. Bounds checker is a great tool, but
you just can’t interact with a game built for final checking, its just
waaaaay too slow. You can let a demo loop play back overnight, but
that doesn’t exercise any of the server or networking code.

The key point: Journaling of time along with other inputs turns a
realtime application into a batch process, with all the attendant
benefits for quality control and debugging. These problems, and
many more, just go away. With a full input trace, you can accurately
restart the session and play back to any point (conditional
breakpoint on a frame number), or let a session play back at an
arbitrarily degraded speed, but cover exactly the same code paths..

I’m sure lots of people realize that immediately, but it only truly sunk
in for me recently. In thinking back over the years, I can see myself
feeling around the problem, implementing partial journaling of
network packets, and included the “fixedtime” cvar to eliminate most
timing reproducibility issues, but I never hit on the proper global
solution. I had always associated journaling with turning an
interactive application into a batch application, but I never
considered the small modification necessary to make it applicable to
a realtime application.

In fact, I was probably blinded to the obvious because of one of my
very first successes: one of the important technical achievements
of Commander Keen 1 was that, unlike most games of the day, it
adapted its play rate based on the frame speed (remember all those
old games that got unplayable when you got a faster computer?). I
had just resigned myself to the non-deterministic timing of frames
that resulted from adaptive simulation rates, and that probably
influenced my perspective on it all the way until this project.

Its nice to see a problem clearly in its entirety for the first time, and
know exactly how to address it.

This effectively treats the second processor as a dedicated geometry
accelerator for the 3D card. This can only improve performance if the
card isn’t the bottleneck, but voodoo2 and TNT cards aren’t hitting their
limits at 640*480 on even very fast processors right now.

For single player games where there is a lot of cpu time spent running the
server, there could conceivably be up to an 80% speed improvement, but for
network games and timedemos a more realistic goal is a 40% or so speed
increase. I will be very satisfied if I can makes a dual pentium-pro 200
system perform like a pII-300.

I started on the specialized code in the renderer, but it struck me that
it might be possible to implement SMP acceleration with a generic OpenGL
driver, which would allow Quake2 / sin / halflife to take advantage of it
well before QuakeArena ships.

It took a day of hacking to get the basic framework set up: an smpgl.dll
that spawns another thread that loads the original oepngl32.dll or
3dfxgl.dll, and watches a work que for all the functions to call.

I get it basically working, then start doing some timings. Its 20%
slower than the single processor version.

I go in and optimize all the queing and working functions, tune the
communications facilities, check for SMP cache collisions, etc.

After a day of optimizing, I finally squeak out some performance gains on
my tests, but they aren’t very impressive: 3% to 15% on one test scene,
but still slower on the another one.

This was fairly depressing. I had always been able to get pretty much
linear speedups out of the multithreaded utilities I wrote, even up to
sixteen processors. The difference is that the utilities just split up
the work ahead of time, then don’t talk to each other until they are done,
while here the two threads work in a high bandwidth producer / consumer
relationship.

I finally got around to timing the actual communication overhead, and I was
appalled: it was taking 12 msec to fill the que, and 17 msec to read it out
on a single frame, even with nothing else going on. I’m surprised things
got faster at all with that much overhead.

The test scene I was using created about 1.5 megs of data to relay all the
function calls and vertex data for a frame. That data had to go to main
memory from one processor, then back out of main memory to the other.
Admitedly, it is a bitch of a scene, but that is where you want the
acceleration…

The write times could be made over twice as fast if I could turn on the
PII’s write combining feature on a range of memory, but the reads (which
were the gating factor) can’t really be helped much.

Streaming large amounts of data to and from main memory can be really grim.
The next write may force a cache writeback to make room for it, then the
read from memory to fill the cacheline (even if you are going to write over
the entire thing), then eventually the writeback from the cache to main
memory where you wanted it in the first place. You also tend to eat one
more read when your program wants to use the original data that got evicted
at the start.

What is really needed for this type of interface is a streaming read cache
protocol that performs similarly to the write combining: three dedicated
cachelines that let you read or write from a range without evicting other
things from the cache, and automatically prefetching the next cacheline as
you read.

Intel’s write combining modes work great, but they can’t be set directly
from user mode. All drivers that fill DMA buffers (like OpenGL ICDs…)
should definately be using them, though.

Prefetch instructions can help with the stalls, but they still don’t prevent
all the wasted cache evictions.

It might be possible to avoid main memory alltogether by arranging things
so that the sending processor ping-pongs between buffers that fit in L2,
but I’m not sure if a cache coherent read on PIIs just goes from one L2
to the other, or if it becomes a forced memory transaction (or worse, two
memory transactions). It would also limit the maximum amount of overlap
in some situations. You would also get cache invalidation bus traffic.

I could probably trim 30% of my data by going to a byte level encoding of
all the function calls, instead of the explicit function pointer / parameter
count / all-parms-are-32-bits that I have now, but half of the data is just
raw vertex data, which isn’t going to shrink unless I did evil things like
quantize floats to shorts.

Too much effort for what looks like a reletively minor speedup. I’m giving
up on this aproach, and going back to explicit threading in the renderer so
I can make most of the communicated data implicit.

Oh well. It was amusing work, and I learned a few things along the way.

The riva-128 was a troublesome part. It scored well on benchmarks, but it had
some pretty broken aspects to it, and I never reccomended it (you are better
off with an intel I740).

There aren’t any troublesome aspects to TNT. Its just great. Good work, Nvidia.

In terms of raw speed, a 16 bit color multitexture app (like quake / quake 2)
should still run a bit faster on a voodoo2, and an SLI voodoo2 should be faster
for all 16 bit color rendering, but TNT has a lot of other things going for it:

32 bit color and 24 bit z buffers. They cost speed, but it is usually a better
quality tradeoff to go one resolution lower but with twice the color depth.

More flexible multitexture combine modes. Voodoo can use its multitexture for
diffuse lightmaps, but not for the specular lightmaps we offer in QuakeArena.
If you want shiny surfaces, voodoo winds up leaving half of its texturing
power unused (you can still run with diffuse lightmaps for max speed).

Stencil buffers. There aren’t any apps that use it yet, but stencil allows
you to do a lot of neat tricks.

More texture memory. Even more than it seems (16 vs 8 or 12), because all of the
TNT’s memory can be used without restrictions. Texture swapping is the voodoo’s
biggest problem.

3D in desktop applications. There is enough memory that you don’t have to worry
about window and desktop size limits, even at 1280*1024 true color resolution.

Better OpenGL ICD. 3dfx will probably do something about that, though.

This is the shape of 3D boards to come. Professional graphics level
rendering quality with great performance at a consumer price.

We will be releasing preliminary QuakeArena benchmarks on all the new boards
in a few weeks. Quake 2 is still a very good benchmark for moderate polygon
counts, so our test scenes for QA involve very high polygon counts, which
stresses driver quality a lot more. There are a few surprises in the current
timings…

—

A few of us took a couple days off in vegas this weekend. After about
ten hours at the tables over friday and saturday, I got a tap on the shoulder…

Three men in dark suits introduced themselves and explained that I was welcome
to play any other game in the casino, but I am not allowed to play
blackjack anymore.

Ah well, I guess my blackjack days are over. I was actually down a bit for
the day when they booted me, but I made +$32k over five trips to vegas in the
past two years or so.

I knew I would get kicked out sooner or later, because I don’t play “safely”.
I sit at the same table for several hours, and I range my bets around 10 to 1.

On a normal 4:3 aspect ratio screen, a 90 degree horizontal field of view
gives a 75 degree vertical field of view. If you keep the vertical fov
constant and run on a wide screen, you get a 106 degree horizontal fov.

Because we specify fov with the horizontal measurement, you need to change
fov when going into or out of a wide screen mode. I am considering changing
fov to be the vertical measurement, but it would probably cause a lot of
confusion if “fov 90″ becomes a big fisheye.

Many video card drivers are supporting the ultra high res settings
like 1920 * 1080, but hopefully they will also add support for lower
settings that can be good for games, like 856 * 480.

I spent a day out at apple last week going over technical issues.

I’m feeling a lot better about MacOS X. Almost everything I like about
rhapsody will be there, plus some solid additions.

I presented the OpenGL case directly to Steve Jobs as strongly as possible.

If Apple embraces OpenGL, I will be strongly behind them. I like OpenGL more
than I dislike MacOS.

—

Last friday I got a phone call: “want to make some exhibition runs at the
import / domestic drag wars this sunday?”. It wasn’t particularly good
timing, because the TR had a slipping clutch and the F50 still hasn’t gotten
its computer mapping sorted out, but we got everything functional in time.

The tech inspector said that my cars weren’t allowed to run in the 11s
at the event because they didn’t have roll cages, so I was supposed to go
easy.

The TR wasn’t running its best, only doing low 130 mph runs. The F50 was
making its first sorting out passes at the event, but it was doing ok. My
last pass was an 11.8(oops) @ 128, but we still have a ways to go to get the
best times out of it.

I’m getting some racing tires on the F50 before I go back. It sucked watching
a tiny honda race car jump ahead of me off the line.

I think ESPN took some footage at the event.

Rear wheel numbers:
602 HP @ 8200 rpm
418 ft-lb @ 7200 rpm

This is very low boost, but I got the 50% power increase I was looking for,
and hopefully it won’t be making any contributions to my piston graveyard.

There will be an article in Turbo magazine about it, and several other car
magazines want to test it out. They usually start out with “He did WHAT
to an F50???”

Brian is getting a nitrous kit installed in his viper, and Cash just got his
suspension beefed up, so we will be off to the dragstrip again next month to
sort everything out again.

I was dissapointed with the original DR1 release. It was very slow and
seemed to have added the worst elements of the mac experience (who the hell
came up with that windowshade minimizing?) while taking away some of the
strengths of NEXTSTEP.

Things are a whole lot better in the latest release. General speed is up,
memory consumption is down, and the UI feels consistant and productive.

Its still not as fast as windows, and probably never will be, but I think the
tradeoffs are valid.

There are so many things that are just fundamentally better in the rhapsody
design than in windows: frameworks, the yellow box apis, fat binaries,
buffered windows, strong multi user support, strong system / local seperation,
netinfo, etc.

Right now, I think WindowsNT is the best place to do graphics development work,
but if the 3D acceleration issue was properly addressed on rhapsody, I think that
I could be happy using it as my primary development platform.

I ported the current Quake codebase to rhapsody to test out conix’s beta OpenGL.
The game isn’t really playable with the software emulated OpenGL, but it
functions properly, and it makes a fine dedicated server.

We are going to try to stay on top of the portability a little better for QA.
Quake 2 slid a bit because we did the development on NT instead of NEXTSTEP,
and that made the irix port a lot more of a hassle than the original glquake port.

I plan on using the rhapsody system as a dedicated server during development,
and Brian will be using an Alpha-NT system for a lot of testing, which should
give us pretty good coverage of the portability issues.

I’m supposed to go out and have a bunch of meetings at apple next month to cover
games, graphics, and hardware. Various parts of apple have scheduled
meetings with me on three seperate occasions over the past couple years, but they
have always been canceled for one reason or another (they laid off the people
I was going to meet with once…).

I have said some negative things about MacOs before, but my knowledge of
the mac is five years old. There was certainly the possibility that things
had improved since then, so I spent some time browsing mac documentation
recently. I was pretty amused. A stack sniffer. Patching trap vectors.
Cooperative multitasking. Application memory partitions. Heh.

I’m scared of MacOS X. As far as I can tell, The basic plan is to take rhapsody
and bolt all the MacOS APIs into the kernel. I understand that that may well
be a sensible biz direction, but I fear it.

In other operating system news, Be has glquake running hardware accelerated on
their upcoming OpenGL driver architecture. I gave them access to the glquake and
quake 2 codebases for development purposes, and I expect we will work out an
agreement for distribution of the ports.

Any X server vendors working on hardware accelerated OpenGL should get in touch
with Zoid about interfacing and tuning with the Id OpenGL games on linux.

The way this played out in public is a bit unfortunate. Everyone at Id is
busy full time with the new product, so we just weren’t paying enough attention
to the Quake 2 modifications. Some people managed to read into my last update
that we were blaming Zoid for things. Uh, no. I think he was acting within
his charter (catering to the community) very well, it just interfered with an
aspect of the game that shouldn’t have been modified. We just never made it
explicitly clear that it shouldn’t have been modified.

It is a bit amusing how after the QuakeArena anouncement, I got flamed by
lots of people for abandoning single player play (even though we aren’t, really)
but after I say that Quake 2 can’t forget that it is a single player game, I get
flamed by a different set of people who think it is stupid to care about single
player anymore when all “everyone” plays is multiplayer. The joy of having a
wide audience that knows your email address.

Zoid changed the movement code in a way that he felt improved gameplay in the
3.15 release.

We don’t directly supervise most of the work Zoid does. One of the main
reasons we work with him is that I respect his judgment, and I feel that his
work benefits the community quite a bit with almost no effort on my part. If
I had to code review every change he made, it wouldn’t be worth the effort.

Zoid has “ownership” of the Quake, Glquake, and QuakeWorld codebases. We don’t
intend to do any more modifications at Id on those sources, so he has pretty
free rein within his discretion.

We passed over the Quake 2 codebase to him for the addition of new features
like auto download, but it might have been a bit premature, because official
mission packs were still in development, and unlike glquake and quakeworld,
Q2 is a product that must remain official and supported, so the scope of his
freedoms should have been spelled out a little more clearly.

The air movement code wasn’t a good thing to change in Quake 2, because the
codebase still had to support all the commercial single player levels, and
subtle physics changes can have lots of unintended effects.

QuakeWorld didn’t support single player maps, so it was a fine place to
experiment with physics changes.

QuakeArena is starting with fresh new data, so it is also a good place to
experiment with physics changes.

Quake 2 cannot be allowed to evolve in a way that detracts from the commercial
single player levels.

The old style movement should not be refered to as “real world physics”. None
of the quake physics are remotely close to real world physics, so I don’t think
one way is significantly more “real” than the other. In Q2, you accelerate from
0 to 27 mph in 1/30 of a second, which just as unrealistic as being able to
accelerate in midair…

We changed our minds.

The new product is going to be called “Quake Arena”, and will consist
exclusively of deathmatch style gaming (including CTF and other derivatives).
The single player game will just be a progression through a ranking ladder
against bot AIs. We think that can still be made an enjoyable game, but
it is definately a gamble.

In the past, we have always been designing two games at once, the single
player game and the multi player game, and they often had conflicting goals.
For instance, the client-server communications channel discouraged massive
quantities of moving entities that would have been interesting in single
player, while the maps and weapons designed for single player were not ideal
for multiplayer. The largest conflict was just raw development time. Time
spent on monsters is time not spent on player movement. Time spent on unit
goals is time not spent on game rules.

There are many wonderful gaming experiences in single player FPS, but we are
choosing to leave them behind to give us a purity of focus that will let us
make significant advances in the multiplayer experience.

The emphasis will be on making every aspect as robust and high quality as
possible, rather than trying to add every conceivable option anyone could
want. We will not be trying to take the place of every mod ever produced, but
we hope to satisfy a large part of the network gaming audience with the out of
box experience.

There is a definite effect on graphics technology decisions. Much of the
positive feedback in a single player FPS is the presentation of rich visual
scenes, which are often at the expense of framerate. A multiplayer level
still needs to make a good first impression, but after you have seen it a
hundred times, the speed of the game is more important. This means that there
are many aggressive graphics technologies that I will not pursue because they
are not apropriate to the type of game we are creating.

The graphics engine will still be OpenGL only, with significant new features
not seen anywhere before, but it will also have fallback modes to render at
roughly Quake-2 quality and speed.

With sub 200 msec network connections of reasonable bandwidth, pure
interpolating is a reasonable solution that is very robust and elegant.

With modem based internet connections having 300+ msec pings and patchy
delivery quality, pure interpolation just doesn’t give a good enough game
play experience.

Quake 1 had all entities in the world strictly interpolated (with a 20 hz
default clock), but had several aspects of the game hard coded on the client,
like the view bobbing, damage flashes, and status bar.

QuakeWorld was my experimentation with adding a lot of specialized logic to
improve network play. An advantage I had was that the gameplay was all done,
so I didn’t mind adding quite hardcoded things to improve nailguns and
shotguns, among other things. The largest change was adding client side
movement prediction, which basically threw out the notion of the general
purpose client.

Quake 2 was intended to be more general and flexible than Q1/QW, with almost
everything completely configurable by the server. At the time of q2test, it
was (with a fixed 10 hz clock).

Before shipping, I wound up integrated client side movement prediction like
QW. Having gone that far, I really should have moved the simulation of a lot
of the other view presentation logic (head bobs / kicks, etc) back to the
client. Because these are still run on the server, a lagged connection will
give you odd effects like falling off a cliff, running away, then having the
head kick and the landing crunch happen when you are 50 feet away from the
point of impact.

So basically I wound up losing the elegance, but I didn’t reap all the
benefits I could have.

I am still holding to my stronger networking belief, though — centralized,
authoritative servers, as opposed to peer to peer interaction. I REALLY
think distributed simulation among clients is a VERY BAD idea for networked
games. Yes, there are some theoretical advantages to being able to hand off
the simulation of some objects, but I have plenty of reasons to not want to
do it. Client side movement prediction is simulation, but it has no bearing
on the server, it is strictly to give a better presentation of the data the
server has provided.

The new paradigm is that the server controls all information necessary for
the rules of the game to function, but the client controls all presentation
of that information to the user through models, audio, and motion.

There were moves in that direction visible in Quake 2 — the temp entities
and entity events that combined sounds and model animations run entirely on
the client side. Everything will soon be like this.

This saves some degree of network bandwidth, because instead of specifying
the model, skin, frame, etc, we can just say what type of entity it is, and
the client can often determine everything else by itself. This also enables
more aggressive multi-part entities that would have been unreasonable to do
if they each had to be sent seperately over the network connection.

Almost all cycling animations can be smoother. If the client knows that the
character is going through his death animation for instance, it can advance
the frames itself, rather than having the server tell it when every single
frame changes.

Motion of projectiles can be predicted accurately on the client side.

All aspects of your own characters movement and presentation should be
completely smooth until acted upon (shot) by an outside entity.

All the clever coding in the world can’t teleport bits from other computers,
so lag doesn’t go away, but most of the other hitchy effects of network play
can be resolved. Lag reduction is really a seperate topic. QuakeWorld had
instant response packets, because it was designed for a dedicated server
only, which helped quite a bit.

During the projects development, the client side code will be in a C DLL, but
I intend to Do The Right Thing and make it java based before shipping. I
absolutely refuse to download binary code to a client.

Mouse sampling on win95 only happens every 25ms. It doesn’t matter if you
check the cursor or use DirectInput, the values will only change 40 times
a second.

This means that with normal checking, the mouse control will feel slightly
stuttery whenever the framerate is over 20 fps, because on some frames you
will be getting one input sample, and on other frames you will be getting
two. The difference between two samples and three isn’t very noticable, so
it isn’t much of an issue below 20 fps. Above 40 fps it is a HUGE issue,
because the frames will be bobbing between one sample and zero samples.

I knew there were some sampling quantization issues early on, so I added
the “m_filter 1″ variable, but it really wasn’t an optimal solution. It
averaged together the samples collected at the last two frames, which
worked out ok if the framerate stayed consistantly high and you were only
averaging together one to three samples, but when the framerate dropped to
10 fps or so, you wound up averaging together a dozen more samples than
were really needed, giving the “rubber stick” feel to the mouse control.

I now have three modes of mouse control:

in_mouse 1:
Mouse control with standard win-32 cursor calls, just like Quake 2.

in_mouse 2:
Mouse control using DirectInput to sample the mouse reletive counters
each frame. This behaves like winquake with -dinput. There isn’t a lot
of difference between this and 1, but you get a little more precision, and
you never run into window clamping issues. If at some point in the future
microsoft changes the implementation of DirectInput so that it processes
all pending mouse events exactly when the getState call happens, this will
be the ideal input mode.

in_mouse 3:
Processes DirectInput mouse movement events, and filters the amount of
movement over the next 25 milliseconds. This effectively adds about 12 ms
of latency to the mouse control, but the movement is smooth and consistant
at any variable frame rate. This will be the default for Quake 3, but some
people may want the 12ms faster (but rougher) response time of mode 2.

It takes a pretty intense player to even notice the difference in most
cases, but if you have a setup that can run a very consistant 30 fps you
will probably apreciate the smoothness. At 60 fps, anyone can tell the
difference, but rendering speeds will tend to cause a fair amount of
jitter at those rates no matter what the mouse is doing.

DirectInput on WindowsNT does not log mouse events as they happen, but
seems to just do a poll when called, so they can’t be filtered properly.

Keyboard sampling appears to be millisecond precise on both OS, though.

In doing this testing, it has become a little bit more tempting to try to
put in more leveling optimizations to allow 60 hz framerates on the highest
end hardware, but I have always shied away from targeting very high
framerates as a goal, because when you miss by a tiny little bit, the drop
from 60 to 30 ( 1 to 2 vertical retraces ) fps is extremely noticable.

–

I have also concluded that the networking architecture for Quake 2 was
just not the right thing. The interpolating 10 hz server made a lot of
animation easier, which fit with the single player focus, but it just
wasn’t a good thing for internet play.

Quake 3 will have an all new entity communication mechanism that should
be solidly better than any previous system. I have some new ideas that go
well beyond the previous work that I did on QuakeWorld.

Its tempting to try to roll the new changes back into Quake 2, but a lot
of them are pretty fundamental, and I’m sure we would bust a lot of
important single player stuff while gutting the network code.

(Yes, we made some direction changes in Quake 3 since the original
announcement when it was to be based on the Quake 2 game and networking
with just a new graphics engine)

11.6 @ 125 Bob Norwood’s ferrari P4 race car (2200 lbs)
11.9 @ 139 John Carmack’s twin turbo testarossa (3815 lbs)
11.9 @ 117 Paul Steed’s YZF600R bike
12.1 @ 122 John Carmack’s F50 (3205 lbs)
12.3 @ 117 Brian’s Viper GTS (3560 lbs)
13.7 @ 103 John Cash’s supercharged M3
14.8 @ ??? Someone’s lexus GS400
15.0 @ ??? Someone’s volkswagon GTI
15.1 @ ??? Christian’s boxter (with Tim driving)

Weight is the key for good ETs. The TR has considerably better power
to weight ratio than the P4, but it can’t effectively use most of the power
until it gets into third gear. The viper is actually making more power than
the F50, (Brian got a big kick out of that after his dyno run) but 350 lbs
more than compensated for it.

I wanted to hit 140 in the TR, but the clutch started slipping on the last
run and I called it a day.

I was actually surprised the F50 ran 122 mph, which is the same the F40 did
on a 25 degree cooler day. I was running with the top off, so it might
even be capable of going a bit faster with it on.

The F50 and the viper were both very consistant performers, but the TR and
the supercharged M3 were all over the place with their runs.

Brian nocked over a tenth off of his times even in spite of the heat, due to
launch practice and some inlet modifications. He also power shifted on
his best run.

It was pretty funny watching the little volkswagon consistantly beat up on
a tire shredding trans-am.

George Broussard had his newly hopped up 911 turbo, but it broke the trans
on its very first run. We were expecting him to be in the 11’s.

We probably won’t run again until either I get the F50 souped up, or my
GTO gets finished.

11.6 @ 125 Bob Norwood’s ferrari P4 race car (2200 lbs)
11.9 @ 139 John Carmack’s twin turbo testarossa (3815 lbs)
11.9 @ 117 Paul Steed’s YZF600R bike
12.1 @ 122 John Carmack’s F50 (3205 lbs)
12.3 @ 117 Brian’s Viper GTS (3560 lbs)
13.7 @ 103 John Cash’s supercharged M3
14.0 @ 96 Scott Miller’s lexus GS400
15.0 @ ??? Someone’s volkswagon GTI
15.1 @ ??? Christian’s boxter (with Tim driving)

Weight is the key for good ETs. The TR has considerably better power
to weight ratio than the P4, but it can’t effectively use most of the power
until it gets into third gear. The viper is actually making more power than
the F50, (Brian got a big kick out of that after his dyno run) but 350 lbs
more than compensated for it.

I wanted to hit 140 in the TR, but the clutch started slipping on the last
run and I called it a day.

I was actually surprised the F50 ran 122 mph, which is the same the F40 did
on a 25 degree cooler day. I was running with the top off, so it might
even be capable of going a bit faster with it on.

The F50 and the viper were both very consistant performers, but the TR and
the supercharged M3 were all over the place with their runs.

Brian nocked over a tenth off of his times even in spite of the heat, due to
launch practice and some inlet modifications. He also power shifted on
his best run.

It was pretty funny watching the little volkswagon consistantly beat up on
a tire shredding trans-am.

George Broussard had his newly hopped up 911 turbo, but it broke the trans
on its very first run. We were expecting him to be in the 11’s.

We probably won’t run again until either I get the F50 souped up, or my
GTO gets finished.

There are three places where text input is handled in the game: the console,
the chat line, and the menu fields. They all used completely different code
to manage the input line and display the output. Some allowed pasting from
the system clipboard, some allowed scrolling, some accepted unix control
character commands, etc. A big mess.

Quake 3 will finally have full support for international keyboards and
character sets. This turned out to be a bit more trouble than expected
because of the way Quake treated keys and characters, and it led to a
rewrite of a lot of the keyboard handling, including the full cleanup and
improvement of text fields.

A similar cleanup of the text printing hapened when Cash implemented general
colored text: we had at least a half dozen different little loops to print
strings with slightly different attributes, but now we have a generalized one
that handles embedded color commands or force-to-color printing.

Amidst all the high end graphics work, sometimes it is nice to just fix up
something elementary.

I spent a little while doing some basic research with lummigraphs, which
are sort of a digital hologram. The space requirements are IMMENSE, on
the order of several gigs uncompressed for even a single full sized room.
I was considering the possibility of using very small lumigraph fragments
(I called them “lumigraphlets”) as imposters for large clusters of areas,
similar to aproximating an area with a texture map, but it would effectively
be a view dependent texture.

The results were interesting, but transitioning seamlessly would be difficult,
the memory was still large, and it has all the same caching issues that any
impostor scheme has.

Another aproach I worked on was basically extending the sky box code style of
rendering from quake 2 into a complete rendering system. Take a large number
of environment map snapshots, and render a view by interpolating between up
to four maps (if in a tetrahedral arangement) based on the view position.

A simple image based interpolating doesn’t convey a sense of motion, because
it basically just ghosts between seperate points unless the maps are VERY
close together reletive to the nearest point visible in the images.

If the images that make up the environment map cube also contain depth values
at some (generally lower) resolution, instead of rendering the environment
map as six big flat squares at infinity, you can render it as a lot of little
triangles at the proper world coordinates for the individual texture points.
A single environment map like this can be walked around in and gives a sense
of motion. If you have multiple maps from nearby locations, they can be
easily blended together. Some effort should be made to nudge the mesh
samples so that as many points are common between the maps as possible, but
even a regular grid works ok.

You get texture smearing when occluded detail should be revealed, and if you
move too far from the original camera point the textures blur out a lot, but
it is still a very good effect, is completely complexity insensitive, and is
aliasing free except when the view position causes a silhouette crease in
the depth data.

Even with low res environment maps like in Quake2, each snapshot would consume
700k, so taking several hundred environment images throughout a level would
generate too much data. Obviously there is a great deal of redundancy — you
will have several environment maps that contain the same wall image, for
instance. I had an interesting idea for compressing it all. If you ignore
specular lighting and atmospheric effects, any surface that is visible in
multiple environment maps can be represented by a single copy of it and
perspective transformation of that image. Single image, transformations,
sounds like… fractal compression. Normal fractal compression only deals
with affine maps, but the extension to projective maps seems logical.

I think that a certain type of game could be done with a technology like that,
but in the end, I didn’t think it was the right direction for a first person
shooter.

There is a tie in between lummigraphs, multiple environment maps, specularity,
convolution, and dynamic indirect lighting. Its nagging at me, but it hasn’t
come completely clear.

Other topics for when I get the time to write more:

Micro environment map based model lighting. Convolutions of environment maps
by phong exponent, exponent of one with normal vector is diffuse lighting.

Full surface texture representation. Interior antaliasing with edge
matched texels.

Octree represented surface voxels. Drawing and tracing.

Bump mapping, and why most of the aproaches being suggested for hardware
are bogus.

Parametric patches vs implicit functions vs subdivision surfaces.

Why all analytical boundary representations basically suck.

Finite element radiosity vs photon tracing.

etc.

The many forced releases of Quake 2 due to hacker attacks has certainly
taught me to be a lot more wary.

It was a convenient feature for us, but it turned out to be irresponsible.
Sorry.

There will be new releases of QuakeWorld and Quake 2 soon.

The front and rear views are definately cooler on the F50, but I think I
like the F40 side view better. I haven’t taken the top off the F50 yet,
though (its supposed to be a 40 minute job…).

Adjustable front suspension. Press a button and it raises two inches,
which means you can actually drive it up into strip malls. The F40 had
to be driven into my garage at an angle to keep the front from rubbing.
This makes the car actually fairly practical for daily driving.

Drastically better off idle torque. You have to rev the F40 a fair amount
to even get it moving, and if you are moving at 2000 rpm in first gear,
a honda can pull away from you until it starts making boost at 3500 rpm.
The f50 has enough torque that you don’t even need to rev to get moving,
and it goes quite well by just flooring it after you are moving. No need
to wreck a clutch by slipping it out from 4000 rpm.

Much nicer clutch. The F40 clutch was a very low-tech single disk clutch
that required more effort than on my crazy TR with over twice the torque.

Better rearward visibility. The F40’s lexan fastback made everything to
your rear a blur.

Better shifting. A much smoother six speed than the F40’s five speed.

Better suspension. Some bumps that would upset the F40 badly are handled
without any problems.

Better aerodynamics. A flat underbody with tunnels is a good thing if you
are going to be moving at very high speeds.

I beleive the F50 could probably lap a road coarse faster than the F40, but
in a straight line, the F40 is faster. The F50 felt a fair amount slower,
but I was chalking that up to the lack of non-linear turbo rush. Today I
drove it down to the dyno and we got real numbers.

It only made 385 hp at the rear wheels, which is maybe 450 at the crank if
you are being generous. The F40 made 415, but that was with the boost
cranked up a bit over stock.

We’re going to have to do something about that.

I’m thinking that a mild twin-turbo job will do the trick. Six pounds of
boost should get it up to a health 500 hp at the rear wheels, which will
keep me happy. I don’t want to turn it into a science project like my
TR, I just want to make sure it is well out of the range of any normal
cars.

I may put that in line after my GTO gets finished.

We will be going back to the dragstrip in a couple weeks, and I will be
exercising both the F50 and the TR there. Cash’s supercharged M3 will
probably show some of the porsches a thing or two, as well.

I’ll probably rent a road coarse sometime soon, but I’m not in too much of
a hurry to run the F50 into the weeds.

My TR finally got put back together after a terrific nitrous explosion
just before the last dragstrip. It now makes 1000.0 hp at the rear wheels.
Contrast that with the 415 rear wheel hp that the F40 made. Of cource, a
loaded testarossa does weigh about 4000 lbs…

My project car is somewhat nearing completion. My mechanic says it will
be running in six weeks, but mechanics can be even more optimistic than
software developers. I’m betting on fall. It should really be something
when completed: a carbon fiber bodied ferrari GTO with a custom, one-of-a
kind billet alluminum 4 valve DOHC 5.2L V12 with twin turbos running
around 30 lbs of boost. It should be good for quite a bit more hp than my
TR, and the entire car will only weigh 2400 lbs.

———

The distance between a cool demo and production code is vast. Two months
ago, I had some functional demos of several pieces of the Quake 3 rendering
tech, but today it still isn’t usable as a full replacement for ref_gl yet.

Writing a modern game engine is a lot of work.

The new architecture is turning out very elegent. Not having to support
software rendering or color index images is helping a lot, but it is also
nice to reflect on just how much I have learned in the couple years since
the original Quake renderer was written.

My C coding style has changed for Quake 3, which is going to give me a nice
way of telling at a glance which code I have or haven’t touched since
Quake 2. In fact, there have been enough evolutions in my style that you
can usually tell what year I wrote a piece of code by just looking at
a single function:

/*
=============
=
= Function headers like this are DOOM or earlier
=
=============
*/

/*
=============
Function Headers like this are Quake or later
=============
*/

{
// comments not indented were written on NEXTSTEP
// (quake 1)

// indented comments were written on
// Visual C++ (glquake / quakeworld, quake2)
}

for (testnum=0 ; testnum<4 ; testnum++)
{ // older coding style
}

for (testNumber = 0 ; testNumber < 4 ; testNumber++) {
// quake 3 coding style
}

Not being limited to supporting a 320*240 256 color screen is
very, very nice, and will make everyone’s lives a lot easier.

All of our new source artwork is being done in 24 bit TGA files,
but the engine will continue to load .wal files and .pcx files
for developer’s convenience. Each pcx can have its own palette
now though, because it is just converted to 24 bit at load time.

Q3 is going to have a fixed virtual screen coordinate system,
independant of resolution. I tried that back in the original
glquake, but the fixed coordinate system was only 320*200, which
was excessively low. Q2 went with a dynamic layout at different
resolutions, which was a pain, and won’t scale to the high resolutions
that very fast cards will be capable of running at next year.

All screen drawing is now done assuming the screen is 640*480, and
everything is just scaled as you go higher or lower. This makes
laying out status bars and HUDs a ton easier, and will let us
do a lot cooler looking screens.

There will be an interface to let game dlls draw whatever they want
on the screen, precisely where they want it. You can suck up a lot
of network bandwidth doing that though, so some care will be needed.

–

Going to the completely opposite end of the hardware spectrum from
quake 3…

I have been very pleased with the fallout from the release of the
DOOM source code.

At any given spot in design space, there are different paths you
can take to move forward. I have usually chosen to try to make a
large step to a completely new area, but the temptation is there
to just clean up and improve in the same area, continuously
polishing the same program.

I am enjoying seeing several groups pouring over DOOM, fixing it
up and enhancing it. Cleaning up long standing bugs. Removing
internal limitations. Orthogonalizing feature sets. Etc.

The two that I have been following closest are Team TNT’s BOOM
engine project, which is a clear headed, well engineered
improvement on the basic DOOM technical decisions, and Bruce Lewis’
glDoom project.

Any quakers feeling nostalgic should browse around:

http://www.doomworld.com/

Nobody broke down, and some good times were posted.

11.9 @ 122 John Carmack F40
12.2 @ 122 George Broussard custom turbo 911
12.4 @ 116 Brian Hook Viper GTS
13.4 @ 106 John Romero custom turbo testarossa
13.6 @ 106 Todd Hollenshead ‘vette
13.9 @ 100 Paul Steed 911
14.0 @ 99 Tim Willits 911
14.3 @ 101 Bear Turbo Supra
14.4 @ 98 Alan Blum turbo rx-7
14.7 @ 92 Brandon James M3
15.3 @ 92 Christian Boxster
15.5 @ 93 Jen (Hook’s Chick) Turbo Volvo
16.1 @ 89 Ms. Donna Mustang GT
17.4 @ 82 Anna (Carmack’s Chick) Honda Accord
18.1 @ 75 Jennifer (Jim Molinets’ Chick) Saturn

We had three significant no-shows for various reasons: my TR,
Adrian’s viper, and Cash’s supercharged M3 were all in the shop.

–

There is a public discussion / compilation going on at openquake for
suggestions to improve technical aspects of quake 3:

http://www.openquake.org/q3suggest/

This is sooo much better than just dropping me an email when a thought
hits you. There are many, many thousands of you out there, and there
needs to be some filtering process so we can get the information
efficiently.

We will read and evaluate everything that makes it through the
discussion process. There are two possible reasons why features
don’t make it into our games — either we decide that the effort is
better spent elsewhere, or we just don’t think about it. Sometimes the
great ideas are completely obvious when suggested, but were just missed.
That is what I most hope to see.

When the suggestions involve engineering tradeoffs and we have to
consider the implementation effort of a feature vs its benefits, the
best way to convince us to pursue it is to specify EXACTLY what benefits
would be gained by undertaking the work, and specifying a clean interface
to the feature from the file system data and the gamex86 code.

We hack where necessary, but I am much more willing to spend my time on
an elegant extension that has multiple uses, rather than adding api bulk
for specific features. Point out things that are clunky and inelegant
in the current implementation. Even if it doesn’t make any user visible
difference, restructuring api for cleanliness is still a worthwhile goal.

We have our own ideas about game play features, so we may just disagree
with you. Even if you-and-all-your-friends are SURE that your
suggestions will make the game a ton better, we may not think it
fits with our overall direction. We aren’t going to be all things to
all people, and we don’t design by committee.