diff --git a/include/J3ML/LinearAlgebra.h b/include/J3ML/LinearAlgebra.h index f6acdba..25a643c 100644 --- a/include/J3ML/LinearAlgebra.h +++ b/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 -#include -#include -#include -#include - - -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) - -// 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 -{ +// TODO: Implement Templated Linear Algebra +// 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" - - -} \ No newline at end of file +using namespace J3ML::LinearAlgebra; diff --git a/src/J3ML/J3ML.cpp b/src/J3ML/J3ML.cpp new file mode 100644 index 0000000..da0b9df --- /dev/null +++ b/src/J3ML/J3ML.cpp @@ -0,0 +1,43 @@ +#include + + +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) { + + } +} \ No newline at end of file diff --git a/src/J3ML/LinearAlgebra/Vector2.cpp b/src/J3ML/LinearAlgebra/Vector2.cpp index f99306a..773521a 100644 --- a/src/J3ML/LinearAlgebra/Vector2.cpp +++ b/src/J3ML/LinearAlgebra/Vector2.cpp @@ -17,17 +17,12 @@ namespace J3ML::LinearAlgebra { float Vector2::operator[](std::size_t index) const { - assert(index < 2); - if (index == 0) return x; - if (index == 1) return y; - return 0; + return At(index); } float &Vector2::operator[](std::size_t index) { - assert(index < 2); - if (index == 0) return x; - if (index == 1) return y; + return At(index); } 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; + } } \ No newline at end of file