Project 2: Technical Challenges

by Mike Gleicher on November 7, 2014

(read the main project description first!)

In Graphics Town, you need to make objects and behaviors that look cool. This could be mainly an art project. But, since it’s a graphics class, we want to make sure that you try your hand at enough graphics programming things that this stretches your learning about computer graphics.

There are four levels of succeeding at a technical challenge:

  1. You thought about doing it and got started.
  2. You got it implemented, and almost working. It’s probably close.
  3. It works, and you can show that it works on simple examples.
  4. You use it for something cool.

For the basic requirements, you must “attempt” enough technical challenges. Attempt means getting to phase #2. “Look at this code that doesn’t do anything” is not an attempt, “I’m getting it to show something, it’s just not right all the time” can be. Of course, to get more than the minimum grade, you should go beyond the minimum assignment.

As far as enough… We try to quantify how hard different technical challenges are, so you can get a sense of “enough.” The guide is really rough, and everything has a range – but even that doesn’t capture it. There’s such a range of what things can mean. And such a range of what people do.

For the minimum requirement, “enough” is 3 hardness points – per person. if you’re concerned that you’re not going to make this, then you are probably best off assuming that what you’re doing is at the minimum (so 1 point per challenge).

We used to try to have minimums for grade levels (for example, you must attempt 6, and succeed at 4 to get a B). These never worked out. With any challenge there is such a wide range of what people do, how they succeed at it, …

It is important that if you do something, you are able to show it off in the demo/make a picture for your album. So if you model some nice object, make sure there’s a fast way to get the camera to go there. Or, if you do subdivision, show different levels of the same object so we can tell you really did the subdivision.

It’s also valuable to use your technical challenge for something cool. After your got the subdivision to work, and smoothed a cube to show the different levels, also show a cool car racing around or a sailboat tacking in the wind… Cool uses of the tech is worth a lot!

Also, this is a list of suggestions – it’s not all inclusive. You can look at old years for more ideas (although, some of them are obsolete. like nowadays, writing a basic shader is not a technical challenge: it’s a basic requirement). If you have another idea, ask! (and we might add it here).

In general, each suggestion is worth “one or more challenge points.” In some places, we’ve commented why even a basic version might be worth more.

Note: each project can only get credit for each challenge once. So if there are two people, only one person can count it. But once the challenge is complete, you can use it over and over to add artistic coolness or complexity coolness.

Note 2: some of these techniques we haven’t discussed in class. Some of them we won’t. Part of this project is for you to figure out what some of these things are so you can decide whether or not you want to try them.

Curved Surfaces

Note: you are required to have a curved surface. So, you’ll get at least 1 point in this category. Getting proper texture coordinates on your curved surface is also a trick.

  • Surface of revolution – (generally this is the simplest) – you can get a TC point for this, but just barely.
  • Generalized Cylinder / Sweep – being able to support general curves for the “spine” or general cross-sections is tricky, and worth more. Be sure to create objects that show off the capability!
  • Subdivision surfaces – doing it by hand (taking an object and figuring out what happens when you subdivide it one or two times) isn’t so hard. A better thing to do is to implement subdivision assuming a regular grid to start with. Implementing subdivision it for an arbitrary mesh is quite tricky, since you need data structures that allow you to quickly find the neighbors of a vertex. If you can do Catmull-Clark or Butterfly or some other scheme on an arbitary mesh, that’s really hard (several TC points).
  • Parametric patch – making a single parmetric patch (e.g. a Bezier patch or a cubic B-Spline patch) isn’t hard. Hardly a technical challenge. Making multiple patches that fit together and are controlled well enough that you can make an interesting object can be worth a TC point or several.

Rendering Hacks

  • Local lights – light sources that only effect nearby objects (but dynamically get the right objects) are a bit of a trick to do in the GL model. Past students have shown this in cool ways (a siren on a police car only illuminated things nearby).
  • Inter-object shadows and reflections by trickery. There are variants of the drop shadow hack (from Project 1) to put shadows and reflections on other objects. I put this into a different category than the more principled shadow maps / environment approaches.
  • Shadow Maps – these are worth multiple TC points, since pulling them off is difficult within the framework (since multi-pass is not well supported). Even a simple shadow map implementation (if it works) is impressive. There are ways to cheat (make it so the shadow maps are not dynamic) – you are more likely to get this to work, but its less challenging.
  • Dynamic Environment maps – where you actually are reflecting the (moving) objects in the scene by multi-pass rendering. Again tricky to pull off given the way that the framework is setup, so this is probably worth multiple TCs.
  • Non-Photorealistic rendering – if you intentionally make something that has a “stylized look” (like your whole world is toon shaded, or looks like a watercolor painting), it’s very cool – and probably a significant (multiple TC point) technical challenge.
  • Screen-space ambient occlusion rendering. Adds a little shadowing to the scene after it is drawn. Tricky to make work well, but can look very cool.
  • Pre-computed shadows (light maps) – go along with shadows above. Can be a simple trick (paint on the textures), can be really fancy (where you actually do some ray casting to compute the shadowing). Ambient occlusion is one possible technique.

Advanced Texturing

Doing some kind of advanced texturing is a requirement. Almost all are worth some TC points.

  • Skybox – possibly the easiest way to get TC points. just make sure to do it right (have the box be viewer centered, draw it first without Z-buffering to fake it being behind all objects, or draw it last and have it fail all Z-tests with drawn objects)  …
  • Billboard – maybe the second easiest way to get TC points. This refers to the graphics technique where the textured surface turns to always face the viewer to give the illusion of a 3D object, even though what is drawn is flat. Nice trees can be done this way.
  • Projector Textures
  • Environment Map – if you have a pre-drawn map, that’s one thing. If you somehow create the map of your actual scene by an extra rendering pass, very challenging.
  • Bump Mapping – simple to do now that you know how to write shaders. Hard to use well. This is a case where success level 4 becomes more important.
  • Parallax Mapping, or other advanced shader tricks, to make the surfaces look non-smooth.

Other Modeling Methods

Other than what? Other than just having pre-set polygons or curves?

  • Complex Procedural/Parametric Model – Generate complex shapes using a procedure. You might make branching trees, buildings with lots of columns, fractal mountains, …
  • Fractals – Implement fractal geometry (a random kind of subdivision) to make some complex shapes like mountains or trees. Or bumpy terrain.
  • L-Systems or other Plant Generators – These are procedural models like fractals that have specific rules for generating trees (or other plants).

Animation (Dynamic Modeling Effects)

  • Particle Systems – Model a complex, moving object as a set of little particles. You can make fireworks, rain, snow, fountains, fire, smoke, … It’s not the fanciest method, but it can be a cool, cheap effect. And students have done cool stuff with it in this project.
  • Fake Physics – Use some kind of math techniques to make “physical” animations (like flags waving or water ripples in a pool, or flames). Rather than trying to simulate the physics, experiment with using procedural “hacks” (a waving flag can be a sine wave …). Bonus challenge for doing fake physics using the shaders (for example, having the flag movement or water waves generated in the vertex shaders).
  • Flocking – kindof like a fancy particle system where the particles look at their neighbors. (old page from Games class, or a newer games class assignment with pointers)
  • Skinned articulated characters – if you make an articulated character (like a human or an animal or …) and use skinning (smoothing over joints), that’s a technical challenge – and since you’ll probably want to animate the articulated character in an interesting way (like making it walk), that will probably be a technical challenge too.
  • Very Complex Behaviors – Some behaviors are so complicated that they constitute a technical challenge. For example, my example driving behaviors is a technical challenge.
    A better traffic system so that cars stop at the stop signs qualifies. Or cars don’t drive through one another, but slow down and wait behind other cars.
    Having characters that moved in interesting ways (we’ve seen walking robots, slithering snakes, inching inch-worms) adds even more.
    A flock of skiers that skied down a mountain was a personal favorite from an old project. The gondola (cable car) was basically a train from the previous assignment with a piecewise linear track that it hung from (towers) – but it was very cool.

Getting cool objects

Many students will inevitably want to load in objects defined in some model format. I’ll bet that someone will find a good model loader, and post where they got it to Piazza. This is a fine thing to do. Incorporating a model loader generally is not a technical challenge (but if the one you do try to incorporate turns out to be a technical challenge, you can negotiate with us). But:

  • Writing your own model loader – this is a technical challenge. You need to load in models in a real format (and demonstrate that it really works to read models that are generated by someone else). Even if you pick a simple file format, you’ll have to figure it out, how to make it robust (since files are often wrong), …
  • Writing an animation loader – this is a bigger technical challenge since the file formats are generally complicated. For a good challenge, try to write a loader for the BVH file format (motion capture data). This would be worth multiple TC points if you really get it to work. This is often a 777 assignment, but since 777 isn’t going to be offered any time soon…


I don’t mean making the buttons nicer!

  • Better “Look At” controls – When you look at an object of interest (or ride something, or follow it), you get no control of the camera. You could update the UI to allow some user control – for example to turn your head when driving in the car, or to move around an object you are looking at what still looking at it (this is called orbiting).
  • Making better following – (a variant of better lookat) – make it so you can always see the object, yet don’t get bounced around too much (so the follower doesn’t go through walls).
  • Better navigation – imagine something that avoided bumping into things, or planned nice routes to destinations (without going through things) or …
  • Make a game of it! –  You could even imagine more of a user interface that allowed you to make a game of it. Race the cars, deliver pizzas, …

Everything Else?

In case it isn’t clear, these are just suggestions. Any graphics programming thing is fair game. Something you saw in class? Something you wanted to learn about but didn’t see? Just make sure to talk to us about it first.

I might regret giving such an open-ended instruction to such a big class. But it will be worth it to see all the cool things people come up with.

{ 1 trackback }

Previous post:

Next post: