Miuna/j3ml-fork
1
0
Fork 0
forked from josh/j3ml
Code Pull Requests Activity

Implement ToQuat

Browse Source
This commit is contained in:
josh
2024-01-07 02:14:31 -05:00
parent a1d4df30c7
commit cc9ff95daa
5 changed files with 42 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
include/J3ML/LinearAlgebra/Matrix2x2.h
View File

@@ -12,10 +12,20 @@ namespace LinearAlgebra {
static const Matrix2x2 Identity; static const Matrix2x2 Identity;
static const Matrix2x2 NaN; static const Matrix2x2 NaN;
Matrix2x2() {}
Matrix2x2(float val);
Matrix2x2(float m00, float m01, float m10, float m11);
Matrix2x2(const Vector2& r1, const Vector2& r2);
Vector2 GetRow(int index) const; Vector2 GetRow(int index) const;
Vector2 GetColumn(int index) const; Vector2 GetColumn(int index) const;
float At(int x, int y) const; float At(int x, int y) const;
float Determinant() const;
Matrix2x2 Inverse() const;
Matrix2x2 Transpose() const;
Vector2 Transform(const Vector2& rhs) const;
Vector2 operator * (const Vector2& rhs) const; Vector2 operator * (const Vector2& rhs) const;
Matrix2x2 operator * (const Matrix2x2 &rhs) const; Matrix2x2 operator * (const Matrix2x2 &rhs) const;

4
include/J3ML/LinearAlgebra/Matrix3x3.h
View File

@@ -99,13 +99,9 @@ namespace LinearAlgebra {
Matrix3x3 Transpose() const; Matrix3x3 Transpose() const;
// Transforms the given vectors by this matrix M, i.e. returns M * (x,y,z) // Transforms the given vectors by this matrix M, i.e. returns M * (x,y,z)
Vector2 Transform(const Vector2& rhs) const; Vector2 Transform(const Vector2& rhs) const;
Vector3 Transform(const Vector3& rhs) const; Vector3 Transform(const Vector3& rhs) const;
Vector3 operator[] (float index) const;
Vector3 operator * (const Vector3& rhs) const; Vector3 operator * (const Vector3& rhs) const;
Matrix3x3 operator * (const Matrix3x3& rhs) const; Matrix3x3 operator * (const Matrix3x3& rhs) const;

2
include/J3ML/LinearAlgebra/Matrix4x4.h
View File

@@ -2,8 +2,6 @@
#include <J3ML/LinearAlgebra.h> #include <J3ML/LinearAlgebra.h>
namespace LinearAlgebra { namespace LinearAlgebra {
/// A 4-by-4 matrix for affine transformations and perspective projections of 3D geometry. /// A 4-by-4 matrix for affine transformations and perspective projections of 3D geometry.
/* This matrix can represent the most generic form of transformations for 3D objects, /* This matrix can represent the most generic form of transformations for 3D objects,

3
include/J3ML/LinearAlgebra/Vector3.h
View File

@@ -123,12 +123,9 @@ public:
Vector3 operator+() const; // TODO: Implement Vector3 operator+() const; // TODO: Implement
// Unary - operator (Negation) // Unary - operator (Negation)
Vector3 operator-() const; Vector3 operator-() const;
public: public:
float x = 0; float x = 0;
float y = 0; float y = 0;
float z = 0; float z = 0;
}; };
} }

54
tests/LinearAlgebra/Vector3Tests.cpp
View File

@@ -3,16 +3,23 @@
using Vector3 = LinearAlgebra::Vector3; using Vector3 = LinearAlgebra::Vector3;
void EXPECT_V3_EQ(const Vector3& lhs, const Vector3& rhs)
{
EXPECT_FLOAT_EQ(lhs.x, rhs.x);
EXPECT_FLOAT_EQ(lhs.y, rhs.y);
EXPECT_FLOAT_EQ(lhs.z, rhs.z);
}
TEST(Vector3Test, V3_Constructor_Default) TEST(Vector3Test, V3_Constructor_Default)
{ {
EXPECT_EQ(Vector3(), Vector3::Zero); EXPECT_V3_EQ(Vector3(), Vector3::Zero);
} }
TEST(Vector3Test, V3_Constructor_XYZ) TEST(Vector3Test, V3_Constructor_XYZ)
{ {
Vector3 Input {0, 1, 0}; Vector3 Input {0, 1, 0};
EXPECT_EQ(Input, Vector3::Down); EXPECT_V3_EQ(Input, Vector3::Down);
} }
TEST(Vector3Test, V3_Addition_Op) { TEST(Vector3Test, V3_Addition_Op) {
@@ -21,7 +28,7 @@ TEST(Vector3Test, V3_Addition_Op) {
Vector3 ExpectedResult {3,3,3}; Vector3 ExpectedResult {3,3,3};
EXPECT_EQ(A + B, ExpectedResult); EXPECT_V3_EQ(A + B, ExpectedResult);
} }
TEST(Vector3Test, V3_Addition_Method) { TEST(Vector3Test, V3_Addition_Method) {
Vector3 A {1,1,1}; Vector3 A {1,1,1};
@@ -29,7 +36,7 @@ TEST(Vector3Test, V3_Addition_Method) {
Vector3 ExpectedResult {3,3,3}; Vector3 ExpectedResult {3,3,3};
EXPECT_EQ(A.Add(B), ExpectedResult); EXPECT_V3_EQ(A.Add(B), ExpectedResult);
} }
TEST(Vector3Test, V3_Addition_Static) { TEST(Vector3Test, V3_Addition_Static) {
Vector3 A {1,1,1}; Vector3 A {1,1,1};
@@ -37,7 +44,7 @@ TEST(Vector3Test, V3_Addition_Static) {
Vector3 ExpectedResult {4,4,4}; Vector3 ExpectedResult {4,4,4};
EXPECT_EQ(Vector3::Add(A, B), ExpectedResult); EXPECT_V3_EQ(Vector3::Add(A, B), ExpectedResult);
} }
TEST(Vector3Test, V3_Subtract_Op) { TEST(Vector3Test, V3_Subtract_Op) {
Vector3 A {2,2,2}; Vector3 A {2,2,2};
@@ -45,7 +52,7 @@ TEST(Vector3Test, V3_Subtract_Op) {
Vector3 ExpectedResult {1.5f, 1.5f, 1.5f}; Vector3 ExpectedResult {1.5f, 1.5f, 1.5f};
EXPECT_EQ(A - B, ExpectedResult); EXPECT_V3_EQ(A - B, ExpectedResult);
} }
TEST(Vector3Test, V3_Subtract_Method) { TEST(Vector3Test, V3_Subtract_Method) {
Vector3 A {3,3,3}; Vector3 A {3,3,3};
@@ -53,7 +60,7 @@ TEST(Vector3Test, V3_Subtract_Method) {
Vector3 ExpectedResult {2,2,2}; Vector3 ExpectedResult {2,2,2};
EXPECT_EQ(A.Sub(B), ExpectedResult); EXPECT_V3_EQ(A.Sub(B), ExpectedResult);
} }
TEST(Vector3Test, V3_Subtract_Static) { TEST(Vector3Test, V3_Subtract_Static) {
Vector3 A {4,4,4}; Vector3 A {4,4,4};
@@ -61,7 +68,7 @@ TEST(Vector3Test, V3_Subtract_Static) {
Vector3 ExpectedResult {3,3,3}; Vector3 ExpectedResult {3,3,3};
EXPECT_EQ(Vector3::Sub(A, B), ExpectedResult); EXPECT_V3_EQ(Vector3::Sub(A, B), ExpectedResult);
} }
TEST(Vector3Test, V3_Scalar_Mult_Op) { TEST(Vector3Test, V3_Scalar_Mult_Op) {
Vector3 A { 1,1,1}; Vector3 A { 1,1,1};
@@ -69,7 +76,7 @@ TEST(Vector3Test, V3_Scalar_Mult_Op) {
Vector3 ExpectedResult {1.5f, 1.5f, 1.5f}; Vector3 ExpectedResult {1.5f, 1.5f, 1.5f};
EXPECT_EQ(A * B, ExpectedResult); EXPECT_V3_EQ(A * B, ExpectedResult);
} }
TEST(Vector3Test, V3_Scalar_Mult_Method) { TEST(Vector3Test, V3_Scalar_Mult_Method) {
Vector3 A {3,3,3}; Vector3 A {3,3,3};
@@ -77,7 +84,7 @@ TEST(Vector3Test, V3_Scalar_Mult_Method) {
Vector3 ExpectedResult {4.5f, 4.5f, 4.5f}; Vector3 ExpectedResult {4.5f, 4.5f, 4.5f};
EXPECT_EQ(A.Mul(B), ExpectedResult); EXPECT_V3_EQ(A.Mul(B), ExpectedResult);
} }
TEST(Vector3Test, V3_Scalar_Mult_Static) { TEST(Vector3Test, V3_Scalar_Mult_Static) {
Vector3 A {2,2,2}; Vector3 A {2,2,2};
@@ -85,21 +92,21 @@ TEST(Vector3Test, V3_Scalar_Mult_Static) {
Vector3 ExpectedResult {3.f, 3.f, 3.f}; Vector3 ExpectedResult {3.f, 3.f, 3.f};
EXPECT_EQ(Vector3::Mul(A, B), ExpectedResult); EXPECT_V3_EQ(Vector3::Mul(A, B), ExpectedResult);
} }
TEST(Vector3Test, V3_Scalar_Div_Op) { TEST(Vector3Test, V3_Scalar_Div_Op) {
Vector3 A {4,4,4}; Vector3 A {4,4,4};
float B = 2.f; float B = 2.f;
Vector3 ExpectedResult {2,2,2}; Vector3 ExpectedResult {2,2,2};
EXPECT_EQ(A / B, ExpectedResult); EXPECT_V3_EQ(A / B, ExpectedResult);
} }
TEST(Vector3Test, V3_Scalar_Div_Method) { TEST(Vector3Test, V3_Scalar_Div_Method) {
Vector3 A {6,6,6}; Vector3 A {6,6,6};
float B = 2.f; float B = 2.f;
Vector3 ExpectedResult { 3,3,3}; Vector3 ExpectedResult { 3,3,3};
EXPECT_EQ(A.Div(B), ExpectedResult); EXPECT_V3_EQ(A.Div(B), ExpectedResult);
} }
TEST(Vector3Test, V3_Scalar_Div_Static) { TEST(Vector3Test, V3_Scalar_Div_Static) {
Vector3 A {3,3,3}; Vector3 A {3,3,3};
@@ -107,7 +114,7 @@ TEST(Vector3Test, V3_Scalar_Div_Static) {
Vector3 ExpectedResult { 2.f, 2.f, 2.f}; Vector3 ExpectedResult { 2.f, 2.f, 2.f};
EXPECT_EQ(Vector3::Div(A, B), ExpectedResult); EXPECT_V3_EQ(Vector3::Div(A, B), ExpectedResult);
} }
TEST(Vector3Test, V3_Sizeof) { TEST(Vector3Test, V3_Sizeof) {
EXPECT_EQ(sizeof(Vector3), 12); EXPECT_EQ(sizeof(Vector3), 12);
@@ -121,14 +128,14 @@ TEST(Vector3Test, V3_Min) {
Vector3 Minimum {3,3,3}; Vector3 Minimum {3,3,3};
Vector3 ExpectedResult {2,2,2}; Vector3 ExpectedResult {2,2,2};
EXPECT_EQ(Input.Min(Minimum), ExpectedResult); EXPECT_V3_EQ(Input.Min(Minimum), ExpectedResult);
} }
TEST(Vector3Test, V3_Max) { TEST(Vector3Test, V3_Max) {
Vector3 Input {2,2,2}; Vector3 Input {2,2,2};
Vector3 Maximum {3,3,3}; Vector3 Maximum {3,3,3};
Vector3 ExpectedResult {3,3,3}; Vector3 ExpectedResult {3,3,3};
EXPECT_EQ(Input.Max(Maximum), ExpectedResult); EXPECT_V3_EQ(Input.Max(Maximum), ExpectedResult);
} }
TEST(Vector3Test, V3_Clamp) { TEST(Vector3Test, V3_Clamp) {
Vector3 Input {5,-1,8}; Vector3 Input {5,-1,8};
@@ -137,7 +144,7 @@ TEST(Vector3Test, V3_Clamp) {
Vector3 ExpectedResult {5,1,5}; Vector3 ExpectedResult {5,1,5};
EXPECT_EQ(Input.Clamp(Minimum, Maximum), ExpectedResult); EXPECT_V3_EQ(Input.Clamp(Minimum, Maximum), ExpectedResult);
} }
TEST(Vector3Test, V3_DotProduct) { TEST(Vector3Test, V3_DotProduct) {
@@ -155,7 +162,7 @@ TEST(Vector3Test, V3_CrossProduct) {
Vector3 ExpectedResult {0,0,0}; Vector3 ExpectedResult {0,0,0};
EXPECT_EQ(A.Cross(B), ExpectedResult); EXPECT_V3_EQ(A.Cross(B), ExpectedResult);
} }
TEST(Vector3Test, V3_Project) { TEST(Vector3Test, V3_Project) {
@@ -167,7 +174,7 @@ TEST(Vector3Test, V3_Normalize) {
Vector3 Input {2, 0, 0}; Vector3 Input {2, 0, 0};
Vector3 ExpectedResult {1, 0, 0}; Vector3 ExpectedResult {1, 0, 0};
EXPECT_EQ(Input, ExpectedResult); EXPECT_V3_EQ(Input.Normalize(), ExpectedResult);
} }
TEST(Vector3Test, V3_Lerp) TEST(Vector3Test, V3_Lerp)
{ {
@@ -175,13 +182,16 @@ TEST(Vector3Test, V3_Lerp)
Vector3 Finish {}; Vector3 Finish {};
float Percent = 50; float Percent = 50;
Vector3 ExpectedResult {}; Vector3 ExpectedResult {};
EXPECT_EQ(Start.Lerp(Finish, Percent), ExpectedResult); EXPECT_V3_EQ(Start.Lerp(Finish, Percent), ExpectedResult);
} }
TEST(Vector3Test, V3_AngleBetween) { TEST(Vector3Test, V3_AngleBetween) {
Vector3 A{ .5f, .5f, .5f}; Vector3 A{ .5f, .5f, .5f};
Vector3 B {.25f, .75f, .25f}; Vector3 B {.25f, .75f, .25f};
A = A.Normalize(); A = A.Normalize();
B = B.Normalize(); B = B.Normalize();
LinearAlgebra::Angle2D ExpectedResult {0,0}; LinearAlgebra::Angle2D ExpectedResult {-0.697914, -2.35619};
EXPECT_EQ(A.AngleBetween(B), ExpectedResult); std::cout << A.AngleBetween(B).x << ", " << A.AngleBetween(B).y << "";
auto angle = A.AngleBetween(B);
EXPECT_FLOAT_EQ(angle.x, ExpectedResult.x);
EXPECT_FLOAT_EQ(angle.y, ExpectedResult.y);
} }