void Moose::Spatial::COrientable::RotateLocal( float fRightAngle, float fUpAngle, float fForwardAngle ) { /* Get the Rotations from LOCAL axis */ CQuaternion qOne; qOne.CreateFromAxisAngle( m_vRight[0], m_vRight[1], m_vRight[2], fRightAngle ); CQuaternion qTwo; qTwo.CreateFromAxisAngle( m_vUpward[0], m_vUpward[1], m_vUpward[2], fUpAngle ); qOne = qTwo * qOne; qTwo.CreateFromAxisAngle( m_vForward[0], m_vForward[1], m_vForward[2], fForwardAngle ); qOne = qTwo * qOne; /* Apply the combined rotation to each vector */ RotateAllDirections(qOne); m_qRotation = qOne * m_qRotation; SetRotationChanged(1); }
void Moose::Spatial::COrientable::Rotate( float fXAngle, float fYAngle, float fZAngle ) { // get rotations CQuaternion qOne; qOne.CreateFromAxisAngle( 1.0, 0.0, 0.0, fXAngle ); CQuaternion qTwo; qTwo.CreateFromAxisAngle( 0.0, 1.0, 0.0, fYAngle ); qOne = qTwo * qOne; qTwo.CreateFromAxisAngle( 0.0, 0.0, 1.0, fZAngle ); qOne = qTwo * qOne; RotateAllDirections(qOne); m_qRotation = qOne * m_qRotation; SetRotationChanged(1); }
void Moose::Spatial::COrientable::RotateAroundZ( float degrees ) { CQuaternion q; q.CreateFromAxisAngle( 0.0f, 0.0f, 1.0f, degrees ); m_qRotation = q * m_qRotation; RotateAllDirections( q ); SetRotationChanged(1); }
void Moose::Spatial::COrientable::RotateAroundForward( float fDegrees ) { /* get rotations using local m_vForward */ CQuaternion q; q.CreateFromAxisAngle( m_vForward[0], m_vForward[1], m_vForward[2], fDegrees ); m_qRotation = q * m_qRotation; RotateVector(q,m_vRight); RotateVector(q,m_vUpward); SetRotationChanged(1); m_vRight.Normalize(); m_vUpward.Normalize(); }
void RenderScene() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear The Screen And The Depth Buffer glLoadIdentity(); // Reset The matrix /////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// * // Position View Up Vector gluLookAt(0, 1, 2, 0, 0, 0, 0, 1, 0); // This determines where the camera's position and view is // This sets our line width to %250, since 1 is %100 for normal line width glLineWidth(2.5f); // Turn off lighting so our line isn't effected by it glDisable(GL_LIGHTING); // Create a static variable to hold the increasing rotation static float rotation = 0; // Create a 4x4 matrix to be used to convert a quaternion to a matrix float matrix[16]; // Create a quaternion to rotate the line segment around the y-axis CQuaternion qRotationY; // Now we need to assign a rotation to our quaternion. Since a quaternion // isn't intuitive to us, we want to assign a rotation by an axis and angle. // This means, we give it an axis and an angle to rotate around that axis. // This is what glRotatef() takes as well. // Assign the y-axis and the current rotation to our quaternion. This will then // be converted to (x, y, z and w). At first you might think of the x, y, z and // w as the axis and angle, but it's not really. It's a 4D spherical rotation. qRotationY.CreateFromAxisAngle(0, 1, 0, rotation); // Once we have our desired rotation stored in a quaternion, in order for us to // do anything useful with it, we need to convert it to a matrix. This matrix // will then be multiplied by our current model view matrix, which performs the rotation. // Pass in our local matrix and store the rotation // matrix to be applied to our current matrix. qRotationY.CreateMatrix(matrix); // To apply our rotation, we multiply the new quaternion matrix by the current matrix. glMultMatrixf(matrix); // After applying the rotation, we now want to draw the line segment glBegin (GL_LINES); // This is our BEGIN to draw glColor3ub(255, 255, 0); // Make the Left vertex YELLOW glVertex3f(g_vLine[0].x, g_vLine[0].y, g_vLine[0].z); glColor3ub(255, 0, 0); // Make the Right vertex RED glVertex3f(g_vLine[1].x, g_vLine[1].y, g_vLine[1].z); glEnd(); // This is the END of drawing // Turn lighting back on for the sphere glEnable(GL_LIGHTING); // Instead of calculating the sphere ourselves, we are going to use quadrics. // Check out the tutorial on quadrics if this is confusing for you. // Allocate a quadric object to use as a sphere GLUquadricObj *pObj = gluNewQuadric(); // Get a Quadric off the stack // Here we create a quaternion that will be used to rotate the sphere around the line CQuaternion qSphereRotation; // Set the rotation of this quaternion to rotate around the x-axis with a faster rotation qSphereRotation.CreateFromAxisAngle(1, 0, 0, rotation * 8); // Once more, fill the matrix with the quaternion rotation matrix qSphereRotation.CreateMatrix(matrix); // Apply this matrix to our current matrix, which happens to still have the original // rotation that was applied from the line segment. This is how we get the sphere // to rotate around the line, wherever it goes. glMultMatrixf(matrix); // Turn the sphere green glColor3ub(0, 255, 0); // Move the sphere to it's current position. This can be changed by the arrow keys. // The higher the y position of the sphere, the large the radius of rotation the sphere // has around the line. glTranslatef(g_vPosition.x, g_vPosition.y, g_vPosition.z); // Draw the quadric as a sphere with the radius of .05 and a 15 by 15 detail. // To increase the detail of the sphere, just increase the 2 last parameters. gluSphere(pObj, .05f, 15, 15); // Free the Quadric gluDeleteQuadric(pObj); // Increase the rotation degree rotation++; /////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// * SwapBuffers(g_hDC); // Swap the backbuffers to the foreground }