Project3S16

Topics:

• Kevin will make pod
• Sky box with Textures
• View Frustum Culling
• Camera in scene graph: bear sits in pod (or bunny), switch to that perspective; other camera is outside view

• extra credit: split screen for both camera views?

project 4: roller coaster editor

Project 3: Wedding Cake

In this project you will need to implement a scene graph to render a novel theme park ride. The ride is the Wedding Cake from the Centrifuge Brain Project video - the relevant part of the video starts 2:00 minutes into the clip.

The total score for this project is 100 points. Additionally, you can obtain up to 10 points of extra credit.

1. Scene Graph Engine (30 Points)

Implement a scene graph structure to simplify rendering of the ride. Use the following hierarchy:

The classes should have at least the following functionality:

• Class Node should be abstract and serve as the common base class. It should implement an abstract draw method: virtual void draw(Matrix4 C) = 0, and also an abstract virtual void update() = 0 method to separate bounding sphere updates from rendering.
• Group should store a list of pointers to child nodes (std::list<Node*>) and provide functionality to add and remove child nodes (addChild(), removeChild()). Its draw method needs to traverse the list of children and call each child node's draw function.
• Geode should be an abstract class. It should set OpenGL's ModelView matrix to the current C matrix, and have an abstract render function to render its geometry.
• MatrixTransform should store a 4x4 transformation matrix M which is multiplied with matrix C, which is passed to the draw method.
• Sphere should have a draw function which draws a sphere. You can use glutSolidSphere for that, or use your own tessellation algorithm.
• Cube should have a draw function which draws a cube. You can use glutSolidCube for that, or use your own implementation of a cube.

2. The Wedding Cake Ride (20 Points)

First get your software ready to recursively traverse the scene graph for rendering by creating a root node of type Group and calling its draw() function with the identity matrix as its parameter.

We provide a 3D model of a pod for the ride. Use a cylinder for the vertical center post, and smaller cylinders for the horizontal arms that hold the pods.

Rotation

The ride should have three levels of pods, each with three big arms to hold three pods each. The center post that holds everything should rotate, as well as each set of three pods, and also each pod should rotate about its pivot point.

Translation

Each of the three arms on each of the three levels should be able to extend its length.

3. Culling (30 Points)

Add a bounding sphere (Vector3 for its center point, and a radius) to your Node class, and implement code to update the bounding box parameters in all other classes of your scene graph. You also need to add code to your Node class to display each node's bounding sphere as a wireframe sphere with glutWireSphere. Support the 'b' key to toggle these bounding spheres on and off. (10 points)

Note: You do not need to find the smallest possible bounding sphere, but you can approximate it:

• Find minimum and maximum extents of your geometry in x,y and z (bounding box).
• The center of the bounding sphere is the center of the bounding box.
• The radius of the bounding sphere is equal to half the diameter of the bounding box.

At the least, the bounding sphere should not include any neighboring robots in their entirety.

Extend the Node class to perform view frustum culling using the bounding spheres of the objects. If the bounding sphere of an object is completely outside of the view frustum, the object should be culled (not rendered). Your culling algorithm should make use of a utility function to test whether a bounding sphere intersects with a given plane, or whether the sphere is entirely on one side of the plane. (10 points)

Test your implementation by constructing a scene which consists of a sufficiently large amount of your robots to speed up rendering when object culling is used. (10 points)

• Create only one instance of your robot class, which you reference every time you render a robot. This saves a great deal of memory.

• Create a scene graph with two platoons of as many robots as it takes to render at around 20 fps. Distribute the robots of each platoon on a regular 2D grid.

• Choose the camera parameters so that many of the robots are located outside of the view frustum (off-screen), so that culling kicks in.

• Use your rotation and scale routines to allow the user to rotate the camera and zoom in and out. You can modify the camera position either with your mouse control functions, or with keyboard keys of your choice.

• Compare the frame rates with and without object-level culling by supporting the keyboard key 'c' to toggle culling on and off, and displaying the rendering rate (frames per second) in the console window for every frame (frames_per_second = 1/rendering_time). Tweak the number of robots, their spatial density, and your camera parameters until your frame rate is substantially higher (50%+) with culling enabled.

Notes:

• All your robots need to be walking like in part 2. This means that you need to re-calculate the bounding spheres each frame, or use bounding spheres which contain the entire animation.
• For the calculation of the view frustum bounding planes you may want to take a look at the Lighthouse3D web site.
• To monitor memory consumption you can use the following tools:
  • Windows: Visual Studio 2015's Diagnostics Tool, or Task Manager
  • Mac: Activity Monitor
  • Linux: top

This image illustrates the grid layout of the robots:

Grading:

• -15 if camera can't be moved to demonstrate that culling works.

4. Animation (20 Points)

Animate the robots and the platoons like in the above mentioned video. Your animation needs to consist of at least 4 turns and changes of direction of the robots. The platoons need to move in different directions at least once (i.e., they can't be walking synchronously all the time). Make the platoons interleave each other like in the video. It is not critical that there is no collision between them, we will deal with that in the extra credit section. The animation needs to be running automatically, so you will need a way to script it.

Grading:

• -5 if robots don't turn in place
• -5 if the two platoons don't move independently
• -5 if the platoons make fewer than 4 turns

5. Extra Credit: Collision Detection (10 Points)

Implement a bounding sphere based collision detection algorithm and visually indicate when two or more robots collide. For example, you could draw the colliding robots' bounding spheres in red. Tweak the interleaving part of your animation so that the robots never intersect. Add a manual control mode to control the walking direction of each platoon independently so that you can force collisions. For instance, one platoon could be controlled with the WASD keys, the other with IJKL.