From 4f646be2d08fb214cbb25ddbce30614f42d2b989 Mon Sep 17 00:00:00 2001 From: Kearwood Kip Gilbert Date: Sat, 29 Jul 2017 18:02:43 -0700 Subject: [PATCH] /s/KRQuaternion/Quaternion/ --- kraken/KRModel.cpp | 2 +- kraken/KRNode.cpp | 22 +- kraken/KRNode.h | 6 +- kraken/KRScene.cpp | 2 +- kraken/matrix4.cpp | 445 ++++++++++++++++++ kraken/public/KRTriangle3.h | 6 +- kraken/public/kraken.h | 4 +- kraken/public/matrix4.h | 115 +++++ .../public/{KRQuaternion.h => quaternion.h} | 66 +-- kraken/{KRQuaternion.cpp => quaternion.cpp} | 98 ++-- kraken_win/kraken.vcxproj | 4 +- kraken_win/kraken.vcxproj.filters | 12 +- 12 files changed, 671 insertions(+), 111 deletions(-) create mode 100644 kraken/matrix4.cpp create mode 100644 kraken/public/matrix4.h rename kraken/public/{KRQuaternion.h => quaternion.h} (56%) rename kraken/{KRQuaternion.cpp => quaternion.cpp} (73%) mode change 100755 => 100644 diff --git a/kraken/KRModel.cpp b/kraken/KRModel.cpp index 85b7f24..ab85b3a 100755 --- a/kraken/KRModel.cpp +++ b/kraken/KRModel.cpp @@ -200,7 +200,7 @@ void KRModel::render(KRCamera *pCamera, std::vector &point_light if(m_faces_camera) { Vector3 model_center = Matrix4::Dot(matModel, Vector3::Zero()); Vector3 camera_pos = viewport.getCameraPosition(); - matModel = KRQuaternion(Vector3::Forward(), Vector3::Normalize(camera_pos - model_center)).rotationMatrix() * matModel; + matModel = Quaternion(Vector3::Forward(), Vector3::Normalize(camera_pos - model_center)).rotationMatrix() * matModel; } pModel->render(getName(), pCamera, point_lights, directional_lights, spot_lights, viewport, matModel, m_pLightMap, renderPass, m_bones[pModel], m_rim_color, m_rim_power, lod_coverage); diff --git a/kraken/KRNode.cpp b/kraken/KRNode.cpp index 0f4a981..591ea56 100755 --- a/kraken/KRNode.cpp +++ b/kraken/KRNode.cpp @@ -213,7 +213,7 @@ void KRNode::setWorldTranslation(const Vector3 &v) void KRNode::setWorldRotation(const Vector3 &v) { if(m_parentNode) { - setLocalRotation((KRQuaternion(v) * -m_parentNode->getWorldRotation()).eulerXYZ()); + setLocalRotation((Quaternion(v) * -m_parentNode->getWorldRotation()).eulerXYZ()); setPreRotation(Vector3::Zero()); setPostRotation(Vector3::Zero()); } else { @@ -543,7 +543,7 @@ const Matrix4 &KRNode::getModelMatrix() * Matrix4::Translation(m_scalingPivot) * Matrix4::Translation(m_scalingOffset) * Matrix4::Translation(-m_rotationPivot) - //* (KRQuaternion(m_postRotation) * KRQuaternion(m_localRotation) * KRQuaternion(m_preRotation)).rotationMatrix() + //* (Quaternion(m_postRotation) * Quaternion(m_localRotation) * Quaternion(m_preRotation)).rotationMatrix() * Matrix4::Rotation(m_postRotation) * Matrix4::Rotation(m_localRotation) * Matrix4::Rotation(m_preRotation) @@ -565,7 +565,7 @@ const Matrix4 &KRNode::getModelMatrix() * Matrix4::Translation(m_scalingPivot) * Matrix4::Translation(m_scalingOffset) * Matrix4::Translation(-m_rotationPivot) - //* (KRQuaternion(m_postRotation) * KRQuaternion(m_localRotation) * KRQuaternion(m_preRotation)).rotationMatrix() + //* (Quaternion(m_postRotation) * Quaternion(m_localRotation) * Quaternion(m_preRotation)).rotationMatrix() * Matrix4::Rotation(m_postRotation) * Matrix4::Rotation(m_localRotation) * Matrix4::Rotation(m_preRotation) @@ -600,7 +600,7 @@ const Matrix4 &KRNode::getBindPoseMatrix() * Matrix4::Translation(m_initialScalingPivot) * Matrix4::Translation(m_initialScalingOffset) * Matrix4::Translation(-m_initialRotationPivot) - //* (KRQuaternion(m_initialPostRotation) * KRQuaternion(m_initialLocalRotation) * KRQuaternion(m_initialPreRotation)).rotationMatrix() + //* (Quaternion(m_initialPostRotation) * Quaternion(m_initialLocalRotation) * Quaternion(m_initialPreRotation)).rotationMatrix() * Matrix4::Rotation(m_initialPostRotation) * Matrix4::Rotation(m_initialLocalRotation) * Matrix4::Rotation(m_initialPreRotation) @@ -623,7 +623,7 @@ const Matrix4 &KRNode::getBindPoseMatrix() * Matrix4::Translation(m_initialScalingPivot) * Matrix4::Translation(m_initialScalingOffset) * Matrix4::Translation(-m_initialRotationPivot) - // * (KRQuaternion(m_initialPostRotation) * KRQuaternion(m_initialLocalRotation) * KRQuaternion(m_initialPreRotation)).rotationMatrix() + // * (Quaternion(m_initialPostRotation) * Quaternion(m_initialLocalRotation) * Quaternion(m_initialPreRotation)).rotationMatrix() * Matrix4::Rotation(m_initialPostRotation) * Matrix4::Rotation(m_initialLocalRotation) * Matrix4::Rotation(m_initialPreRotation) @@ -701,24 +701,24 @@ const Matrix4 &KRNode::getActivePoseMatrix() } -const KRQuaternion KRNode::getWorldRotation() { - KRQuaternion world_rotation = KRQuaternion(m_postRotation) * KRQuaternion(m_localRotation) * KRQuaternion(m_preRotation); +const Quaternion KRNode::getWorldRotation() { + Quaternion world_rotation = Quaternion(m_postRotation) * Quaternion(m_localRotation) * Quaternion(m_preRotation); if(m_parentNode) { world_rotation = world_rotation * m_parentNode->getWorldRotation(); } return world_rotation; } -const KRQuaternion KRNode::getBindPoseWorldRotation() { - KRQuaternion world_rotation = KRQuaternion(m_initialPostRotation) * KRQuaternion(m_initialLocalRotation) * KRQuaternion(m_initialPreRotation); +const Quaternion KRNode::getBindPoseWorldRotation() { + Quaternion world_rotation = Quaternion(m_initialPostRotation) * Quaternion(m_initialLocalRotation) * Quaternion(m_initialPreRotation); if(dynamic_cast(m_parentNode)) { world_rotation = world_rotation * m_parentNode->getBindPoseWorldRotation(); } return world_rotation; } -const KRQuaternion KRNode::getActivePoseWorldRotation() { - KRQuaternion world_rotation = KRQuaternion(m_postRotation) * KRQuaternion(m_localRotation) * KRQuaternion(m_preRotation); +const Quaternion KRNode::getActivePoseWorldRotation() { + Quaternion world_rotation = Quaternion(m_postRotation) * Quaternion(m_localRotation) * Quaternion(m_preRotation); if(dynamic_cast(m_parentNode)) { world_rotation = world_rotation * m_parentNode->getActivePoseWorldRotation(); } diff --git a/kraken/KRNode.h b/kraken/KRNode.h index 2ddadbe..3859826 100755 --- a/kraken/KRNode.h +++ b/kraken/KRNode.h @@ -111,10 +111,10 @@ public: const Vector3 getWorldTranslation(); const Vector3 getWorldScale(); - const KRQuaternion getWorldRotation(); + const Quaternion getWorldRotation(); - const KRQuaternion getBindPoseWorldRotation(); - const KRQuaternion getActivePoseWorldRotation(); + const Quaternion getBindPoseWorldRotation(); + const Quaternion getActivePoseWorldRotation(); const Vector3 localToWorld(const Vector3 &local_point); const Vector3 worldToLocal(const Vector3 &world_point); diff --git a/kraken/KRScene.cpp b/kraken/KRScene.cpp index 9e65df6..8fd613e 100755 --- a/kraken/KRScene.cpp +++ b/kraken/KRScene.cpp @@ -565,7 +565,7 @@ void KRScene::addDefaultLights() { KRDirectionalLight *light1 = new KRDirectionalLight(*this, "default_light1"); - light1->setLocalRotation((KRQuaternion(Vector3(0.0, M_PI * 0.10, 0.0)) * KRQuaternion(Vector3(0.0, 0.0, -M_PI * 0.15))).eulerXYZ()); + light1->setLocalRotation((Quaternion(Vector3(0.0, M_PI * 0.10, 0.0)) * Quaternion(Vector3(0.0, 0.0, -M_PI * 0.15))).eulerXYZ()); m_pRootNode->addChild(light1); } diff --git a/kraken/matrix4.cpp b/kraken/matrix4.cpp new file mode 100644 index 0000000..7e56545 --- /dev/null +++ b/kraken/matrix4.cpp @@ -0,0 +1,445 @@ +// +// Matrix4.cpp +// KREngine +// +// Copyright 2012 Kearwood Gilbert. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without modification, are +// permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this list of +// conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, this list +// of conditions and the following disclaimer in the documentation and/or other materials +// provided with the distribution. +// +// THIS SOFTWARE IS PROVIDED BY KEARWOOD GILBERT ''AS IS'' AND ANY EXPRESS OR IMPLIED +// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL KEARWOOD GILBERT OR +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// The views and conclusions contained in the software and documentation are those of the +// authors and should not be interpreted as representing official policies, either expressed +// or implied, of Kearwood Gilbert. +// + +#include "KREngine-common.h" + +#include "public/Matrix4.h" + +Matrix4::Matrix4() { + // Default constructor - Initialize with an identity matrix + static const float IDENTITY_MATRIX[] = { + 1.0, 0.0, 0.0, 0.0, + 0.0, 1.0, 0.0, 0.0, + 0.0, 0.0, 1.0, 0.0, + 0.0, 0.0, 0.0, 1.0 + }; + memcpy(c, IDENTITY_MATRIX, sizeof(float) * 16); + +} + +Matrix4::Matrix4(float *pMat) { + memcpy(c, pMat, sizeof(float) * 16); +} + +Matrix4::Matrix4(const Vector3 &axis_x, const Vector3 &axis_y, const Vector3 &axis_z, const Vector3 &trans) +{ + c[0] = axis_x.x; c[1] = axis_x.y; c[2] = axis_x.z; c[3] = 0.0f; + c[4] = axis_y.x; c[5] = axis_y.y; c[6] = axis_y.z; c[7] = 0.0f; + c[8] = axis_z.x; c[9] = axis_z.y; c[10] = axis_z.z; c[11] = 0.0f; + c[12] = trans.x; c[13] = trans.y; c[14] = trans.z; c[15] = 1.0f; +} + +Matrix4::~Matrix4() { + +} + +float *Matrix4::getPointer() { + return c; +} + +// Copy constructor +Matrix4::Matrix4(const Matrix4 &m) { + memcpy(c, m.c, sizeof(float) * 16); +} + +Matrix4& Matrix4::operator=(const Matrix4 &m) { + if(this != &m) { // Prevent self-assignment. + memcpy(c, m.c, sizeof(float) * 16); + } + return *this; +} + +float& Matrix4::operator[](unsigned i) { + return c[i]; +} + +float Matrix4::operator[](unsigned i) const { + return c[i]; +} + +// Overload comparison operator +bool Matrix4::operator==(const Matrix4 &m) const { + return memcmp(c, m.c, sizeof(float) * 16) == 0; +} + +// Overload compound multiply operator +Matrix4& Matrix4::operator*=(const Matrix4 &m) { + float temp[16]; + + int x,y; + + for (x=0; x < 4; x++) + { + for(y=0; y < 4; y++) + { + temp[y + (x*4)] = (c[x*4] * m.c[y]) + + (c[(x*4)+1] * m.c[y+4]) + + (c[(x*4)+2] * m.c[y+8]) + + (c[(x*4)+3] * m.c[y+12]); + } + } + + memcpy(c, temp, sizeof(float) << 4); + return *this; +} + +// Overload multiply operator +Matrix4 Matrix4::operator*(const Matrix4 &m) const { + Matrix4 ret = *this; + ret *= m; + return ret; +} + + +/* Generate a perspective view matrix using a field of view angle fov, + * window aspect ratio, near and far clipping planes */ +void Matrix4::perspective(float fov, float aspect, float nearz, float farz) { + + memset(c, 0, sizeof(float) * 16); + + float range= tan(fov * 0.5) * nearz; + c[0] = (2 * nearz) / ((range * aspect) - (-range * aspect)); + c[5] = (2 * nearz) / (2 * range); + c[10] = -(farz + nearz) / (farz - nearz); + c[11] = -1; + c[14] = -(2 * farz * nearz) / (farz - nearz); + /* + float range= atan(fov / 20.0f) * nearz; + float r = range * aspect; + float t = range * 1.0; + + c[0] = nearz / r; + c[5] = nearz / t; + c[10] = -(farz + nearz) / (farz - nearz); + c[11] = -(2.0 * farz * nearz) / (farz - nearz); + c[14] = -1.0; + */ +} + +/* Perform translation operations on a matrix */ +void Matrix4::translate(float x, float y, float z) { + Matrix4 newMatrix; // Create new identity matrix + + newMatrix.c[12] = x; + newMatrix.c[13] = y; + newMatrix.c[14] = z; + + *this *= newMatrix; +} + +void Matrix4::translate(const Vector3 &v) +{ + translate(v.x, v.y, v.z); +} + +/* Rotate a matrix by an angle on a X, Y, or Z axis */ +void Matrix4::rotate(float angle, AXIS axis) { + const int cos1[3] = { 5, 0, 0 }; // cos(angle) + const int cos2[3] = { 10, 10, 5 }; // cos(angle) + const int sin1[3] = { 9, 2, 4 }; // -sin(angle) + const int sin2[3] = { 6, 8, 1 }; // sin(angle) + + /* + X_AXIS: + + 1, 0, 0, 0 + 0, cos(angle), -sin(angle), 0 + 0, sin(angle), cos(angle), 0 + 0, 0, 0, 1 + + Y_AXIS: + + cos(angle), 0, -sin(angle), 0 + 0, 1, 0, 0 + sin(angle), 0, cos(angle), 0 + 0, 0, 0, 1 + + Z_AXIS: + + cos(angle), -sin(angle), 0, 0 + sin(angle), cos(angle), 0, 0 + 0, 0, 1, 0 + 0, 0, 0, 1 + + */ + + Matrix4 newMatrix; // Create new identity matrix + + newMatrix.c[cos1[axis]] = cos(angle); + newMatrix.c[sin1[axis]] = -sin(angle); + newMatrix.c[sin2[axis]] = -newMatrix.c[sin1[axis]]; + newMatrix.c[cos2[axis]] = newMatrix.c[cos1[axis]]; + + *this *= newMatrix; +} + +void Matrix4::rotate(const Quaternion &q) +{ + *this *= q.rotationMatrix(); +} + +/* Scale matrix by separate x, y, and z amounts */ +void Matrix4::scale(float x, float y, float z) { + Matrix4 newMatrix; // Create new identity matrix + + newMatrix.c[0] = x; + newMatrix.c[5] = y; + newMatrix.c[10] = z; + + *this *= newMatrix; +} + +void Matrix4::scale(const Vector3 &v) { + scale(v.x, v.y, v.z); +} + +/* Scale all dimensions equally */ +void Matrix4::scale(float s) { + scale(s,s,s); +} + + // Initialize with a bias matrix +void Matrix4::bias() { + static const float BIAS_MATRIX[] = { + 0.5, 0.0, 0.0, 0.0, + 0.0, 0.5, 0.0, 0.0, + 0.0, 0.0, 0.5, 0.0, + 0.5, 0.5, 0.5, 1.0 + }; + memcpy(c, BIAS_MATRIX, sizeof(float) * 16); +} + + +/* Generate an orthographic view matrix */ +void Matrix4::ortho(float left, float right, float top, float bottom, float nearz, float farz) { + memset(c, 0, sizeof(float) * 16); + c[0] = 2.0f / (right - left); + c[5] = 2.0f / (bottom - top); + c[10] = -1.0f / (farz - nearz); + c[11] = -nearz / (farz - nearz); + c[15] = 1.0f; +} + +/* Replace matrix with its inverse */ +bool Matrix4::invert() { + // Based on gluInvertMatrix implementation + + float inv[16], det; + int i; + + inv[0] = c[5]*c[10]*c[15] - c[5]*c[11]*c[14] - c[9]*c[6]*c[15] + + c[9]*c[7]*c[14] + c[13]*c[6]*c[11] - c[13]*c[7]*c[10]; + inv[4] = -c[4]*c[10]*c[15] + c[4]*c[11]*c[14] + c[8]*c[6]*c[15] + - c[8]*c[7]*c[14] - c[12]*c[6]*c[11] + c[12]*c[7]*c[10]; + inv[8] = c[4]*c[9]*c[15] - c[4]*c[11]*c[13] - c[8]*c[5]*c[15] + + c[8]*c[7]*c[13] + c[12]*c[5]*c[11] - c[12]*c[7]*c[9]; + inv[12] = -c[4]*c[9]*c[14] + c[4]*c[10]*c[13] + c[8]*c[5]*c[14] + - c[8]*c[6]*c[13] - c[12]*c[5]*c[10] + c[12]*c[6]*c[9]; + inv[1] = -c[1]*c[10]*c[15] + c[1]*c[11]*c[14] + c[9]*c[2]*c[15] + - c[9]*c[3]*c[14] - c[13]*c[2]*c[11] + c[13]*c[3]*c[10]; + inv[5] = c[0]*c[10]*c[15] - c[0]*c[11]*c[14] - c[8]*c[2]*c[15] + + c[8]*c[3]*c[14] + c[12]*c[2]*c[11] - c[12]*c[3]*c[10]; + inv[9] = -c[0]*c[9]*c[15] + c[0]*c[11]*c[13] + c[8]*c[1]*c[15] + - c[8]*c[3]*c[13] - c[12]*c[1]*c[11] + c[12]*c[3]*c[9]; + inv[13] = c[0]*c[9]*c[14] - c[0]*c[10]*c[13] - c[8]*c[1]*c[14] + + c[8]*c[2]*c[13] + c[12]*c[1]*c[10] - c[12]*c[2]*c[9]; + inv[2] = c[1]*c[6]*c[15] - c[1]*c[7]*c[14] - c[5]*c[2]*c[15] + + c[5]*c[3]*c[14] + c[13]*c[2]*c[7] - c[13]*c[3]*c[6]; + inv[6] = -c[0]*c[6]*c[15] + c[0]*c[7]*c[14] + c[4]*c[2]*c[15] + - c[4]*c[3]*c[14] - c[12]*c[2]*c[7] + c[12]*c[3]*c[6]; + inv[10] = c[0]*c[5]*c[15] - c[0]*c[7]*c[13] - c[4]*c[1]*c[15] + + c[4]*c[3]*c[13] + c[12]*c[1]*c[7] - c[12]*c[3]*c[5]; + inv[14] = -c[0]*c[5]*c[14] + c[0]*c[6]*c[13] + c[4]*c[1]*c[14] + - c[4]*c[2]*c[13] - c[12]*c[1]*c[6] + c[12]*c[2]*c[5]; + inv[3] = -c[1]*c[6]*c[11] + c[1]*c[7]*c[10] + c[5]*c[2]*c[11] + - c[5]*c[3]*c[10] - c[9]*c[2]*c[7] + c[9]*c[3]*c[6]; + inv[7] = c[0]*c[6]*c[11] - c[0]*c[7]*c[10] - c[4]*c[2]*c[11] + + c[4]*c[3]*c[10] + c[8]*c[2]*c[7] - c[8]*c[3]*c[6]; + inv[11] = -c[0]*c[5]*c[11] + c[0]*c[7]*c[9] + c[4]*c[1]*c[11] + - c[4]*c[3]*c[9] - c[8]*c[1]*c[7] + c[8]*c[3]*c[5]; + inv[15] = c[0]*c[5]*c[10] - c[0]*c[6]*c[9] - c[4]*c[1]*c[10] + + c[4]*c[2]*c[9] + c[8]*c[1]*c[6] - c[8]*c[2]*c[5]; + + det = c[0]*inv[0] + c[1]*inv[4] + c[2]*inv[8] + c[3]*inv[12]; + + if (det == 0) { + return false; + } + + det = 1.0 / det; + + for (i = 0; i < 16; i++) { + c[i] = inv[i] * det; + } + + return true; +} + +void Matrix4::transpose() { + float trans[16]; + for(int x=0; x<4; x++) { + for(int y=0; y<4; y++) { + trans[x + y * 4] = c[y + x * 4]; + } + } + memcpy(c, trans, sizeof(float) * 16); +} + +/* Dot Product, returning Vector3 */ +Vector3 Matrix4::Dot(const Matrix4 &m, const Vector3 &v) { + return Vector3( + v.c[0] * m.c[0] + v.c[1] * m.c[4] + v.c[2] * m.c[8] + m.c[12], + v.c[0] * m.c[1] + v.c[1] * m.c[5] + v.c[2] * m.c[9] + m.c[13], + v.c[0] * m.c[2] + v.c[1] * m.c[6] + v.c[2] * m.c[10] + m.c[14] + ); +} + +Vector4 Matrix4::Dot4(const Matrix4 &m, const Vector4 &v) { +#ifdef KRAKEN_USE_ARM_NEON + + Vector4 d; + asm volatile ( + "vld1.32 {d0, d1}, [%1] \n\t" //Q0 = v + "vld1.32 {d18, d19}, [%0]! \n\t" //Q1 = m + "vld1.32 {d20, d21}, [%0]! \n\t" //Q2 = m+4 + "vld1.32 {d22, d23}, [%0]! \n\t" //Q3 = m+8 + "vld1.32 {d24, d25}, [%0]! \n\t" //Q4 = m+12 + + "vmul.f32 q13, q9, d0[0] \n\t" //Q5 = Q1*Q0[0] + "vmla.f32 q13, q10, d0[1] \n\t" //Q5 += Q1*Q0[1] + "vmla.f32 q13, q11, d1[0] \n\t" //Q5 += Q2*Q0[2] + "vmla.f32 q13, q12, d1[1] \n\t" //Q5 += Q3*Q0[3] + + "vst1.32 {d26, d27}, [%2] \n\t" //Q4 = m+12 + : /* no output registers */ + : "r"(m.c), "r"(v.c), "r"(d.c) + : "q0", "q9", "q10","q11", "q12", "q13", "memory" + ); + return d; +#else + return Vector4( + v.c[0] * m.c[0] + v.c[1] * m.c[4] + v.c[2] * m.c[8] + m.c[12], + v.c[0] * m.c[1] + v.c[1] * m.c[5] + v.c[2] * m.c[9] + m.c[13], + v.c[0] * m.c[2] + v.c[1] * m.c[6] + v.c[2] * m.c[10] + m.c[14], + v.c[0] * m.c[3] + v.c[1] * m.c[7] + v.c[2] * m.c[11] + m.c[15] + ); +#endif +} + +// Dot product without including translation; useful for transforming normals and tangents +Vector3 Matrix4::DotNoTranslate(const Matrix4 &m, const Vector3 &v) +{ + return Vector3( + v.x * m.c[0] + v.y * m.c[4] + v.z * m.c[8], + v.x * m.c[1] + v.y * m.c[5] + v.z * m.c[9], + v.x * m.c[2] + v.y * m.c[6] + v.z * m.c[10] + ); +} + +/* Dot Product, returning w component as if it were a Vector4 (This will be deprecated once Vector4 is implemented instead*/ +float Matrix4::DotW(const Matrix4 &m, const Vector3 &v) { + return v.x * m.c[0*4 + 3] + v.y * m.c[1*4 + 3] + v.z * m.c[2*4 + 3] + m.c[3*4 + 3]; +} + +/* Dot Product followed by W-divide */ +Vector3 Matrix4::DotWDiv(const Matrix4 &m, const Vector3 &v) { + Vector4 r = Dot4(m, Vector4(v, 1.0f)); + return Vector3(r) / r.w; +} + +Matrix4 Matrix4::LookAt(const Vector3 &cameraPos, const Vector3 &lookAtPos, const Vector3 &upDirection) +{ + Matrix4 matLookat; + Vector3 lookat_z_axis = lookAtPos - cameraPos; + lookat_z_axis.normalize(); + Vector3 lookat_x_axis = Vector3::Cross(upDirection, lookat_z_axis); + lookat_x_axis.normalize(); + Vector3 lookat_y_axis = Vector3::Cross(lookat_z_axis, lookat_x_axis); + + matLookat.getPointer()[0] = lookat_x_axis.x; + matLookat.getPointer()[1] = lookat_y_axis.x; + matLookat.getPointer()[2] = lookat_z_axis.x; + + matLookat.getPointer()[4] = lookat_x_axis.y; + matLookat.getPointer()[5] = lookat_y_axis.y; + matLookat.getPointer()[6] = lookat_z_axis.y; + + matLookat.getPointer()[8] = lookat_x_axis.z; + matLookat.getPointer()[9] = lookat_y_axis.z; + matLookat.getPointer()[10] = lookat_z_axis.z; + + matLookat.getPointer()[12] = -Vector3::Dot(lookat_x_axis, cameraPos); + matLookat.getPointer()[13] = -Vector3::Dot(lookat_y_axis, cameraPos); + matLookat.getPointer()[14] = -Vector3::Dot(lookat_z_axis, cameraPos); + + return matLookat; +} + +Matrix4 Matrix4::Invert(const Matrix4 &m) +{ + Matrix4 matInvert = m; + matInvert.invert(); + return matInvert; +} + +Matrix4 Matrix4::Transpose(const Matrix4 &m) +{ + Matrix4 matTranspose = m; + matTranspose.transpose(); + return matTranspose; +} + +Matrix4 Matrix4::Translation(const Vector3 &v) +{ + Matrix4 m; + m[12] = v.x; + m[13] = v.y; + m[14] = v.z; +// m.translate(v); + return m; +} + +Matrix4 Matrix4::Rotation(const Vector3 &v) +{ + Matrix4 m; + m.rotate(v.x, X_AXIS); + m.rotate(v.y, Y_AXIS); + m.rotate(v.z, Z_AXIS); + return m; +} + +Matrix4 Matrix4::Scaling(const Vector3 &v) +{ + Matrix4 m; + m.scale(v); + return m; +} + diff --git a/kraken/public/KRTriangle3.h b/kraken/public/KRTriangle3.h index 68dd2b3..fa8d30b 100644 --- a/kraken/public/KRTriangle3.h +++ b/kraken/public/KRTriangle3.h @@ -29,8 +29,8 @@ // or implied, of Kearwood Gilbert. // -#ifndef KRTRIANGLE3_H -#define KRTRIANGLE3_H +#ifndef KRAKEN_TRIANGLE3_H +#define KRAKEN_TRIANGLE3_H #include "Vector3.h" @@ -62,4 +62,4 @@ public: } // namespace kraken -#endif // KRTRIANGLE3_H +#endif // KRAKEN_TRIANGLE3_H diff --git a/kraken/public/kraken.h b/kraken/public/kraken.h index 3efce16..fc83638 100644 --- a/kraken/public/kraken.h +++ b/kraken/public/kraken.h @@ -5,8 +5,8 @@ #include "vector2.h" #include "vector3.h" #include "vector4.h" -#include "Matrix4.h" -#include "KRQuaternion.h" +#include "matrix4.h" +#include "quaternion.h" #include "KRAABB.h" #include "KRTriangle3.h" diff --git a/kraken/public/matrix4.h b/kraken/public/matrix4.h new file mode 100644 index 0000000..c84ee0a --- /dev/null +++ b/kraken/public/matrix4.h @@ -0,0 +1,115 @@ +// +// Matrix4.h +// Kraken +// +// Copyright 2017 Kearwood Gilbert. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without modification, are +// permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this list of +// conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, this list +// of conditions and the following disclaimer in the documentation and/or other materials +// provided with the distribution. +// +// THIS SOFTWARE IS PROVIDED BY KEARWOOD GILBERT ''AS IS'' AND ANY EXPRESS OR IMPLIED +// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL KEARWOOD GILBERT OR +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// The views and conclusions contained in the software and documentation are those of the +// authors and should not be interpreted as representing official policies, either expressed +// or implied, of Kearwood Gilbert. +// + + +#include "vector3.h" +#include "vector4.h" + +#ifndef KRAKEN_MATRIX4_H +#define KRAKEN_MATRIX4_H + +namespace kraken { + +typedef enum { + X_AXIS, + Y_AXIS, + Z_AXIS +} AXIS; + +class Quaternion; + +class Matrix4 { +public: + + float c[16]; // Matrix components, in column-major order + + // Default constructor - Creates an identity matrix + Matrix4(); + + Matrix4(float *pMat); + + Matrix4(const Vector3 &axis_x, const Vector3 &axis_y, const Vector3 &axis_z, const Vector3 &trans); + + // Destructor + ~Matrix4(); + + // Copy constructor + Matrix4(const Matrix4 &m); + + // Overload assignment operator + Matrix4& operator=(const Matrix4 &m); + + // Overload comparison operator + bool operator==(const Matrix4 &m) const; + + // Overload compound multiply operator + Matrix4& operator*=(const Matrix4 &m); + + float& operator[](unsigned i); + float operator[](unsigned i) const; + + // Overload multiply operator + //Matrix4& operator*(const Matrix4 &m); + Matrix4 operator*(const Matrix4 &m) const; + + float *getPointer(); + + void perspective(float fov, float aspect, float nearz, float farz); + void ortho(float left, float right, float top, float bottom, float nearz, float farz); + void translate(float x, float y, float z); + void translate(const Vector3 &v); + void scale(float x, float y, float z); + void scale(const Vector3 &v); + void scale(float s); + void rotate(float angle, AXIS axis); + void rotate(const Quaternion &q); + void bias(); + bool invert(); + void transpose(); + + static Vector3 DotNoTranslate(const Matrix4 &m, const Vector3 &v); // Dot product without including translation; useful for transforming normals and tangents + static Matrix4 Invert(const Matrix4 &m); + static Matrix4 Transpose(const Matrix4 &m); + static Vector3 Dot(const Matrix4 &m, const Vector3 &v); + static Vector4 Dot4(const Matrix4 &m, const Vector4 &v); + static float DotW(const Matrix4 &m, const Vector3 &v); + static Vector3 DotWDiv(const Matrix4 &m, const Vector3 &v); + + static Matrix4 LookAt(const Vector3 &cameraPos, const Vector3 &lookAtPos, const Vector3 &upDirection); + + static Matrix4 Translation(const Vector3 &v); + static Matrix4 Rotation(const Vector3 &v); + static Matrix4 Scaling(const Vector3 &v); +}; + +} // namespace kraken + +#endif // KRAKEN_MATRIX4_H diff --git a/kraken/public/KRQuaternion.h b/kraken/public/quaternion.h similarity index 56% rename from kraken/public/KRQuaternion.h rename to kraken/public/quaternion.h index 8e0f4b7..3561869 100644 --- a/kraken/public/KRQuaternion.h +++ b/kraken/public/quaternion.h @@ -1,5 +1,5 @@ // -// KRQuaternion.h +// Quaternion.h // KREngine // // Copyright 2012 Kearwood Gilbert. All rights reserved. @@ -29,40 +29,40 @@ // or implied, of Kearwood Gilbert. // -#ifndef KRQUATERNION_H -#define KRQUATERNION_H +#ifndef KRAKEN_QUATERNION_H +#define KRAKEN_QUATERNION_H -#include "Vector3.h" +#include "vector3.h" namespace kraken { -class KRQuaternion { +class Quaternion { public: - KRQuaternion(); - KRQuaternion(float w, float x, float y, float z); - KRQuaternion(const KRQuaternion& p); - KRQuaternion(const Vector3 &euler); - KRQuaternion(const Vector3 &from_vector, const Vector3 &to_vector); - ~KRQuaternion(); + Quaternion(); + Quaternion(float w, float x, float y, float z); + Quaternion(const Quaternion& p); + Quaternion(const Vector3 &euler); + Quaternion(const Vector3 &from_vector, const Vector3 &to_vector); + ~Quaternion(); - KRQuaternion& operator =( const KRQuaternion& p ); - KRQuaternion operator +(const KRQuaternion &v) const; - KRQuaternion operator -(const KRQuaternion &v) const; - KRQuaternion operator +() const; - KRQuaternion operator -() const; + Quaternion& operator =( const Quaternion& p ); + Quaternion operator +(const Quaternion &v) const; + Quaternion operator -(const Quaternion &v) const; + Quaternion operator +() const; + Quaternion operator -() const; - KRQuaternion operator *(const KRQuaternion &v); - KRQuaternion operator *(float num) const; - KRQuaternion operator /(float num) const; + Quaternion operator *(const Quaternion &v); + Quaternion operator *(float num) const; + Quaternion operator /(float num) const; - KRQuaternion& operator +=(const KRQuaternion& v); - KRQuaternion& operator -=(const KRQuaternion& v); - KRQuaternion& operator *=(const KRQuaternion& v); - KRQuaternion& operator *=(const float& v); - KRQuaternion& operator /=(const float& v); + Quaternion& operator +=(const Quaternion& v); + Quaternion& operator -=(const Quaternion& v); + Quaternion& operator *=(const Quaternion& v); + Quaternion& operator *=(const float& v); + Quaternion& operator /=(const float& v); - friend bool operator ==(KRQuaternion &v1, KRQuaternion &v2); - friend bool operator !=(KRQuaternion &v1, KRQuaternion &v2); + friend bool operator ==(Quaternion &v1, Quaternion &v2); + friend bool operator !=(Quaternion &v1, Quaternion &v2); float& operator [](unsigned i); float operator [](unsigned i) const; @@ -72,19 +72,19 @@ public: Matrix4 rotationMatrix() const; void normalize(); - static KRQuaternion Normalize(const KRQuaternion &v1); + static Quaternion Normalize(const Quaternion &v1); void conjugate(); - static KRQuaternion Conjugate(const KRQuaternion &v1); + static Quaternion Conjugate(const Quaternion &v1); - static KRQuaternion FromAngleAxis(const Vector3 &axis, float angle); - static KRQuaternion Lerp(const KRQuaternion &a, const KRQuaternion &b, float t); - static KRQuaternion Slerp(const KRQuaternion &a, const KRQuaternion &b, float t); - static float Dot(const KRQuaternion &v1, const KRQuaternion &v2); + static Quaternion FromAngleAxis(const Vector3 &axis, float angle); + static Quaternion Lerp(const Quaternion &a, const Quaternion &b, float t); + static Quaternion Slerp(const Quaternion &a, const Quaternion &b, float t); + static float Dot(const Quaternion &v1, const Quaternion &v2); private: float m_val[4]; }; } // namespace kraken -#endif // KRQUATERNION_H +#endif // KRAKEN_QUATERNION_H diff --git a/kraken/KRQuaternion.cpp b/kraken/quaternion.cpp old mode 100755 new mode 100644 similarity index 73% rename from kraken/KRQuaternion.cpp rename to kraken/quaternion.cpp index 2765588..03e1438 --- a/kraken/KRQuaternion.cpp +++ b/kraken/quaternion.cpp @@ -1,5 +1,5 @@ // -// KRQuaternion.cpp +// Quaternion.cpp // KREngine // // Copyright 2012 Kearwood Gilbert. All rights reserved. @@ -35,28 +35,28 @@ namespace kraken { -KRQuaternion::KRQuaternion() { +Quaternion::Quaternion() { m_val[0] = 1.0; m_val[1] = 0.0; m_val[2] = 0.0; m_val[3] = 0.0; } -KRQuaternion::KRQuaternion(float w, float x, float y, float z) { +Quaternion::Quaternion(float w, float x, float y, float z) { m_val[0] = w; m_val[1] = x; m_val[2] = y; m_val[3] = z; } -KRQuaternion::KRQuaternion(const KRQuaternion& p) { +Quaternion::Quaternion(const Quaternion& p) { m_val[0] = p[0]; m_val[1] = p[1]; m_val[2] = p[2]; m_val[3] = p[3]; } -KRQuaternion& KRQuaternion::operator =( const KRQuaternion& p ) { +Quaternion& Quaternion::operator =( const Quaternion& p ) { m_val[0] = p[0]; m_val[1] = p[1]; m_val[2] = p[2]; @@ -64,11 +64,11 @@ KRQuaternion& KRQuaternion::operator =( const KRQuaternion& p ) { return *this; } -KRQuaternion::KRQuaternion(const Vector3 &euler) { +Quaternion::Quaternion(const Vector3 &euler) { setEulerZYX(euler); } -KRQuaternion::KRQuaternion(const Vector3 &from_vector, const Vector3 &to_vector) { +Quaternion::Quaternion(const Vector3 &from_vector, const Vector3 &to_vector) { Vector3 a = Vector3::Cross(from_vector, to_vector); m_val[0] = a[0]; @@ -78,18 +78,18 @@ KRQuaternion::KRQuaternion(const Vector3 &from_vector, const Vector3 &to_vector) normalize(); } -KRQuaternion::~KRQuaternion() { +Quaternion::~Quaternion() { } -void KRQuaternion::setEulerXYZ(const Vector3 &euler) +void Quaternion::setEulerXYZ(const Vector3 &euler) { - *this = KRQuaternion::FromAngleAxis(Vector3(1.0f, 0.0f, 0.0f), euler.x) - * KRQuaternion::FromAngleAxis(Vector3(0.0f, 1.0f, 0.0f), euler.y) - * KRQuaternion::FromAngleAxis(Vector3(0.0f, 0.0f, 1.0f), euler.z); + *this = Quaternion::FromAngleAxis(Vector3(1.0f, 0.0f, 0.0f), euler.x) + * Quaternion::FromAngleAxis(Vector3(0.0f, 1.0f, 0.0f), euler.y) + * Quaternion::FromAngleAxis(Vector3(0.0f, 0.0f, 1.0f), euler.z); } -void KRQuaternion::setEulerZYX(const Vector3 &euler) { +void Quaternion::setEulerZYX(const Vector3 &euler) { // ZYX Order! float c1 = cos(euler[0] * 0.5f); float c2 = cos(euler[1] * 0.5f); @@ -104,15 +104,15 @@ void KRQuaternion::setEulerZYX(const Vector3 &euler) { m_val[3] = c1 * c2 * s3 - s1 * s2 * c3; } -float KRQuaternion::operator [](unsigned i) const { +float Quaternion::operator [](unsigned i) const { return m_val[i]; } -float &KRQuaternion::operator [](unsigned i) { +float &Quaternion::operator [](unsigned i) { return m_val[i]; } -Vector3 KRQuaternion::eulerXYZ() const { +Vector3 Quaternion::eulerXYZ() const { double a2 = 2 * (m_val[0] * m_val[2] - m_val[1] * m_val[3]); if(a2 <= -0.99999) { return Vector3( @@ -137,7 +137,7 @@ Vector3 KRQuaternion::eulerXYZ() const { } -bool operator ==(KRQuaternion &v1, KRQuaternion &v2) { +bool operator ==(Quaternion &v1, Quaternion &v2) { return v1[0] == v2[0] && v1[1] == v2[1] @@ -145,7 +145,7 @@ bool operator ==(KRQuaternion &v1, KRQuaternion &v2) { && v1[3] == v2[3]; } -bool operator !=(KRQuaternion &v1, KRQuaternion &v2) { +bool operator !=(Quaternion &v1, Quaternion &v2) { return v1[0] != v2[0] || v1[1] != v2[1] @@ -153,7 +153,7 @@ bool operator !=(KRQuaternion &v1, KRQuaternion &v2) { || v1[3] != v2[3]; } -KRQuaternion KRQuaternion::operator *(const KRQuaternion &v) { +Quaternion Quaternion::operator *(const Quaternion &v) { float t0 = (m_val[3]-m_val[2])*(v[2]-v[3]); float t1 = (m_val[0]+m_val[1])*(v[0]+v[1]); float t2 = (m_val[0]-m_val[1])*(v[2]+v[3]); @@ -165,7 +165,7 @@ KRQuaternion KRQuaternion::operator *(const KRQuaternion &v) { float t8 = t5+t6+t7; float t9 = (t4+t8)/2; - return KRQuaternion( + return Quaternion( t0+t9-t5, t1+t9-t8, t2+t9-t7, @@ -173,24 +173,24 @@ KRQuaternion KRQuaternion::operator *(const KRQuaternion &v) { ); } -KRQuaternion KRQuaternion::operator *(float v) const { - return KRQuaternion(m_val[0] * v, m_val[1] * v, m_val[2] * v, m_val[3] * v); +Quaternion Quaternion::operator *(float v) const { + return Quaternion(m_val[0] * v, m_val[1] * v, m_val[2] * v, m_val[3] * v); } -KRQuaternion KRQuaternion::operator /(float num) const { +Quaternion Quaternion::operator /(float num) const { float inv_num = 1.0f / num; - return KRQuaternion(m_val[0] * inv_num, m_val[1] * inv_num, m_val[2] * inv_num, m_val[3] * inv_num); + return Quaternion(m_val[0] * inv_num, m_val[1] * inv_num, m_val[2] * inv_num, m_val[3] * inv_num); } -KRQuaternion KRQuaternion::operator +(const KRQuaternion &v) const { - return KRQuaternion(m_val[0] + v[0], m_val[1] + v[1], m_val[2] + v[2], m_val[3] + v[3]); +Quaternion Quaternion::operator +(const Quaternion &v) const { + return Quaternion(m_val[0] + v[0], m_val[1] + v[1], m_val[2] + v[2], m_val[3] + v[3]); } -KRQuaternion KRQuaternion::operator -(const KRQuaternion &v) const { - return KRQuaternion(m_val[0] - v[0], m_val[1] - v[1], m_val[2] - v[2], m_val[3] - v[3]); +Quaternion Quaternion::operator -(const Quaternion &v) const { + return Quaternion(m_val[0] - v[0], m_val[1] - v[1], m_val[2] - v[2], m_val[3] - v[3]); } -KRQuaternion& KRQuaternion::operator +=(const KRQuaternion& v) { +Quaternion& Quaternion::operator +=(const Quaternion& v) { m_val[0] += v[0]; m_val[1] += v[1]; m_val[2] += v[2]; @@ -198,7 +198,7 @@ KRQuaternion& KRQuaternion::operator +=(const KRQuaternion& v) { return *this; } -KRQuaternion& KRQuaternion::operator -=(const KRQuaternion& v) { +Quaternion& Quaternion::operator -=(const Quaternion& v) { m_val[0] -= v[0]; m_val[1] -= v[1]; m_val[2] -= v[2]; @@ -206,7 +206,7 @@ KRQuaternion& KRQuaternion::operator -=(const KRQuaternion& v) { return *this; } -KRQuaternion& KRQuaternion::operator *=(const KRQuaternion& v) { +Quaternion& Quaternion::operator *=(const Quaternion& v) { float t0 = (m_val[3]-m_val[2])*(v[2]-v[3]); float t1 = (m_val[0]+m_val[1])*(v[0]+v[1]); float t2 = (m_val[0]-m_val[1])*(v[2]+v[3]); @@ -226,7 +226,7 @@ KRQuaternion& KRQuaternion::operator *=(const KRQuaternion& v) { return *this; } -KRQuaternion& KRQuaternion::operator *=(const float& v) { +Quaternion& Quaternion::operator *=(const float& v) { m_val[0] *= v; m_val[1] *= v; m_val[2] *= v; @@ -234,7 +234,7 @@ KRQuaternion& KRQuaternion::operator *=(const float& v) { return *this; } -KRQuaternion& KRQuaternion::operator /=(const float& v) { +Quaternion& Quaternion::operator /=(const float& v) { float inv_v = 1.0f / v; m_val[0] *= inv_v; m_val[1] *= inv_v; @@ -243,17 +243,17 @@ KRQuaternion& KRQuaternion::operator /=(const float& v) { return *this; } -KRQuaternion KRQuaternion::operator +() const { +Quaternion Quaternion::operator +() const { return *this; } -KRQuaternion KRQuaternion::operator -() const { - return KRQuaternion(-m_val[0], -m_val[1], -m_val[2], -m_val[3]); +Quaternion Quaternion::operator -() const { + return Quaternion(-m_val[0], -m_val[1], -m_val[2], -m_val[3]); } -KRQuaternion Normalize(const KRQuaternion &v1) { +Quaternion Normalize(const Quaternion &v1) { float inv_magnitude = 1.0f / sqrtf(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2] + v1[3] * v1[3]); - return KRQuaternion( + return Quaternion( v1[0] * inv_magnitude, v1[1] * inv_magnitude, v1[2] * inv_magnitude, @@ -261,7 +261,7 @@ KRQuaternion Normalize(const KRQuaternion &v1) { ); } -void KRQuaternion::normalize() { +void Quaternion::normalize() { float inv_magnitude = 1.0f / sqrtf(m_val[0] * m_val[0] + m_val[1] * m_val[1] + m_val[2] * m_val[2] + m_val[3] * m_val[3]); m_val[0] *= inv_magnitude; m_val[1] *= inv_magnitude; @@ -269,17 +269,17 @@ void KRQuaternion::normalize() { m_val[3] *= inv_magnitude; } -KRQuaternion Conjugate(const KRQuaternion &v1) { - return KRQuaternion(v1[0], -v1[1], -v1[2], -v1[3]); +Quaternion Conjugate(const Quaternion &v1) { + return Quaternion(v1[0], -v1[1], -v1[2], -v1[3]); } -void KRQuaternion::conjugate() { +void Quaternion::conjugate() { m_val[1] = -m_val[1]; m_val[2] = -m_val[2]; m_val[3] = -m_val[3]; } -Matrix4 KRQuaternion::rotationMatrix() const { +Matrix4 Quaternion::rotationMatrix() const { Matrix4 matRotate; /* @@ -309,19 +309,19 @@ Matrix4 KRQuaternion::rotationMatrix() const { } -KRQuaternion KRQuaternion::FromAngleAxis(const Vector3 &axis, float angle) +Quaternion Quaternion::FromAngleAxis(const Vector3 &axis, float angle) { float ha = angle * 0.5f; float sha = sin(ha); - return KRQuaternion(cos(ha), axis.x * sha, axis.y * sha, axis.z * sha); + return Quaternion(cos(ha), axis.x * sha, axis.y * sha, axis.z * sha); } -float KRQuaternion::Dot(const KRQuaternion &v1, const KRQuaternion &v2) +float Quaternion::Dot(const Quaternion &v1, const Quaternion &v2) { return v1.m_val[0] * v2.m_val[0] + v1.m_val[1] * v2.m_val[1] + v1.m_val[2] * v2.m_val[2] + v1.m_val[3] * v2.m_val[3]; } -KRQuaternion KRQuaternion::Lerp(const KRQuaternion &a, const KRQuaternion &b, float t) +Quaternion Quaternion::Lerp(const Quaternion &a, const Quaternion &b, float t) { if (t <= 0.0f) { return a; @@ -332,7 +332,7 @@ KRQuaternion KRQuaternion::Lerp(const KRQuaternion &a, const KRQuaternion &b, fl return a * (1.0f - t) + b * t; } -KRQuaternion KRQuaternion::Slerp(const KRQuaternion &a, const KRQuaternion &b, float t) +Quaternion Quaternion::Slerp(const Quaternion &a, const Quaternion &b, float t) { if (t <= 0.0f) { return a; @@ -343,7 +343,7 @@ KRQuaternion KRQuaternion::Slerp(const KRQuaternion &a, const KRQuaternion &b, f } float coshalftheta = Dot(a, b); - KRQuaternion c = a; + Quaternion c = a; // Angle is greater than 180. We can negate the angle/quat to get the // shorter rotation to reach the same destination. diff --git a/kraken_win/kraken.vcxproj b/kraken_win/kraken.vcxproj index 1d008c2..9c55038 100755 --- a/kraken_win/kraken.vcxproj +++ b/kraken_win/kraken.vcxproj @@ -171,7 +171,7 @@ - + @@ -275,7 +275,7 @@ - + diff --git a/kraken_win/kraken.vcxproj.filters b/kraken_win/kraken.vcxproj.filters index 2f47495..a73a49e 100755 --- a/kraken_win/kraken.vcxproj.filters +++ b/kraken_win/kraken.vcxproj.filters @@ -42,9 +42,6 @@ Source Files - - Source Files - Source Files @@ -252,6 +249,9 @@ Source Files + + Source Files + @@ -482,9 +482,6 @@ Header Files\public - - Header Files\public - Header Files\public @@ -500,5 +497,8 @@ Header Files\public + + Header Files\public + \ No newline at end of file