Removed MathLibraryInterface

include/Collisions/CheckCollisionVisitorInterface.h

@@ -1,25 +1,17 @@
 #pragma once
-#include "../pch.h"
 #include "../Dynamics/TimerInterface.h"
-#include "../Geometrics/Math/MathLibraryInterface.h"
+#include "../pch.h"
 #include <Collisions/CollisionTestResult/CollisionTestResult.h>
 #include <Collisions/CollisionTestResult/CollisionTestResultBuilder.h>
 
-namespace Barta{
-	class CheckCollisionVisitorInterface{
-	public:
-		CheckCollisionVisitorInterface() = default;
-		virtual ~CheckCollisionVisitorInterface() = default;
+namespace Barta {
+class CheckCollisionVisitorInterface {
+public:
+    CheckCollisionVisitorInterface() = default;
+    virtual ~CheckCollisionVisitorInterface() = default;
 
-		virtual CollisionTestResult checkStaticCollision(
-			const MathLibraryInterface& mathLib,
-			CollisionTestResultBuilder& collisionTestResultBuilder
-		) const = 0;
+    virtual CollisionTestResult checkStaticCollision(CollisionTestResultBuilder& collisionTestResultBuilder) const = 0;
 
-		virtual CollisionTestResult checkDynamicCollision(
-			const MathLibraryInterface& mathLib,
-			const float delta_time,
-			CollisionTestResultBuilder& collisionTestResultBuilder
-		) const = 0;
-	};
+    virtual CollisionTestResult checkDynamicCollision(const float delta_time, CollisionTestResultBuilder& collisionTestResultBuilder) const = 0;
+};
 }

include/Collisions/CheckCollisionVisitors/AABB_AABBCheckCollisionVisitor.h

@@ -13,14 +13,9 @@ class AABB_AABBCheckCollisionVisitor: public CheckCollisionVisitorInterface {
 public:
     AABB_AABBCheckCollisionVisitor(const AABB& aabb1, const AABB& aabb2, const DynamicsDifference& dynamicsDifference) noexcept;
 
-    CollisionTestResult checkStaticCollision(const MathLibraryInterface& mathLib, CollisionTestResultBuilder& collisionTestResultBuilder)
-        const override;
+    CollisionTestResult checkStaticCollision(CollisionTestResultBuilder& collisionTestResultBuilder) const override;
 
-    CollisionTestResult checkDynamicCollision(
-        const MathLibraryInterface& mathLib,
-        float delta_time,
-        CollisionTestResultBuilder& collisionTestResultBuilder
-    ) const override;
+    CollisionTestResult checkDynamicCollision(float delta_time, CollisionTestResultBuilder& collisionTestResultBuilder) const override;
 
 private:
     const AABB aabb1;

include/Collisions/CheckCollisionVisitors/CircleAABBCheckCollisionVisitor.h

@@ -12,14 +12,9 @@ class CircleAABBCheckCollisionVisitor: public CheckCollisionVisitorInterface {
     CircleAABBCheckCollisionVisitor(const Circle& circle, const AABB& aabb, const DynamicsDifference& dynamicsDifference);
     virtual ~CircleAABBCheckCollisionVisitor();
 
-    CollisionTestResult checkStaticCollision(const MathLibraryInterface& mathLib, CollisionTestResultBuilder& collisionTestResultBuilder)
-        const override;
+    CollisionTestResult checkStaticCollision(CollisionTestResultBuilder& collisionTestResultBuilder) const override;
 
-    CollisionTestResult checkDynamicCollision(
-        const MathLibraryInterface& mathLib,
-        float delta_time,
-        CollisionTestResultBuilder& collisionTestResultBuilder
-    ) const override;
+    CollisionTestResult checkDynamicCollision(float delta_time, CollisionTestResultBuilder& collisionTestResultBuilder) const override;
 
 private:
     const Circle circle;

include/Collisions/CheckCollisionVisitors/CircleCircleCheckCollisionVisitor.h

@@ -10,14 +10,9 @@ class CircleCircleCheckCollisionVisitor: public CheckCollisionVisitorInterface {
     CircleCircleCheckCollisionVisitor(const Circle& circle1, const Circle& circle2, const DynamicsDifference& dynamicsDifference);
     virtual ~CircleCircleCheckCollisionVisitor();
 
-    CollisionTestResult checkStaticCollision(const MathLibraryInterface& mathLib, CollisionTestResultBuilder& collisionTestResultBuilder)
-        const override;
+    CollisionTestResult checkStaticCollision(CollisionTestResultBuilder& collisionTestResultBuilder) const override;
 
-    CollisionTestResult checkDynamicCollision(
-        const MathLibraryInterface& mathLib,
-        float delta_time,
-        CollisionTestResultBuilder& collisionTestResultBuilder
-    ) const override;
+    CollisionTestResult checkDynamicCollision(float delta_time, CollisionTestResultBuilder& collisionTestResultBuilder) const override;
 
 private:
     const Circle circle1;

include/Collisions/CheckCollisionVisitors/OBB_AABBCheckCollisionVisitor.h

@@ -12,14 +12,9 @@ class OBB_AABBCheckCollisionVisitor: public CheckCollisionVisitorInterface {
 public:
     OBB_AABBCheckCollisionVisitor(const OBB& obb, const AABB& aabb, const DynamicsDifference& dynamicsDifference) noexcept;
 
-    CollisionTestResult checkStaticCollision(const MathLibraryInterface& mathLib, CollisionTestResultBuilder& collisionTestResultBuilder)
-        const override;
+    CollisionTestResult checkStaticCollision(CollisionTestResultBuilder& collisionTestResultBuilder) const override;
 
-    CollisionTestResult checkDynamicCollision(
-        const MathLibraryInterface& mathLib,
-        float deltaTime,
-        CollisionTestResultBuilder& collisionTestResultBuilder
-    ) const override;
+    CollisionTestResult checkDynamicCollision(float deltaTime, CollisionTestResultBuilder& collisionTestResultBuilder) const override;
     Vector2f calculateCollisionPoint() const;
 
 private:

include/Collisions/CollisionDetectionStrategies/DynamicCollisionDetectionStrategy.h

@@ -1,20 +1,17 @@
 #pragma once
+#include "../../Dynamics/TimerInterface.h"
 #include "../../pch.h"
-#include"../CollisionDetectionStrategyInterface.h"
-#include"../../Dynamics/TimerInterface.h"
-#include "../../Geometrics/Math/MathLibraryInterface.h"
+#include "../CollisionDetectionStrategyInterface.h"
 
-namespace Barta{
-	class DynamicCollisionDetectionStrategy : public CollisionDetectionStrategyInterface{
-	public:
-		DynamicCollisionDetectionStrategy(std::unique_ptr<MathLibraryInterface> mathLibrary, const TimerInterface& timer);
-		virtual ~DynamicCollisionDetectionStrategy() noexcept = default;
+namespace Barta {
+class DynamicCollisionDetectionStrategy: public CollisionDetectionStrategyInterface {
+public:
+    DynamicCollisionDetectionStrategy(const TimerInterface& timer);
+    virtual ~DynamicCollisionDetectionStrategy() noexcept = default;
 
-		virtual CollisionTestResult acceptCheckCollisionVisitor( const CheckCollisionVisitorInterface& checkCollisionVisitor ) const override;
-	private:
-		const TimerInterface& timer;
+    virtual CollisionTestResult acceptCheckCollisionVisitor(const CheckCollisionVisitorInterface& checkCollisionVisitor) const override;
 
-		std::unique_ptr<MathLibraryInterface> mathLibrary;
-	};
+private:
+    const TimerInterface& timer;
+};
 }
-

include/Collisions/CollisionDetectionStrategies/StaticCollisionDetectionStrategy.h

@@ -1,21 +1,15 @@
 #pragma once
 
-#include <Collisions/CollisionTestResult/CollisionTestResult.h>
 #include "../../pch.h"
-#include"../CollisionDetectionStrategyInterface.h"
-#include "../../Geometrics/Math/MathLibraryInterface.h"
-
-namespace Barta{
-	class StaticCollisionDetectionStrategy : public CollisionDetectionStrategyInterface{
-
-	public:
-		StaticCollisionDetectionStrategy(std::unique_ptr<MathLibraryInterface>);
-		virtual ~StaticCollisionDetectionStrategy() noexcept = default;
+#include "../CollisionDetectionStrategyInterface.h"
+#include <Collisions/CollisionTestResult/CollisionTestResult.h>
 
-		virtual CollisionTestResult acceptCheckCollisionVisitor( const CheckCollisionVisitorInterface& checkCollisionVisitor ) const override;
+namespace Barta {
+class StaticCollisionDetectionStrategy: public CollisionDetectionStrategyInterface {
+public:
+    StaticCollisionDetectionStrategy();
+    virtual ~StaticCollisionDetectionStrategy() noexcept = default;
 
-	private:
-		std::unique_ptr<MathLibraryInterface> mathLibrary;
-	};
+    virtual CollisionTestResult acceptCheckCollisionVisitor(const CheckCollisionVisitorInterface& checkCollisionVisitor) const override;
+};
 }
-

include/Geometrics/Intersections.h

@@ -1,69 +1,76 @@
 #pragma once
-#include "Segment.h"
+#include "../Utilities/QuadraticEquation.h"
 #include "BartaShapes/AABB.h"
 #include "BartaShapes/Circle.h"
-#include "Math/QuadraticEquation.h"
+#include "Segment.h"
 
 namespace Barta {
-	namespace Intersections {
-		auto segmentAndCircle(const Segment& I, const Circle& c) noexcept {
-			auto d = I.getEnd() - I.getBeginning();
-			auto m = I.getBeginning() - c.getCenter();
-			auto eq = QuadraticEquation(d*d, m*d*2.f, m*m - c.getRadius()*c.getRadius());
-			eq.solve();
-			auto sol = eq.getSolutions();
+namespace Intersections {
+    auto segmentAndCircle(
+        const Segment& I,
+        const Circle& c
+    ) noexcept {
+        auto d = I.getEnd() - I.getBeginning();
+        auto m = I.getBeginning() - c.getCenter();
+        auto eq = Utils::QuadraticEquation(d * d, m * d * 2.f, m * m - c.getRadius() * c.getRadius());
+        eq.solve();
+        auto sol = eq.getSolutions();
 
-			sol.erase(std::remove_if(sol.begin(), sol.end(), [] (float t) {
-				return t < 0.f || 1.f < t;
-			}), sol.end());
+        sol.erase(std::remove_if(sol.begin(), sol.end(), [](float t) { return t < 0.f || 1.f < t; }), sol.end());
 
-			return sol;
-		}
+        return sol;
+    }
 
-		float lineAndLineRespectToFirst(const Segment& I1, const Segment& I2) noexcept {
-			auto perpendicular = (I2.getEnd() - I2.getBeginning()).perpendicular();
-			auto denom = (perpendicular * (I1.getEnd() - I1.getBeginning()));
-			if (denom == 0.f) {
-				return std::numeric_limits<float>::infinity();
-			}
+    float lineAndLineRespectToFirst(
+        const Segment& I1,
+        const Segment& I2
+    ) noexcept {
+        auto perpendicular = (I2.getEnd() - I2.getBeginning()).perpendicular();
+        auto denom = (perpendicular * (I1.getEnd() - I1.getBeginning()));
+        if (denom == 0.f) {
+            return std::numeric_limits<float>::infinity();
+        }
 
-			return (perpendicular * (I2.getBeginning() - I1.getBeginning())) / denom;
-		}
+        return (perpendicular * (I2.getBeginning() - I1.getBeginning())) / denom;
+    }
 
-		auto segmentAndSegment(const Segment& I1, const Segment& I2) noexcept {
-			std::vector<std::tuple<float, float>> result;
-			auto barCoords= std::tuple<float, float>(
-				lineAndLineRespectToFirst(I1, I2),
-				lineAndLineRespectToFirst(I2, I1)
-			);
+    auto segmentAndSegment(
+        const Segment& I1,
+        const Segment& I2
+    ) noexcept {
+        std::vector<std::tuple<float, float>> result;
+        auto barCoords = std::tuple<float, float>(lineAndLineRespectToFirst(I1, I2), lineAndLineRespectToFirst(I2, I1));
 
-			if (0.f <= std::get<0>(barCoords) && std::get<0>(barCoords) <= 1.f && 0.f <= std::get<1>(barCoords) && std::get<1>(barCoords) <= 1.f) {
-				result.push_back(barCoords);
-			}
+        if (0.f <= std::get<0>(barCoords) && std::get<0>(barCoords) <= 1.f && 0.f <= std::get<1>(barCoords) && std::get<1>(barCoords) <= 1.f) {
+            result.push_back(barCoords);
+        }
 
-			return result;
-		}
+        return result;
+    }
 
-		auto segmentAndAABB(const Segment& I, const AABB& aabb) {
-			decltype(segmentAndSegment(I, I)) intersections;
-			for (const auto& side : aabb.getSides()) {
-				auto sideIntersections = segmentAndSegment(I, side);
-				intersections.insert(intersections.end(), sideIntersections.begin(), sideIntersections.end());
-			}
+    auto segmentAndAABB(
+        const Segment& I,
+        const AABB& aabb
+    ) {
+        decltype(segmentAndSegment(I, I)) intersections;
+        for (const auto& side: aabb.getSides()) {
+            auto sideIntersections = segmentAndSegment(I, side);
+            intersections.insert(intersections.end(), sideIntersections.begin(), sideIntersections.end());
+        }
 
-            if (intersections.size() == 2) {
-                if (std::get<0>(intersections[0]) > std::get<0>(intersections[1])) {
-                    auto temp = intersections[0];
-                    intersections[0] = intersections[1];
-                    intersections[1] = temp;
-                }
+        if (intersections.size() == 2) {
+            if (std::get<0>(intersections[0]) > std::get<0>(intersections[1])) {
+                auto temp = intersections[0];
+                intersections[0] = intersections[1];
+                intersections[1] = temp;
             }
+        }
 
-            if (intersections.size() > 2) {
-                throw std::runtime_error("size too long");
-            }
+        if (intersections.size() > 2) {
+            throw std::runtime_error("size too long");
+        }
 
-			return intersections;
-		}
-	}
-}
+        return intersections;
+    }
+}
+}