Large Restructure and Organization x2

include/J3ML/LinearAlgebra.h

@@ -1,76 +1,30 @@
+//// Dawsh Linear Algebra Library - Everything you need for 3D math
+/// @file LinearAlgebra.h
+/// @description Includes all LinearAlgebra classes and functions
+/// @author Josh O'Leary, William Tomasine II
+/// @copyright 2024 Redacted Software
+/// @license Unlicense - Public Domain
+/// @revision 1.3
+/// @edited 2024-02-26
+
 #pragma once
-#include <cstdint>
-#include <cmath>
-#include <cstdlib>
-#include <algorithm>
-#include <functional>
-
-
-namespace J3ML::Math
-{
-    const float Pi = M_PI;
-    inline float Radians(float degrees) { return degrees * (Pi/180.f); }
-    inline float Degrees(float radians) { return radians * (180.f/Pi); }
-
-
-    struct NumberRange
-    {
-        float LowerBound;
-        float UpperBound;
-    };
-
-
-    float NormalizeToRange(float input, float fromLower, float fromUpper, float toLower, float toUpper);
-    float NormalizeToRange(float input, const NumberRange& from, const NumberRange& to);
-    // auto rotation_normalized = NormalizeToRange(inp, {0, 360}, {-1, 1});
-    inline float Lerp(float a, float b, float t);
-
-}
-
-
-// Dawsh Linear Algebra Library - Everything you need for 3D math
-namespace J3ML::LinearAlgebra {
-    class Vector2; // A type representing a position in a 2-dimensional coordinate space.
-    class Vector3; // A type representing a position in a 3-dimensional coordinate space.
-    class Vector4; // A type representing a position in a 4-dimensional coordinate space.
-    class Angle2D; // Uses x,y components to represent a 2D rotation.
-    class EulerAngle; // Uses pitch,yaw,roll components to represent a 3D orientation.
-    class AxisAngle; //
-    class CoordinateFrame; //
-    class Matrix2x2;
-    class Matrix3x3;
-    class Matrix4x4;
-    class Transform2D;
-    class Transform3D;
-    class Quaternion;
-
-
-    using Position = Vector3;
-}
 
 // TODO: Enforce Style Consistency (Function Names use MicroSoft Case)
-
+// TODO: Implement Templated Linear Algebra
-// Note: Josh Linear Algebra Types are designed as Immutable Data Types
-// x, y, z, w, etc. values should not and can not be set directly.
-// rather, you just construct a new type and assign it.
-// This might sound ass-backwards for many object types.
-// But mathematically, a vector or matrix is defined by it's size, and values.
-// Changing the value of one axis fundamentally changes the definition of the vector/matrix.
-// So we enforce this conceptually at code level...
-// If you're wondering how it remains performant, it only heap-allocates a tiny space (4*n bytes for vectors) (4*n*m bytes for matrices)
-// Just Trust Me Bro - Josjh
-#define MUTABLE true // Toggle This For: Ugly math, ugly code, and an ugly genital infection!
-
-#if MUTABLE
-#define IMMUTABLE !MUTABLE
-#endif
-
-namespace LinearAlgebra
-{
 
 
+// Library Code //
 
+#include "J3ML/LinearAlgebra/Vector2.h"
+#include "J3ML/LinearAlgebra/Vector3.h"
+#include "J3ML/LinearAlgebra/Vector4.h"
+#include "J3ML/LinearAlgebra/Quaternion.h"
+#include "J3ML/LinearAlgebra/AxisAngle.h"
+#include "J3ML/LinearAlgebra/EulerAngle.h"
+#include "J3ML/LinearAlgebra/Matrix2x2.h"
+#include "J3ML/LinearAlgebra/Matrix3x3.h"
+#include "J3ML/LinearAlgebra/Matrix4x4.h"
+#include "J3ML/LinearAlgebra/Transform2D.h"
+#include "J3ML/LinearAlgebra/CoordinateFrame.h"
 
-
+using namespace J3ML::LinearAlgebra;
-
-}

src/J3ML/J3ML.cpp

@@ -0,0 +1,43 @@
+#include <J3ML/J3ML.h>
+
+
+namespace J3ML
+{
+
+    Math::Rotation Math::operator ""_degrees(long double rads) { return {Radians((float)rads)}; }
+
+    Math::Rotation Math::operator ""_deg(long double rads) { return {Radians((float)rads)}; }
+
+    Math::Rotation Math::operator ""_radians(long double rads) { return {(float)rads}; }
+
+    Math::Rotation Math::operator ""_rad(long double rads) { return {(float)rads}; }
+
+    float Math::FastRSqrt(float x) {
+        return 1.f / FastSqrt(x);
+    }
+
+    float Math::RSqrt(float x) {
+        return 1.f / Sqrt(x);
+    }
+
+    float Math::Radians(float degrees) { return degrees * (Pi/180.f); }
+
+    float Math::Degrees(float radians) { return radians * (180.f/Pi); }
+
+    Math::Rotation::Rotation() : valueInRadians(0) {}
+
+    Math::Rotation::Rotation(float value) : valueInRadians(value) {}
+
+    Math::Rotation Math::Rotation::operator+(const Math::Rotation &rhs) {
+        valueInRadians += rhs.valueInRadians;
+    }
+
+    float Math::Interp::SmoothStart(float t) {
+        assert(t >= 0.f && t <= 1.f);
+        return t*t;
+    }
+
+    int Math::BitTwiddling::CountBitsSet(u32 value) {
+
+    }
+}

src/J3ML/LinearAlgebra/Vector2.cpp

@@ -17,17 +17,12 @@ namespace J3ML::LinearAlgebra {
 
     float Vector2::operator[](std::size_t index) const
     {
-        assert(index < 2);
+        return At(index);
-        if (index == 0) return x;
-        if (index == 1) return y;
-        return 0;
     }
 
     float &Vector2::operator[](std::size_t index)
     {
-        assert(index < 2);
+        return At(index);
-        if (index == 0) return x;
-        if (index == 1) return y;
     }
 
     bool Vector2::IsWithinMarginOfError(const Vector2& rhs, float margin) const
@@ -263,4 +258,70 @@ namespace J3ML::LinearAlgebra {
     }
 
     Vector2 Vector2::Abs() const { return {std::abs(x), std::abs(y)};}
+
+    float *Vector2::ptr() {
+        return &x;
+    }
+
+    const float *Vector2::ptr() const { return &x;}
+
+    const float Vector2::At(std::size_t index) const {
+        assert(index >= 0);
+        assert(index < Dimensions);
+        return ptr()[index];
+    }
+
+    float &Vector2::At(std::size_t index) {
+        assert(index >= 0);
+        assert(index < Dimensions);
+        return ptr()[index];
+    }
+
+    Vector2 &Vector2::operator/=(float scalar) {
+        x /= scalar;
+        y /= scalar;
+
+        return *this;
+    }
+
+    Vector2 &Vector2::operator*=(float scalar) {
+        x *= scalar;
+        y *= scalar;
+
+        return *this;
+    }
+
+    Vector2 &Vector2::operator-=(const Vector2 &rhs) // Subtracts a vector from this vector, in-place
+    {
+        x -= rhs.x;
+        y -= rhs.y;
+
+        return *this;
+    }
+
+    Vector2 &Vector2::operator+=(const Vector2 &rhs) // Adds a vector to this vector, in-place.
+    {
+        x += rhs.x;
+        y += rhs.y;
+
+        return *this;
+    }
+
+    Vector2 &Vector2::operator=(const Vector2 &rhs) {
+        x = rhs.x;
+        y = rhs.y;
+
+        return *this;
+    }
+
+    Vector2::Vector2(const float *data) {
+        assert(data);
+        x = data[0];
+        y = data[1];
+    }
+
+    Vector2::Vector2(float scalar) {
+        x = scalar;
+        y = scalar;
+    }
 }