Oh Hi

First step in my attempt to study Quake 3′s source code: getting the thing to compile and run.

Quake 3′s source code respository is available on github. But to run the game, you still need to buy it, because the repository contains only the code and not the game data files. I bought my copy of Quake 3 from Steam.

I'm compiling the code on Windows 10 using Visual Studio 2017 Community Edition.

After you have Visual Studio installed and downloaded the Quake 3 repository, open quake3.sln from the repository. The first time you open quake3.sln, Visual Studio will probably ask you if you want to upgrade the solution to your version of Visual Studio. Click yes.

Once you have the solution open, compile the projects. Normally, you should be able to compile all the projects in a solution at once by simplying clicking "Build Solution" in the Build menu. That doesn’t work here for some reason. You have to compile each project individually by right clicking on them in the Solution Explorer and selecting "Build". The order does not matter as long as the project "quake3" is compiled last.

During compilation, you might run into a problem with the "ui" project's output file name. Right click on the "ui" project and select "Properties". In the Properties menu, select the "General" tab. In that tab, there is a field called "Target Name" with the value "$(ProjectName)". Change the value to "$(ProjectName)x86_new" and click OK.

To run the game, first you have to download the copy of Quake 3 you bought. Open the game's folder and copy its path. For example, a Steam copy would have a path like “C:\Program Files (x86)\Steam\steamapps\common\Quake 3 Arena".

Back in Visual Studio, right click on the "quake3" project and select "Set as StartUp Project". Right click on "quake3" again and select "Properties". Go to the "Debugging" tab, and paste the path you copied earlier into the "Working Directory" field. Then in the "Command Arguments" field, paste in this line:

+set sv_pure 0 +set vm_game 0 +set vm_cgame 0 +set vm_ui 0

I found that line on the gamedev stackexchange when the game was crashing on startup because of something related to UI and VM.

Now, press F5, and the game should start running.

Implemented rough metal materials with the proper fresnel function for conductors. For this render, I used silver on the model.

A few weeks ago I stumbled across Daz Studio and played with it briefly. I made this render with the starter assets.

As it was rendering I noticed that direct illumination and indirect illumination were calculated separately, because direct illumination converged much faster. My own ray tracer couldn’t do that, as the only light source in this scene is the sword, which is a polygon mesh, and my ray tracer didn’t support mesh light for direct illumination.

typedef struct MeshLight_s { float intensity; vec3 color; int num_triangles; float* cdf; void** triangles; ObjType type;  }MeshLight;

To do direct illumination with mesh light, I essentially have to generate uniform random points on the surface of the mesh, and do intersection test with these mesh points and the point that’s actually being shaded.

First I have to randomly select a triangle on the mesh for sampling. Since the triangles could have different sizes, and I want uniform random points on the mesh, the probability of picking a particular triangle should be proportional to its area.

The cdf member of the MeshLight struct stands for cumulative distribution function, and it is an array of floats. Each element of cdf uniquely corresponds to one of the mesh triangles. It stores for each triangle the sum of that triangle’s area plus the area of all the triangles that came before it. For example, the value at cdf[2] is the area of triangles[0], triangles[1], and triangles[2] added together. The area of a triangle can be computed by taking the cross product of two of its edges and divide it by 2. The elements of cdf are then normalized by dividing them by the surface area of the mesh.

To randomly pick a triangle, I generate a random number r in the interval [0, 1), find the index i for which cdf[i] >= r, and cdf[i-1] < r, then use that index to retrieve the triangle from the triangles array.

Once I have the triangle, I can generate uniform samples within it using this formula:

P = (1 - sqrt(r1))*A + (sqrt(r1)*(1 - r2))*B + (r2*sqrt(r1))*C

where A, B, and C are the vertices of the triangle, and r1 and r2 are random numbers from the interval [0, 1]. (source:https://math.stackexchange.com/questions/18686/uniform-random-point-in-triangle)

Some test renders:

Just added Russian roulette for secondary rays in my ray tracer. I really should have done it long ago, because it's such a simple thing. When I first tried it, the book I was referencing seemed to imply that with Russian roulette, you don’t need to limit the number of bounces, so I was getting stack overflow errors from too many bounces.

Anyway, this is without Russian roulette at 6 bounces and 400 samples.

This is with Russian roulette at 10 max bounces and 400 samples.