Animating 3D Polygon Meshes

• We're going to transform each part of the mesh using a matrix.  Each matrix is called a 'bone', since there's usually one for each semi-rigid part of the mesh.  It's easier to give the animating locations of a few dozen bones than all the thousands of vertices in the mesh, and you can add 'inverse kinematics' to simplify the bone animation process--drag a hand around, and the elbow and shoulder positions can update automatically.
  
• We identify how much of each bone applies to each vertex by painting vertex weights on, one for each bone.  The part of the mesh right next to the bone will have weight 1.0, and far away parts will have weight 0.0.
  

1. Create a meshed polygon object (see last lecture).
   
2. Create an "Armature" containing "Bones" for each part of the mesh you want to move.  Start by Add -> Armature -> Single Bone, and then enter edit mode and hit shift-A to make new bones in that armature.  Line up the bones with the major parts of the mesh, and add names for the bones.
   
3. Select the mesh in Object mode, and add an Armature modifier to the mesh.  Set the "Object" to the armature you just created.  Bind to Vertex Groups, not Envelope.   DON'T HIT APPLY!  This will bake the bone deformations into the mesh--you want to leave the armature modifier active to be able to move the bones around and have the mesh follow it.
   
4. Enter Weight Paint mode, and paint the parts of the mesh you want to move with each bone.  This is the proportion of each bone to use to transform each vertex, and so it ranges from zero (bone does not affect vertex) to one (bone totally defines location of vertex).  Feather the edges, so the mesh deforms smoothly.  Name the vertex groups (paint colors) the same as each of your bones--Blender matches bones to vertex groups using the names.  (It would probably be better to use the 'bone envelopes' to initially create the vertex weights, and then tweak them as needed, but I haven't figured out how to do this yet.)
   
5. Finally, to move the parts of the meshed object, select the armature, enter 'Pose Mode', and move the bone around.  The mesh should move with the bones!  You can still go back and tweak the bone weights.

Vertex Buffer Object

• size, the number of floats per vertex (usually 3; it's hardcoded to 3 for glNormalPointer!)
  
• type, the data type (usually GL_FLOAT, occasionally GL_SHORT to save space, or even GL_BYTE for colors)
• stride, the distance in bytes between each vertex's data.  This is usually sizeof(yourVertexStruct).
• pointer, the distance in bytes from the start of the buffer to the corresponding vertex data.  This is zero for the first element, 12 for the second vec3 (because you have to skip over the first), 24 for the third vec3, and so on.  This is passed as a "void *", and back in the pre-vertexbuffer days could point directly to CPU data, but now you pass the buffer data separately.

	static GLuint vb=0; 
	if (vb==0) { /* set up the vertex buffer object */
		glGenBuffersARB(1,&vb);  /* make a buffer */
		glBindBufferARB(GL_ARRAY_BUFFER_ARB,vb);
		 /* Copy our vtx array (on the CPU) into our new GPU buffer */
		glBufferDataARB(GL_ARRAY_BUFFER_ARB,sizeof(myVertex)*vtx.size(),
			&vtx[0],GL_STATIC_DRAW_ARB);

		/* Tell OpenGL how our array is laid out */
		glEnableClientState(GL_VERTEX_ARRAY);
 		glVertexPointer(3,GL_FLOAT,sizeof(vtx[0]), (void *)0); /* myVertex.xyz is first thing in struct */
		glEnableClientState(GL_COLOR_ARRAY);
		glColorPointer (3,GL_FLOAT,sizeof(vtx[0]), (void *)12); /* myVertex.color starts 12 bytes after struct start */
		glBindBufferARB(GL_ARRAY_BUFFER_ARB,0); /* back to plain OpenGL */
	}
	/* Draw all our (GPU) points.  
	   This is way faster than looping over vtx and calling glVertex many times! */
	glBindBufferARB(GL_ARRAY_BUFFER_ARB,vb);
	glDrawArrays(GL_POINTS,0,vtx.size());
	glBindBufferARB(GL_ARRAY_BUFFER_ARB,0);

	static GLuint eb=0; 
	if (eb==0) { /* set up the element buffer object */
		glGenBuffersARB(1,&eb);  /* make a buffer */
		glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,vb);
		 /* Copy our idx array (on the CPU) into our new GPU buffer */
		glBufferDataARB(GL_ARRAY_BUFFER_ARB,sizeof(int)*idx.size(),
			&idx[0],GL_STATIC_DRAW_ARB);
		glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,0); /* back to plain OpenGL */
	}
	glBindBufferARB(GL_ARRAY_BUFFER_ARB,vb); /* vertex data */
	glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,eb); /* index data */
	glDrawElements(GL_TRIANGLES,idx.size(),GL_UNSIGNED_INT,0);
	glBindBufferARB(GL_ARRAY_BUFFER_ARB,0);
	glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,0);