Slashdot Mirror
Quake III Gets Real Time Ray-Tracing Treatment
Ozh writes "Did you ever wonder what you could do with a cluster of 20 AMD XP 1800s? Some German students and videogame fans did, and their answer has been what they call 'ray-tracing egoshooters', an entirely raytraced game engine which 'runs about 20 fps@36 GHz in 512x512 with 4xFSAA'. The first game to get this treatment is Quake 3 Arena : the screenshots look slightly better than the original 3D engine but the video (56 Mb, 3'19) is quite dramatic."
That's pretty nice. Unfortunately most of the effect can be simulated using tricks and still run on a regular computer. Especially with all the stuff you can do on the GPU now.
They need to soften the shadows also. Either by using tricks or radiosity. Right now it looks kinda meh...
Interesting effort though.
Well, its known to be slower in implementation. It also forces lighting on the rendering. After all, we're tracing rays of light, here. But in theory, raytracing is where the future resides. I'm told, though I don't fully understand the logic behind it, that raytracing should scale to higher poly scenes than rasterizing. The big problem it seems is that its difficult to find hacks to speed up rendering. Most speed enhancements are data restructuring, like subregion partitioning. The idea being that if a ray doesn't intersect a region, it can't intersect anything in the subregion and you don't need to test it.
The real benefit is free occulsion culling, shadows, lighting, reflections, and essentially a physical simulation of how things actually work in life. There's been a few boards prototyped to do ray-tracing. Just google for Real-Time Raytracing. The paper behind it suggests that a hardware raytracer scales nearly linearly with the amount of tracer units behind it. These days its difficult to take a hardware prototype and beat the market standard with a wholly different paradigm, especially when the benchmark is OpenGL based. OpenGL only provides for 4 light sources, and little point. The prototype that exists is incredibly large and not well suited to current small desktop cases. But given the right set of talent, this is an interesting concept that could prove to take over poly pushers eventually.
I Browse at +4 Flamebait
Open Source Sysadmin
Dammit, don't give Carmack any ideas! I'll barely be able to run Doom 3!
Someone put a lot of computers together to make a powerful distributed system that is capable of rendering Quake using ray-tracing.
Here is an example of a (not real time) raytraced image (one that doesn't use radiosity -- just straight raytracing). In theory, given enough CPU power, they could pull this off.
Ray-tracing uses a method of 3d rendering that is currently beyond dedicated 3d hardware and must be done in software.
The main benefits of ray-tracing from a quality perspective are:
* True, accurate shadows from *everything* (most games, even stuff like Neverwinter Nights have hackish shadow engines that don't realistically display what lighting would look like in real life. These are calculated in real-time, not the precalculated shadows that you'll see in, say, Quake, where the light sources never move. You could throw a flickering lantern across a bar with bottles falling down and have all the bottles cast their own shadows.
* Advanced lighting. Currently, real-time 3d engines are very limited in the types of light they can produce -- generally, only spherical point sources of light.
* Refraction. You can have glass, ooze, or water truly refract light and distort images, not just use some sorta-lame effect to vaguely approximate it. Think of looking through a glass lens or a window in an old house.
* Volumetric fog (where you have "clumps" or "clouds" of fog, rather than just a global constant flag fog covering everything). Quake 3 had some rather (IMHO) impressive hacks to emulate volumetric fog -- ray tracing allows *true* volumetric fog -- people vanishing in swirling clouds of fog and mist and the like, not just a straight visibility dropoff.
* Reflections (there are a lot of hacks to approximate this off with existing 3d engines), but raytracers are *made* for this sort of thing.
* True curved and arbitrarily-shaped surfaces.
* Light projections (with shadowing and all that). They show a bit of this in the demo -- you could have, say, two people having a swordfight in a theater and the picture washing over them, or a scene in a church, with dusty light from the stained glass windows washing over the characters.
Basic ray-tracing does have some flaws. The shadows are sharp and hard -- sharper and harder than in real life. There are hacks to do soft shadows, but there isn't a particularly good an efficient way to pull them off.
It's hard to deal with things like laser beams or light beams coming out of a prism in ray-tracing. You need to do forward raytracing/photon mapping for this, which I suspect that they aren't doing.
Ray tracers tend to look a bit "eerie", for lack of a better word. They tend to leave shadowed areas very dark -- in real life, light will bounce around in corners and things a bit (even surfaces that don't look "reflective" to us will do so). So if I shine a flashlight, a raytracer will show a perfectly accurate cone of light (unlike existing 3d engines) that will spill properly over all surfaces. However, that cone of light will be a *cone* -- normally, when I shine a flashlight in a room, it lights up the entire side to some degree because of light bouncing off of objects.
There are some really nice things about ray tracers. They tend to parallelize really well, so you can theoretically put lots of computers together to do renders (as these folks did), or have lots of chips in parallel to theoretically make a custom piece of hardware.
May we never see th
People have been giving good pros and cons to ray tracing, but I haven't seen a comment explain what it is. Now it's been awhile since my graphics course (so this may be terribly wrong), but from what I remember raytracing works something like this:
1. Imagine a ray shooting out of your eye through each pixel on your screen. So ray shoots into the 3D world and it might hit an object. The purpose of the ray is to collect light information.
2. If it hits an object, it will bounce off at a certain angle (depending on the object). After it bounces around a couple times, it might eventually hit a light source or you might set a limit to how many times it can bounce. Each time it bounces off an object, it might lose some intensity depending on the surface of the object.
3. After all the bouncing, it collects light information (depending on what it hits, the surface, the lighting) and now that pixel now has more accurate light info for rendering.
What this allows is much more realistic mirrors, reflections, lightings, shadows, etc. but as you can imagine, bouncing off all those rays takes lots and lots of computation. Radiosity was mentioned, and that's basically shooting millions of rays FROM the light sources first (instead of from the users eye to each pixel). But again, lots of calculations.
If you're wondering how current games look so good without raytracing, it's due to lots of clever hacks and simulations for lighting/shading. Raytracing is kind of a brute-force/realistic method. Hope that helps someone...