Implement by-Reference operators

include/J3ML/Algorithm/DifferentialSolvers.h

@@ -0,0 +1,36 @@
+//
+// Created by dawsh on 2/8/24.
+//
+
+namespace J3ML::Algorithm
+{
+    /// Implementations for a variety of Differential Equation Solving algorithms
+    namespace Solvers
+    {
+
+        // Consider a differential equation
+        // dy/dx = (x + y + xy)
+        float eq(float x, float y)
+        {
+            return (x + y + x*y);
+        }
+
+        float euler(float x0, float y, float h, float x)
+        {
+            float temp = -0.f;
+            // Iterating till the point at which we need approximation
+            while (x0 < x) {
+                temp = y;
+                y = y + h * eq(x0, y);
+                x0 = x0 + h;
+            }
+            return y;
+        }
+
+        class EulerMethodSolver {};
+        class SemiImplicitEulerMethodSolver {};
+        class GaussSeidelMethodSolver {};
+        class GradientDescentSolver {};
+        class VerletIntegrationSolver {};
+    }
+}

include/J3ML/Algorithm/Spring.h

@@ -0,0 +1,21 @@
+//
+// Created by dawsh on 2/8/24.
+//
+
+namespace J3ML::Algorithm
+{
+    // Numerical model of a "Spring" object
+    // Simulates any oscillating system i.e. a mass suspended from a spring.
+    class Spring
+    {
+        float Dampening;
+        float Stiffness;
+        float Goal;
+        float RestLength = 1.f;
+
+        bool Overdamped() const;
+        bool Undamped() const;
+        bool Underdamped() const;
+        bool CriticallyDamped() const;
+    };
+}

include/J3ML/Geometry/AABB.h

@@ -24,7 +24,6 @@
 
 namespace J3ML::Geometry
 {
-
     using namespace LinearAlgebra;
     // A 3D axis-aligned bounding box
     // This data structure can be used to represent coarse bounds of objects, in situations where detailed triangle-level
@@ -135,6 +134,7 @@ namespace J3ML::Geometry
         AABB Intersection(const AABB& rhs) const;
         bool IntersectLineAABB(const Vector3& linePos, const Vector3& lineDir, float tNear, float tFar) const;
 
+
         void SetFrom(const Vector3 *pVector3, int i);
 
         void SetFromCenterAndSize(const Vector3 &center, const Vector3 &size);

include/J3ML/LinearAlgebra/Vector2.h

@@ -6,9 +6,6 @@
 namespace J3ML::LinearAlgebra {
     using namespace J3ML;
 
-
-
-
     /// A 2D (x, y) ordered pair.
     class Vector2 {
     public:
@@ -16,6 +13,7 @@ namespace J3ML::LinearAlgebra {
         Vector2();
         /// Constructs a new Vector2 with the value (X, Y)
         Vector2(float X, float Y);
+        Vector2(float* xyPtr);
         Vector2(const Vector2& rhs);   // Copy Constructor
         //Vector2(Vector2&&) = default;   // Move Constructor
 
@@ -31,6 +29,11 @@ namespace J3ML::LinearAlgebra {
         void SetX(float newX);
         void SetY(float newY);
 
+        float* ptr()
+        {
+            return &x;
+        }
+
         Vector2 Abs() const;
 
         bool IsWithinMarginOfError(const Vector2& rhs, float margin=0.001f) const;
@@ -39,7 +42,8 @@ namespace J3ML::LinearAlgebra {
         bool IsZero(float epsilonSq = 1e-6f) const;
         bool IsPerpendicular(const Vector2& other, float epsilonSq=1e-5f) const;
 
-        float operator[](std::size_t index);
+        float operator[](std::size_t index) const;
+        float &operator[](std::size_t index);
         bool operator == (const Vector2& rhs) const;
         bool operator != (const Vector2& rhs) const;
 
@@ -74,10 +78,6 @@ namespace J3ML::LinearAlgebra {
         static float Magnitude(const Vector2& of);
 
 
-
-
-
-
         bool IsFinite() const;
         static bool IsFinite(const Vector2& v);
 

include/J3ML/LinearAlgebra/Vector3.h

@@ -32,6 +32,11 @@ public:
     static const Vector3 Infinity;
     static const Vector3 NegativeInfinity;
 
+    float* ptr()
+    {
+        return &x;
+    }
+
     static void Orthonormalize(Vector3& a, Vector3& b)
     {
         a = a.Normalize();
@@ -79,6 +84,7 @@ public:
     bool IsPerpendicular(const Vector3& other, float epsilonSq=1e-5f) const;
 
     float operator[](std::size_t index) const;
+    float &operator[](std::size_t index);
     bool operator == (const Vector3& rhs) const;
     bool operator != (const Vector3& rhs) const;
 

include/J3ML/LinearAlgebra/Vector4.h

@@ -2,7 +2,6 @@
 
 #include <J3ML/LinearAlgebra.h>
 
-
 namespace J3ML::LinearAlgebra {
     class Vector4 {
     public:
@@ -16,6 +15,11 @@ namespace J3ML::LinearAlgebra {
         Vector4(Vector4&& move) = default;
         Vector4& operator=(const Vector4& rhs);
 
+        float* ptr()
+        {
+            return &x;
+        }
+
         float GetX() const;
         float GetY() const;
         float GetZ() const;