Dear ambitious students,

To stave off confusion or missed expectations regarding the "advanced
techniques" on your video game, the TAs and I have put together a few
guidelines to help you gauge how much work we are expecting in order to qualify
for full credit on these techniques.

Guideline #1: Of the 5 weeks allotted for this assignment, you should be
spending about 2.5 weeks on the general game engine and 2.5 weeks on your
advanced techniques.  This translates to us expecting roughly a student-week's
worth of effort out of each advanced feature.  If your implementation of a
feature looks as if it had been hacked into your game in a few hours, it will
likely not receive full credit.  The Advanced Techniques are supposed to be
advanced, after all.

Guideline #2: we'll be grading your advanced techniques on a bucket system:
minus, check-minus, check, check-plus, plus.  Your grade on this scale will
depend on the difficulty of what was implemented.  Enclosed below is a
breakdown of the techniques we listed in the project handout, with rough
estimations of how much functionality is expected for each grade.

Guideline #3: Grades will be proportional to effort.  If you implement all
features at the "Too easy" level, you will probably get less than a B.  Teams
with reasonable implementations of advanced features at the "Better" level will
probably get about a B+ or A-.  To get an A, we need to see outstanding effort
(roughly corresponding to the "Advanced" level below) on one or more feature.
In general, although implementing more features will increase your grade, we
prefer that you implement fewer features but do them well, and we will grade
accordingly.  Note: in the comments you will soon receive on your game
proposals, some of us refer to the "Advanced" level in the list below
as the "Whiz-bang" level.

Guideline #4: the more complex requirements for a feature are only if you
intend to count that feature as one of your official Advanced Techniques.  For
example, if you only need simple view frustum culling in your program, and
you've already implemented N*2 other advanced features and don't want/need
frustum culling to count as one of them, you can take the "Too easy" way out
(see below).

-Your teaching staff


On-screen control panel:

Too easy: restart and quit buttons, two or three scores updated occasionally.
Better: UI widgets whose look and feel are customized for your game, like a
2-axis control stick for an airplane, or an overview 2D "radar" map of your
game world.
Advanced: realistically modeled airplane cockpit, with a detailed
texture/bitmap for the "dashboard," along with dynamic OpenGL gauges, dials,
etc.  Of course, if you downloaded the cockpit from the web, you can't claim
it as one of your advanced features for credit.

View Frustum culling:

Too Easy: Only discarding parts of the scene 180 degrees behind the eyepoint,
or doing pre-computed 2D culling of chunks of the scene.
Better: General 3D view frustum culling of bounding volumes, either in
worldspace or eye-coordinate space.
Advanced: A well-organized tree data structure, handling your geometric
transformations and providing a hierarchy of bounding volumes.

Level of detail control:

Too Easy: not drawing objects beyond some distance threshold.
Better: Creating multiple, simplified versions of models offline and choosing
between them at runtime based on relevant criteria such as distance from the
viewpoint, projected screen area, velocity, current rendering load, etc.
Advanced: Geomorphed or blended transitions between different LODs, or
dynamically adjusted continuous level of detail techniques such as progressive

Occlusion culling:
Too Easy: Pre-computed coarse-grained list of 2D/3D scene areas not-visible
from certain zones (ie. only rendering the floor of the building the user
is on).
Better: BSP trees, portal culling, offline PVS calculations.
Advanced: Handling dynamic, moving objects, hierarchical occlusion masks, etc.

Procedural and physically-based modeling:

Too easy: procedural 2D textures, e.g. made using Perlin noise.
Better: fractal mountains, modeling using implicit functions.
Advanced: flowing water modeled using particles, volumetrically modeled and
animated smoke, genetic textures.  A good reference is the book, "Texturing and
modeling", by Ebert, Musgrave, Peachey, Perlin, and Worley.

Collision detection:

Too easy: simple hard-coded tests based on your knowledge of the size of some
object (essentially point-point testing with some threshold).  Also too easy is
collisions of points with axis-aligned walls.
Better: Efficient collisions of arbitrary polygons with each other.
Advanced: Collisions of procedural objects (not converted to polygons) with
each other, predicting time of collision for objects with curved trajectories.

Simulated dynamics:

Too easy: some object moving according to basic Newtonian physics.
Better: springs, friction, damping, interacting systems behaving according to
physical laws, e.g. simple articulated objects.
Advanced: cloth, hair, deformable objects.  Hard to do in real time!

Advanced rendering effects:

Too easy: environmental reflectance maps, multiple textures blended together.
Better: shadows using multi-pass rendering, lighting using projected textures,
bump mapping.
Advanced: displacement mapping.


Too Easy: Enemy characters walk straight towards the user.
Better: Computer-controlled agents do pathfinding with the A* or D* algorithm,
or demonstrate simple "learning" over time.
Advanced: neural network learning, sophisticated emergent flocking
behaviors, etc.

Game level editor:

Too easy: choosing between predefined levels or permutations.
Better: control over shape of world and any objects/obstacles in it.
Really advanced: control over all game parameters.
Interactive graphical editors are worth more than text-based editors.