The assignment

For the last assignment, you wrote code to generate a polygonal model using L-systems. For this assignment, you will write code to interactively walk around another model. You will become a tourist, walking around the the steets of a city generated with an L-system. You should write a program that renders the city from the point of view of a person at street level, and allows the user to walk around the city. Your program should have the following user interface:

• You should use a perspective projection (use the gluPerspective function). You should set your near clipping distance so that walls are not clipped when you move close to them (otherwise you could see through the walls). Experiment a bit to find a value that works well.
• Clicking and dragging with the mouse should adjust the camera orientation, allowing your virtual tourist to look up or down or side to side. If you want to use freeform motion, without a click, that is fine, as long as the interface is easy to use (Do not force the TA to fight with his mouse while he is grading your project).
• You should prevent the tourist's head from flipping itself upside down by not allowing the user to rotate the camera across the y axis.
• The w, a, s, and d keys (or the arrow keys, your choice) should move the tourist forwards, backwards, leftwards, and rightwards (respectively). You should be able to hold the movement keys down and obtain continuous motion. Movement should be confined to a two-dimensional plane just above the city street. So, if you are looking down at the street and press w, your tourist should move parallel to the street, not down.
• Your movement rate must be some reasonable speed that you select, measured in world-space units per second. DO NOT simply translate forwards by a constant amount each frame. This leads to unstable movement because the speed becomes tied to the rendering rate. Pick a speed that allows the TA to walk rapidly around your city while grading.

In addition to moving about and looking around at the city, you must also prevent the tourist from walking through walls. This does not have to be particularly efficient, but it has to work right. You can use the following algorithm:

• Construct a line segment between the current camera position, and the new position after moving.
• Test for intersection between this line segment and each wall. Note that because your walls are perpendicular to the floor, this reduces to a 2D line-line intersection test.
• If the segment intersects any walls, don't allow the move.

Extra Credit (some mandatory for those taking 634)

• Plant some trees in the city using your L-system generation from Project 2. Collision detection for trees can be pretty coarse, using a bounding box or sphere.(5 points - mandatory for 634 .
• Implement the matrix math for the viewing transform manually (no use of glRotate, glTranslate, or gluLookAt). You may still use gluPerspective to set the projection matrix. (5 points - mandatory for 634)
• Improve the collision handling. Instead of stopping movement when the tourist runs into a wall, allow movement to continue parallel to the wall. You should do this by decomposing the movement vector into components normal and tangent to the wall and discarding the normal component. Be sure to maintain a consistent distance from the wall as well. (5 points)
• Give your person the ability to jump. Must make sure to use an initial upwards velocity and a constant downwards acceleration (i.e. gravity) for a realistic jump. (5 points)

City model file format

The model file contains polygons that you should draw on the screen (both roads and buildings). Geometry is defined in terms of quads, so what you'll see in the file are groups of four vertices, each defined by three floating point numbers, separated by spaces. A fifth line in each group defines a color for the quad (which you don't necessarily need to use). The vertices are defined using absolute world-space coordinates, with the city existing mostly in the XZ plane. The file format was designed for ease of use rather than efficiency, so there will be some redundant points. There may also be some overlapping quads, as the file was generated using an L-system.

Example quad:

-0.117647 0 -0.117647    #vertex 1
0.913149 0 -0.117647     #vertex 2
0.913149 0 0.117647      #vertex 3
-0.117647 0 0.117647     #vertex 4
0.5 0.5 0.5              #color

    x1 y1 x2 y2

Using OpenGL

As with assignment 2, we will be using FreeGLUT, an implementation of the OpenGL Utility Toolkit (i.e. GLUT), which is installed on the UMBC GL system at:

    /afs/umbc.edu/users/o/l/olano/home/public/freeglut

The OpenGL libraries are installed on the university GL system. While it is possible to work remotely using ssh, you are encouraged to work locally on one of the OIT lab machines (just reboot into Linux). The sample code from assignment 2 for using GLUT in Linux is located at:

    /afs/umbc.edu/users/r/h/rheingan/pub/435/Proj2

For more information about OpenGL and GLUT, you have several resources available:

• The OpenGL Programming Guide (The Red Book)
• http://www.opengl.org: The official OpenGL website
• http://nehe.gamedev.net: A collection of OpenGL tutorials that some students have found useful in the past.
• http://freeglut.sourceforge.net: The FreeGLUT website, with API documentation.
• Google

Tips on Implementing Movement

This section contains a few tips on how to implement your movement code. There are several functions you want to know about. The first two are glutKeyboardFunc and glutKeyboardUpFunc. These allow you to set a callback function that is called by GLUT when keys change state. To keep track of whether the keys are pressed, use these callbacks to toggle a set of global variables as the keys change state.

The second function you want to know about is called clock(), which is declared in the standard C <time.h> header file. clock() returns the number of clock ticks that have elapsed since your program started. To convert this to seconds, divide by the constant CLOCKS_PER_SEC. Since you are dealing with very small time steps, you will probably need to use floating point for your elapsed time. You can do this using an idle callback function (specified by glutIdleFunc) to provide per-frame movement.

For some reason, the clock() function on linux.gl does not return anything that even remotely resembles elapsed time. I would strongly suggest that you work locally, rather than SSHing to linux.gl. You can do this by booting the OIT lab machines into Linux. Tell us in your readme file where you did your development.

Strategy

1. Start by implementing just the camera translations. These should be easy. Once those work, add rotation. Save collision detection for last, after you have smooth camera movement.
2. Beware of numerical precision. Remember that floating point computation is not exact. Your collision detection routine will need to deal with floating point roundoff error in a robust manner, otherwise you'll be able to randomly pass through walls.
3. If your collision detection doesn't seem to be working right, build yourself a test harness that calls the collision detection function for a fixed (small) city with a variety of movement vectors. This will let you test your code in a controlled fashion.

What to turn in

Submit your assignment as 'Proj3'. Include your source code and makefile. Also include a readme file with a description what hardware/software environment you used to develop your project, and a description of any help you received (or a statement that no help beyond the text and course staff was received). Your readme file should also include any instructions necessary for using your program.

Working at home

If possible, don't. We test things out on the university computers and may or may not be able to help you if things don't work right for you at home. If you do work at home, your final submitted version must be able to run on the gl machines and must be electronically submitted there.