In 2001, when studying my last year Master of Computer Science at the University of Antwerp (Belgium), I followed the course "Computer Graphics 2". We were required to do several tasks; most of them weren't really necessary, but as I am a CG freak, I did them anyway, and quickly aspired to discover all-there-is-to-know about OpenGL and its rendering techniques.

For the course, we used the book "Computer Graphics Using OpenGL", written by Francis S. Hill, Jr. The two images below show the front covers of the second and third edition, respectively left and right. This latter, third, edition features an assortiment of blue spheres on its cover; this is actually one of my creations, for which I received credit. Besides that, the book also contains numerous other colour illustrations, which are also featured in the ray tracing gallery.

Second edition Prentice Hall Amazon		Third edition Prentice Hall Amazon

Below, you can find all my C++ code that encompasses a ray tracer based on an earlier version from the course book.

• A Quick Overview
• Ray Tracing Engine Features
• Scene Description Language
• Galleries
• C++ Code and Documentation

I learned to tame OpenGL, using anti-aliasing, Gouraud shading, depth buffering, texture mapping, animation, and various ways of rendering. You have to practice if you want to learn, so following this advice, I wrote some small demonstration programs. All these programs were based on the same rendering engine which in turn was based on GLUT (i.e., the OpenGL Utility Toolkit). The result was a flexible C++ class called TOpenGLApp that included complete lighting and rendering control, routines for automatically drawing primitives, and a complete 'flight simulator' interface which lets you fly around a custom-built 3D scene. Derived from this class are the following demo programs:

• Cube: a rotating cube is shown with flat 2D textures painted on its sides. For the textures I used Escher's fishes, which could be replaced by photographs of the (then existing) research group 'TICO' at the University of Antwerp.

• Landscape: whilst listening to a boring lecture on macro-economics, I worked out some form of landscape generation, together with a friend of mine. At the end of the lecture, the challenge was set and I worked hard to get a reliable interface for quickly generating landscapes. These landscapes are based on terrain maps which can be loaded from bitmap files or, if you wish, they can be generated on the fly by using fractal subdivisions. The famous Mandelbrot set really came to life with this demo; and those beautiful landscapes, based on plasma clouds, are now only a key press away. Furthermore, I introduced some sea animation using the equations for running and standing physical waves.

• Swarm: this demo was based on my simulation of a 2D particle swarm. I took the simulation into the 3D realm which resulted in a scene in which cones are flying around you, clustering together and breaking off as they sometimes do. With minor adaptations, the demo was enhanced so you could fly in fog and see teapots circling around you (and yes, even the dreaded Borg cubes are among us).

• SDLViewer/RayTracer: this is the final demonstration program I wrote. A ray tracer is basically a simple program that casts rays from your eye into a 3D scene and determines the intersections of these rays with all the objects in the scene. Based on this information, highly realistic renderings can be made of real-life surroundings. The only price we have to pay is a (serious) decrease in rendering speed. The program was based on the code used in the book's second edition, but with serious improvements. Foremost of all: Hill didn't do a good job at OOP in C++, so I took the liberty of rewriting all his code in a standard style (Taligent convention) that clearly reflects the logical constructions I created. The ray tracer is based on an SDL description of a 3D scene (Scene Description Language). I extended the language and gave it some powerful keywords. Time after time I improved the ray tracer and added more and more effects.

My ray tracing rendering engine (conveniently called SvenGL) is quite powerful, here's a list of the features it supports and the effects it can handle:

• reflection (including gloss which is blurred reflection) and refraction/transparency (including translucency which is blurred refraction), supporting interpenetrating transparent objects using a priority list. Both gloss and translucency are implemented using "non-weighted jittered discrete cone tracing" which can render more realistic reflections and refractions,
• anti-aliasing using regular supersamples or jittered stochastic supersampling (both techniques use either a 5x5 or 9x9 grid),
• Phong shading model for the lighting equations,
• point lights and completely configurable spot lights,
• hard and soft shadows using modified shadow feelers that take in account the transparency/opacity of objects,
• multiple light sources with the capability of post-normalisation of the colors in a rendered scene,
• light source attenuation with the distance,
• linear atmospheric attenuation with the distance,
• linear fog,
• support for rendering SDL scenes (which can include other SDL scenes),
• advanced objects such as the family of 3D algebraic surfaces quadrics (e.g., hyperbolic paraboloid), cubics, and quartics (e.g., Steiner's Roman surface),
• various meshes (which can be Phong shaded) with support for 3VN, 3DV, 3DM files, and Wavefront's Object Files (OBJ),
• easy to use generic world extents and world extent intersection testing for speeding up complex intersection tests,
• CSG objects (Constructive Solid Geometry) for rapidly creating complex shapes,
• solid 3D textures (including cubes, 1D-, 2D-, and 3D-contour lines, wood grain, marble, and cow spots),
• procedural 2D textures (including a checker board),
• bilinearly interpolated image 2D textures (for rendering those really realistic scenes),
• motion blurring of shapes (based on translations, scalings, and rotations),
• post-visualisation of the reflected/refracted rays and the normals on the surfaces,
• completely user-configurable parameters,
• nearly 20 MB of textures, SDL scenes, and meshes,
• ...

Things not implemented:

• depth-of-field,
• adaptive tree depth control,
• adaptive supersampling,
• relativistic ray tracing,
• dispersion of different wavelengths,
• bump mapping,
• particle rendering,
• modeling the Klein bottle (I mean of course its 3D immersion),
• superquadrics,
• global illumination using photon mapping,
• world extents for Boolean objects,
• projection extents,
• swept surfaces and surfaces of revolution,
• parallel computations (ray tracing using several machines),
• ...

Take a look at the class tree supporting the various shapes (note that many other shapes are rendered as meshes, click here to see the complete list):

    |
    +-- Material
    |
    +-- GeometricObject
        |
        +-- Boolean
        |   |
        |   +-- UnionBool
        |   +-- IntersectionBool
        |   +-- DifferenceBool
        |
        +-- Shape
            |
            +-- Cube
            +-- Mesh
            +-- Sphere
            +-- TaperedCylinder
            +-- Torus
            |
            +-- AlgebraicSurface
                |
                +-- QuadricSurface
                |   |
                |   +-- OneSheetHyperboloid
                |   +-- TwoSheetHyperboloid
                |   +-- EllipticCylinder
                |   +-- EllipticCone
                |   +-- EllipticParaboloid
                |   +-- HyperbolicParaboloid
                |
                +-- CubicSurface
                |   |
                |   +-- PinchedSurfaceWithHoles
                |   +-- PinchedSurfaceWithLobe
                |
                +-- QuarticSurface
                    |
                    +-- FourLobes
                    +-- SteinersRomanSurface
                    +-- ToothCube

SDL is an acronym that stands for Scene Description Language and it is the standard interface adopted in my ray tracing programs (SDLViewer and RayTracer). The syntax is very straightforward and this page is intended to give you a quick reference.

Note that SDL is case-insensitive and that the keywords' parameters need to reside all on one line.

• Comments
• Lights
• Transformations
• Shapes
• Boolean objects (CSG)
• Material properties
• Motion blur
• Global scene attributes
• Textures
• Macros
• Including other SDL files

light     <px> <py> <pz> <red> <green> <blue>
spotlight <px> <py> <pz> <red> <green> <blue> <dx> <dy> <dz>
          <cut-off angle> <exponent>
	

identityAffine
rotate         <angle> <ux> <uy> <uz>
translate      <dx> <dy> <dz>
scale          <sx> <sy> <sz>
transform      <x1> <y1> <z1> <x2> <y2> <z2> <x3> <y3> <z3>
push
pop
	

buckyball
cone                    <distort-texture>
cube
cylinder                <distort-texture>
diamond
dodecahedron
icosahedron
mesh                    <filename (3VN, 3DV, 3DM or OBJ)>
                        <interpolate-normals>
octahedron
pyramid
sphere
taperedCylinder         <small-radius> <distort-texture>
teapot
tetrahedron
torus                   <tube-radius> <torus-radius>
oneSheetHyperboloid     <box-extent-width> <box-extent-height>
                        <box-extent-depth>
twoSheetHyperboloid     <box-extent-width> <box-extent-height>
                        <box-extent-depth>
ellipticCylinder        <box-extent-width> <box-extent-height>
                        <box-extent-depth>
ellipticCone            <box-extent-width> <box-extent-height>
                        <box-extent-depth>
ellipticParaboloid      <box-extent-width> <box-extent-height>
                        <box-extent-depth>
hyperbolicParaboloid    <box-extent-width> <box-extent-height>
                        <box-extent-depth>
pinchedSurfaceWithHoles <box-extent-width> <box-extent-height>
                        <box-extent-depth>
pinchedSurfaceWithLobe  <box-extent-width> <box-extent-height>
                        <box-extent-depth>
fourLobes               <box-extent-width> <box-extent-height>
                        <box-extent-depth>
steinersRomanSurface    <box-extent-width> <box-extent-height>
                        <box-extent-depth>
toothCube               <box-extent-width> <box-extent-height>
                        <box-extent-depth>
	

difference   <left-child> <right-child>
intersection <left-child> <right-child>
union        <left-child> <right-child>
	

defaultmaterials
surfaceRoughness         <value>
emissive                 <red> <green> <blue>
ambient                  <red> <green> <blue>
diffuse                  <red> <green> <blue>
specular                 <red> <green> <blue>
specularExponent         <value>
lightBackFaces           <value>
reflectivity             <value>
glossStrength            <value>
transparency             <value>
translucencyStrength     <value>
priority                 <value>
speedOfLight             <value>
retainAmbientColor       <value>
retainDiffuseColor       <value>
retainSpecularReflection <value>
disableRefraction        <value>
	

mbClear
mbRotate         <angle> <ux> <uy> <uz>
mbTranslate      <dx> <dy> <dz>
mbScale          <sx> <sy> <sz>
mbEnable
	

eyePoint                 <x> <y> <z>
viewPoint                <x> <y> <z>
viewAngle                <value>
upDirection              <dx> <dy> <dz>
background               <red> <green> <blue>
globalAmbient            <red> <green> <blue>
lightAttenuation         <constant-factor> <linear-factor>
                         <quadratic-factor>
atmosphericAttenuation   <front-plane> <front-scale> <back-plane>
                         <back-scale> <red> <green> <blue>
fog                      <fog-start> <fog-end> <red> <green> <blue>
shadowFeelerEpsilon      <value>
reflectivityEpsilon      <value>
transparencyEpsilon      <value>
meshEpsilon              <value>
adaptedShadowComputation <value>
minReflectivity          <value>
minTransparency          <value>
maxRecursionDepth        <value>
showExtents              <value>
motionBlur               <#frames> <methods>
                         [<final-frame-brightness>]
	

solidTexture      <type> <parameters>
imageTexture      <filename> <method> <tile-s> <tile-t>
proceduralTexture <type> <method> <parameters>
flatTextureOffset <s-offset> <t-offset>
	

def <name> { <definition> }
use <name>
	

include <filename>
	

• Cube
• Landscape
• Swarm
• SDLViewer/RayTracer
• Ray Traced MPEG Movies

Below, you can find all the code as written in C++. It was tested under Linux (using a Makefile) and with Microsoft Visual C++ 6.0 (OpenGL and GLUT are of course required in both cases). I also included the executables that run under Windows 98/2000/XP. There is also a zipped data tarball which needs to be extracted in the directory where the executables are located (this data directory contains all the textures, meshes, SDL scenes, ... which make up nearly 20 MB). In order to get started, you should read the software package's documentation, which is included below.

The code itself accounts for 22438 lines (666 kB), the scene files and documentation files account for 11760 lines (449 kB). In total there are 144 files that account for 34198 lines (1 MB). Just to give you an idea...

• The Software Package
  
  
  • C++ sourcecode (ZIP, 270 KiB)
  • Miscellaneous datafiles (ZIP, 8.31 MiB)
  • Microsoft Windows 98/2000/XP executables (ZIP, 1.41 MiB)

• SvenGL Documentation
  
  
  • Advanced Computer Graphics using OpenGL (PDF, 296 KiB)
  • You know you've been ray tracing too long when... (PDF, 79 KiB)

• OpenGL Documentation
  
  
  • The OpenGL Graphics System: A Specification (version 1.2.1) (PDF, 1.31 MiB)
  • The OpenGL Utility Toolkit (GLUT) Programming Interface (API version 3) (PDF, 403 KiB)

• Computer Graphics related Articles and Books
  
  
  • Advanced Global Illumination
    by Philip Dutré, Philippe Bekaert, and Kavita Bala
    A.K. Peters, Ltd., 2003
    ISBN 1-56881-177-2
  • An Introduction to Ray Tracing
    edited by Andrew S. Glassner
    Morgan Kaufmann Publishers, Inc., 8th edition, 1989 (2000)
    ISBN 0-12-286160-4
  • Computer Graphics: Principles and Practice
    by James D. Foley, Andries van Dam, Steven K. Feiner, and John F. Hughes
    Addison-Wesley Publishing Corporation, 2nd edition, 1990 (1993)
    ISBN 0-201-12110-7
  • Realistic Image Synthesis Using Photon Mapping
    by Henrik Wann Jensen
    A.K. Peters, Ltd., 2001
    ISBN 1-56881-147-0
  • Realistic Ray Tracing
    by Peter Shirley
    A.K. Peters, Ltd., 2000
    ISBN 1-56881-110-1