图形、游戏开发OPENGL的源代码

//********************************************************************************// // // // - "Talk to me like I'm a 3 year old!" Programming Lessons - // // // // $Author: DigiBen digiben@gametutorials.com // // // // $Program: MD3 Animation // // // // $Description: Demonstrates animating Quake3 characters with quaternions // // // // $Date: 3/28/02 // // // //********************************************************************************// #include "main.h" #include "Md3.h" //////////// *** NEW *** ////////// *** NEW *** ///////////// *** NEW *** //////////////////// /////////////////////////////////////////////////////////////////////////////////// // // This version of the tutorial incorporates the animation data stored in the MD3 // character files. We will be reading in the .cfg file that stores the animation // data. The rotations and translations of the models will be done using a matrix. // There will be no more calls to glTranslatef(). To create the rotation and // translation matrix, quaternions will be used. This is because quaternions // are excellent for interpolating between 2 rotations, as well as not overriding // another translation causing "gimbal lock". // // So, why do we need to interpolate? Well, the animations for the character are // stored in key frames. Instead of saving each frame of an animation, key frames // are stored to cut down on memory and disk space. The files would be huge if every // frame was saved for every animation, as well as creating a huge memory footprint. // Can you imagine having 10+ models in memory with all of that animation data? // // The animation key frames are stored in 2 ways. The torso and legs mesh have vertices // stored for each of the key frames, along with separate rotations and translations // for the basic bone animation. Remember, that each .md3 represents a bone, that needs // to be connected at a joint. For instance, the torso is connected to the legs, and the // head is connected to the torso. So, that makes 3 bones and 2 joints. If you add the // weapon, the weapon is connected to the hand joint, which gives us 4 bones and 3 joints. // Unlike conventional skeletal animation systems, the main animations of the character's // movement, such as a gesture or swimming animation, are done not with bones, but with // vertex key frames, like in the .md2 format. Since the lower, upper, head and weapon models // are totally different models, which aren't seamlessly connected to each other, then parent // node needs to end a message (a translation and rotation) down to all it's child nodes to // tell them where they need to be in order for the animation to look right. A good example // of this is when the legs has the DEATH3 animation set, The legs might kick back into a back // flip that lands the character on their face, dead. Well, since the main models are separate, // if the legs didn't tell the torso where to go, then the model's torso would stay in the same // place and the body would detach itself from the legs. The exporter calculates all this stuff // for you of course. // // But getting back to the interpolation, since we use key frames, if we didn't interpolate // between them, the animation would look very jumping and unnatural. It would also go too // fast. By interpolating, we create a smooth transition between each key frame. // // As seen in the .md2 tutorials, interpolating between vertices is easy if we use the // linear interpolation function: p(t) = p0 + t(p1 - p0). The same goes for translations, // since it's just 2 3D points. This is not so for the rotations. The Quake3 character // stores the rotations for each key frame in a 3x3 matrix. This isn't a simple linear // interpolation that needs to be performed. If we convert the matrices to a quaternion, // then use spherical linear interpolation (SLERP) between the current frame's quaternion // and the next key frame's quaternion, we will have a new interpolated quaternion that // can be converted into a 4x4 matrix to be applied to the current model view matrix in OpenGL. // After finding the interpolated translation to be applied, we can slip that into the rotation // matrix before it's applied to the current matrix, which will require only one matrix command. // // You'll notice that in the CreateFromMatrix() function in our quaternion class, I allow a // row and column count to be passed in. This is just a dirty way to allow a 3x3 or 4x4 matrix // to be passed in. Instead of creating a whole new function and copy and pasting the main // code, it seemed fitting for a tutorial. It's obvious that the quaternion class is missing // a tremendous amount of functions, but I chose to only keep the functions that we would use. // // For those of you who don't know what interpolation us, here is a section abstracted // from the MD2 Animation tutorial: // // ------------------------------------------------------------------------------------- // Interpolation: Gamedev.net's Game Dictionary say interpolation is "using a ratio // to step gradually a variable from one value to another." In our case, this // means that we gradually move our vertices from one key frame to another key frame. // There are many types of interpolation, but we are just going to use linear. // The equation for linear interpolation is this: // // p(t) = p0 + t(p1 - p0) // // t - The current time with 0 being the start and 1 being the end // p(t) - The result of the equation with time t // p0 - The starting position // p1 - The ending position // // Let's throw in an example with numbers to test this equation. If we have // a vertex stored at 0 along the X axis and we wanted to move the point to // 10 with 5 steps, see if you can fill in the equation without a time just yet. // // Finished? You should have come up with: // // p(t) = 0 + t(10 - 0) // p(t) = 0 + 10t // p(t) = 10t // // Now, all we need it a time from 0 to 1 to pass in, which will allow us to find any // point from 0 to 10, depending on the time. Since we wanted to find out the distance // we need to travel each frame if we want to reach the end point in 5 steps, we just // divide 1 by 5: 1/5 = 0.2 // // We can then pass this into our equation: // // p(0.2) = 10 * 0.2 // p(0.2) = 2 // // What does that tell us? It tells us we need to move the vertex along the x // axis each frame by a distance of 2 to reach 10 in 5 steps. Yah yah, this isn't // rocket science, but it's important to know that what your mind would have done // immediately without thinking about it, is linear interpolation. // // Are you starting to see how this applies to our model? If we only read in key // frames, then we need to interpolate every vertex between the current and next // key frame for animation. To get a perfect idea of what is going on, try // taking out the interpolation and just render the key frames. You will notice // that you can still see what is kinda going on, but it moves at an incredible pace! // There is not smoothness, just a really fast jumpy animation. // ------------------------------------------------------------------------------------ // // Let's jump into the code (hold your breath!) // // ////////////////////////////// CREATE MATRIX \\\\\\\\\\\\\\\\\\\\\\\\\\\\\* ///// ///// This function converts a quaternion to a rotation matrix ///// ////////////////////////////// CREATE MATRIX \\\\\\\\\\\\\\\\\\\\\\\\\\\\\* void CQuaternion::CreateMatrix(float *pMatrix) { // Make sure the matrix has allocated memory to store the rotation data if(!pMatrix) return; // Fill in the rows of the 4x4 m