Code:

float CalculateHorizontalDistance() {if (!mpPlayer) return 0.f;return distanceFromPlayer * glm::cos(glm::radians(-UpAngle));}float CalculateVerticalDistance() {if (!mpPlayer) return 0.f;return distanceFromPlayer * glm::sin(glm::radians(-UpAngle));}void calculateCameraPosition(float horizDistance, float verticDistance){float theta = mpPlayer->GetRotationY() + angleAroundPlayer;float offsetX = horizDistance * glm::sin(glm::radians(theta));float offsetZ = horizDistance * glm::cos(glm::radians(theta));Position.x = mpPlayer->GetPosition().x - offsetX;Position.y = mpPlayer->GetPosition().y + verticDistance;Position.z = mpPlayer->GetPosition().z - offsetZ;}

Code:

void updateCameraVectors(){// Yawglm::quat aroundY = glm::angleAxis(glm::radians(-RightAngle), glm::vec3(0, 1, 0));// Pitchglm::quat aroundX = glm::angleAxis(glm::radians(UpAngle), glm::vec3(1, 0, 0));// Rollglm::quat aroundZ = glm::angleAxis(glm::radians(RollAngle), glm::vec3(0, 0, 1));Orientation = aroundY * aroundX * aroundZ;glm::quat qF = Orientation * glm::quat(0, 0, 0, -1) * glm::conjugate(Orientation);Front = { qF.x, qF.y, qF.z };Right = glm::normalize(glm::cross(Front, WorldUp));Up = glm::normalize(glm::cross(Right, Front));}

Code:

glm::mat4 GetViewMatrix(){// You should know the camera move reversely relative to the user input.// That's the point of Graphics Cameraglm::quat reverseOrient = glm::conjugate(Orientation);glm::mat4 rot = glm::mat4_cast(reverseOrient);glm::mat4 translation = glm::translate(glm::mat4(1.0), -Position);return rot * translation;}

Code:

cameraTransform = spaceshipTransform * cameraTransformLocalFrame;

Code:

// Compute where the Camera is goingcameraTargetRotation = spaceshipRotation * cameraLocalRotation;// Compute the deltaRotation between where the Camera is, and where it wants to bedeltaRotation = cameraTargetRotation * cameraRotation.inverse();// Note: how did I know how to compute deltaRotation?// The trick is to imagine these rotations are operating FROM THE LEFT on a// hypothetical vector on the far RIGHT.  The inverse rotation operates first// and would rotate the vector into camera-local.  The second rotation would// rotate that result back into the world-frame exactly where it is targeted.// In other words: the end result would be deltaRotation.// We want to move the Camera toward its destination, but not the full delta.// This is where Quaternion's really shine.  We can calculate a "partial rotation"// in the right direction by interpolating on the 4D hypersphere.// We can either lerp (linear interpolate) which is fast or slerp (spherically interpolate)// which is slightly more CPU expensive.//// In any case we have to compute the the fraction of interpolation between 0 and 1.// Best to do this dynamically using the timestep between last frame since otherwise// the rate of Camera movement will be affected by the framerate of the simulation.// This is easy to tune by setting the natural exponential decay time.  Think of this// like a "half-life" however it is the time for the delta to reduce to 1/e of what// it was.  For fast slewing use a short timescale and for slow slewing increase the// timescale.const CAMERA_SLEW_TIMESCALE = 0.3; // seconds, tune this as necessaryfraction = timestep / CAMERA_SLEW_TIMESCSALE;if (fraction > 1.0) {    // DANGER! fractions greater than 1.0 are not stable    fraction = 1.0;}// Compute new cameraRotation//// DANGER! Quaternions have a discrepancy of two: for every valid rotation there// are two Quaternions on the hypersphere that map to it.  Normally this is not// a problem but it IS when interpolating between two Quaternions.  Always interpolate// between the nearest of the two.  To do this we check their dot-product and if it// is negative then they are on opposite hypersphers and we negate one of them// to the other side.if (deltaRotation.dot(cameraRotation) < 0.0) {    deltaRotation *= -1.0;}partialDeltaRotaton = identityRotation.slerp(deltaRotation, fraction);cameraRotation = partialDeltaRotation * cameraRotation;// DANGER! When multiplying two Quaternions together the result can be slightly non-normal// (unit length != 1.0).  This is not a problem when the result will be discarded after// it is used.  However, when a result is saved and used to recompute itself, like we're// doing here for for cameraRotation, then eventually floating point error will creep in// and we'll end up with Quaternions that cause linear distortions.  Therefore, it is// important to nomalize cameraRotation after each fresh computation.cameraRotation.normalize();

Code:

btScalar yaw;btScalar pitch;btScalar roll;body->getCenterOfMassTransform().getBasis().getEulerZYX(yaw, pitch, roll, 1);

Code:

glm::vec4 getRotation(btRigidBody* body){glm::vec4 Rotation;btQuaternion q = body->getCenterOfMassTransform().getRotation();btVector3 v = q.getAxis();Rotation.x = v.x();Rotation.y = v.y();Rotation.z = v.z();Rotation.w = q.getAngle();return Rotation;}float GetRotationY() {glm::vec4 Rotation = getRotation(mBody);return Rotation.y * Rotation.w; }