CSE581 Lab2

CSE581 Lab2 - 3D Hierarchical Animated Model with Perspective Viewing

PRELIMINARY VERSION: expect some final tweaking before it's officially finalized Sample Lab2 executable
This is a little different that the lab you're supposed to do:

The camera control allows you to look under the groundplane to show the difference between a 'filled' front face and a 'lined' back face. For the assignment, you should clamp the angle to prevent viewing from below the groundplane.
The right mouse button pops up a menu to handle resume/stop of the animation as well as some up date parameters - these are not part of the assignment.

Example
simple robotic arm

OBJECTIVE:
This lab is to introduce you to 3D perspective animation in OpenGL, including:

perspective viewing that is reasonable and effective
simple illumination by a static light source
camera control by mouse movement that is reasonable and effective
creation of a simple 3D polygonal data and the use of OpenGL display lists
hierarchical model with multiple joints and an end grabber
hardcoded animation (interpolated joint angles with joint limits)

SPECIFICATIONS:

BASICS

As in lab1, 'q' should terminate the program
Create a groundplane +/- 100 in x, and z
Use perspective projection to view the scene. For example,
```
  gluPerspective(30.0, 1.0, 10.0, 600.0);
```

Use at least one static light source. It should not move with respect to the environment - that just means you specify it after the glLookAt command and before any transformations. Use the following commands to implement simple illumination:


	// Create light components
	GLfloat ambientLight[] = { 0.2f, 0.2f, 0.2f, 1.0f };
	GLfloat diffuseLight[] = { 0.8f, 0.8f, 0.8, 1.0f };
	GLfloat specularLight[] = { 0.5f, 0.5f, 0.5f, 1.0f };
	GLfloat position[] = { -50.0f, 40.0f, -50.0f, 1.0f };

	glEnable(GL_LIGHTING);

	glEnable(GL_LIGHT0);

	// Assign created components to GL_LIGHT0
	glLightfv(GL_LIGHT0, GL_AMBIENT, ambientLight);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseLight);
	glLightfv(GL_LIGHT0, GL_SPECULAR, specularLight);
	glLightfv(GL_LIGHT0, GL_POSITION, position);

Use the following commands to set the material properties (color, in this case) of the objects. For example, to color the groundplane blue:
```
     float colorBlue[] = {0.0,0.0,1.0,1.0};
     glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, colorBlue);
```
You can also let the current color be assigned to material properties (AMBIENT_AND_DIFFUSE by default) by:
```
glEnable(GL_COLOR_MATERIAL)
```

CAMERA/EYE CONTROL
- Keep the center of interest (aka lookat point) to be the origin
- Keep the 'head up' vector (0,1,0)
- To control the position of the eye. Use spherical coordinates where:
  - theta is the angle made with the x-z plane
  - phi is the angle made with the x-y plane; clamp theta to positive-only values.
  - the position of eye is at (d,0,0) when theta=0 and phi=0.
  - the initial value of d = 300, and angles of π/4.
  - to find the coordinates of the camera to use in the LookAt commend, rotate the point (d,0,0) around the z-axis by theta, then rotate that point around the y-axis by phi.
- Use the mouse left button to modify theta and phi (then recalculate the eye position and reissue the lookat command) so that the mouse appears to be grabbing a world sphere and rotating it in front of the observer: use motion in the x direction of the window to modify phi and motion in the y direction of the window to modify theta.
  - at mouse down, record current mouse location in cx, cy and the current spherical coordiantes ctheta, cphi
  - When left mouse button is down, use bottom to top movement of the mouse to modify theta. For example : theta = ctheta + ygain*(cy-y)/height (where ygain is some constant multiplier to produce reasonable interaction with the mouse.
  - When left mouse button is down, use side to side movement of the mouse to modify phi. For example, phi = cphi + xgain*(cx-x)/width
- With the middle mouse button down, use mouse movement in the up and down direction on the window to zoom in and zoom out by modifying the distance, d, of the eye. Then recalculate the eye position.
CREATE SIMPLE POLYGON DATA AND USE OF DISPLAY LIST
- Use a display list to hold the definition of a cube, including its normals. Use the following list commands:
  - glGenList()
  - glNewList()
  - glEndList()
  - glCallList()
- For this lab, you must define your own cube using glVertex commands and you must use a display list for the cube. Define the cube using ordered faces:
  - Use the eight vertices (+/-1, +/-1, +/-1)
  - Specify the order of front faces, e.g., glFrontFace(GL_CW)
  - Use GL_QUADS to define the 6 faces so the vertices appear in counterclockwise order (CCW ordering is the default) when viewed from the front
  - Specify an outward pointing normal for each quad. For example, for the face at z = 1, the normal would be (0,0,1)
HIERARCHICAL MODEL
- Create a hierarchically defined robotic arm with a base and at least 3 arm joints and a multi-finger (more than 2) grabber (see the example); place it in the middle of the groundplane. Most, if not all, of the parts can be build out of transformed cubes. A reasonable size for the model (with respect to measurements given in sample commands elsewhere in this specification) would be roughly 10 units wide and 20 units high, but use whatever you think is reasonable (or rather, what you think the grader would think is reasonable). Note that you do not have to match my robotic arm - you only have to construct a robotic arm that satisfies the specifications above.
- Construct each element of the hierarchy by
  - scaling the cube into the desired shape
  - translating the shape so it's point of rotation is at the origin
  - rotating the shape (joint articulation)
  - translating the rotated shape so the point of rotation (the current origin) is translated up to where it attaches to it's parent shape
  Note this is the order of operations the cube goes through; the order they appear in an OpenGl program would be a reverse of this.
- the articulation and relative positioning of each element is composited with the ModelView matrix, but not the scaline and translating of the cube shape.
- Use glPushMatrix() and glPopMatrix() to save and restore the current ModelView matrix and use OpenGL transformation commands for compositing transformation matrices. For a linear sequence of joints, the matrix operations would look something like this:
```
M = I
for i=0 to n
  M = M Pi Ai
  save M
  M = M Di
  Vi
  restore M

where Pi is the transform to position the element relative to its parent
      Ai is the transform that animates the element
      Di is the transform that prepares the element for animation
         (scales and translates the joint to the origin)
      Vi are the vertex commands that define the element
```
For the multi-finger grabber, you need to save and restore the matrix before and after the matrices for each finger
ANIMATION
- Animate the armature of the model by writing a routine that updates the state of the model (updateModel(), for example). This routine will update each joint angle independently using:
  - current value,
  - lower limit,
  - upper limit,
  - delta value.
  Update the current value by the delta value at each time step. Negate the delta value whenever the current value exceeds either one of the limits. Choose values that result in reasonable motion at a reasonable speed.
- Use the built-in timer function in OpenGL to automatically animate the model.
```
     glutTimerFunc(1000/fps,updateModel,0)
```
  where updateModel is the user-supplied callback routine that updates the state of the model. The timer instruction must be re-issued in the updateModel callback routine in order to set up the next iteration.
- Use double buffering to render frames of the animation.
  - While one buffer is used to refresh the display, the other buffer is used to hold the image currently being drawn. Once the new image is ready the roles of the buffers are swapped - the new image is used to update the display and the old image is used to assemble the next new image.
  - Initial display mode must be set using GLUT_DOUBLE mode as in
```
     glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH)
```
  - The actual buffer swap is performed using
```
     glutSwapBuffers()
```
    which is typically issued right after all the OpenGl commands have been issued that display all the models.

NOTES:

I suggest you implement in the following order:
1. the BASICS, as described above, with a fixed camera above the groundplane
2. add interactve camera control
3. add a model of a cube at the center of the groundplane using a display list
4. add a model of a simple robot arm putting in arbitrary angles for the joints
  1. code the linear series of joints first
  2. then add the multi-finger grabber at the end
5. animate the model by updating angles every frame, use double buffering and use the timer function to continuously update the display.
Labs #3 and #4 will be extensions of this lab so pay attention to good programming practices.

EXTRA CREDIT:

(0-10 pts) Use your imagination in designing the model. Specifically, include multiple branches in the hierarchy
(0-10 pts) Use your imagination in animating the model. For example, make the motion of the robotic arm appear as if it is engaged in some task.