Physics: specify AABB by its minimal and maximal dimensions.

Center + size was confusing for entering and also with bad
performance for computing collisions.

src/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp

@@ -27,8 +27,8 @@ template<std::uint8_t dimensions> AxisAlignedBoxRenderer<dimensions>::AxisAligne
 template<std::uint8_t dimensions> void AxisAlignedBoxRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) {
     /* Half scale, because the box is 2x2(x2) */
     typename DimensionTraits<dimensions>::MatrixType transformation =
-        DimensionTraits<dimensions>::MatrixType::translation(axisAlignedBox.transformedPosition())*
-        DimensionTraits<dimensions>::MatrixType::scaling(axisAlignedBox.transformedSize()/2);
+        DimensionTraits<dimensions>::MatrixType::translation((axisAlignedBox.transformedMin()+axisAlignedBox.transformedMax())/2)*
+        DimensionTraits<dimensions>::MatrixType::scaling((axisAlignedBox.transformedMax()-axisAlignedBox.transformedMin())/2);
     this->shader->setTransformationProjectionMatrix(projectionMatrix*transformation)
         ->setColor(options->color())
         ->use();

src/Physics/AxisAlignedBox.cpp

@@ -21,8 +21,8 @@
 namespace Magnum { namespace Physics {
 
 template<std::uint8_t dimensions> void AxisAlignedBox<dimensions>::applyTransformationMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
-    _transformedPosition = (matrix*typename DimensionTraits<dimensions>::PointType(_position)).vector();
-    _transformedSize = matrix.rotationScaling()*_size;
+    _transformedMin = (matrix*typename DimensionTraits<dimensions>::PointType(_min)).vector();
+    _transformedMax = (matrix*typename DimensionTraits<dimensions>::PointType(_max)).vector();
 }
 
 template class AxisAlignedBox<2>;

src/Physics/AxisAlignedBox.h

@@ -34,7 +34,7 @@ namespace Magnum { namespace Physics {
 template<std::uint8_t dimensions> class MAGNUM_PHYSICS_EXPORT AxisAlignedBox: public AbstractShape<dimensions> {
     public:
         /** @brief Constructor */
-        inline explicit AxisAlignedBox(const typename DimensionTraits<dimensions>::VectorType& position, const typename DimensionTraits<dimensions>::VectorType& size): _position(position), _transformedPosition(position), _size(size), _transformedSize(size) {}
+        inline explicit AxisAlignedBox(const typename DimensionTraits<dimensions>::VectorType& min, const typename DimensionTraits<dimensions>::VectorType& max): _min(min), _max(max), _transformedMin(min), _transformedMax(max) {}
 
         inline typename AbstractShape<dimensions>::Type type() const override {
             return AbstractShape<dimensions>::Type::AxisAlignedBox;
@@ -42,37 +42,37 @@ template<std::uint8_t dimensions> class MAGNUM_PHYSICS_EXPORT AxisAlignedBox: pu
 
         void applyTransformationMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) override;
 
-        /** @brief Position */
-        inline typename DimensionTraits<dimensions>::VectorType position() const {
-            return _position;
+        /** @brief Minimal coordinates */
+        inline typename DimensionTraits<dimensions>::VectorType min() const {
+            return _min;
         }
 
-        /** @brief Set position */
-        inline void setPosition(const typename DimensionTraits<dimensions>::VectorType& position) {
-            _position = position;
+        /** @brief Set minimal coordinates */
+        inline void setMin(const typename DimensionTraits<dimensions>::VectorType& min) {
+            _min = min;
         }
 
-        /** @brief Size */
-        inline typename DimensionTraits<dimensions>::VectorType size() const { return _size; }
+        /** @brief Maximal coordinates */
+        inline typename DimensionTraits<dimensions>::VectorType max() const { return _max; }
 
-        /** @brief Set size */
-        inline void setSize(const typename DimensionTraits<dimensions>::VectorType& size) {
-            _size = size;
+        /** @brief Set maximal coordinates */
+        inline void setMax(const typename DimensionTraits<dimensions>::VectorType& max) {
+            _max = max;
         }
 
-        /** @brief Transformed position */
-        inline typename DimensionTraits<dimensions>::VectorType transformedPosition() const {
-            return _transformedPosition;
+        /** @brief Transformed minimal coordinates */
+        inline typename DimensionTraits<dimensions>::VectorType transformedMin() const {
+            return _transformedMin;
         }
 
-        /** @brief Transformed size */
-        inline typename DimensionTraits<dimensions>::VectorType transformedSize() const {
-            return _transformedSize;
+        /** @brief Transformed maximal coordinates */
+        inline typename DimensionTraits<dimensions>::VectorType transformedMax() const {
+            return _transformedMax;
         }
 
     private:
-        typename DimensionTraits<dimensions>::VectorType _position, _transformedPosition,
-            _size, _transformedSize;
+        typename DimensionTraits<dimensions>::VectorType _min, _max,
+            _transformedMin, _transformedMax;
 };
 
 /** @brief Two-dimensional axis-aligned box */

src/Physics/Test/AxisAlignedBoxTest.cpp

@@ -35,13 +35,9 @@ AxisAlignedBoxTest::AxisAlignedBoxTest() {
 void AxisAlignedBoxTest::applyTransformation() {
     Physics::AxisAlignedBox3D box({-1.0f, -2.0f, -3.0f}, {1.0f, 2.0f, 3.0f});
 
-    box.applyTransformationMatrix(Matrix4::scaling({2.0f, -1.0f, 1.5f}));
-    CORRADE_COMPARE(box.transformedPosition(), Vector3(-2.0f, 2.0f, -4.5f));
-    CORRADE_COMPARE(box.transformedSize(), Vector3(2.0f, -2.0f, 4.5f));
-
-    box.applyTransformationMatrix(Matrix4::translation(Vector3(1.0f))*Matrix4::rotation(deg(90.0f), Vector3::xAxis()));
-    CORRADE_COMPARE(box.transformedPosition(), Vector3(0.0f, 4.0f, -1.0f));
-    CORRADE_COMPARE(box.transformedSize(), Vector3(1.0f, -3.0f, 2.0f));
+    box.applyTransformationMatrix(Matrix4::translation(Vector3(1.0f))*Matrix4::scaling({2.0f, -1.0f, 1.5f}));
+    CORRADE_COMPARE(box.transformedMin(), Vector3(-1.0f, 3.0f, -3.5f));
+    CORRADE_COMPARE(box.transformedMax(), Vector3(3.0f, -1.0f, 5.5f));
 }
 
 }}}