Physics: AxisAlignedBox / Point collision.

src/Physics/AxisAlignedBox.cpp

@@ -17,6 +17,7 @@
 
 #include "Math/Matrix3.h"
 #include "Math/Matrix4.h"
+#include "Physics/Point.h"
 
 namespace Magnum { namespace Physics {
 
@@ -25,6 +26,18 @@ template<std::uint8_t dimensions> void AxisAlignedBox<dimensions>::applyTransfor
     _transformedMax = (matrix*typename DimensionTraits<dimensions>::PointType(_max)).vector();
 }
 
+template<std::uint8_t dimensions> bool AxisAlignedBox<dimensions>::collides(const AbstractShape<dimensions>* other) const {
+    if(other->type() == AbstractShape<dimensions>::Type::Point)
+        return *this % *static_cast<const Point<dimensions>*>(other);
+
+    return AbstractShape<dimensions>::collides(other);
+}
+
+template<std::uint8_t dimensions> bool AxisAlignedBox<dimensions>::operator%(const Point<dimensions>& other) const {
+    return (other.transformedPosition() >= _transformedMin).all() &&
+           (other.transformedPosition() < _transformedMax).all();
+}
+
 template class AxisAlignedBox<2>;
 template class AxisAlignedBox<3>;
 

src/Physics/AxisAlignedBox.h

@@ -20,7 +20,8 @@
  */
 
 #include "Math/Vector3.h"
-#include "AbstractShape.h"
+#include "Physics/AbstractShape.h"
+#include "Physics/Physics.h"
 
 #include "corradeCompatibility.h"
 
@@ -42,6 +43,8 @@ template<std::uint8_t dimensions> class MAGNUM_PHYSICS_EXPORT AxisAlignedBox: pu
 
         void applyTransformationMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) override;
 
+        bool collides(const AbstractShape<dimensions>* other) const override;
+
         /** @brief Minimal coordinates */
         inline typename DimensionTraits<dimensions>::VectorType min() const {
             return _min;
@@ -70,6 +73,9 @@ template<std::uint8_t dimensions> class MAGNUM_PHYSICS_EXPORT AxisAlignedBox: pu
             return _transformedMax;
         }
 
+        /** @brief Collision with point */
+        bool operator%(const Point<dimensions>& other) const;
+
     private:
         typename DimensionTraits<dimensions>::VectorType _min, _max,
             _transformedMin, _transformedMax;
@@ -81,6 +87,9 @@ typedef AxisAlignedBox<2> AxisAlignedBox2D;
 /** @brief Three-dimensional axis-aligned box */
 typedef AxisAlignedBox<3> AxisAlignedBox3D;
 
+/** @collisionoperator{Point,AxisAlignedBox} */
+template<std::uint8_t dimensions> inline bool operator%(const Point<dimensions>& a, const AxisAlignedBox<dimensions>& b) { return b % a; }
+
 }}
 
 #endif

src/Physics/Test/AxisAlignedBoxTest.cpp

@@ -18,18 +18,23 @@
 #include "Math/Constants.h"
 #include "Math/Matrix4.h"
 #include "Physics/AxisAlignedBox.h"
+#include "Physics/Point.h"
+
+#include "ShapeTestBase.h"
 
 namespace Magnum { namespace Physics { namespace Test {
 
-class AxisAlignedBoxTest: public Corrade::TestSuite::Tester {
+class AxisAlignedBoxTest: public Corrade::TestSuite::Tester, ShapeTestBase {
     public:
         AxisAlignedBoxTest();
 
         void applyTransformation();
+        void collisionPoint();
 };
 
 AxisAlignedBoxTest::AxisAlignedBoxTest() {
-    addTests(&AxisAlignedBoxTest::applyTransformation);
+    addTests(&AxisAlignedBoxTest::applyTransformation,
+             &AxisAlignedBoxTest::collisionPoint);
 }
 
 void AxisAlignedBoxTest::applyTransformation() {
@@ -40,6 +45,19 @@ void AxisAlignedBoxTest::applyTransformation() {
     CORRADE_COMPARE(box.transformedMax(), Vector3(3.0f, -1.0f, 5.5f));
 }
 
+void AxisAlignedBoxTest::collisionPoint() {
+    Physics::AxisAlignedBox3D box({-1.0f, -2.0f, -3.0f}, {1.0f, 2.0f, 3.0f});
+    Physics::Point3D point1({-1.5f, -1.0f, 2.0f});
+    Physics::Point3D point2({0.5f, 1.0f, -2.5f});
+
+    randomTransformation(box);
+    randomTransformation(point1);
+    randomTransformation(point2);
+
+    VERIFY_NOT_COLLIDES(box, point1);
+    VERIFY_COLLIDES(box, point2);
+}
+
 }}}
 
 CORRADE_TEST_MAIN(Magnum::Physics::Test::AxisAlignedBoxTest)