Final Project - Math 155A - Spring 2005
Instructor: Sam Buss,  Univ. of California, San Diego

Final Project - Create an individual project using OpenGL. 

Due Dates: Project finished by: Tuesday, May 31, midnight. 
                    Grading: Wednesday, June 1 thru Friday morning, June 3. (Must be graded during these three days!)

Goals: Design and create a significant OpenGL program that incorporates new aspects of OpenGL.  Evaluation will be based on technical and artistic merits.

What to hand in:  (1) Make a directory called FinalProject in your Math 155A ieng9 directory.    Place, in that directory, all your source files and project files (including .sln and .vcproj files), plus any texture files or other resources used by your project.  Also, place a file called readme.txt that describes you project, how you implemented and documents how to run your program.
    (2)
You must upload also, a thumbnail GIF file, at least one full size screenshot and an HTML file which includes the content of your readme file, and shows off your project.  .Your web page should show off your final project in its best light.  Many of you will also want to upload also your executable file, and include directions on how to run the program.  A few of you may  want to upload more sophisticated set of web pages.
       
As usual, grading will be personalized and one-on-one with a TA or with Sam Buss.  Your program must run on the PC lab, you must come into the PC lab and meet one of us.  You will have to show your source code, run the program, possibly make changes on the spot to your program and recompile as requested by the grader, and be able to explain how your program works and why it renders what it does. Your files should be complete and project must recompile in the ieng9 directory.    This grading will be done by appointment and MUST be done by Friday MORNING, June 3.    Grading is on a scale of 1-20.
 

FOR FINAL PROJECT:

  1. Pick a topic of your choosing.  Guidelines for this include:

    1. Your program must use OpenGL / GLUT in the spirit of this course.  Exceptions to this must be pre-approved by Professor Buss.
    2. You should spend approximately total hours of work on the final project.  If you find yourself spending more than 25 hours, cut the project short.
    3. Design a project that can be implemented in stages, so if you get stuck on one part and cannot complete everything as planned, you will still have a project to demo.
    4. You should incorporate some technical aspects of OpenGL or computer graphics that is new (that is, technical tools not used in any of your earlier projects).
      Examples of this new technical content could include the use of texture maps, mouse controls, the use of extensive animation, transparency and blending, environment maps, spotlight, shadows, the use of Bezier curves or surfaces, etc.
    5. It most cases, the project should be independent work of one student..  Joint projects should be undertaken ONLY with prior permission and only if the responsibilities of different contributors are distinctly delineated.  Special prior permission is required from Prof. Buss for any joint projects.
    6. You should not use code from outside CSE 167 (e.g., downloaded code).   In rare cases, I may give an exemption to this, but only if you project includes a substantial extension of the other code.
    7. You should discuss with a TA or Professor Buss what your project will be, not later than Friday, May 20.  A good time to do this would be at the same time you have Project #4 graded.
    8. Some suggested projects are listed below under "3.".  You can find old sets of similar projects for my courses and others at the following sites:
          - http://www.math.ucsd.edu/~sbuss/CourseWeb/CSE167_2004F/FinalProjectsView.html (From Fall 2004, CSE 167 final projects.  Very similar to this course.)
          - http://www.math.ucsd.edu/~sbuss/CourseWeb/CSE167_2003F/FinalProjectsOnline.html (From Fall 2003, CSE 167 final projects.  Very similar to this course.)
          - http://www.math.ucsd.edu/~sbuss/CourseWeb/Math155WinterSpring01/FinalProjectJpegs/index.html  (From Winter 2001, Math 155A. Similar to this course.)
          - http://www.math.ucsd.edu/~sbuss/CourseWeb/Math217/StudentProjects/Final.html (Not all of these would be appropriate as projects for our course.)
          - http://www.student.cs.uwaterloo.ca/~cs488/gallery-A5.html (A rather stunning set of the best final projects from a undergrad/grad course at U. Waterloo.  That course covers ray tracing, which we do not cover until next quarter, and many of their projects are raytraced.  Still their projects may provide some inspiration.)
  2. You will need to turn in the following items:
    1. All documentation, source code and executables and supporting materials (such as texture maps) in your Math 155A ieng9 home directory, named FinalProject.
    2. Create a file named readme.txt or readme.html that describes all relevant aspects of your project.  This includes a short description of the project and its aims and how well you met your aims.  It should also contain documentation on how to run your program including all controls.  In addition it should discuss the algorithms or techniques you used.   This file should be 1 or 2 pages of text.  It should be placed both in the FinalProject directory and be on, or accessible from, your HTML page.
    3. Create an HTML file index.html and image files that show off your project.   This  HTML file and associated files let you create a web page (or set of web pages) that present your project.  So please take some time to make your HTML files and web pages are well-designed to "sell" your project.   Include in the HTML file a short description of the project (probably taken from your readme file).  If appropriate, include the executable file and the necessary texture files in a zip file that can be downloaded via your HTML page.  Also, include one or more images generated by your project and have your HTML page display them. 
    4. Create a image file called thumb.gif  in the same format as was used for Projects 3 and 4.  (Its dimensions should be 160 pixels wide and 120 pixels high.)
    5. Put the readme file and the files thumb.gif and index.html and all associated files invoked by your index.html together into a zip file.  (Yes, this might put a zip file inside a zip file, this is OK!)
    6. Upload your files into the Final Project area for the Math 155A course. 
    7. Verify that the files are correctly uploaded and that your html file is set up so that people can access all the files.
  3. Some suggested project topics include:
    1. Design a museum room.  Include artwork as texture maps.  Include lights, benches, wood floors, rugs, doors, etc. if you wish.  The user should be able to navigate the scene and change view direction with keyboard or mouse controls.  (This is a fairly standard project and has been done a lot in the past, so please embellish it in some way.)   Try adding textures to items in the room, such as three dimensional wood picture frames, or stylish ceiling lights, or spotlights on the pictures, or a curved sculpture, etc.
    2. Design a dining room or living room with furniture.  Use lots of textures.
    3. Design an outdoor scene.  Maybe a cottage or mountain.  Again, use textures.
    4. Build a robot.  Animate it.  Make it walk or dance or respond to keyboard controls.
    5. Build a model of a robot arm.  Let the user control joints with keyboard controls.  Perhaps there is a goal, such as to make the robot push a button.
    6. Model a space ship, a death star, a toaster, or some other technological device.  Possibly give it some animated behavior.
    7. Build a simple car and a region (or a track) where it can be driven under user control.  (Or airplane, or space ship, etc.)
    8. Build a virtual roller coaster.  Let the user's viewpoint follow along (in or behind) the roller coaster car.  Include some interesting scenery.
    9. Take photographs of a room or two from around UCSD or from your residence with a digital camera.  Also take photographs of furniture.  Make a three-dimensional  model of this area and its furnishings in OpenGL, using your photographs as texture maps.  Allow the user to navigate with arrows or other keyboard controls around the scene.  (Sort of like Quake without the shooting.)  Warning: going from photographs and modeling a scene so as to look quasi-realistic can be expectedly challenging.
    10. Use transparency to build a fish bowl (for instance).  Warning:  in the past this has proven to be a very difficult project to implement well.
    11. Make a simple video game.  Warning: lots of work!
    12. Create three (or five) balls that move around in a juggling pattern.  Add arms and hands that appear to toss them.
    13. Create a room with interesting items including a large mirror that shows a mirror image of the room.  Let the user be able to navigate through the room with mouse buttons.  (The OpenGL stencil buffer might be useful for rendering a mirror.
    14. Be creative!  Make your own suggestion.
  4. It would be a excellent idea to talk about your project in the preliminary design stage with me or with the TA's.  We may be able to give you some pointers on how best to approach your project.
  5. Grading is based on both technical merit and on artistic merit.
     

TECHNICAL SUGGESTIONS (watch this space for updates):

  1. Texture mapping images. 

    1. Make sure your images have enough resolution, but not more than needed for your program. 
    2. Use mipmapping.
    3. Convert your image to bitmap format (.bmp).   Use the supplied sample code (at http://math.ucsd.edu/~sbuss/MathCG) to help load and manage texture maps.
    4. If you apply a texture map to a quad that is a portion of a wall or other large flat surface, use polygon offsets to avoid z-fighting.  For example: a picture on museum wall.
    5. Do not re-load the texture map, or even re-mipmap it, every time through your draw loop.  Do it once per texture map (as in the FourTextures sample program).
  2. Blending and transparency.
    1. It is often  necessary to render all transparent objects from back to front to achieve consistent and attractive results.  (Painter's algorithm.)
    2. glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) is usually the best blending function specification.