Project 2: Graphics Town

by Mike Gleicher on November 7, 2014

Our final project this semester will be the same final project that we’ve used in 559 for many years. Students always seem to like it. We (professor/TA) always like it since students always find new and different things to do.

This is a big long project description. And there’s more. Two other pages discuss the framework code and suggest technical challenges. And hidden in there are some gallery pages of old projects (although check the history – the projects were different back then)

Overview

The goal of this project is to create a town. It has to be a living town, with things moving around in it.

You will create a program that allows the user to explore the town by flying around in it, or by looking at it from the vantage point of an inhabitant. Your town cannot be a dead place: there must be things moving around in it.

What is in your town, as well as what is happening there is up to you. We hope you will be creative. Make houses, trees, stores, cars, roads, helicopters, construction equipment, people, boats, …What goes on in the town is up to you – make the cars drive around, drawbridges open and close, construction equipment operate, fire trucks fight fires (with flames and smoke and water coming from file hoses) …

We hesitate to tell you what to do, since students in the past have come up with some really creative things – we’ve seen cities with skyscrapers, space cities with flying saucers, a Harry Potter city with flying broomsticks, … There is a gallery page with some old projects if you want some ideas.

If this sounds like its arbitrarily open-ended, you have the right idea. Clearly, you could make this as fancy as you want. Obviously, we will try to set our expectations to be only somewhat unreasonable 🙂 Our goal is to give you the opportunity to demonstrate your competence at writing 3D graphics programs, as well as an opportunity to experiment with some more advanced topics that you think are interesting.

The catch is that we do need for you to demonstrate your competence with creating 3D graphics programs. So, there is a list of required things you must do, but there is a lot of flexibility in terms of how you meet these requirements.

In terms of which fancier features to implement? You should pick the things that are most interesting to you. We will give you lots of ideas…

For this project, we will provide you with framework code to build on. Years of 559 students have used it successfully (see the history), and it allows you to focus on adding cool features, rather than dealing with basic infrastructure. If you really don’t want to use our code, you can start from scratch – but then you’ll need to recreate the basic functionality first.

You will be allowed to work in pairs on this assignment, subject to some rules.

Working Together

You are encouraged to work with a partner, subject to some rules.

Each person must:

  • Create at least one curved surface object.
  • Create at least one texture that wraps onto a non-flat object.
  • Write at least one shader pair that is a procedural texture (and use it on an object)
  • Write at least one shader pair that is affected by the direction of the sun (or moving light source).
  • Write at least one behavior.
  • Do some technical challenges (see below).

Other than that, the requirements are the same as for individuals – we expect you to have a little more than we expect individuals to have. Each person must document the pieces they did individually, in addition to the overall documentation for the whole town.

Teams must choose to work together by the November 19th checkpoint. Teams may not split up after the November 26th checkpoint. Generally, teams get the same grade, but we reserve the right to make exceptions.

Objectives

If you understand what we want you to get out of this project, it will be easier for you to understand how we will assess what you do.

The overall goal of this project is to give you an opportunity to explore topics in interactive graphics: how do you make things that look interesting, and be interactive. While some of this is artistic (you need to pick interesting objects to make and good textures/… to look nice), some of it is technical: you need to pick things that can be implemented efficiently and have interesting behavior.

If you’re concerned about having to be “artistic” – just try to be different than what the provided sample is. Don’t use the example houses in their regular grid. (An easy way to do this is just avoid using the “SimpleLot” and “SimpleSubdivision” classes).

In terms of your grade, effort spent on technical aspects is more valuable. For example, it is better to spend your time making a simple “blocky” car drive around in an interesting way, or to make a simple shaped car out of parametric surfaces, or to light the car in an interesting way, then to carefully model a gorgeous model of a car. (of course, if you want to make model a gorgeous car, implement bezier patches to display its curved body, have it realistically race around a track … – we won’t complain).

Some specific things we want you to learn from this assignment (which will explain some of the requirements):

  1. To learn how to work within someone else’s code – even if that code isn’t perfect. (so, you need to use the framework code, unless you get specific permission otherwise)
  2. To try out some of the technical topics that we’ve discussed in class (subdivision surfaces, environment maps, …) or topics we won’t discuss too much in class (particle systems, fractals, …)
  3. To get some experience with how textures are used to make simple objects look more interesting.
  4. To get some experience with creating geometry for graphics.
  5. To gain some experience creating the behavior/motion of graphics objects.
  6. To work with shaders.

OpenGL

The framework code is written using “old fashioned” OpenGL.

For this assignment, you may use a mix of old and new OpenGL. You are welcome to use the old style OpenGL transform stack and transformations. You should not use the old OpenGL lighting.

All of the objects in the example use old-style lighting. That means you either need to replace them, or at least change the way they do lighting (since you are not supposed to use fixed-function lighting).

You are discouraged from using the “old-style” immediate mode drawing commands (like issuing individual vertices), but you are allowed to do it if you want to.

If you decide not to use the framework code, you can make it purely modern opengl. Or you can use the OpenGL matrix stack.

Timetable

(all Wednesdays)

  • November 19 – Startup checkpoint (Assignment 9 will be posted). You must tell us if you plan to work with a partner. You must also give a tentative list of technical challenges you are interested in, and (optionally) some ideas for what you want to do overall. You are not tied to these – we mainly ask to make sure you are thinking about things, also so we can plan help sessions (if a lot of people are interested in a particular technical challenge, we will either use class time for it, or make a video help, or have an outside lab session).
  • November 26 – Signs of life checkpoint – you will have to show us a picture of your town. Your picture must show that your town is already looking like something other than the example. This is the last day to “break up” your group.
  • December 3 – Project planning – you will tell us what you expect to have to show at the end, and give us a picture to tell us about your progress. This will help us help you decide if you’re doing “enough.”
  • December 10 – Project Due. Note: the university has all sorts of rules about how late we can accept projects, so we cannot promise that there will be many extensions possible.

The Basic Requirements

  1. Multiple objects moving at any time (besides the ones that I made)
  2. Multiple different types of behaviors (besides the ones that I made)
  3. Multiple different types of buildings / scenery (besides the ones that I made)
  4. Multiple new textures. Some must be hand painted. Some must not be flat (that is, it must wrap onto multiple polygons)
  5. You must attempt “enough” technical challenges (see the technical challenges page – which tries to define “enough” and “attempt”).
  6. You must have at least 3 shaders in your program (by “shader” we mean a pair of vertex/fragment programs attached to an object). At least one of these shaders must provide a procedural texture, and at least one of the shaders must be (properly) affected by the lighting (explained in a moment). At least one of the shaders must be affected by the time of day (so you need to figure out how to pass the time of day to the shader).
  7. You program must work at a sufficient frame rate (which isn’t hard since the computers are so fast).
  8. You must add something that is effected by the time of day (besides the one shader used to fullfill the requirement above). For example, you can have an object that changes color (the shader is sensitive to the time of day) and shape (something besides the shader is sensitive to the time of day).
  9. You must use at least one type of “advanced” texture mapping: multi-texturing, projective (slide projector) texturing, environment mapping, bump mapping, a skybox, or shadow mapping. Mixing a procedural and an image based texture is a multi-texture (and isn’t hard since you have to write the shader). (if you want to pick something not on this list, you may want to check with us to make sure it counts)
  10. An object made out of a curved surface. You can implement subdivision, or some form of parametric surfaces, or do a surface of revolution, or … This is described more on the technical challenges page.
  11. The objects that you make cannot use “Old Style” OpenGL lighting. They must have shaders.
    Update: it’s OK if some of your objects use “Old Style” lighting – in practice, we won’t have time to check to make sure that all of your objects have shaders. However, we do care that enough of them do.

Good assignments always go way beyond the minimums.

Evaluating aspects

There are three aspects of this project, all will be considered in evaluating your project:

  1. Technical challenge (how much hard graphics technique did you use). See the technical challenges page. Note: that some of the technical challenge of the project comes from how complicated the objects are, how complex your shaders are, etc.
  2. Visual Complexity of your world (how cool/interesting does it look – sometimes a few really interesting things can be as good as a lot of simpler things). The first criteria is that it is different than the sample solution. You should avoid using same regular grid of houses from the example. Getting rid of my silly looking houses is an important first step, even if your make new ones that aren’t much better.
  3. Behavioral Complexity of your world (how interesting are the things that happen in it).

This is the order of importance. While having some degree of success in all categories is important, sometimes excellence in one category can outweigh deficiencies in another. However, you must meet the minimum basic requirements.

Note that it is important that you are able to show off the features of your system. If you have written a shader, you need to use it on an object that makes it clear that your shader is doing what it advertises.

The Framework Code

We strongly encourage you to use the framework code – it will let you focus on trying to do the more fun stuff (making things in the town). See the discussion of the Framework.

Creating your own framework will count as a technical challenge, but it won’t count as much as the effort it takes. That is, it’s probably 10 times more work than most other “hard” challenges, but it will only count as about the same. From past experience, most people who want to build there own frameworks also want to put lots of cool stuff in it. They usually have some very cool thing they want to do that will be really difficult to do with the class framework.

If you build your own framework, you must have the main features of the standard framework (navigation, ability to ride objects, sights, …).

Other Resources

Many students in past years have either written loaders for various model formats, or found model file readers on the web. You are welcome to do either. However, be sure to give proper attribution if you appropriate code or models. Also, be sure to include all of the models in the handin.

If you do use a model reader, remember that you must make some of the objects yourself.

Also, there is technical challenge in writing a model loader yourself. Interfacing to a model loader you found, there is some challenge there. Building your own model loader for a common file format: bigger challenge – especially if you demonstrate that it can load a variety of models from around the web.

Grading

Unfortunately, it is very difficult to give a grading procedure ahead of time. Every project is so different.

It’s most fun to grade these projects with live demos. However, the grading has to be done quite quickly (since it has to fit in with the exam schedule), and there are a lot of students. It’s unclear if we’ll be able to do demos with everyone. More details on this will be given as we get closer to the final deadline.

Some students are concerned that we don’t give more clear grading criteria, however, it is hard for this project. To help with this, we will schedule some “open lab” hours before the project is due so you can describe your ideas and show us your preliminary results and we can give you some idea as to whether you are attempting to do enough to get the grade you want.

Generally, meeting the minimum requirements and making a town that looks qualitatively different than the example gets a B. Most students do much better than that.

The project is graded on an A-F grading scale, and used to figure the final grade as described in the class grading policy.

Print Friendly, PDF & Email

Previous post:

Next post: