683 Lab 1: Rotating Cube

Right now, this is a draft - it may need some improvement here and there, but the assignment itself and the due date are finalized.

last update: 24 Sept 2010; 12:45pm

PRELIMINARY NOTES

• The emphasis in this class is on motion control algorithms. Attention to display quality and user interface will be considered only to the extent that they serve to support the presentation of the motion.
• For the labs in this class, there will 3 types of files:
  1. Main - sets up interactive OpenGL view environment: camera, lights, calling the simulation routines below. Once written, this procedure can be used in each of the labs to follow with minimal modification.
     • manages user interaction
     • calls routines in lab source code file
     • sets up OpenGL (or other display) environment
     See main.c for details.
  2. Animation - the lab-specific algorithm to be implemented. The actual algorithm will obviously change from lab to lab, but each will have the same interface to the main routine. The animation routine should support the following functions callable by Main:
     1. Animation_init() - initializes the animation
     2. Animation_reset() - resets the animation to start over
     3. Animation_step() - (optional) advance the animation once and renders. this differs from run only when there are more one iteration per render; useful for debugging.
     4. Animation_render() - render the current state of the animation system
  3. Support - (optional) utility routines that can be reused in each of the labs to follow. There are 3 classes:
     1. drawing geometry such as cubes and prisms, e.g.

          draw_cube()
        

     2. setting material properties, e.g.

          set_material("redPlastic");
        

     3. performing matrix and vector operations, e.g.

          set_matrix3x3_translate(m)
        

        you can either write your own or use a suitable library
     See below for more detailed examples.

The animation part of this lab is fairly trivial. This lab is mainly intended to get everybody to organize a simulation system and associated support routines that they can use in future labs and to make sure everyone has the programming and OpenGL skills necessary for the class.

Placve a red cube (+/- 0.5, +/- 0.5, +/- 0.5) 5 units along the x-axis at (5,0,0). Rotate it around the global y-axis and at the same time rotate around its own z-axis.

Draw a reasonable groundplane and y-axis. For example, represent the y-axis by a cube (+/- 0.5, +/- 10.0, +/- 0.5)

Each frame, update the angles by some reasonable constant.

To initialize:

• set 'a' to 0

To reset:

• set 'a' to 0

To step the animation:

• upate 'a' by the update constant

To render

• draw the groundplane and y-axis
• for the rotating cube, do the following transformation in order:
  • scale the cube appropriately
  • then rotate the cube around the z-axis by 'a' degrees
  • then translate the cube out 5 units along the x-axis
  • then rotate the cube 'a' degrees around the y-axis
  • draw the cube
  NOTE: in OpenGL you need to specify the transformation is reverse order.

throughout the quarter set up source code files for drawing geometry, set material properties, and (needed later) matrix operations

Geometry

for example,
draw-cube() - a routine that draws a cube in openGL

void  draw_cube()
{

  glShadeModel(GL_FLAT);

  // draw polygon at z=-1.0
  glBegin(GL_POLYGON);
  glNormal3f( 0.0, 0.0, -1.0);
  glVertex3f(-1.0,  1.0, -1.0);
  glVertex3f(-1.0, -1.0, -1.0);
  glVertex3f( 1.0, -1.0, -1.0);
  glVertex3f( 1.0,  1.0, -1.0);
  glEnd();

  // draw polygon at z= 1.0
  glBegin(GL_POLYGON);
  glNormal3f(0.0, 0.0 , 1.0);
  glVertex3f(-1.0,  1.0, 1.0);
  glVertex3f( 1.0,  1.0, 1.0);
  glVertex3f( 1.0, -1.0, 1.0);
  glVertex3f(-1.0, -1.0, 1.0);
  glEnd();

  // draw polygon at x= -1.0
  glBegin(GL_POLYGON);
  glNormal3f(-1.0,  0.0,  0.0);
  glVertex3f(-1.0,  1.0, 1.0);
  glVertex3f(-1.0, -1.0, 1.0);
  glVertex3f(-1.0, -1.0,-1.0);
  glVertex3f(-1.0,  1.0,-1.0);
  glEnd();

  // draw polygon at x= 1.0
  glBegin(GL_POLYGON);
  glNormal3f(1.0, 0.0, 0.0);
  glVertex3f( 1.0,  1.0, 1.0);
  glVertex3f( 1.0,  1.0,-1.0);
  glVertex3f( 1.0, -1.0,-1.0);
  glVertex3f( 1.0, -1.0, 1.0);
  glEnd();

  // draw polygon at y = 1.0
  glBegin(GL_POLYGON);
  glNormal3f(0.0, 1.0, 0.0);
  glVertex3f( 1.0,  1.0, 1.0);
  glVertex3f(-1.0,  1.0, 1.0);
  glVertex3f(-1.0,  1.0,-1.0);
  glVertex3f( 1.0,  1.0,-1.0);
  glEnd();

  // draw polygon at y = -1.0
  glBegin(GL_POLYGON);
  glNormal3f(0.0, -1.0, 0.0);
  glVertex3f( 1.0, -1.0,  1.0);
  glVertex3f( 1.0, -1.0, -1.0);
  glVertex3f(-1.0, -1.0, -1.0);
  glVertex3f(-1.0, -1.0,  1.0);
  glEnd();
}

material_td redPlastic = {
	0.4, 0.0, 0.0, 1.0 },
	0.6, 0.0, 0.0, 1.0 },
	0.0, 0.0, 0.0, 1.0 },
	0 }
	};

void  set_material(char *name)
{
  material_td *material;
  // printf("%s\\n",name);

  if (!strcmp(name,"redPlasticMaterial" )) material = &redPlastic;
  else if (!strcmp(name,"greenPlasticMaterial" )) material = &greenPlastic;
  else material = &redPlastic;

  glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT,material->ambient);
  glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE,material->diffuse);
  glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR,material->specular);
  glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, material->shininess);

}

    set_material("redPlasticMaterial");
    draw_cube();

Matrix/Vector Operations

Some useful operations would be to:

• set up identity, translation, rotation, and scale matrices
• multiply 3x3 matrices and matrix with a vector
• perform vector calculations such as cross product, dot product, normalize, length of a vector