mirror of https://github.com/mosra/magnum.git
Vladimír Vondruš
13 years ago
20 changed files with 715 additions and 715 deletions
@ -0,0 +1,167 @@ |
|||||||
|
/*
|
||||||
|
This file is part of Magnum. |
||||||
|
|
||||||
|
Copyright © 2010, 2011, 2012, 2013 Vladimír Vondruš <mosra@centrum.cz> |
||||||
|
|
||||||
|
Permission is hereby granted, free of charge, to any person obtaining a |
||||||
|
copy of this software and associated documentation files (the "Software"), |
||||||
|
to deal in the Software without restriction, including without limitation |
||||||
|
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
||||||
|
and/or sell copies of the Software, and to permit persons to whom the |
||||||
|
Software is furnished to do so, subject to the following conditions: |
||||||
|
|
||||||
|
The above copyright notice and this permission notice shall be included |
||||||
|
in all copies or substantial portions of the Software. |
||||||
|
|
||||||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||||
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||||
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
||||||
|
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||||
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
||||||
|
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
||||||
|
DEALINGS IN THE SOFTWARE. |
||||||
|
*/ |
||||||
|
|
||||||
|
#include "Composition.h" |
||||||
|
|
||||||
|
#include <algorithm> |
||||||
|
#include <Utility/Assert.h> |
||||||
|
|
||||||
|
#include "Physics/Implementation/CollisionDispatch.h" |
||||||
|
|
||||||
|
namespace Magnum { namespace Physics { |
||||||
|
|
||||||
|
/*
|
||||||
|
Hierarchy implementation notes: |
||||||
|
|
||||||
|
The hierarchy is stored in flat array to provide easy access for the user and |
||||||
|
to save some allocations. Each node has zero, one or two subnodes. Value of |
||||||
|
`Node::rightNode` describes which child nodes exist: |
||||||
|
|
||||||
|
* 0 - no child subnodes |
||||||
|
* 1 - only left subnode exists |
||||||
|
* 2 - only right subnode exists |
||||||
|
* >2 - both child nodes exist |
||||||
|
|
||||||
|
If left node exists, it is right next to current one. If right node exists, it |
||||||
|
is at position `Node::rightNode-1` relative to current one (this applies also |
||||||
|
when `rightNode` is equal to 2, right node is right next to current one, |
||||||
|
because there are no left nodes). |
||||||
|
|
||||||
|
The node also specifies which shapes belong to it. Root node owns whole shape |
||||||
|
array and `Node::rightShape` marks first shape belonging to the right child |
||||||
|
node, relatively to begin. This recurses into child nodes, thus left child node |
||||||
|
has shapes from parent's begin to parent's `rightShape`. |
||||||
|
|
||||||
|
Shapes are merged together by concatenating its node and shape list and adding |
||||||
|
new node at the beginning with properly set `rightNode` and `rightShape`. |
||||||
|
Because these values are relative to parent, they don't need to be modified |
||||||
|
when concatenating. |
||||||
|
*/ |
||||||
|
|
||||||
|
template<UnsignedInt dimensions> Composition<dimensions>::Composition(const Composition<dimensions>& other): _shapeCount(other._shapeCount), _nodeCount(other._nodeCount) { |
||||||
|
copyShapes(0, other); |
||||||
|
copyNodes(0, other); |
||||||
|
} |
||||||
|
|
||||||
|
template<UnsignedInt dimensions> Composition<dimensions>::Composition(Composition<dimensions>&& other): _shapeCount(other._shapeCount), _nodeCount(other._nodeCount), _shapes(other._shapes), _nodes(other._nodes) { |
||||||
|
other._shapes = nullptr; |
||||||
|
other._shapeCount = 0; |
||||||
|
|
||||||
|
other._nodes = nullptr; |
||||||
|
other._nodeCount = 0; |
||||||
|
} |
||||||
|
|
||||||
|
template<UnsignedInt dimensions> Composition<dimensions>::~Composition() { |
||||||
|
for(std::size_t i = 0; i != _shapeCount; ++i) |
||||||
|
delete _shapes[i]; |
||||||
|
|
||||||
|
delete[] _shapes; |
||||||
|
delete[] _nodes; |
||||||
|
} |
||||||
|
|
||||||
|
template<UnsignedInt dimensions> Composition<dimensions>& Composition<dimensions>::operator=(const Composition<dimensions>& other) { |
||||||
|
for(std::size_t i = 0; i != _shapeCount; ++i) |
||||||
|
delete _shapes[i]; |
||||||
|
|
||||||
|
if(_shapeCount != other._shapeCount) { |
||||||
|
delete[] _shapes; |
||||||
|
_shapeCount = other._shapeCount; |
||||||
|
_shapes = new Implementation::AbstractShape<dimensions>*[_shapeCount]; |
||||||
|
} |
||||||
|
|
||||||
|
if(_nodeCount != other._nodeCount) { |
||||||
|
delete[] _nodes; |
||||||
|
_nodeCount = other._nodeCount; |
||||||
|
_nodes = new Node[_nodeCount]; |
||||||
|
} |
||||||
|
|
||||||
|
copyShapes(0, other); |
||||||
|
copyNodes(0, other); |
||||||
|
return *this; |
||||||
|
} |
||||||
|
|
||||||
|
template<UnsignedInt dimensions> Composition<dimensions>& Composition<dimensions>::operator=(Composition<dimensions>&& other) { |
||||||
|
std::swap(other._shapeCount, _shapeCount); |
||||||
|
std::swap(other._nodeCount, _nodeCount); |
||||||
|
std::swap(other._shapes, _shapes); |
||||||
|
std::swap(other._nodes, _nodes); |
||||||
|
return *this; |
||||||
|
} |
||||||
|
|
||||||
|
template<UnsignedInt dimensions> void Composition<dimensions>::copyShapes(const std::size_t offset, Composition<dimensions>&& other) { |
||||||
|
std::move(other._shapes, other._shapes+other._shapeCount, _shapes+offset); |
||||||
|
delete[] other._shapes; |
||||||
|
other._shapes = nullptr; |
||||||
|
other._shapeCount = 0; |
||||||
|
} |
||||||
|
|
||||||
|
template<UnsignedInt dimensions> void Composition<dimensions>::copyShapes(const std::size_t offset, const Composition<dimensions>& other) { |
||||||
|
for(std::size_t i = 0; i != other._shapeCount; ++i) |
||||||
|
_shapes[i+offset] = other._shapes[i]->clone(); |
||||||
|
} |
||||||
|
|
||||||
|
template<UnsignedInt dimensions> void Composition<dimensions>::copyNodes(std::size_t offset, const Composition<dimensions>& other) { |
||||||
|
std::copy(other._nodes, other._nodes+other._nodeCount, _nodes+offset); |
||||||
|
} |
||||||
|
|
||||||
|
template<UnsignedInt dimensions> Composition<dimensions> Composition<dimensions>::transformed(const typename DimensionTraits<dimensions>::MatrixType& matrix) const { |
||||||
|
Composition<dimensions> out(*this); |
||||||
|
for(std::size_t i = 0; i != _shapeCount; ++i) |
||||||
|
_shapes[i]->transform(matrix, out._shapes[i]); |
||||||
|
return out; |
||||||
|
} |
||||||
|
|
||||||
|
template<UnsignedInt dimensions> bool Composition<dimensions>::collides(const Implementation::AbstractShape<dimensions>* const a, const std::size_t node, const std::size_t shapeBegin, const std::size_t shapeEnd) const { |
||||||
|
/* Empty group */ |
||||||
|
if(shapeBegin == shapeEnd) return false; |
||||||
|
|
||||||
|
CORRADE_INTERNAL_ASSERT(node < _nodeCount && shapeBegin < shapeEnd); |
||||||
|
|
||||||
|
/* Collision on the left child. If the node is leaf one (no left child
|
||||||
|
exists), do it directly, recurse instead. */ |
||||||
|
const bool collidesLeft = (_nodes[node].rightNode == 0 || _nodes[node].rightNode == 2) ? |
||||||
|
Implementation::collides(a, _shapes[shapeBegin]) : |
||||||
|
collides(a, node+1, shapeBegin, shapeBegin+_nodes[node].rightShape); |
||||||
|
|
||||||
|
/* NOT operation */ |
||||||
|
if(_nodes[node].operation == CompositionOperation::Not) |
||||||
|
return !collidesLeft; |
||||||
|
|
||||||
|
/* Short-circuit evaluation for AND/OR */ |
||||||
|
if((_nodes[node].operation == CompositionOperation::Or) == collidesLeft) |
||||||
|
return collidesLeft; |
||||||
|
|
||||||
|
/* Now the collision result depends only on the right child. Similar to
|
||||||
|
collision on the left child. */ |
||||||
|
return (_nodes[node].rightNode < 2) ? |
||||||
|
Implementation::collides(a, _shapes[shapeBegin+_nodes[node].rightShape]) : |
||||||
|
collides(a, node+_nodes[node].rightNode-1, shapeBegin+_nodes[node].rightShape, shapeEnd); |
||||||
|
} |
||||||
|
|
||||||
|
#ifndef DOXYGEN_GENERATING_OUTPUT |
||||||
|
template class MAGNUM_PHYSICS_EXPORT Composition<2>; |
||||||
|
template class MAGNUM_PHYSICS_EXPORT Composition<3>; |
||||||
|
#endif |
||||||
|
|
||||||
|
}} |
||||||
@ -0,0 +1,298 @@ |
|||||||
|
#ifndef Magnum_Physics_Composition_h |
||||||
|
#define Magnum_Physics_Composition_h |
||||||
|
/*
|
||||||
|
This file is part of Magnum. |
||||||
|
|
||||||
|
Copyright © 2010, 2011, 2012, 2013 Vladimír Vondruš <mosra@centrum.cz> |
||||||
|
|
||||||
|
Permission is hereby granted, free of charge, to any person obtaining a |
||||||
|
copy of this software and associated documentation files (the "Software"), |
||||||
|
to deal in the Software without restriction, including without limitation |
||||||
|
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
||||||
|
and/or sell copies of the Software, and to permit persons to whom the |
||||||
|
Software is furnished to do so, subject to the following conditions: |
||||||
|
|
||||||
|
The above copyright notice and this permission notice shall be included |
||||||
|
in all copies or substantial portions of the Software. |
||||||
|
|
||||||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||||
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||||
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
||||||
|
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||||
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
||||||
|
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
||||||
|
DEALINGS IN THE SOFTWARE. |
||||||
|
*/ |
||||||
|
|
||||||
|
/** @file
|
||||||
|
* @brief Class Magnum::Physics::Composition, enum Magnum::Physics::CompositionOperation |
||||||
|
*/ |
||||||
|
|
||||||
|
#include <type_traits> |
||||||
|
#include <utility> |
||||||
|
#include <Utility/Assert.h> |
||||||
|
|
||||||
|
#include "DimensionTraits.h" |
||||||
|
#include "Physics/Physics.h" |
||||||
|
#include "Physics/magnumPhysicsVisibility.h" |
||||||
|
#include "Physics/shapeImplementation.h" |
||||||
|
|
||||||
|
namespace Magnum { namespace Physics { |
||||||
|
|
||||||
|
namespace Implementation { |
||||||
|
template<class> struct ShapeHelper; |
||||||
|
|
||||||
|
template<UnsignedInt dimensions> inline AbstractShape<dimensions>* getAbstractShape(Composition<dimensions>& group, std::size_t i) { |
||||||
|
return group._shapes[i]; |
||||||
|
} |
||||||
|
template<UnsignedInt dimensions> inline const AbstractShape<dimensions>* getAbstractShape(const Composition<dimensions>& group, std::size_t i) { |
||||||
|
return group._shapes[i]; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** @brief Shape operation */ |
||||||
|
enum class CompositionOperation: UnsignedByte { |
||||||
|
Not, /**< Boolean NOT */ |
||||||
|
And, /**< Boolean AND */ |
||||||
|
Or /**< Boolean OR */ |
||||||
|
}; |
||||||
|
|
||||||
|
/**
|
||||||
|
@brief Composition of shapes |
||||||
|
|
||||||
|
Result of logical operations on shapes. |
||||||
|
See @ref collision-detection for brief introduction. |
||||||
|
*/ |
||||||
|
template<UnsignedInt dimensions> class MAGNUM_PHYSICS_EXPORT Composition { |
||||||
|
friend Implementation::AbstractShape<dimensions>* Implementation::getAbstractShape<>(Composition<dimensions>&, std::size_t); |
||||||
|
friend const Implementation::AbstractShape<dimensions>* Implementation::getAbstractShape<>(const Composition<dimensions>&, std::size_t); |
||||||
|
friend struct Implementation::ShapeHelper<Composition<dimensions>>; |
||||||
|
|
||||||
|
public: |
||||||
|
enum: UnsignedInt { |
||||||
|
Dimensions = dimensions /**< Dimension count */ |
||||||
|
}; |
||||||
|
|
||||||
|
/** @brief Shape type */ |
||||||
|
#ifdef DOXYGEN_GENERATING_OUTPUT |
||||||
|
enum class Type { |
||||||
|
Point, /**< Point */ |
||||||
|
Line, /**< Line */ |
||||||
|
LineSegment, /**< @ref LineSegment "Line segment" */ |
||||||
|
Sphere, /**< Sphere */ |
||||||
|
Capsule, /**< Capsule */ |
||||||
|
AxisAlignedBox, /**< @ref AxisAlignedBox "Axis aligned box" */ |
||||||
|
Box, /**< Box */ |
||||||
|
Plane /**< Plane (3D only) */ |
||||||
|
}; |
||||||
|
#else |
||||||
|
typedef typename Implementation::ShapeDimensionTraits<dimensions>::Type Type; |
||||||
|
#endif |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Default constructor |
||||||
|
* |
||||||
|
* Creates empty hierarchy. |
||||||
|
*/ |
||||||
|
inline explicit Composition(): _shapeCount(0), _nodeCount(0), _shapes(nullptr), _nodes(nullptr) {} |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Unary operation constructor |
||||||
|
* @param operation Unary operation |
||||||
|
* @param a Operand |
||||||
|
*/ |
||||||
|
template<class T> explicit Composition(CompositionOperation operation, T&& a); |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Binary operation constructor |
||||||
|
* @param operation Binary operation |
||||||
|
* @param a Left operand |
||||||
|
* @param b Right operand |
||||||
|
*/ |
||||||
|
template<class T, class U> explicit Composition(CompositionOperation operation, T&& a, U&& b); |
||||||
|
|
||||||
|
/** @brief Copy constructor */ |
||||||
|
Composition(const Composition<dimensions>& other); |
||||||
|
|
||||||
|
/** @brief Move constructor */ |
||||||
|
Composition(Composition<dimensions>&& other); |
||||||
|
|
||||||
|
~Composition(); |
||||||
|
|
||||||
|
/** @brief Assigment operator */ |
||||||
|
Composition<dimensions>& operator=(const Composition<dimensions>& other); |
||||||
|
|
||||||
|
/** @brief Move assignment operator */ |
||||||
|
Composition<dimensions>& operator=(Composition<dimensions>&& other); |
||||||
|
|
||||||
|
/** @brief Transformed shape */ |
||||||
|
Composition<dimensions> transformed(const typename DimensionTraits<dimensions>::MatrixType& matrix) const; |
||||||
|
|
||||||
|
/** @brief Count of shapes in the hierarchy */ |
||||||
|
inline std::size_t size() const { return _shapeCount; } |
||||||
|
|
||||||
|
/** @brief Type of shape at given position */ |
||||||
|
inline Type type(std::size_t i) const { return _shapes[i]->type(); } |
||||||
|
|
||||||
|
/** @brief Shape at given position */ |
||||||
|
template<class T> const T& get(std::size_t i) const; |
||||||
|
|
||||||
|
/** @brief Collision with another shape */ |
||||||
|
#ifdef DOXYGEN_GENERATING_OUTPUT |
||||||
|
template<class T> inline bool operator%(const T& other) const { |
||||||
|
#else |
||||||
|
template<class T> inline auto operator%(const T& other) const -> typename std::enable_if<std::is_same<decltype(Implementation::TypeOf<T>::type()), typename Implementation::ShapeDimensionTraits<dimensions>::Type>::value, bool>::type { |
||||||
|
#endif |
||||||
|
Implementation::Shape<T> a(other); |
||||||
|
return collides(&a); |
||||||
|
} |
||||||
|
|
||||||
|
private: |
||||||
|
struct Node { |
||||||
|
std::size_t rightNode, rightShape; |
||||||
|
CompositionOperation operation; |
||||||
|
}; |
||||||
|
|
||||||
|
inline bool collides(const Implementation::AbstractShape<dimensions>* a) const { |
||||||
|
return collides(a, 0, 0, _shapeCount); |
||||||
|
} |
||||||
|
|
||||||
|
bool collides(const Implementation::AbstractShape<dimensions>* a, std::size_t node, std::size_t shapeBegin, std::size_t shapeEnd) const; |
||||||
|
|
||||||
|
template<class T> inline constexpr static std::size_t shapeCount(const T&) { |
||||||
|
return 1; |
||||||
|
} |
||||||
|
inline constexpr static std::size_t shapeCount(const Composition<dimensions>& hierarchy) { |
||||||
|
return hierarchy._shapeCount; |
||||||
|
} |
||||||
|
template<class T> inline constexpr static std::size_t nodeCount(const T&) { |
||||||
|
return 0; |
||||||
|
} |
||||||
|
inline constexpr static std::size_t nodeCount(const Composition<dimensions>& hierarchy) { |
||||||
|
return hierarchy._nodeCount; |
||||||
|
} |
||||||
|
|
||||||
|
template<class T> inline void copyShapes(std::size_t offset, const T& shape) { |
||||||
|
_shapes[offset] = new Implementation::Shape<T>(shape); |
||||||
|
} |
||||||
|
void copyShapes(std::size_t offset, Composition<dimensions>&& other); |
||||||
|
void copyShapes(std::size_t offset, const Composition<dimensions>& other); |
||||||
|
|
||||||
|
template<class T> inline void copyNodes(std::size_t, const T&) {} |
||||||
|
void copyNodes(std::size_t offset, const Composition<dimensions>& other); |
||||||
|
|
||||||
|
std::size_t _shapeCount, _nodeCount; |
||||||
|
Implementation::AbstractShape<dimensions>** _shapes; |
||||||
|
Node* _nodes; |
||||||
|
}; |
||||||
|
|
||||||
|
/** @brief Two-dimensional shape hierarchy */ |
||||||
|
typedef Composition<2> Composition2D; |
||||||
|
|
||||||
|
/** @brief Three-dimensional shape hierarchy */ |
||||||
|
typedef Composition<3> Composition3D; |
||||||
|
|
||||||
|
#ifdef DOXYGEN_GENERATING_OUTPUT |
||||||
|
/** @debugoperator{Magnum::Physics::Composition} */ |
||||||
|
template<UnsignedInt dimensions> Debug operator<<(Debug debug, typename Composition<dimensions>::Type value); |
||||||
|
#endif |
||||||
|
|
||||||
|
/** @relates Composition
|
||||||
|
@brief Collision of shape with Composition |
||||||
|
*/ |
||||||
|
#ifdef DOXYGEN_GENERATING_OUTPUT |
||||||
|
template<UnsignedInt dimensions, class T> inline bool operator%(const T& a, const Composition<dimensions>& b) { |
||||||
|
#else |
||||||
|
template<UnsignedInt dimensions, class T> inline auto operator%(const T& a, const Composition<dimensions>& b) -> typename std::enable_if<std::is_same<decltype(Implementation::TypeOf<T>::type()), typename Implementation::ShapeDimensionTraits<dimensions>::Type>::value, bool>::type { |
||||||
|
#endif |
||||||
|
return b % a; |
||||||
|
} |
||||||
|
|
||||||
|
#ifdef DOXYGEN_GENERATING_OUTPUT |
||||||
|
/** @relates Composition
|
||||||
|
@brief Logical NOT of shape |
||||||
|
*/ |
||||||
|
template<class T> inline Composition<T::Dimensions> operator!(T a); |
||||||
|
|
||||||
|
/** @relates Composition
|
||||||
|
@brief Logical AND of two shapes |
||||||
|
|
||||||
|
[Short-circuit evaluation](http://en.wikipedia.org/wiki/Short-circuit_evaluation)
|
||||||
|
is used here, so this operation can be used for providing simplified shape |
||||||
|
version, because collision with @p b is computed only if @p a collides. |
||||||
|
See @ref collision-detection-shape-simplification for an example. |
||||||
|
*/ |
||||||
|
template<class T> inline Composition<T::Dimensions> operator&&(T a, T b); |
||||||
|
|
||||||
|
/** @relates Composition
|
||||||
|
@brief Logical OR of two shapes |
||||||
|
|
||||||
|
[Short-circuit evaluation](http://en.wikipedia.org/wiki/Short-circuit_evaluation)
|
||||||
|
is used, so if collision with @p a is detected, collision with @p b is not |
||||||
|
computed. |
||||||
|
*/ |
||||||
|
template<class T> inline Composition<T::Dimensions> operator||(T a, T b); |
||||||
|
#endif |
||||||
|
|
||||||
|
#ifndef DOXYGEN_GENERATING_OUTPUT |
||||||
|
#define enableIfIsShapeType typename std::enable_if< \ |
||||||
|
std::is_same<decltype(Implementation::TypeOf<T>::type()), typename Implementation::ShapeDimensionTraits<T::Dimensions>::Type>::value, \
|
||||||
|
Composition<T::Dimensions>>::type |
||||||
|
#define enableIfAreShapeType typename std::enable_if< \ |
||||||
|
std::is_same<decltype(Implementation::TypeOf<T>::type()), typename Implementation::ShapeDimensionTraits<T::Dimensions>::Type>::value && \
|
||||||
|
std::is_same<decltype(Implementation::TypeOf<U>::type()), typename Implementation::ShapeDimensionTraits<T::Dimensions>::Type>::value, \
|
||||||
|
Composition<T::Dimensions>>::type |
||||||
|
template<class T> inline auto operator!(T&& a) -> enableIfIsShapeType { |
||||||
|
return Composition<T::Dimensions>(CompositionOperation::Not, std::forward<T>(a)); |
||||||
|
} |
||||||
|
template<class T, class U> inline auto operator&&(T&& a, U&& b) -> enableIfAreShapeType { |
||||||
|
return Composition<T::Dimensions>(CompositionOperation::And, std::forward<T>(a), std::forward<U>(b)); |
||||||
|
} |
||||||
|
template<class T, class U> inline auto operator||(T&& a, U&& b) -> enableIfAreShapeType { |
||||||
|
return Composition<T::Dimensions>(CompositionOperation::Or, std::forward<T>(a), std::forward<U>(b)); |
||||||
|
} |
||||||
|
#undef enableIfIsShapeType |
||||||
|
#undef enableIfAreShapeType |
||||||
|
#endif |
||||||
|
|
||||||
|
template<UnsignedInt dimensions> template<class T> Composition<dimensions>::Composition(CompositionOperation operation, T&& a): _shapeCount(shapeCount(a)), _nodeCount(nodeCount(a)+1), _shapes(new Implementation::AbstractShape<dimensions>*[_shapeCount]), _nodes(new Node[_nodeCount]) { |
||||||
|
CORRADE_ASSERT(operation == CompositionOperation::Not, |
||||||
|
"Physics::Composition::Composition(): unary operation expected", ); |
||||||
|
_nodes[0].operation = operation; |
||||||
|
|
||||||
|
/* 0 = no children, 1 = left child only */ |
||||||
|
_nodes[0].rightNode = (nodeCount(a) == 0 ? 0 : 1); |
||||||
|
_nodes[0].rightShape = shapeCount(a); |
||||||
|
copyNodes(1, a); |
||||||
|
copyShapes(0, std::forward<T>(a)); |
||||||
|
} |
||||||
|
|
||||||
|
template<UnsignedInt dimensions> template<class T, class U> Composition<dimensions>::Composition(CompositionOperation operation, T&& a, U&& b): _shapeCount(shapeCount(a) + shapeCount(b)), _nodeCount(nodeCount(a) + nodeCount(b) + 1), _shapes(new Implementation::AbstractShape<dimensions>*[_shapeCount]), _nodes(new Node[_nodeCount]) { |
||||||
|
CORRADE_ASSERT(operation != CompositionOperation::Not, |
||||||
|
"Physics::Composition::Composition(): binary operation expected", ); |
||||||
|
_nodes[0].operation = operation; |
||||||
|
|
||||||
|
/* 0 = no children, 1 = left child only, 2 = right child only, >2 = both */ |
||||||
|
if(nodeCount(a) == 0 && nodeCount(b) == 0) |
||||||
|
_nodes[0].rightNode = 0; |
||||||
|
else if(nodeCount(b) == 0) |
||||||
|
_nodes[0].rightNode = 1; |
||||||
|
else _nodes[0].rightNode = nodeCount(a) + 2; |
||||||
|
|
||||||
|
_nodes[0].rightShape = shapeCount(a); |
||||||
|
copyNodes(1, a); |
||||||
|
copyNodes(nodeCount(a) + 1, b); |
||||||
|
copyShapes(shapeCount(a), std::forward<U>(b)); |
||||||
|
copyShapes(0, std::forward<T>(a)); |
||||||
|
} |
||||||
|
|
||||||
|
template<UnsignedInt dimensions> template<class T> inline const T& Composition<dimensions>::get(std::size_t i) const { |
||||||
|
CORRADE_ASSERT(_shapes[i]->type() == Implementation::TypeOf<T>::type(), |
||||||
|
"Physics::Composition::get(): given shape is not of type" << Implementation::TypeOf<T>::type() << |
||||||
|
"but" << _shapes[i]->type(), *static_cast<T*>(nullptr)); |
||||||
|
return static_cast<Implementation::Shape<T>*>(_shapes[i])->shape; |
||||||
|
} |
||||||
|
|
||||||
|
}} |
||||||
|
|
||||||
|
#endif |
||||||
@ -1,58 +0,0 @@ |
|||||||
/*
|
|
||||||
This file is part of Magnum. |
|
||||||
|
|
||||||
Copyright © 2010, 2011, 2012, 2013 Vladimír Vondruš <mosra@centrum.cz> |
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any person obtaining a |
|
||||||
copy of this software and associated documentation files (the "Software"), |
|
||||||
to deal in the Software without restriction, including without limitation |
|
||||||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|
||||||
and/or sell copies of the Software, and to permit persons to whom the |
|
||||||
Software is furnished to do so, subject to the following conditions: |
|
||||||
|
|
||||||
The above copyright notice and this permission notice shall be included |
|
||||||
in all copies or substantial portions of the Software. |
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|
||||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|
||||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
|
||||||
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|
||||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|
||||||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|
||||||
DEALINGS IN THE SOFTWARE. |
|
||||||
*/ |
|
||||||
|
|
||||||
#include "ObjectShapeGroup.h" |
|
||||||
|
|
||||||
#include "Physics/AbstractObjectShape.h" |
|
||||||
|
|
||||||
namespace Magnum { namespace Physics { |
|
||||||
|
|
||||||
template<UnsignedInt dimensions> void ObjectShapeGroup<dimensions>::setClean() { |
|
||||||
/* Clean all objects */ |
|
||||||
if(!this->isEmpty()) { |
|
||||||
std::vector<SceneGraph::AbstractObject<dimensions>*> objects(this->size()); |
|
||||||
for(std::size_t i = 0; i != this->size(); ++i) |
|
||||||
objects[i] = (*this)[i]->object(); |
|
||||||
|
|
||||||
objects[0]->setClean(objects); |
|
||||||
} |
|
||||||
|
|
||||||
dirty = false; |
|
||||||
} |
|
||||||
|
|
||||||
template<UnsignedInt dimensions> AbstractObjectShape<dimensions>* ObjectShapeGroup<dimensions>::firstCollision(const AbstractObjectShape<dimensions>* shape) { |
|
||||||
setClean(); |
|
||||||
for(std::size_t i = 0; i != this->size(); ++i) |
|
||||||
if((*this)[i] != shape && (*this)[i]->collides(shape)) |
|
||||||
return (*this)[i]; |
|
||||||
|
|
||||||
return nullptr; |
|
||||||
} |
|
||||||
|
|
||||||
#ifndef DOXYGEN_GENERATING_OUTPUT |
|
||||||
template class MAGNUM_PHYSICS_EXPORT ObjectShapeGroup<2>; |
|
||||||
template class MAGNUM_PHYSICS_EXPORT ObjectShapeGroup<3>; |
|
||||||
#endif |
|
||||||
|
|
||||||
}} |
|
||||||
@ -1,113 +0,0 @@ |
|||||||
#ifndef Magnum_Physics_ObjectShapeGroup_h |
|
||||||
#define Magnum_Physics_ObjectShapeGroup_h |
|
||||||
/*
|
|
||||||
This file is part of Magnum. |
|
||||||
|
|
||||||
Copyright © 2010, 2011, 2012, 2013 Vladimír Vondruš <mosra@centrum.cz> |
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any person obtaining a |
|
||||||
copy of this software and associated documentation files (the "Software"), |
|
||||||
to deal in the Software without restriction, including without limitation |
|
||||||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|
||||||
and/or sell copies of the Software, and to permit persons to whom the |
|
||||||
Software is furnished to do so, subject to the following conditions: |
|
||||||
|
|
||||||
The above copyright notice and this permission notice shall be included |
|
||||||
in all copies or substantial portions of the Software. |
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|
||||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|
||||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
|
||||||
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|
||||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|
||||||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|
||||||
DEALINGS IN THE SOFTWARE. |
|
||||||
*/ |
|
||||||
|
|
||||||
/** @file
|
|
||||||
* @brief Class Magnum::Physics::ObjectShapeGroup, typedef Magnum::Physics::ObjectShapeGroup2D, Magnum::Physics::ObjectShapeGroup3D |
|
||||||
*/ |
|
||||||
|
|
||||||
#include <vector> |
|
||||||
|
|
||||||
#include "Physics/Physics.h" |
|
||||||
#include "SceneGraph/FeatureGroup.h" |
|
||||||
|
|
||||||
#include "magnumPhysicsVisibility.h" |
|
||||||
|
|
||||||
namespace Magnum { namespace Physics { |
|
||||||
|
|
||||||
/**
|
|
||||||
@brief Group of object shapes |
|
||||||
|
|
||||||
See ObjectShape for more information. |
|
||||||
@see @ref scenegraph, ObjectShapeGroup2D, ObjectShapeGroup3D |
|
||||||
*/ |
|
||||||
template<UnsignedInt dimensions> class MAGNUM_PHYSICS_EXPORT ObjectShapeGroup: public SceneGraph::FeatureGroup<dimensions, AbstractObjectShape<dimensions>> { |
|
||||||
friend class AbstractObjectShape<dimensions>; |
|
||||||
|
|
||||||
public: |
|
||||||
/**
|
|
||||||
* @brief Constructor |
|
||||||
* |
|
||||||
* Marks the group as dirty. |
|
||||||
*/ |
|
||||||
inline explicit ObjectShapeGroup(): dirty(true) {} |
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Whether the group is dirty |
|
||||||
* @return True if any object in the group is dirty, false otherwise. |
|
||||||
*/ |
|
||||||
inline bool isDirty() const { return dirty; } |
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Set the group as dirty |
|
||||||
* |
|
||||||
* If some body in the group changes its transformation, it sets dirty |
|
||||||
* status also on the group to indicate that the body and maybe also |
|
||||||
* group state needs to be cleaned before computing collisions. |
|
||||||
* |
|
||||||
* @see setClean() |
|
||||||
*/ |
|
||||||
inline void setDirty() { dirty = true; } |
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Set the group and all bodies as clean |
|
||||||
* |
|
||||||
* This function is called before computing any collisions to ensure |
|
||||||
* all objects are cleaned. |
|
||||||
*/ |
|
||||||
void setClean(); |
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief First collision of given shape with other shapes in the group |
|
||||||
* |
|
||||||
* Returns first shape colliding with given one. If there aren't any |
|
||||||
* collisions, returns `nullptr`. Calls setClean() before the |
|
||||||
* operation. |
|
||||||
*/ |
|
||||||
AbstractObjectShape<dimensions>* firstCollision(const AbstractObjectShape<dimensions>* shape); |
|
||||||
|
|
||||||
private: |
|
||||||
bool dirty; |
|
||||||
}; |
|
||||||
|
|
||||||
/**
|
|
||||||
@brief Group of two-dimensional shaped objects |
|
||||||
|
|
||||||
See ObjectShape for more information. |
|
||||||
@see ObjectShapeGroup3D |
|
||||||
*/ |
|
||||||
typedef ObjectShapeGroup<2> ObjectShapeGroup2D; |
|
||||||
|
|
||||||
/**
|
|
||||||
@brief Group of three-dimensional shaped objects |
|
||||||
|
|
||||||
See ObjectShape for more information. |
|
||||||
@see ObjectShapeGroup2D |
|
||||||
*/ |
|
||||||
typedef ObjectShapeGroup<3> ObjectShapeGroup3D; |
|
||||||
|
|
||||||
}} |
|
||||||
|
|
||||||
#endif |
|
||||||
Loading…
Reference in new issue