mrq/reactphysics3d
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix virtual constructors, use c++11 scoped enums, use c++11 delete methods instead of private constructors

Browse Source
This commit is contained in:
Daniel Chappuis 2016-07-08 07:25:37 +02:00
parent be957ba41a
commit f5ade0f52d
74 changed files with 412 additions and 416 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/body/Body.h
View File

@ -75,14 +75,6 @@ class Body {
/// Pointer that can be used to attach user data to the body
void* mUserData;
// -------------------- Methods -------------------- //
/// Private copy-constructor
Body(const Body& body);
/// Private assignment operator
Body& operator=(const Body& body);
public :
// -------------------- Methods -------------------- //
@ -90,6 +82,12 @@ class Body {
/// Constructor
Body(bodyindex id);
/// Deleted copy-constructor
Body(const Body& body) = delete;
/// Deleted assignment operator
Body& operator=(const Body& body) = delete;
/// Destructor
virtual ~Body();

2
src/body/CollisionBody.cpp
View File

@ -38,7 +38,7 @@ using namespace reactphysics3d;
* @param id ID of the body
*/
CollisionBody::CollisionBody(const Transform& transform, CollisionWorld& world, bodyindex id)
: Body(id), mType(DYNAMIC), mTransform(transform), mProxyCollisionShapes(nullptr),
: Body(id), mType(BodyType::DYNAMIC), mTransform(transform), mProxyCollisionShapes(nullptr),
mNbCollisionShapes(0), mContactManifoldsList(nullptr), mWorld(world) {
}

16
src/body/CollisionBody.h
View File

@ -54,7 +54,7 @@ class CollisionWorld;
/// DYNAMIC : A dynamic body has non-zero mass, non-zero velocity determined by forces and its
/// position is determined by the physics engine. A dynamic body can collide with other
/// dynamic, static or kinematic bodies.
enum BodyType {STATIC, KINEMATIC, DYNAMIC};
enum class BodyType {STATIC, KINEMATIC, DYNAMIC};
// Class CollisionBody
/**
@ -87,12 +87,6 @@ class CollisionBody : public Body {
// -------------------- Methods -------------------- //
/// Private copy-constructor
CollisionBody(const CollisionBody& body);
/// Private assignment operator
CollisionBody& operator=(const CollisionBody& body);
/// Reset the contact manifold lists
void resetContactManifoldsList();
@ -122,6 +116,12 @@ class CollisionBody : public Body {
/// Destructor
virtual ~CollisionBody();
/// Deleted copy-constructor
CollisionBody(const CollisionBody& body) = delete;
/// Deleted assignment operator
CollisionBody& operator=(const CollisionBody& body) = delete;
/// Return the type of the body
BodyType getType() const;
@ -208,7 +208,7 @@ inline BodyType CollisionBody::getType() const {
inline void CollisionBody::setType(BodyType type) {
mType = type;
if (mType == STATIC) {
if (mType == BodyType::STATIC) {
// Update the broad-phase state of the body
updateBroadPhaseState();

18
src/body/RigidBody.cpp
View File

@ -76,7 +76,7 @@ void RigidBody::setType(BodyType type) {
recomputeMassInformation();
// If it is a static body
if (mType == STATIC) {
if (mType == BodyType::STATIC) {
// Reset the velocity to zero
mLinearVelocity.setToZero();
@ -84,7 +84,7 @@ void RigidBody::setType(BodyType type) {
}
// If it is a static or a kinematic body
if (mType == STATIC || mType == KINEMATIC) {
if (mType == BodyType::STATIC || mType == BodyType::KINEMATIC) {
// Reset the inverse mass and inverse inertia tensor to zero
mMassInverse = decimal(0.0);
@ -119,7 +119,7 @@ void RigidBody::setType(BodyType type) {
*/
void RigidBody::setInertiaTensorLocal(const Matrix3x3& inertiaTensorLocal) {
if (mType != DYNAMIC) return;
if (mType != BodyType::DYNAMIC) return;
mInertiaTensorLocal = inertiaTensorLocal;
@ -134,7 +134,7 @@ void RigidBody::setInertiaTensorLocal(const Matrix3x3& inertiaTensorLocal) {
*/
void RigidBody::setCenterOfMassLocal(const Vector3& centerOfMassLocal) {
if (mType != DYNAMIC) return;
if (mType != BodyType::DYNAMIC) return;
const Vector3 oldCenterOfMass = mCenterOfMassWorld;
mCenterOfMassLocal = centerOfMassLocal;
@ -152,7 +152,7 @@ void RigidBody::setCenterOfMassLocal(const Vector3& centerOfMassLocal) {
*/
void RigidBody::setMass(decimal mass) {
if (mType != DYNAMIC) return;
if (mType != BodyType::DYNAMIC) return;
mInitMass = mass;
@ -267,7 +267,7 @@ void RigidBody::removeCollisionShape(const ProxyShape* proxyShape) {
void RigidBody::setLinearVelocity(const Vector3& linearVelocity) {
// If it is a static body, we do nothing
if (mType == STATIC) return;
if (mType == BodyType::STATIC) return;
// Update the linear velocity of the current body state
mLinearVelocity = linearVelocity;
@ -285,7 +285,7 @@ void RigidBody::setLinearVelocity(const Vector3& linearVelocity) {
void RigidBody::setAngularVelocity(const Vector3& angularVelocity) {
// If it is a static body, we do nothing
if (mType == STATIC) return;
if (mType == BodyType::STATIC) return;
// Set the angular velocity
mAngularVelocity = angularVelocity;
@ -329,12 +329,12 @@ void RigidBody::recomputeMassInformation() {
mCenterOfMassLocal.setToZero();
// If it is STATIC or KINEMATIC body
if (mType == STATIC || mType == KINEMATIC) {
if (mType == BodyType::STATIC || mType == BodyType::KINEMATIC) {
mCenterOfMassWorld = mTransform.getPosition();
return;
}
assert(mType == DYNAMIC);
assert(mType == BodyType::DYNAMIC);
// Compute the total mass of the body
for (ProxyShape* shape = mProxyCollisionShapes; shape != nullptr; shape = shape->mNext) {

18
src/body/RigidBody.h
View File

@ -103,12 +103,6 @@ class RigidBody : public CollisionBody {
// -------------------- Methods -------------------- //
/// Private copy-constructor
RigidBody(const RigidBody& body);
/// Private assignment operator
RigidBody& operator=(const RigidBody& body);
/// Remove a joint from the joints list
void removeJointFromJointsList(MemoryAllocator& memoryAllocator, const Joint* joint);
@ -128,6 +122,12 @@ class RigidBody : public CollisionBody {
/// Destructor
virtual ~RigidBody();
/// Deleted copy-constructor
RigidBody(const RigidBody& body) = delete;
/// Deleted assignment operator
RigidBody& operator=(const RigidBody& body) = delete;
/// Set the type of the body (static, kinematic or dynamic)
void setType(BodyType type);
@ -407,7 +407,7 @@ inline void RigidBody::setIsSleeping(bool isSleeping) {
inline void RigidBody::applyForceToCenterOfMass(const Vector3& force) {
// If it is not a dynamic body, we do nothing
if (mType != DYNAMIC) return;
if (mType != BodyType::DYNAMIC) return;
// Awake the body if it was sleeping
if (mIsSleeping) {
@ -432,7 +432,7 @@ inline void RigidBody::applyForceToCenterOfMass(const Vector3& force) {
inline void RigidBody::applyForce(const Vector3& force, const Vector3& point) {
// If it is not a dynamic body, we do nothing
if (mType != DYNAMIC) return;
if (mType != BodyType::DYNAMIC) return;
// Awake the body if it was sleeping
if (mIsSleeping) {
@ -455,7 +455,7 @@ inline void RigidBody::applyForce(const Vector3& force, const Vector3& point) {
inline void RigidBody::applyTorque(const Vector3& torque) {
// If it is not a dynamic body, we do nothing
if (mType != DYNAMIC) return;
if (mType != BodyType::DYNAMIC) return;
// Awake the body if it was sleeping
if (mIsSleeping) {

14
src/collision/CollisionDetection.cpp
View File

@ -209,8 +209,8 @@ void CollisionDetection::computeNarrowPhase() {
pair->update();
// Check that at least one body is awake and not static
bool isBody1Active = !body1->isSleeping() && body1->getType() != STATIC;
bool isBody2Active = !body2->isSleeping() && body2->getType() != STATIC;
bool isBody1Active = !body1->isSleeping() && body1->getType() != BodyType::STATIC;
bool isBody2Active = !body2->isSleeping() && body2->getType() != BodyType::STATIC;
if (!isBody1Active && !isBody2Active) continue;
// Check if the bodies are in the set of bodies that cannot collide between each other
@ -220,7 +220,9 @@ void CollisionDetection::computeNarrowPhase() {
// Select the narrow phase algorithm to use according to the two collision shapes
const CollisionShapeType shape1Type = shape1->getCollisionShape()->getType();
const CollisionShapeType shape2Type = shape2->getCollisionShape()->getType();
NarrowPhaseAlgorithm* narrowPhaseAlgorithm = mCollisionMatrix[shape1Type][shape2Type];
const int shape1Index = static_cast<int>(shape1Type);
const int shape2Index = static_cast<int>(shape2Type);
NarrowPhaseAlgorithm* narrowPhaseAlgorithm = mCollisionMatrix[shape1Index][shape2Index];
// If there is no collision algorithm between those two kinds of shapes
if (narrowPhaseAlgorithm == nullptr) continue;
@ -312,7 +314,7 @@ void CollisionDetection::computeNarrowPhaseBetweenShapes(CollisionCallback* call
pair->update();
// Check if the two bodies are allowed to collide, otherwise, we do not test for collision
if (body1->getType() != DYNAMIC && body2->getType() != DYNAMIC) continue;
if (body1->getType() != BodyType::DYNAMIC && body2->getType() != BodyType::DYNAMIC) continue;
bodyindexpair bodiesIndex = OverlappingPair::computeBodiesIndexPair(body1, body2);
if (mNoCollisionPairs.count(bodiesIndex) > 0) continue;
@ -322,7 +324,9 @@ void CollisionDetection::computeNarrowPhaseBetweenShapes(CollisionCallback* call
// Select the narrow phase algorithm to use according to the two collision shapes
const CollisionShapeType shape1Type = shape1->getCollisionShape()->getType();
const CollisionShapeType shape2Type = shape2->getCollisionShape()->getType();
NarrowPhaseAlgorithm* narrowPhaseAlgorithm = mCollisionMatrix[shape1Type][shape2Type];
const int shape1Index = static_cast<int>(shape1Type);
const int shape2Index = static_cast<int>(shape2Type);
NarrowPhaseAlgorithm* narrowPhaseAlgorithm = mCollisionMatrix[shape1Index][shape2Index];
// If there is no collision algorithm between those two kinds of shapes
if (narrowPhaseAlgorithm == nullptr) continue;

14
src/collision/CollisionDetection.h
View File

@ -116,12 +116,6 @@ class CollisionDetection : public NarrowPhaseCallback {
// -------------------- Methods -------------------- //
/// Private copy-constructor
CollisionDetection(const CollisionDetection& collisionDetection);
/// Private assignment operator
CollisionDetection& operator=(const CollisionDetection& collisionDetection);
/// Compute the broad-phase collision detection
void computeBroadPhase();
@ -151,6 +145,12 @@ class CollisionDetection : public NarrowPhaseCallback {
/// Destructor
~CollisionDetection();
/// Deleted copy-constructor
CollisionDetection(const CollisionDetection& collisionDetection) = delete;
/// Deleted assignment operator
CollisionDetection& operator=(const CollisionDetection& collisionDetection) = delete;
/// Set the collision dispatch configuration
void setCollisionDispatch(CollisionDispatch* collisionDispatch);
@ -234,7 +234,7 @@ class CollisionDetection : public NarrowPhaseCallback {
// Return the Narrow-phase collision detection algorithm to use between two types of shapes
inline NarrowPhaseAlgorithm* CollisionDetection::getCollisionAlgorithm(CollisionShapeType shape1Type,
CollisionShapeType shape2Type) const {
return mCollisionMatrix[shape1Type][shape2Type];
return mCollisionMatrix[static_cast<int>(shape1Type)][static_cast<int>(shape2Type)];
}
// Set the collision dispatch configuration

12
src/collision/ContactManifold.h
View File

@ -130,12 +130,6 @@ class ContactManifold {
// -------------------- Methods -------------------- //
/// Private copy-constructor
ContactManifold(const ContactManifold& contactManifold);
/// Private assignment operator
ContactManifold& operator=(const ContactManifold& contactManifold);
/// Return the index of maximum area
int getMaxArea(decimal area0, decimal area1, decimal area2, decimal area3) const;
@ -162,6 +156,12 @@ class ContactManifold {
/// Destructor
~ContactManifold();
/// Deleted copy-constructor
ContactManifold(const ContactManifold& contactManifold) = delete;
/// Deleted assignment operator
ContactManifold& operator=(const ContactManifold& contactManifold) = delete;
/// Return a pointer to the first proxy shape of the contact
ProxyShape* getShape1() const;

16
src/collision/ProxyShape.h
View File

@ -85,14 +85,6 @@ class ProxyShape {
/// proxy shape will collide with every collision categories by default.
unsigned short mCollideWithMaskBits;
// -------------------- Methods -------------------- //
/// Private copy-constructor
ProxyShape(const ProxyShape& proxyShape);
/// Private assignment operator
ProxyShape& operator=(const ProxyShape& proxyShape);
public:
// -------------------- Methods -------------------- //
@ -102,7 +94,13 @@ class ProxyShape {
const Transform& transform, decimal mass);
/// Destructor
~ProxyShape();
virtual ~ProxyShape();
/// Deleted copy-constructor
ProxyShape(const ProxyShape& proxyShape) = delete;
/// Deleted assignment operator
ProxyShape& operator=(const ProxyShape& proxyShape) = delete;
/// Return the collision shape
const CollisionShape* getCollisionShape() const;

14
src/collision/RaycastInfo.h
View File

@ -46,14 +46,6 @@ struct RaycastInfo {
private:
// -------------------- Methods -------------------- //
/// Private copy constructor
RaycastInfo(const RaycastInfo& raycastInfo);
/// Private assignment operator
RaycastInfo& operator=(const RaycastInfo& raycastInfo);
public:
// -------------------- Attributes -------------------- //
@ -91,6 +83,12 @@ struct RaycastInfo {
~RaycastInfo() {
}
/// Deleted copy constructor
RaycastInfo(const RaycastInfo& raycastInfo) = delete;
/// Deleted assignment operator
RaycastInfo& operator=(const RaycastInfo& raycastInfo) = delete;
};
// Class RaycastCallback

4
src/collision/TriangleVertexArray.h
View File

@ -46,10 +46,10 @@ class TriangleVertexArray {
public:
/// Data type for the vertices in the array
enum VertexDataType {VERTEX_FLOAT_TYPE, VERTEX_DOUBLE_TYPE};
enum class VertexDataType {VERTEX_FLOAT_TYPE, VERTEX_DOUBLE_TYPE};
/// Data type for the indices in the array
enum IndexDataType {INDEX_INTEGER_TYPE, INDEX_SHORT_TYPE};
enum class IndexDataType {INDEX_INTEGER_TYPE, INDEX_SHORT_TYPE};
protected:

17
src/collision/broadphase/BroadPhaseAlgorithm.h
View File

@ -109,6 +109,9 @@ class BroadPhaseRaycastCallback : public DynamicAABBTreeRaycastCallback {
}
// Destructor
virtual ~BroadPhaseRaycastCallback() {}
// Called for a broad-phase shape that has to be tested for raycast
virtual decimal raycastBroadPhaseShape(int32 nodeId, const Ray& ray);
@ -159,14 +162,6 @@ class BroadPhaseAlgorithm {
/// Reference to the collision detection object
CollisionDetection& mCollisionDetection;
// -------------------- Methods -------------------- //
/// Private copy-constructor
BroadPhaseAlgorithm(const BroadPhaseAlgorithm& algorithm);
/// Private assignment operator
BroadPhaseAlgorithm& operator=(const BroadPhaseAlgorithm& algorithm);
public :
@ -177,6 +172,12 @@ class BroadPhaseAlgorithm {
/// Destructor
~BroadPhaseAlgorithm();
/// Deleted copy-constructor
BroadPhaseAlgorithm(const BroadPhaseAlgorithm& algorithm) = delete;
/// Deleted assignment operator
BroadPhaseAlgorithm& operator=(const BroadPhaseAlgorithm& algorithm) = delete;
/// Add a proxy collision shape into the broad-phase collision detection
void addProxyCollisionShape(ProxyShape* proxyShape, const AABB& aabb);

5
src/collision/broadphase/DynamicAABBTree.h
View File

@ -101,6 +101,9 @@ class DynamicAABBTreeOverlapCallback {
// Called when a overlapping node has been found during the call to
// DynamicAABBTree:reportAllShapesOverlappingWithAABB()
virtual void notifyOverlappingNode(int nodeId)=0;
// Destructor
virtual ~DynamicAABBTreeOverlapCallback() {}
};
// Class DynamicAABBTreeRaycastCallback
@ -115,6 +118,8 @@ class DynamicAABBTreeRaycastCallback {
// Called when the AABB of a leaf node is hit by a ray
virtual decimal raycastBroadPhaseShape(int32 nodeId, const Ray& ray)=0;
virtual ~DynamicAABBTreeRaycastCallback() {}
};
// Class DynamicAABBTree

6
src/collision/narrowphase/ConcaveVsConvexAlgorithm.cpp
View File

@ -263,8 +263,8 @@ void SmoothCollisionNarrowPhaseCallback::notifyContact(OverlappingPair* overlapp
bool isFirstShapeTriangle;
// If the collision shape 1 is the triangle
if (contactInfo.collisionShape1->getType() == TRIANGLE) {
assert(contactInfo.collisionShape2->getType() != TRIANGLE);
if (contactInfo.collisionShape1->getType() == CollisionShapeType::TRIANGLE) {
assert(contactInfo.collisionShape2->getType() != CollisionShapeType::TRIANGLE);
const TriangleShape* triangleShape = static_cast<const TriangleShape*>(contactInfo.collisionShape1);
triangleVertices[0] = triangleShape->getVertex(0);
@ -274,7 +274,7 @@ void SmoothCollisionNarrowPhaseCallback::notifyContact(OverlappingPair* overlapp
isFirstShapeTriangle = true;
}
else { // If the collision shape 2 is the triangle
assert(contactInfo.collisionShape2->getType() == TRIANGLE);
assert(contactInfo.collisionShape2->getType() == CollisionShapeType::TRIANGLE);
const TriangleShape* triangleShape = static_cast<const TriangleShape*>(contactInfo.collisionShape2);
triangleVertices[0] = triangleShape->getVertex(0);

3
src/collision/narrowphase/ConcaveVsConvexAlgorithm.h
View File

@ -72,6 +72,9 @@ class ConvexVsTriangleCallback : public TriangleCallback {
public:
/// Destructor
virtual ~ConvexVsTriangleCallback() {}
/// Set the collision detection pointer
void setCollisionDetection(CollisionDetection* collisionDetection) {
mCollisionDetection = collisionDetection;

2
src/collision/narrowphase/DefaultCollisionDispatch.cpp
View File

@ -57,7 +57,7 @@ NarrowPhaseAlgorithm* DefaultCollisionDispatch::selectAlgorithm(int type1, int t
CollisionShapeType shape2Type = static_cast<CollisionShapeType>(type2);
// Sphere vs Sphere algorithm
if (shape1Type == SPHERE && shape2Type == SPHERE) {
if (shape1Type == CollisionShapeType::SPHERE && shape2Type == CollisionShapeType::SPHERE) {
return &mSphereVsSphereAlgorithm;
}
// Concave vs Convex algorithm

12
src/collision/narrowphase/EPA/EPAAlgorithm.h
View File

@ -95,12 +95,6 @@ class EPAAlgorithm {
// -------------------- Methods -------------------- //
/// Private copy-constructor
EPAAlgorithm(const EPAAlgorithm& algorithm);
/// Private assignment operator
EPAAlgorithm& operator=(const EPAAlgorithm& algorithm);
/// Add a triangle face in the candidate triangle heap
void addFaceCandidate(TriangleEPA* triangle, TriangleEPA** heap, uint& nbTriangles,
decimal upperBoundSquarePenDepth);
@ -119,6 +113,12 @@ class EPAAlgorithm {
/// Destructor
~EPAAlgorithm();
/// Deleted copy-constructor
EPAAlgorithm(const EPAAlgorithm& algorithm) = delete;
/// Deleted assignment operator
EPAAlgorithm& operator=(const EPAAlgorithm& algorithm) = delete;
/// Initalize the algorithm
void init(MemoryAllocator* memoryAllocator);

14
src/collision/narrowphase/EPA/TriangleEPA.h
View File

@ -74,14 +74,6 @@ class TriangleEPA {
/// Square distance of the point closest point v to the origin
decimal mDistSquare;
// -------------------- Methods -------------------- //
/// Private copy-constructor
TriangleEPA(const TriangleEPA& triangle);
/// Private assignment operator
TriangleEPA& operator=(const TriangleEPA& triangle);
public:
// -------------------- Methods -------------------- //
@ -95,6 +87,12 @@ class TriangleEPA {
/// Destructor
~TriangleEPA();
/// Deleted copy-constructor
TriangleEPA(const TriangleEPA& triangle) = delete;
/// Deleted assignment operator
TriangleEPA& operator=(const TriangleEPA& triangle) = delete;
/// Return an adjacent edge of the triangle
EdgeEPA& getAdjacentEdge(int index);

16
src/collision/narrowphase/EPA/TrianglesStore.h
View File

@ -52,15 +52,7 @@ class TrianglesStore {
TriangleEPA mTriangles[MAX_TRIANGLES];
/// Number of triangles
int mNbTriangles;
// -------------------- Methods -------------------- //
/// Private copy-constructor
TrianglesStore(const TrianglesStore& triangleStore);
/// Private assignment operator
TrianglesStore& operator=(const TrianglesStore& triangleStore);
int mNbTriangles;
public:
@ -72,6 +64,12 @@ class TrianglesStore {
/// Destructor
~TrianglesStore();
/// Deleted copy-constructor
TrianglesStore(const TrianglesStore& triangleStore) = delete;
/// Deleted assignment operator
TrianglesStore& operator=(const TrianglesStore& triangleStore) = delete;
/// Clear all the storage
void clear();

12
src/collision/narrowphase/GJK/GJKAlgorithm.h
View File

@ -68,12 +68,6 @@ class GJKAlgorithm : public NarrowPhaseAlgorithm {
// -------------------- Methods -------------------- //
/// Private copy-constructor
GJKAlgorithm(const GJKAlgorithm& algorithm);
/// Private assignment operator
GJKAlgorithm& operator=(const GJKAlgorithm& algorithm);
/// Compute the penetration depth for enlarged objects.
void computePenetrationDepthForEnlargedObjects(const CollisionShapeInfo& shape1Info,
const Transform& transform1,
@ -92,6 +86,12 @@ class GJKAlgorithm : public NarrowPhaseAlgorithm {
/// Destructor
~GJKAlgorithm();
/// Deleted copy-constructor
GJKAlgorithm(const GJKAlgorithm& algorithm) = delete;
/// Deleted assignment operator
GJKAlgorithm& operator=(const GJKAlgorithm& algorithm) = delete;
/// Initalize the algorithm
virtual void init(CollisionDetection* collisionDetection,
MemoryAllocator* memoryAllocator);

12
src/collision/narrowphase/GJK/Simplex.h
View File

@ -90,12 +90,6 @@ class Simplex {
// -------------------- Methods -------------------- //
/// Private copy-constructor
Simplex(const Simplex& simplex);
/// Private assignment operator
Simplex& operator=(const Simplex& simplex);
/// Return true if some bits of "a" overlap with bits of "b"
bool overlap(Bits a, Bits b) const;
@ -127,6 +121,12 @@ class Simplex {
/// Destructor
~Simplex();
/// Deleted copy-constructor
Simplex(const Simplex& simplex) = delete;
/// Deleted assignment operator
Simplex& operator=(const Simplex& simplex) = delete;
/// Return true if the simplex contains 4 points
bool isFull() const;

16
src/collision/narrowphase/NarrowPhaseAlgorithm.h
View File

@ -47,6 +47,8 @@ class NarrowPhaseCallback {
public:
virtual ~NarrowPhaseCallback() {}
/// Called by a narrow-phase collision algorithm when a new contact has been found
virtual void notifyContact(OverlappingPair* overlappingPair,
const ContactPointInfo& contactInfo)=0;
@ -73,14 +75,6 @@ class NarrowPhaseAlgorithm {
/// Overlapping pair of the bodies currently tested for collision
OverlappingPair* mCurrentOverlappingPair;
// -------------------- Methods -------------------- //
/// Private copy-constructor
NarrowPhaseAlgorithm(const NarrowPhaseAlgorithm& algorithm);
/// Private assignment operator
NarrowPhaseAlgorithm& operator=(const NarrowPhaseAlgorithm& algorithm);
public :
@ -92,6 +86,12 @@ class NarrowPhaseAlgorithm {
/// Destructor
virtual ~NarrowPhaseAlgorithm();
/// Deleted copy-constructor
NarrowPhaseAlgorithm(const NarrowPhaseAlgorithm& algorithm) = delete;
/// Deleted assignment operator
NarrowPhaseAlgorithm& operator=(const NarrowPhaseAlgorithm& algorithm) = delete;
/// Initalize the algorithm
virtual void init(CollisionDetection* collisionDetection, MemoryAllocator* memoryAllocator);

14
src/collision/narrowphase/SphereVsSphereAlgorithm.h
View File

@ -44,14 +44,6 @@ class SphereVsSphereAlgorithm : public NarrowPhaseAlgorithm {
protected :
// -------------------- Methods -------------------- //
/// Private copy-constructor
SphereVsSphereAlgorithm(const SphereVsSphereAlgorithm& algorithm);
/// Private assignment operator
SphereVsSphereAlgorithm& operator=(const SphereVsSphereAlgorithm& algorithm);
public :
// -------------------- Methods -------------------- //
@ -62,6 +54,12 @@ class SphereVsSphereAlgorithm : public NarrowPhaseAlgorithm {
/// Destructor
virtual ~SphereVsSphereAlgorithm();
/// Deleted copy-constructor
SphereVsSphereAlgorithm(const SphereVsSphereAlgorithm& algorithm) = delete;
/// Deleted assignment operator
SphereVsSphereAlgorithm& operator=(const SphereVsSphereAlgorithm& algorithm) = delete;
/// Compute a contact info if the two bounding volume collide
virtual void testCollision(const CollisionShapeInfo& shape1Info,
const CollisionShapeInfo& shape2Info,

2
src/collision/shapes/BoxShape.cpp
View File

@ -38,7 +38,7 @@ using namespace reactphysics3d;
* @param margin The collision margin (in meters) around the collision shape
*/
BoxShape::BoxShape(const Vector3& extent, decimal margin)
: ConvexShape(BOX, margin), mExtent(extent - Vector3(margin, margin, margin)) {
: ConvexShape(CollisionShapeType::BOX, margin), mExtent(extent - Vector3(margin, margin, margin)) {
assert(extent.x > decimal(0.0) && extent.x > margin);
assert(extent.y > decimal(0.0) && extent.y > margin);
assert(extent.z > decimal(0.0) && extent.z > margin);

12
src/collision/shapes/BoxShape.h
View File

@ -61,12 +61,6 @@ class BoxShape : public ConvexShape {
// -------------------- Methods -------------------- //
/// Private copy-constructor
BoxShape(const BoxShape& shape);
/// Private assignment operator
BoxShape& operator=(const BoxShape& shape);
/// Return a local support point in a given direction without the object margin
virtual Vector3 getLocalSupportPointWithoutMargin(const Vector3& direction,
void** cachedCollisionData) const;
@ -90,6 +84,12 @@ class BoxShape : public ConvexShape {
/// Destructor
virtual ~BoxShape();
/// Deleted copy-constructor
BoxShape(const BoxShape& shape) = delete;
/// Deleted assignment operator
BoxShape& operator=(const BoxShape& shape) = delete;
/// Return the extents of the box
Vector3 getExtent() const;

2
src/collision/shapes/CapsuleShape.cpp
View File

@ -37,7 +37,7 @@ using namespace reactphysics3d;
* @param height The height of the capsule (in meters)
*/
CapsuleShape::CapsuleShape(decimal radius, decimal height)
: ConvexShape(CAPSULE, radius), mHalfHeight(height * decimal(0.5)) {
: ConvexShape(CollisionShapeType::CAPSULE, radius), mHalfHeight(height * decimal(0.5)) {
assert(radius > decimal(0.0));
assert(height > decimal(0.0));
}

12
src/collision/shapes/CapsuleShape.h
View File

@ -55,12 +55,6 @@ class CapsuleShape : public ConvexShape {
// -------------------- Methods -------------------- //
/// Private copy-constructor
CapsuleShape(const CapsuleShape& shape);
/// Private assignment operator
CapsuleShape& operator=(const CapsuleShape& shape);
/// Return a local support point in a given direction without the object margin
virtual Vector3 getLocalSupportPointWithoutMargin(const Vector3& direction,
void** cachedCollisionData) const;
@ -89,6 +83,12 @@ class CapsuleShape : public ConvexShape {
/// Destructor
virtual ~CapsuleShape();
/// Deleted copy-constructor
CapsuleShape(const CapsuleShape& shape) = delete;
/// Deleted assignment operator
CapsuleShape& operator=(const CapsuleShape& shape) = delete;
/// Return the radius of the capsule
decimal getRadius() const;

16
src/collision/shapes/CollisionShape.h
View File

@ -40,7 +40,7 @@
namespace reactphysics3d {
/// Type of the collision shape
enum CollisionShapeType {TRIANGLE, BOX, SPHERE, CONE, CYLINDER,
enum class CollisionShapeType {TRIANGLE, BOX, SPHERE, CONE, CYLINDER,
CAPSULE, CONVEX_MESH, CONCAVE_MESH, HEIGHTFIELD};
const int NB_COLLISION_SHAPE_TYPES = 9;
@ -67,12 +67,6 @@ class CollisionShape {
// -------------------- Methods -------------------- //
/// Private copy-constructor
CollisionShape(const CollisionShape& shape);
/// Private assignment operator
CollisionShape& operator=(const CollisionShape& shape);
/// Return true if a point is inside the collision shape
virtual bool testPointInside(const Vector3& worldPoint, ProxyShape* proxyShape) const=0;
@ -92,6 +86,12 @@ class CollisionShape {
/// Destructor
virtual ~CollisionShape();
/// Deleted copy-constructor
CollisionShape(const CollisionShape& shape) = delete;
/// Deleted assignment operator
CollisionShape& operator=(const CollisionShape& shape) = delete;
/// Return the type of the collision shapes
CollisionShapeType getType() const;
@ -136,7 +136,7 @@ inline CollisionShapeType CollisionShape::getType() const {
// Return true if the collision shape type is a convex shape
inline bool CollisionShape::isConvex(CollisionShapeType shapeType) {
return shapeType != CONCAVE_MESH && shapeType != HEIGHTFIELD;
return shapeType != CollisionShapeType::CONCAVE_MESH && shapeType != CollisionShapeType::HEIGHTFIELD;
}
// Return the scaling vector of the collision shape

20
src/collision/shapes/ConcaveMeshShape.cpp
View File

@ -30,9 +30,9 @@ using namespace reactphysics3d;
// Constructor
ConcaveMeshShape::ConcaveMeshShape(TriangleMesh* triangleMesh)
: ConcaveShape(CONCAVE_MESH) {
: ConcaveShape(CollisionShapeType::CONCAVE_MESH) {
mTriangleMesh = triangleMesh;
mRaycastTestType = FRONT;
mRaycastTestType = TriangleRaycastSide::FRONT;
// Insert all the triangles into the dynamic AABB tree
initBVHTree();
@ -72,10 +72,10 @@ void ConcaveMeshShape::initBVHTree() {
// Get the index of the current vertex in the triangle
int vertexIndex = 0;
if (indexType == TriangleVertexArray::INDEX_INTEGER_TYPE) {
if (indexType == TriangleVertexArray::IndexDataType::INDEX_INTEGER_TYPE) {
vertexIndex = ((uint*)vertexIndexPointer)[k];
}
else if (indexType == TriangleVertexArray::INDEX_SHORT_TYPE) {
else if (indexType == TriangleVertexArray::IndexDataType::INDEX_SHORT_TYPE) {
vertexIndex = ((unsigned short*)vertexIndexPointer)[k];
}
else {
@ -83,13 +83,13 @@ void ConcaveMeshShape::initBVHTree() {
}
// Get the vertices components of the triangle
if (vertexType == TriangleVertexArray::VERTEX_FLOAT_TYPE) {
if (vertexType == TriangleVertexArray::VertexDataType::VERTEX_FLOAT_TYPE) {
const float* vertices = (float*)(verticesStart + vertexIndex * vertexStride);
trianglePoints[k][0] = decimal(vertices[0]) * mScaling.x;
trianglePoints[k][1] = decimal(vertices[1]) * mScaling.y;
trianglePoints[k][2] = decimal(vertices[2]) * mScaling.z;
}
else if (vertexType == TriangleVertexArray::VERTEX_DOUBLE_TYPE) {
else if (vertexType == TriangleVertexArray::VertexDataType::VERTEX_DOUBLE_TYPE) {
const double* vertices = (double*)(verticesStart + vertexIndex * vertexStride);
trianglePoints[k][0] = decimal(vertices[0]) * mScaling.x;
trianglePoints[k][1] = decimal(vertices[1]) * mScaling.y;
@ -132,10 +132,10 @@ void ConcaveMeshShape::getTriangleVerticesWithIndexPointer(int32 subPart, int32
// Get the index of the current vertex in the triangle
int vertexIndex = 0;
if (indexType == TriangleVertexArray::INDEX_INTEGER_TYPE) {
if (indexType == TriangleVertexArray::IndexDataType::INDEX_INTEGER_TYPE) {
vertexIndex = ((uint*)vertexIndexPointer)[k];
}
else if (indexType == TriangleVertexArray::INDEX_SHORT_TYPE) {
else if (indexType == TriangleVertexArray::IndexDataType::INDEX_SHORT_TYPE) {
vertexIndex = ((unsigned short*)vertexIndexPointer)[k];
}
else {
@ -143,13 +143,13 @@ void ConcaveMeshShape::getTriangleVerticesWithIndexPointer(int32 subPart, int32
}
// Get the vertices components of the triangle
if (vertexType == TriangleVertexArray::VERTEX_FLOAT_TYPE) {
if (vertexType == TriangleVertexArray::VertexDataType::VERTEX_FLOAT_TYPE) {
const float* vertices = (float*)(verticesStart + vertexIndex * vertexStride);
outTriangleVertices[k][0] = decimal(vertices[0]) * mScaling.x;
outTriangleVertices[k][1] = decimal(vertices[1]) * mScaling.y;
outTriangleVertices[k][2] = decimal(vertices[2]) * mScaling.z;
}
else if (vertexType == TriangleVertexArray::VERTEX_DOUBLE_TYPE) {
else if (vertexType == TriangleVertexArray::VertexDataType::VERTEX_DOUBLE_TYPE) {
const double* vertices = (double*)(verticesStart + vertexIndex * vertexStride);
outTriangleVertices[k][0] = decimal(vertices[0]) * mScaling.x;
outTriangleVertices[k][1] = decimal(vertices[1]) * mScaling.y;

14
src/collision/shapes/ConcaveMeshShape.h
View File

@ -120,12 +120,6 @@ class ConcaveMeshShape : public ConcaveShape {
// -------------------- Methods -------------------- //
/// Private copy-constructor
ConcaveMeshShape(const ConcaveMeshShape& shape);
/// Private assignment operator
ConcaveMeshShape& operator=(const ConcaveMeshShape& shape);
/// Raycast method with feedback information
virtual bool raycast(const Ray& ray, RaycastInfo& raycastInfo, ProxyShape* proxyShape) const;
@ -146,7 +140,13 @@ class ConcaveMeshShape : public ConcaveShape {
ConcaveMeshShape(TriangleMesh* triangleMesh);
/// Destructor
~ConcaveMeshShape();
virtual ~ConcaveMeshShape();
/// Deleted copy-constructor
ConcaveMeshShape(const ConcaveMeshShape& shape) = delete;
/// Deleted assignment operator
ConcaveMeshShape& operator=(const ConcaveMeshShape& shape) = delete;
/// Return the local bounds of the shape in x, y and z directions.
virtual void getLocalBounds(Vector3& min, Vector3& max) const;

2
src/collision/shapes/ConcaveShape.cpp
View File

@ -33,7 +33,7 @@ using namespace reactphysics3d;
// Constructor
ConcaveShape::ConcaveShape(CollisionShapeType type)
: CollisionShape(type), mIsSmoothMeshCollisionEnabled(false),
mTriangleMargin(0), mRaycastTestType(FRONT) {
mTriangleMargin(0), mRaycastTestType(TriangleRaycastSide::FRONT) {
}

15
src/collision/shapes/ConcaveShape.h
View File

@ -42,6 +42,9 @@ class TriangleCallback {
public:
/// Destructor
virtual ~TriangleCallback() {}
/// Report a triangle
virtual void testTriangle(const Vector3* trianglePoints)=0;
@ -70,12 +73,6 @@ class ConcaveShape : public CollisionShape {
// -------------------- Methods -------------------- //
/// Private copy-constructor
ConcaveShape(const ConcaveShape& shape);
/// Private assignment operator
ConcaveShape& operator=(const ConcaveShape& shape);
/// Return true if a point is inside the collision shape
virtual bool testPointInside(const Vector3& localPoint, ProxyShape* proxyShape) const;
@ -89,6 +86,12 @@ class ConcaveShape : public CollisionShape {
/// Destructor
virtual ~ConcaveShape();
/// Deleted copy-constructor
ConcaveShape(const ConcaveShape& shape) = delete;
/// Deleted assignment operator
ConcaveShape& operator=(const ConcaveShape& shape) = delete;
/// Return the triangle margin
decimal getTriangleMargin() const;

2
src/collision/shapes/ConeShape.cpp
View File

@ -38,7 +38,7 @@ using namespace reactphysics3d;
* @param margin Collision margin (in meters) around the collision shape
*/
ConeShape::ConeShape(decimal radius, decimal height, decimal margin)
: ConvexShape(CONE, margin), mRadius(radius), mHalfHeight(height * decimal(0.5)) {
: ConvexShape(CollisionShapeType::CONE, margin), mRadius(radius), mHalfHeight(height * decimal(0.5)) {
assert(mRadius > decimal(0.0));
assert(mHalfHeight > decimal(0.0));

12
src/collision/shapes/ConeShape.h
View File

@ -66,12 +66,6 @@ class ConeShape : public ConvexShape {
// -------------------- Methods -------------------- //
/// Private copy-constructor
ConeShape(const ConeShape& shape);
/// Private assignment operator
ConeShape& operator=(const ConeShape& shape);
/// Return a local support point in a given direction without the object margin
virtual Vector3 getLocalSupportPointWithoutMargin(const Vector3& direction,
void** cachedCollisionData) const;
@ -95,6 +89,12 @@ class ConeShape : public ConvexShape {
/// Destructor
virtual ~ConeShape();
/// Deleted copy-constructor
ConeShape(const ConeShape& shape) = delete;
/// Deleted assignment operator
ConeShape& operator=(const ConeShape& shape) = delete;
/// Return the radius
decimal getRadius() const;

14
src/collision/shapes/ConvexMeshShape.cpp
View File

@ -39,7 +39,7 @@ using namespace reactphysics3d;
* @param margin Collision margin (in meters) around the collision shape
*/
ConvexMeshShape::ConvexMeshShape(const decimal* arrayVertices, uint nbVertices, int stride, decimal margin)
: ConvexShape(CONVEX_MESH, margin), mNbVertices(nbVertices), mMinBounds(0, 0, 0),
: ConvexShape(CollisionShapeType::CONVEX_MESH, margin), mNbVertices(nbVertices), mMinBounds(0, 0, 0),
mMaxBounds(0, 0, 0), mIsEdgesInformationUsed(false) {
assert(nbVertices > 0);
assert(stride > 0);
@ -65,7 +65,7 @@ ConvexMeshShape::ConvexMeshShape(const decimal* arrayVertices, uint nbVertices,
* @param margin Collision margin (in meters) around the collision shape
*/
ConvexMeshShape::ConvexMeshShape(TriangleVertexArray* triangleVertexArray, bool isEdgesInformationUsed, decimal margin)
: ConvexShape(CONVEX_MESH, margin), mMinBounds(0, 0, 0),
: ConvexShape(CollisionShapeType::CONVEX_MESH, margin), mMinBounds(0, 0, 0),
mMaxBounds(0, 0, 0), mIsEdgesInformationUsed(isEdgesInformationUsed) {
TriangleVertexArray::VertexDataType vertexType = triangleVertexArray->getVertexDataType();
@ -79,14 +79,14 @@ ConvexMeshShape::ConvexMeshShape(TriangleVertexArray* triangleVertexArray, bool
for (uint v = 0; v < triangleVertexArray->getNbVertices(); v++) {
// Get the vertices components of the triangle
if (vertexType == TriangleVertexArray::VERTEX_FLOAT_TYPE) {
if (vertexType == TriangleVertexArray::VertexDataType::VERTEX_FLOAT_TYPE) {
const float* vertices = (float*)(verticesStart + v * vertexStride);
Vector3 vertex(vertices[0], vertices[1], vertices[2] );
vertex = vertex * mScaling;
mVertices.push_back(vertex);
}
else if (vertexType == TriangleVertexArray::VERTEX_DOUBLE_TYPE) {
else if (vertexType == TriangleVertexArray::VertexDataType::VERTEX_DOUBLE_TYPE) {
const double* vertices = (double*)(verticesStart + v * vertexStride);
Vector3 vertex(vertices[0], vertices[1], vertices[2] );
@ -109,10 +109,10 @@ ConvexMeshShape::ConvexMeshShape(TriangleVertexArray* triangleVertexArray, bool
for (int k=0; k < 3; k++) {
// Get the index of the current vertex in the triangle
if (indexType == TriangleVertexArray::INDEX_INTEGER_TYPE) {
if (indexType == TriangleVertexArray::IndexDataType::INDEX_INTEGER_TYPE) {
vertexIndex[k] = ((uint*)vertexIndexPointer)[k];
}
else if (indexType == TriangleVertexArray::INDEX_SHORT_TYPE) {
else if (indexType == TriangleVertexArray::IndexDataType::INDEX_SHORT_TYPE) {
vertexIndex[k] = ((unsigned short*)vertexIndexPointer)[k];
}
else {
@ -135,7 +135,7 @@ ConvexMeshShape::ConvexMeshShape(TriangleVertexArray* triangleVertexArray, bool
/// If you use this constructor, you will need to set the vertices manually one by one using
/// the addVertex() method.
ConvexMeshShape::ConvexMeshShape(decimal margin)
: ConvexShape(CONVEX_MESH, margin), mNbVertices(0), mMinBounds(0, 0, 0),
: ConvexShape(CollisionShapeType::CONVEX_MESH, margin), mNbVertices(0), mMinBounds(0, 0, 0),
mMaxBounds(0, 0, 0), mIsEdgesInformationUsed(false) {
}

12
src/collision/shapes/ConvexMeshShape.h
View File

@ -85,12 +85,6 @@ class ConvexMeshShape : public ConvexShape {
// -------------------- Methods -------------------- //
/// Private copy-constructor
ConvexMeshShape(const ConvexMeshShape& shape);
/// Private assignment operator
ConvexMeshShape& operator=(const ConvexMeshShape& shape);
/// Recompute the bounds of the mesh
void recalculateBounds();
@ -128,6 +122,12 @@ class ConvexMeshShape : public ConvexShape {
/// Destructor
virtual ~ConvexMeshShape();
/// Deleted copy-constructor
ConvexMeshShape(const ConvexMeshShape& shape) = delete;
/// Deleted assignment operator
ConvexMeshShape& operator=(const ConvexMeshShape& shape) = delete;
/// Return the local bounds of the shape in x, y and z directions
virtual void getLocalBounds(Vector3& min, Vector3& max) const;

12
src/collision/shapes/ConvexShape.h
View File

@ -48,12 +48,6 @@ class ConvexShape : public CollisionShape {
// -------------------- Methods -------------------- //
/// Private copy-constructor
ConvexShape(const ConvexShape& shape);
/// Private assignment operator
ConvexShape& operator=(const ConvexShape& shape);
// Return a local support point in a given direction with the object margin
Vector3 getLocalSupportPointWithMargin(const Vector3& direction,
void** cachedCollisionData) const;
@ -75,6 +69,12 @@ class ConvexShape : public CollisionShape {
/// Destructor
virtual ~ConvexShape();
/// Deleted copy-constructor
ConvexShape(const ConvexShape& shape) = delete;
/// Deleted assignment operator
ConvexShape& operator=(const ConvexShape& shape) = delete;
/// Return the current object margin
decimal getMargin() const;

2
src/collision/shapes/CylinderShape.cpp
View File

@ -37,7 +37,7 @@ using namespace reactphysics3d;
* @param margin Collision margin (in meters) around the collision shape
*/
CylinderShape::CylinderShape(decimal radius, decimal height, decimal margin)
: ConvexShape(CYLINDER, margin), mRadius(radius),
: ConvexShape(CollisionShapeType::CYLINDER, margin), mRadius(radius),
mHalfHeight(height/decimal(2.0)) {
assert(radius > decimal(0.0));
assert(height > decimal(0.0));

12
src/collision/shapes/CylinderShape.h
View File

@ -63,12 +63,6 @@ class CylinderShape : public ConvexShape {
// -------------------- Methods -------------------- //
/// Private copy-constructor
CylinderShape(const CylinderShape& shape);
/// Private assignment operator
CylinderShape& operator=(const CylinderShape& shape);
/// Return a local support point in a given direction without the object margin
virtual Vector3 getLocalSupportPointWithoutMargin(const Vector3& direction,
void** cachedCollisionData) const;
@ -92,6 +86,12 @@ class CylinderShape : public ConvexShape {
/// Destructor
virtual ~CylinderShape();
/// Deleted copy-constructor
CylinderShape(const CylinderShape& shape) = delete;
/// Deleted assignment operator
CylinderShape& operator=(const CylinderShape& shape) = delete;
/// Return the radius
decimal getRadius() const;

2
src/collision/shapes/HeightFieldShape.cpp
View File

@ -42,7 +42,7 @@ using namespace reactphysics3d;
HeightFieldShape::HeightFieldShape(int nbGridColumns, int nbGridRows, decimal minHeight, decimal maxHeight,
const void* heightFieldData, HeightDataType dataType, int upAxis,
decimal integerHeightScale)
: ConcaveShape(HEIGHTFIELD), mNbColumns(nbGridColumns), mNbRows(nbGridRows),
: ConcaveShape(CollisionShapeType::HEIGHTFIELD), mNbColumns(nbGridColumns), mNbRows(nbGridRows),
mWidth(nbGridColumns - 1), mLength(nbGridRows - 1), mMinHeight(minHeight),
mMaxHeight(maxHeight), mUpAxis(upAxis), mIntegerHeightScale(integerHeightScale),
mHeightDataType(dataType) {

22
src/collision/shapes/HeightFieldShape.h
View File

@ -84,7 +84,7 @@ class HeightFieldShape : public ConcaveShape {
public:
/// Data type for the height data of the height field
enum HeightDataType {HEIGHT_FLOAT_TYPE, HEIGHT_DOUBLE_TYPE, HEIGHT_INT_TYPE};
enum class HeightDataType {HEIGHT_FLOAT_TYPE, HEIGHT_DOUBLE_TYPE, HEIGHT_INT_TYPE};
protected:
@ -125,12 +125,6 @@ class HeightFieldShape : public ConcaveShape {
// -------------------- Methods -------------------- //
/// Private copy-constructor
HeightFieldShape(const HeightFieldShape& shape);
/// Private assignment operator
HeightFieldShape& operator=(const HeightFieldShape& shape);
/// Raycast method with feedback information
virtual bool raycast(const Ray& ray, RaycastInfo& raycastInfo, ProxyShape* proxyShape) const;
@ -165,7 +159,13 @@ class HeightFieldShape : public ConcaveShape {
int upAxis = 1, decimal integerHeightScale = 1.0f);
/// Destructor
~HeightFieldShape();
virtual ~HeightFieldShape();
/// Deleted copy-constructor
HeightFieldShape(const HeightFieldShape& shape) = delete;
/// Deleted assignment operator
HeightFieldShape& operator=(const HeightFieldShape& shape) = delete;
/// Return the number of rows in the height field
int getNbRows() const;
@ -223,9 +223,9 @@ inline void HeightFieldShape::setLocalScaling(const Vector3& scaling) {
inline decimal HeightFieldShape::getHeightAt(int x, int y) const {
switch(mHeightDataType) {
case HEIGHT_FLOAT_TYPE : return ((float*)mHeightFieldData)[y * mNbColumns + x];
case HEIGHT_DOUBLE_TYPE : return ((double*)mHeightFieldData)[y * mNbColumns + x];
case HEIGHT_INT_TYPE : return ((int*)mHeightFieldData)[y * mNbColumns + x] * mIntegerHeightScale;
case HeightDataType::HEIGHT_FLOAT_TYPE : return ((float*)mHeightFieldData)[y * mNbColumns + x];
case HeightDataType::HEIGHT_DOUBLE_TYPE : return ((double*)mHeightFieldData)[y * mNbColumns + x];
case HeightDataType::HEIGHT_INT_TYPE : return ((int*)mHeightFieldData)[y * mNbColumns + x] * mIntegerHeightScale;
default: assert(false); return 0;
}
}

2
src/collision/shapes/SphereShape.cpp
View File

@ -35,7 +35,7 @@ using namespace reactphysics3d;
/**
* @param radius Radius of the sphere (in meters)
*/
SphereShape::SphereShape(decimal radius) : ConvexShape(SPHERE, radius) {
SphereShape::SphereShape(decimal radius) : ConvexShape(CollisionShapeType::SPHERE, radius) {
assert(radius > decimal(0.0));
}

12
src/collision/shapes/SphereShape.h
View File

@ -51,12 +51,6 @@ class SphereShape : public ConvexShape {
// -------------------- Methods -------------------- //
/// Private copy-constructor
SphereShape(const SphereShape& shape);
/// Private assignment operator
SphereShape& operator=(const SphereShape& shape);
/// Return a local support point in a given direction without the object margin
virtual Vector3 getLocalSupportPointWithoutMargin(const Vector3& direction,
void** cachedCollisionData) const;
@ -80,6 +74,12 @@ class SphereShape : public ConvexShape {
/// Destructor
virtual ~SphereShape();
/// Deleted copy-constructor
SphereShape(const SphereShape& shape) = delete;
/// Deleted assignment operator
SphereShape& operator=(const SphereShape& shape) = delete;
/// Return the radius of the sphere
decimal getRadius() const;

20
src/collision/shapes/TriangleShape.cpp
View File

@ -40,11 +40,11 @@ using namespace reactphysics3d;
* @param margin The collision margin (in meters) around the collision shape
*/
TriangleShape::TriangleShape(const Vector3& point1, const Vector3& point2, const Vector3& point3, decimal margin)
: ConvexShape(TRIANGLE, margin) {
: ConvexShape(CollisionShapeType::TRIANGLE, margin) {
mPoints[0] = point1;
mPoints[1] = point2;
mPoints[2] = point3;
mRaycastTestType = FRONT;
mRaycastTestType = TriangleRaycastSide::FRONT;
}
// Destructor
@ -68,32 +68,32 @@ bool TriangleShape::raycast(const Ray& ray, RaycastInfo& raycastInfo, ProxyShape
// product for this test.
const Vector3 m = pq.cross(pc);
decimal u = pb.dot(m);
if (mRaycastTestType == FRONT) {
if (mRaycastTestType == TriangleRaycastSide::FRONT) {
if (u < decimal(0.0)) return false;
}
else if (mRaycastTestType == BACK) {
else if (mRaycastTestType == TriangleRaycastSide::BACK) {
if (u > decimal(0.0)) return false;
}
decimal v = -pa.dot(m);
if (mRaycastTestType == FRONT) {
if (mRaycastTestType == TriangleRaycastSide::FRONT) {
if (v < decimal(0.0)) return false;
}
else if (mRaycastTestType == BACK) {
else if (mRaycastTestType == TriangleRaycastSide::BACK) {
if (v > decimal(0.0)) return false;
}
else if (mRaycastTestType == FRONT_AND_BACK) {
else if (mRaycastTestType == TriangleRaycastSide::FRONT_AND_BACK) {
if (!sameSign(u, v)) return false;
}
decimal w = pa.dot(pq.cross(pb));
if (mRaycastTestType == FRONT) {
if (mRaycastTestType == TriangleRaycastSide::FRONT) {
if (w < decimal(0.0)) return false;
}
else if (mRaycastTestType == BACK) {
else if (mRaycastTestType == TriangleRaycastSide::BACK) {
if (w > decimal(0.0)) return false;
}
else if (mRaycastTestType == FRONT_AND_BACK) {
else if (mRaycastTestType == TriangleRaycastSide::FRONT_AND_BACK) {
if (!sameSign(u, w)) return false;
}

14
src/collision/shapes/TriangleShape.h
View File

@ -34,7 +34,7 @@
namespace reactphysics3d {
/// Raycast test side for the triangle
enum TriangleRaycastSide {
enum class TriangleRaycastSide {
/// Raycast against front triangle
FRONT,
@ -65,12 +65,6 @@ class TriangleShape : public ConvexShape {
// -------------------- Methods -------------------- //
/// Private copy-constructor
TriangleShape(const TriangleShape& shape);
/// Private assignment operator
TriangleShape& operator=(const TriangleShape& shape);
/// Return a local support point in a given direction without the object margin
virtual Vector3 getLocalSupportPointWithoutMargin(const Vector3& direction,
void** cachedCollisionData) const;
@ -95,6 +89,12 @@ class TriangleShape : public ConvexShape {
/// Destructor
virtual ~TriangleShape();
/// Deleted copy-constructor
TriangleShape(const TriangleShape& shape) = delete;
/// Deleted assignment operator
TriangleShape& operator=(const TriangleShape& shape) = delete;
/// Return the local bounds of the shape in x, y and z directions.
virtual void getLocalBounds(Vector3& min, Vector3& max) const;

4
src/configuration.h
View File

@ -61,7 +61,7 @@ using uint32 = unsigned int;
/// Position correction technique used in the constraint solver (for joints).
/// BAUMGARTE_JOINTS : Faster but can be innacurate in some situations.
/// NON_LINEAR_GAUSS_SEIDEL : Slower but more precise. This is the option used by default.
enum JointsPositionCorrectionTechnique {BAUMGARTE_JOINTS, NON_LINEAR_GAUSS_SEIDEL};
enum class JointsPositionCorrectionTechnique {BAUMGARTE_JOINTS, NON_LINEAR_GAUSS_SEIDEL};
/// Position correction technique used in the contact solver (for contacts)
/// BAUMGARTE_CONTACTS : Faster but can be innacurate and can lead to unexpected bounciness
@ -69,7 +69,7 @@ enum JointsPositionCorrectionTechnique {BAUMGARTE_JOINTS, NON_LINEAR_GAUSS_SEIDE
/// the bodies momentum).
/// SPLIT_IMPULSES : A bit slower but the error correction factor is not added to the
/// bodies momentum. This is the option used by default.
enum ContactsPositionCorrectionTechnique {BAUMGARTE_CONTACTS, SPLIT_IMPULSES};
enum class ContactsPositionCorrectionTechnique {BAUMGARTE_CONTACTS, SPLIT_IMPULSES};
// ------------------- Constants ------------------- //

8
src/constraint/BallAndSocketJoint.cpp
View File

@ -81,13 +81,13 @@ void BallAndSocketJoint::initBeforeSolve(const ConstraintSolverData& constraintS
// Compute the inverse mass matrix K^-1
mInverseMassMatrix.setToZero();
if (mBody1->getType() == DYNAMIC || mBody2->getType() == DYNAMIC) {
if (mBody1->getType() == BodyType::DYNAMIC || mBody2->getType() == BodyType::DYNAMIC) {
mInverseMassMatrix = massMatrix.getInverse();
}
// Compute the bias "b" of the constraint
mBiasVector.setToZero();
if (mPositionCorrectionTechnique == BAUMGARTE_JOINTS) {
if (mPositionCorrectionTechnique == JointsPositionCorrectionTechnique::BAUMGARTE_JOINTS) {
decimal biasFactor = (BETA / constraintSolverData.timeStep);
mBiasVector = biasFactor * (x2 + mR2World - x1 - mR1World);
}
@ -162,7 +162,7 @@ void BallAndSocketJoint::solvePositionConstraint(const ConstraintSolverData& con
// If the error position correction technique is not the non-linear-gauss-seidel, we do
// do not execute this method
if (mPositionCorrectionTechnique != NON_LINEAR_GAUSS_SEIDEL) return;
if (mPositionCorrectionTechnique != JointsPositionCorrectionTechnique::NON_LINEAR_GAUSS_SEIDEL) return;
// Get the bodies center of mass and orientations
Vector3& x1 = constraintSolverData.positions[mIndexBody1];
@ -194,7 +194,7 @@ void BallAndSocketJoint::solvePositionConstraint(const ConstraintSolverData& con
skewSymmetricMatrixU1 * mI1 * skewSymmetricMatrixU1.getTranspose() +
skewSymmetricMatrixU2 * mI2 * skewSymmetricMatrixU2.getTranspose();
mInverseMassMatrix.setToZero();
if (mBody1->getType() == DYNAMIC || mBody2->getType() == DYNAMIC) {
if (mBody1->getType() == BodyType::DYNAMIC || mBody2->getType() == BodyType::DYNAMIC) {
mInverseMassMatrix = massMatrix.getInverse();
}

14
src/constraint/BallAndSocketJoint.h
View File

@ -55,7 +55,7 @@ struct BallAndSocketJointInfo : public JointInfo {
*/
BallAndSocketJointInfo(RigidBody* rigidBody1, RigidBody* rigidBody2,
const Vector3& initAnchorPointWorldSpace)
: JointInfo(rigidBody1, rigidBody2, BALLSOCKETJOINT),
: JointInfo(rigidBody1, rigidBody2, JointType::BALLSOCKETJOINT),
anchorPointWorldSpace(initAnchorPointWorldSpace) {}
};
@ -105,12 +105,6 @@ class BallAndSocketJoint : public Joint {
// -------------------- Methods -------------------- //
/// Private copy-constructor
BallAndSocketJoint(const BallAndSocketJoint& constraint);
/// Private assignment operator
BallAndSocketJoint& operator=(const BallAndSocketJoint& constraint);
/// Return the number of bytes used by the joint
virtual size_t getSizeInBytes() const;
@ -135,6 +129,12 @@ class BallAndSocketJoint : public Joint {
/// Destructor
virtual ~BallAndSocketJoint();
/// Deleted copy-constructor
BallAndSocketJoint(const BallAndSocketJoint& constraint) = delete;
/// Deleted assignment operator
BallAndSocketJoint& operator=(const BallAndSocketJoint& constraint) = delete;
};
// Return the number of bytes used by the joint

14
src/constraint/ContactPoint.h
View File

@ -142,14 +142,6 @@ class ContactPoint {
/// Cached rolling resistance impulse
Vector3 mRollingResistanceImpulse;
// -------------------- Methods -------------------- //
/// Private copy-constructor
ContactPoint(const ContactPoint& contact);
/// Private assignment operator
ContactPoint& operator=(const ContactPoint& contact);
public :
@ -161,6 +153,12 @@ class ContactPoint {
/// Destructor
~ContactPoint();
/// Deleted copy-constructor
ContactPoint(const ContactPoint& contact) = delete;
/// Deleted assignment operator
ContactPoint& operator=(const ContactPoint& contact) = delete;
/// Return the reference to the body 1
CollisionBody* getBody1() const;

14
src/constraint/FixedJoint.cpp
View File

@ -89,27 +89,27 @@ void FixedJoint::initBeforeSolve(const ConstraintSolverData& constraintSolverDat
// Compute the inverse mass matrix K^-1 for the 3 translation constraints
mInverseMassMatrixTranslation.setToZero();
if (mBody1->getType() == DYNAMIC || mBody2->getType() == DYNAMIC) {
if (mBody1->getType() == BodyType::DYNAMIC || mBody2->getType() == BodyType::DYNAMIC) {
mInverseMassMatrixTranslation = massMatrix.getInverse();
}
// Compute the bias "b" of the constraint for the 3 translation constraints
decimal biasFactor = (BETA / constraintSolverData.timeStep);
mBiasTranslation.setToZero();
if (mPositionCorrectionTechnique == BAUMGARTE_JOINTS) {
if (mPositionCorrectionTechnique == JointsPositionCorrectionTechnique::BAUMGARTE_JOINTS) {
mBiasTranslation = biasFactor * (x2 + mR2World - x1 - mR1World);
}
// Compute the inverse of the mass matrix K=JM^-1J^t for the 3 rotation
// contraints (3x3 matrix)
mInverseMassMatrixRotation = mI1 + mI2;
if (mBody1->getType() == DYNAMIC || mBody2->getType() == DYNAMIC) {
if (mBody1->getType() == BodyType::DYNAMIC || mBody2->getType() == BodyType::DYNAMIC) {
mInverseMassMatrixRotation = mInverseMassMatrixRotation.getInverse();
}
// Compute the bias "b" for the 3 rotation constraints
mBiasRotation.setToZero();
if (mPositionCorrectionTechnique == BAUMGARTE_JOINTS) {
if (mPositionCorrectionTechnique == JointsPositionCorrectionTechnique::BAUMGARTE_JOINTS) {
Quaternion currentOrientationDifference = orientationBody2 * orientationBody1.getInverse();
currentOrientationDifference.normalize();
const Quaternion qError = currentOrientationDifference * mInitOrientationDifferenceInv;
@ -222,7 +222,7 @@ void FixedJoint::solvePositionConstraint(const ConstraintSolverData& constraintS
// If the error position correction technique is not the non-linear-gauss-seidel, we do
// do not execute this method
if (mPositionCorrectionTechnique != NON_LINEAR_GAUSS_SEIDEL) return;
if (mPositionCorrectionTechnique != JointsPositionCorrectionTechnique::NON_LINEAR_GAUSS_SEIDEL) return;
// Get the bodies positions and orientations
Vector3& x1 = constraintSolverData.positions[mIndexBody1];
@ -256,7 +256,7 @@ void FixedJoint::solvePositionConstraint(const ConstraintSolverData& constraintS
skewSymmetricMatrixU1 * mI1 * skewSymmetricMatrixU1.getTranspose() +
skewSymmetricMatrixU2 * mI2 * skewSymmetricMatrixU2.getTranspose();
mInverseMassMatrixTranslation.setToZero();
if (mBody1->getType() == DYNAMIC || mBody2->getType() == DYNAMIC) {
if (mBody1->getType() == BodyType::DYNAMIC || mBody2->getType() == BodyType::DYNAMIC) {
mInverseMassMatrixTranslation = massMatrix.getInverse();
}
@ -296,7 +296,7 @@ void FixedJoint::solvePositionConstraint(const ConstraintSolverData& constraintS
// Compute the inverse of the mass matrix K=JM^-1J^t for the 3 rotation
// contraints (3x3 matrix)
mInverseMassMatrixRotation = mI1 + mI2;
if (mBody1->getType() == DYNAMIC || mBody2->getType() == DYNAMIC) {
if (mBody1->getType() == BodyType::DYNAMIC || mBody2->getType() == BodyType::DYNAMIC) {
mInverseMassMatrixRotation = mInverseMassMatrixRotation.getInverse();
}

14
src/constraint/FixedJoint.h
View File

@ -55,7 +55,7 @@ struct FixedJointInfo : public JointInfo {
*/
FixedJointInfo(RigidBody* rigidBody1, RigidBody* rigidBody2,
const Vector3& initAnchorPointWorldSpace)
: JointInfo(rigidBody1, rigidBody2, FIXEDJOINT),
: JointInfo(rigidBody1, rigidBody2, JointType::FIXEDJOINT),
anchorPointWorldSpace(initAnchorPointWorldSpace){}
};
@ -116,12 +116,6 @@ class FixedJoint : public Joint {
// -------------------- Methods -------------------- //
/// Private copy-constructor
FixedJoint(const FixedJoint& constraint);
/// Private assignment operator
FixedJoint& operator=(const FixedJoint& constraint);
/// Return the number of bytes used by the joint
virtual size_t getSizeInBytes() const;
@ -146,6 +140,12 @@ class FixedJoint : public Joint {
/// Destructor
virtual ~FixedJoint();
/// Deleted copy-constructor
FixedJoint(const FixedJoint& constraint) = delete;
/// Deleted assignment operator
FixedJoint& operator=(const FixedJoint& constraint) = delete;
};
// Return the number of bytes used by the joint

18
src/constraint/HingeJoint.cpp
View File

@ -129,14 +129,14 @@ void HingeJoint::initBeforeSolve(const ConstraintSolverData& constraintSolverDat
skewSymmetricMatrixU1 * mI1 * skewSymmetricMatrixU1.getTranspose() +
skewSymmetricMatrixU2 * mI2 * skewSymmetricMatrixU2.getTranspose();
mInverseMassMatrixTranslation.setToZero();
if (mBody1->getType() == DYNAMIC || mBody2->getType() == DYNAMIC) {
if (mBody1->getType() == BodyType::DYNAMIC || mBody2->getType() == BodyType::DYNAMIC) {
mInverseMassMatrixTranslation = massMatrix.getInverse();
}
// Compute the bias "b" of the translation constraints
mBTranslation.setToZero();
decimal biasFactor = (BETA / constraintSolverData.timeStep);
if (mPositionCorrectionTechnique == BAUMGARTE_JOINTS) {
if (mPositionCorrectionTechnique == JointsPositionCorrectionTechnique::BAUMGARTE_JOINTS) {
mBTranslation = biasFactor * (x2 + mR2World - x1 - mR1World);
}
@ -155,13 +155,13 @@ void HingeJoint::initBeforeSolve(const ConstraintSolverData& constraintSolverDat
mC2CrossA1.dot(I2C2CrossA1);
const Matrix2x2 matrixKRotation(el11, el12, el21, el22);
mInverseMassMatrixRotation.setToZero();
if (mBody1->getType() == DYNAMIC || mBody2->getType() == DYNAMIC) {
if (mBody1->getType() == BodyType::DYNAMIC || mBody2->getType() == BodyType::DYNAMIC) {
mInverseMassMatrixRotation = matrixKRotation.getInverse();
}
// Compute the bias "b" of the rotation constraints
mBRotation.setToZero();
if (mPositionCorrectionTechnique == BAUMGARTE_JOINTS) {
if (mPositionCorrectionTechnique == JointsPositionCorrectionTechnique::BAUMGARTE_JOINTS) {
mBRotation = biasFactor * Vector2(mA1.dot(b2), mA1.dot(c2));
}
@ -188,13 +188,13 @@ void HingeJoint::initBeforeSolve(const ConstraintSolverData& constraintSolverDat
// Compute the bias "b" of the lower limit constraint
mBLowerLimit = 0.0;
if (mPositionCorrectionTechnique == BAUMGARTE_JOINTS) {
if (mPositionCorrectionTechnique == JointsPositionCorrectionTechnique::BAUMGARTE_JOINTS) {
mBLowerLimit = biasFactor * lowerLimitError;
}
// Compute the bias "b" of the upper limit constraint
mBUpperLimit = 0.0;
if (mPositionCorrectionTechnique == BAUMGARTE_JOINTS) {
if (mPositionCorrectionTechnique == JointsPositionCorrectionTechnique::BAUMGARTE_JOINTS) {
mBUpperLimit = biasFactor * upperLimitError;
}
}
@ -408,7 +408,7 @@ void HingeJoint::solvePositionConstraint(const ConstraintSolverData& constraintS
// If the error position correction technique is not the non-linear-gauss-seidel, we do
// do not execute this method
if (mPositionCorrectionTechnique != NON_LINEAR_GAUSS_SEIDEL) return;
if (mPositionCorrectionTechnique != JointsPositionCorrectionTechnique::NON_LINEAR_GAUSS_SEIDEL) return;
// Get the bodies positions and orientations
Vector3& x1 = constraintSolverData.positions[mIndexBody1];
@ -461,7 +461,7 @@ void HingeJoint::solvePositionConstraint(const ConstraintSolverData& constraintS
skewSymmetricMatrixU1 * mI1 * skewSymmetricMatrixU1.getTranspose() +
skewSymmetricMatrixU2 * mI2 * skewSymmetricMatrixU2.getTranspose();
mInverseMassMatrixTranslation.setToZero();
if (mBody1->getType() == DYNAMIC || mBody2->getType() == DYNAMIC) {
if (mBody1->getType() == BodyType::DYNAMIC || mBody2->getType() == BodyType::DYNAMIC) {
mInverseMassMatrixTranslation = massMatrix.getInverse();
}
@ -513,7 +513,7 @@ void HingeJoint::solvePositionConstraint(const ConstraintSolverData& constraintS
mC2CrossA1.dot(I2C2CrossA1);
const Matrix2x2 matrixKRotation(el11, el12, el21, el22);
mInverseMassMatrixRotation.setToZero();
if (mBody1->getType() == DYNAMIC || mBody2->getType() == DYNAMIC) {
if (mBody1->getType() == BodyType::DYNAMIC || mBody2->getType() == BodyType::DYNAMIC) {
mInverseMassMatrixRotation = matrixKRotation.getInverse();
}

18
src/constraint/HingeJoint.h
View File

@ -82,7 +82,7 @@ struct HingeJointInfo : public JointInfo {
HingeJointInfo(RigidBody* rigidBody1, RigidBody* rigidBody2,
const Vector3& initAnchorPointWorldSpace,
const Vector3& initRotationAxisWorld)
: JointInfo(rigidBody1, rigidBody2, HINGEJOINT),
: JointInfo(rigidBody1, rigidBody2, JointType::HINGEJOINT),
anchorPointWorldSpace(initAnchorPointWorldSpace),
rotationAxisWorld(initRotationAxisWorld), isLimitEnabled(false),
isMotorEnabled(false), minAngleLimit(-1), maxAngleLimit(1),
@ -101,7 +101,7 @@ struct HingeJointInfo : public JointInfo {
const Vector3& initAnchorPointWorldSpace,
const Vector3& initRotationAxisWorld,
decimal initMinAngleLimit, decimal initMaxAngleLimit)
: JointInfo(rigidBody1, rigidBody2, HINGEJOINT),
: JointInfo(rigidBody1, rigidBody2, JointType::HINGEJOINT),
anchorPointWorldSpace(initAnchorPointWorldSpace),
rotationAxisWorld(initRotationAxisWorld), isLimitEnabled(true),
isMotorEnabled(false), minAngleLimit(initMinAngleLimit),
@ -124,7 +124,7 @@ struct HingeJointInfo : public JointInfo {
const Vector3& initRotationAxisWorld,
decimal initMinAngleLimit, decimal initMaxAngleLimit,
decimal initMotorSpeed, decimal initMaxMotorTorque)
: JointInfo(rigidBody1, rigidBody2, HINGEJOINT),
: JointInfo(rigidBody1, rigidBody2, JointType::HINGEJOINT),
anchorPointWorldSpace(initAnchorPointWorldSpace),
rotationAxisWorld(initRotationAxisWorld), isLimitEnabled(true),
isMotorEnabled(false), minAngleLimit(initMinAngleLimit),
@ -250,12 +250,6 @@ class HingeJoint : public Joint {
// -------------------- Methods -------------------- //
/// Private copy-constructor
HingeJoint(const HingeJoint& constraint);
/// Private assignment operator
HingeJoint& operator=(const HingeJoint& constraint);
/// Reset the limits
void resetLimits();
@ -298,6 +292,12 @@ class HingeJoint : public Joint {
/// Destructor
virtual ~HingeJoint();
/// Deleted copy-constructor
HingeJoint(const HingeJoint& constraint) = delete;
/// Deleted assignment operator
HingeJoint& operator=(const HingeJoint& constraint) = delete;
/// Return true if the limits or the joint are enabled
bool isLimitEnabled() const;

18
src/constraint/Joint.h
View File

@ -35,7 +35,7 @@
namespace reactphysics3d {
/// Enumeration for the type of a constraint
enum JointType {BALLSOCKETJOINT, SLIDERJOINT, HINGEJOINT, FIXEDJOINT};
enum class JointType {BALLSOCKETJOINT, SLIDERJOINT, HINGEJOINT, FIXEDJOINT};
// Class declarations
struct ConstraintSolverData;
@ -95,13 +95,13 @@ struct JointInfo {
/// Constructor
JointInfo(JointType constraintType)
: body1(nullptr), body2(nullptr), type(constraintType),
positionCorrectionTechnique(NON_LINEAR_GAUSS_SEIDEL),
positionCorrectionTechnique(JointsPositionCorrectionTechnique::NON_LINEAR_GAUSS_SEIDEL),
isCollisionEnabled(true) {}
/// Constructor
JointInfo(RigidBody* rigidBody1, RigidBody* rigidBody2, JointType constraintType)
: body1(rigidBody1), body2(rigidBody2), type(constraintType),
positionCorrectionTechnique(NON_LINEAR_GAUSS_SEIDEL),
positionCorrectionTechnique(JointsPositionCorrectionTechnique::NON_LINEAR_GAUSS_SEIDEL),
isCollisionEnabled(true) {
}
@ -146,12 +146,6 @@ class Joint {
// -------------------- Methods -------------------- //
/// Private copy-constructor
Joint(const Joint& constraint);
/// Private assignment operator
Joint& operator=(const Joint& constraint);
/// Return true if the joint has already been added into an island
bool isAlreadyInIsland() const;
@ -180,6 +174,12 @@ class Joint {
/// Destructor
virtual ~Joint();
/// Deleted copy-constructor
Joint(const Joint& constraint) = delete;
/// Deleted assignment operator
Joint& operator=(const Joint& constraint) = delete;
/// Return the reference to the body 1
RigidBody* getBody1() const;

18
src/constraint/SliderJoint.cpp
View File

@ -139,14 +139,14 @@ void SliderJoint::initBeforeSolve(const ConstraintSolverData& constraintSolverDa
mR2CrossN2.dot(I2R2CrossN2);
Matrix2x2 matrixKTranslation(el11, el12, el21, el22);
mInverseMassMatrixTranslationConstraint.setToZero();
if (mBody1->getType() == DYNAMIC || mBody2->getType() == DYNAMIC) {
if (mBody1->getType() == BodyType::DYNAMIC || mBody2->getType() == BodyType::DYNAMIC) {
mInverseMassMatrixTranslationConstraint = matrixKTranslation.getInverse();
}
// Compute the bias "b" of the translation constraint
mBTranslation.setToZero();
decimal biasFactor = (BETA / constraintSolverData.timeStep);
if (mPositionCorrectionTechnique == BAUMGARTE_JOINTS) {
if (mPositionCorrectionTechnique == JointsPositionCorrectionTechnique::BAUMGARTE_JOINTS) {
mBTranslation.x = u.dot(mN1);
mBTranslation.y = u.dot(mN2);
mBTranslation *= biasFactor;
@ -155,13 +155,13 @@ void SliderJoint::initBeforeSolve(const ConstraintSolverData& constraintSolverDa
// Compute the inverse of the mass matrix K=JM^-1J^t for the 3 rotation
// contraints (3x3 matrix)
mInverseMassMatrixRotationConstraint = mI1 + mI2;
if (mBody1->getType() == DYNAMIC || mBody2->getType() == DYNAMIC) {
if (mBody1->getType() == BodyType::DYNAMIC || mBody2->getType() == BodyType::DYNAMIC) {
mInverseMassMatrixRotationConstraint = mInverseMassMatrixRotationConstraint.getInverse();
}
// Compute the bias "b" of the rotation constraint
mBRotation.setToZero();
if (mPositionCorrectionTechnique == BAUMGARTE_JOINTS) {
if (mPositionCorrectionTechnique == JointsPositionCorrectionTechnique::BAUMGARTE_JOINTS) {
Quaternion currentOrientationDifference = orientationBody2 * orientationBody1.getInverse();
currentOrientationDifference.normalize();
const Quaternion qError = currentOrientationDifference * mInitOrientationDifferenceInv;
@ -180,13 +180,13 @@ void SliderJoint::initBeforeSolve(const ConstraintSolverData& constraintSolverDa
// Compute the bias "b" of the lower limit constraint
mBLowerLimit = 0.0;
if (mPositionCorrectionTechnique == BAUMGARTE_JOINTS) {
if (mPositionCorrectionTechnique == JointsPositionCorrectionTechnique::BAUMGARTE_JOINTS) {
mBLowerLimit = biasFactor * lowerLimitError;
}
// Compute the bias "b" of the upper limit constraint
mBUpperLimit = 0.0;
if (mPositionCorrectionTechnique == BAUMGARTE_JOINTS) {
if (mPositionCorrectionTechnique == JointsPositionCorrectionTechnique::BAUMGARTE_JOINTS) {
mBUpperLimit = biasFactor * upperLimitError;
}
}
@ -433,7 +433,7 @@ void SliderJoint::solvePositionConstraint(const ConstraintSolverData& constraint
// If the error position correction technique is not the non-linear-gauss-seidel, we do
// do not execute this method
if (mPositionCorrectionTechnique != NON_LINEAR_GAUSS_SEIDEL) return;
if (mPositionCorrectionTechnique != JointsPositionCorrectionTechnique::NON_LINEAR_GAUSS_SEIDEL) return;
// Get the bodies positions and orientations
Vector3& x1 = constraintSolverData.positions[mIndexBody1];
@ -497,7 +497,7 @@ void SliderJoint::solvePositionConstraint(const ConstraintSolverData& constraint
mR2CrossN2.dot(I2R2CrossN2);
Matrix2x2 matrixKTranslation(el11, el12, el21, el22);
mInverseMassMatrixTranslationConstraint.setToZero();
if (mBody1->getType() == DYNAMIC || mBody2->getType() == DYNAMIC) {
if (mBody1->getType() == BodyType::DYNAMIC || mBody2->getType() == BodyType::DYNAMIC) {
mInverseMassMatrixTranslationConstraint = matrixKTranslation.getInverse();
}
@ -540,7 +540,7 @@ void SliderJoint::solvePositionConstraint(const ConstraintSolverData& constraint
// Compute the inverse of the mass matrix K=JM^-1J^t for the 3 rotation
// contraints (3x3 matrix)
mInverseMassMatrixRotationConstraint = mI1 + mI2;
if (mBody1->getType() == DYNAMIC || mBody2->getType() == DYNAMIC) {
if (mBody1->getType() == BodyType::DYNAMIC || mBody2->getType() == BodyType::DYNAMIC) {
mInverseMassMatrixRotationConstraint = mInverseMassMatrixRotationConstraint.getInverse();
}

18
src/constraint/SliderJoint.h
View File

@ -77,7 +77,7 @@ struct SliderJointInfo : public JointInfo {
SliderJointInfo(RigidBody* rigidBody1, RigidBody* rigidBody2,
const Vector3& initAnchorPointWorldSpace,
const Vector3& initSliderAxisWorldSpace)
: JointInfo(rigidBody1, rigidBody2, SLIDERJOINT),
: JointInfo(rigidBody1, rigidBody2, JointType::SLIDERJOINT),
anchorPointWorldSpace(initAnchorPointWorldSpace),
sliderAxisWorldSpace(initSliderAxisWorldSpace),
isLimitEnabled(false), isMotorEnabled(false), minTranslationLimit(-1.0),
@ -96,7 +96,7 @@ struct SliderJointInfo : public JointInfo {
const Vector3& initAnchorPointWorldSpace,
const Vector3& initSliderAxisWorldSpace,
decimal initMinTranslationLimit, decimal initMaxTranslationLimit)
: JointInfo(rigidBody1, rigidBody2, SLIDERJOINT),
: JointInfo(rigidBody1, rigidBody2, JointType::SLIDERJOINT),
anchorPointWorldSpace(initAnchorPointWorldSpace),
sliderAxisWorldSpace(initSliderAxisWorldSpace),
isLimitEnabled(true), isMotorEnabled(false),
@ -120,7 +120,7 @@ struct SliderJointInfo : public JointInfo {
const Vector3& initSliderAxisWorldSpace,
decimal initMinTranslationLimit, decimal initMaxTranslationLimit,
decimal initMotorSpeed, decimal initMaxMotorForce)
: JointInfo(rigidBody1, rigidBody2, SLIDERJOINT),
: JointInfo(rigidBody1, rigidBody2, JointType::SLIDERJOINT),
anchorPointWorldSpace(initAnchorPointWorldSpace),
sliderAxisWorldSpace(initSliderAxisWorldSpace),
isLimitEnabled(true), isMotorEnabled(true),
@ -262,12 +262,6 @@ class SliderJoint : public Joint {
// -------------------- Methods -------------------- //
/// Private copy-constructor
SliderJoint(const SliderJoint& constraint);
/// Private assignment operator
SliderJoint& operator=(const SliderJoint& constraint);
/// Reset the limits
void resetLimits();
@ -296,6 +290,12 @@ class SliderJoint : public Joint {
/// Destructor
virtual ~SliderJoint();
/// Deleted copy-constructor
SliderJoint(const SliderJoint& constraint) = delete;
/// Deleted assignment operator
SliderJoint& operator=(const SliderJoint& constraint) = delete;
/// Return true if the limits or the joint are enabled
bool isLimitEnabled() const;

12
src/engine/CollisionWorld.h
View File

@ -80,12 +80,6 @@ class CollisionWorld {
// -------------------- Methods -------------------- //
/// Private copy-constructor
CollisionWorld(const CollisionWorld& world);
/// Private assignment operator
CollisionWorld& operator=(const CollisionWorld& world);
/// Return the next available body ID
bodyindex computeNextAvailableBodyID();
@ -102,6 +96,12 @@ class CollisionWorld {
/// Destructor
virtual ~CollisionWorld();
/// Deleted copy-constructor
CollisionWorld(const CollisionWorld& world) = delete;
/// Deleted assignment operator
CollisionWorld& operator=(const CollisionWorld& world) = delete;
/// Return an iterator to the beginning of the bodies of the physics world
std::set<CollisionBody*>::iterator getBodiesBeginIterator();

4
src/engine/ContactSolver.cpp
View File

@ -105,8 +105,8 @@ void ContactSolver::initializeForIsland(decimal dt, Island* island) {
internalManifold.frictionCoefficient = computeMixedFrictionCoefficient(body1, body2);
internalManifold.rollingResistanceFactor = computeMixedRollingResistance(body1, body2);
internalManifold.externalContactManifold = externalManifold;
internalManifold.isBody1DynamicType = body1->getType() == DYNAMIC;
internalManifold.isBody2DynamicType = body2->getType() == DYNAMIC;
internalManifold.isBody1DynamicType = body1->getType() == BodyType::DYNAMIC;
internalManifold.isBody2DynamicType = body2->getType() == BodyType::DYNAMIC;
// If we solve the friction constraints at the center of the contact manifold
if (mIsSolveFrictionAtContactManifoldCenterActive) {

16
src/engine/DynamicsWorld.cpp
View File

@ -503,7 +503,7 @@ Joint* DynamicsWorld::createJoint(const JointInfo& jointInfo) {
switch(jointInfo.type) {
// Ball-and-Socket joint
case BALLSOCKETJOINT:
case JointType::BALLSOCKETJOINT:
{
void* allocatedMemory = mMemoryAllocator.allocate(sizeof(BallAndSocketJoint));
const BallAndSocketJointInfo& info = static_cast<const BallAndSocketJointInfo&>(
@ -513,7 +513,7 @@ Joint* DynamicsWorld::createJoint(const JointInfo& jointInfo) {
}
// Slider joint
case SLIDERJOINT:
case JointType::SLIDERJOINT:
{
void* allocatedMemory = mMemoryAllocator.allocate(sizeof(SliderJoint));
const SliderJointInfo& info = static_cast<const SliderJointInfo&>(jointInfo);
@ -522,7 +522,7 @@ Joint* DynamicsWorld::createJoint(const JointInfo& jointInfo) {
}
// Hinge joint
case HINGEJOINT:
case JointType::HINGEJOINT:
{
void* allocatedMemory = mMemoryAllocator.allocate(sizeof(HingeJoint));
const HingeJointInfo& info = static_cast<const HingeJointInfo&>(jointInfo);
@ -531,7 +531,7 @@ Joint* DynamicsWorld::createJoint(const JointInfo& jointInfo) {
}
// Fixed joint
case FIXEDJOINT:
case JointType::FIXEDJOINT:
{
void* allocatedMemory = mMemoryAllocator.allocate(sizeof(FixedJoint));
const FixedJointInfo& info = static_cast<const FixedJointInfo&>(jointInfo);
@ -673,7 +673,7 @@ void DynamicsWorld::computeIslands() {
if (body->mIsAlreadyInIsland) continue;
// If the body is static, we go to the next body
if (body->getType() == STATIC) continue;
if (body->getType() == BodyType::STATIC) continue;
// If the body is sleeping or inactive, we go to the next body
if (body->isSleeping() || !body->isActive()) continue;
@ -706,7 +706,7 @@ void DynamicsWorld::computeIslands() {
// If the current body is static, we do not want to perform the DFS
// search across that body
if (bodyToVisit->getType() == STATIC) continue;
if (bodyToVisit->getType() == BodyType::STATIC) continue;
// For each contact manifold in which the current body is involded
ContactManifoldListElement* contactElement;
@ -771,7 +771,7 @@ void DynamicsWorld::computeIslands() {
// can also be included in the other islands
for (uint i=0; i < mIslands[mNbIslands]->mNbBodies; i++) {
if (mIslands[mNbIslands]->mBodies[i]->getType() == STATIC) {
if (mIslands[mNbIslands]->mBodies[i]->getType() == BodyType::STATIC) {
mIslands[mNbIslands]->mBodies[i]->mIsAlreadyInIsland = false;
}
}
@ -803,7 +803,7 @@ void DynamicsWorld::updateSleepingBodies() {
for (uint b=0; b < mIslands[i]->getNbBodies(); b++) {
// Skip static bodies
if (bodies[b]->getType() == STATIC) continue;
if (bodies[b]->getType() == BodyType::STATIC) continue;
// If the body is velocity is large enough to stay awake
if (bodies[b]->getLinearVelocity().lengthSquare() > sleepLinearVelocitySquare ||

16
src/engine/DynamicsWorld.h
View File

@ -127,12 +127,6 @@ class DynamicsWorld : public CollisionWorld {
// -------------------- Methods -------------------- //
/// Private copy-constructor
DynamicsWorld(const DynamicsWorld& world);
/// Private assignment operator
DynamicsWorld& operator=(const DynamicsWorld& world);
/// Integrate the positions and orientations of rigid bodies.
void integrateRigidBodiesPositions();
@ -186,6 +180,12 @@ class DynamicsWorld : public CollisionWorld {
/// Destructor
virtual ~DynamicsWorld();
/// Deleted copy-constructor
DynamicsWorld(const DynamicsWorld& world) = delete;
/// Deleted assignment operator
DynamicsWorld& operator=(const DynamicsWorld& world) = delete;
/// Update the physics simulation
void update(decimal timeStep);
@ -348,7 +348,7 @@ inline void DynamicsWorld::setNbIterationsPositionSolver(uint nbIterations) {
*/
inline void DynamicsWorld::setContactsPositionCorrectionTechnique(
ContactsPositionCorrectionTechnique technique) {
if (technique == BAUMGARTE_CONTACTS) {
if (technique == ContactsPositionCorrectionTechnique::BAUMGARTE_CONTACTS) {
mContactSolver.setIsSplitImpulseActive(false);
}
else {
@ -362,7 +362,7 @@ inline void DynamicsWorld::setContactsPositionCorrectionTechnique(
*/
inline void DynamicsWorld::setJointsPositionCorrectionTechnique(
JointsPositionCorrectionTechnique technique) {
if (technique == BAUMGARTE_JOINTS) {
if (technique == JointsPositionCorrectionTechnique::BAUMGARTE_JOINTS) {
mConstraintSolver.setIsNonLinearGaussSeidelPositionCorrectionActive(false);
}
else {

2
src/engine/EventListener.h
View File

@ -53,7 +53,7 @@ class EventListener {
/**
* @param contact Information about the contact
*/
virtual void beginContact(const ContactPointInfo& contact) {};
virtual void beginContact(const ContactPointInfo& contact) {}
/// Called when a new contact point is found between two bodies
/**

8
src/engine/Impulse.h
View File

@ -41,9 +41,6 @@ struct Impulse {
// -------------------- Methods -------------------- //
/// Private assignment operator
Impulse& operator=(const Impulse& impulse);
public:
// -------------------- Attributes -------------------- //
@ -78,8 +75,11 @@ struct Impulse {
angularImpulseBody1(impulse.angularImpulseBody1),
linearImpulseBody2(impulse.linearImpulseBody2),
angularImpulseBody2(impulse.angularImpulseBody2) {
;
}
/// Deleted assignment operator
Impulse& operator=(const Impulse& impulse) = delete;
};
}

14
src/engine/Island.h
View File

@ -75,14 +75,6 @@ class Island {
/// Number of bytes allocated for the joints array
size_t mNbAllocatedBytesJoints;
// -------------------- Methods -------------------- //
/// Private assignment operator
Island& operator=(const Island& island);
/// Private copy-constructor
Island(const Island& island);
public:
// -------------------- Methods -------------------- //
@ -94,6 +86,12 @@ class Island {
/// Destructor
~Island();
/// Deleted assignment operator
Island& operator=(const Island& island) = delete;
/// Deleted copy-constructor
Island(const Island& island) = delete;
/// Add a body into the island
void addBody(RigidBody* body);

14
src/engine/OverlappingPair.h
View File

@ -56,14 +56,6 @@ class OverlappingPair {
/// Cached previous separating axis
Vector3 mCachedSeparatingAxis;
// -------------------- Methods -------------------- //
/// Private copy-constructor
OverlappingPair(const OverlappingPair& pair);
/// Private assignment operator
OverlappingPair& operator=(const OverlappingPair& pair);
public:
@ -75,6 +67,12 @@ class OverlappingPair {
/// Destructor
~OverlappingPair();
/// Deleted copy-constructor
OverlappingPair(const OverlappingPair& pair) = delete;
/// Deleted assignment operator
OverlappingPair& operator=(const OverlappingPair& pair) = delete;
/// Return the pointer to first proxy collision shape
ProxyShape* getShape1() const;

16
src/engine/Timer.h
View File

@ -71,14 +71,6 @@ class Timer {
/// True if the timer is running
bool mIsRunning;
// -------------------- Methods -------------------- //
/// Private copy-constructor
Timer(const Timer& timer);
/// Private assignment operator
Timer& operator=(const Timer& timer);
public :
// -------------------- Methods -------------------- //
@ -87,7 +79,13 @@ class Timer {
Timer(double timeStep);
/// Destructor
virtual ~Timer();
~Timer();
/// Deleted copy-constructor
Timer(const Timer& timer) = delete;
/// Deleted assignment operator
Timer& operator=(const Timer& timer) = delete;
/// Return the timestep of the physics engine
double getTimeStep() const;

30
test/tests/collision/TestRaycast.h
View File

@ -288,13 +288,13 @@ class TestRaycast : public Test {
mConcaveMeshIndices.push_back(1); mConcaveMeshIndices.push_back(4); mConcaveMeshIndices.push_back(5);
mConcaveMeshIndices.push_back(5); mConcaveMeshIndices.push_back(7); mConcaveMeshIndices.push_back(6);
mConcaveMeshIndices.push_back(4); mConcaveMeshIndices.push_back(7); mConcaveMeshIndices.push_back(5);
TriangleVertexArray::VertexDataType vertexType = sizeof(decimal) == 4 ? TriangleVertexArray::VERTEX_FLOAT_TYPE :
TriangleVertexArray::VERTEX_DOUBLE_TYPE;
TriangleVertexArray::VertexDataType vertexType = sizeof(decimal) == 4 ? TriangleVertexArray::VertexDataType::VERTEX_FLOAT_TYPE :
TriangleVertexArray::VertexDataType::VERTEX_DOUBLE_TYPE;
mConcaveMeshVertexArray =
new TriangleVertexArray(8, &(mConcaveMeshVertices[0]), sizeof(Vector3),
12, &(mConcaveMeshIndices[0]), sizeof(uint),
vertexType,
TriangleVertexArray::INDEX_INTEGER_TYPE);
TriangleVertexArray::IndexDataType::INDEX_INTEGER_TYPE);
// Add the triangle vertex array of the subpart to the triangle mesh
@ -305,7 +305,7 @@ class TestRaycast : public Test {
// Heightfield shape (plane height field at height=4)
for (int i=0; i<100; i++) mHeightFieldData[i] = 4;
mHeightFieldShape = new HeightFieldShape(10, 10, 0, 4, mHeightFieldData, HeightFieldShape::HEIGHT_FLOAT_TYPE);
mHeightFieldShape = new HeightFieldShape(10, 10, 0, 4, mHeightFieldData, HeightFieldShape::HeightDataType::HEIGHT_FLOAT_TYPE);
mHeightFieldProxyShape = mHeightFieldBody->addCollisionShape(mHeightFieldShape, mShapeTransform);
// Assign proxy shapes to the different categories
@ -1032,7 +1032,7 @@ class TestRaycast : public Test {
// CollisionWorld::raycast()
mCallback.reset();
mTriangleShape->setRaycastTestType(FRONT);
mTriangleShape->setRaycastTestType(TriangleRaycastSide::FRONT);
mWorld->raycast(ray, &mCallback);
test(mCallback.isHit);
test(mCallback.raycastInfo.body == mTriangleBody);
@ -1046,7 +1046,7 @@ class TestRaycast : public Test {
test(approxEqual(mCallback.raycastInfo.worldNormal.z, hitNormal.z, epsilon));
mCallback.reset();
mTriangleShape->setRaycastTestType(BACK);
mTriangleShape->setRaycastTestType(TriangleRaycastSide::BACK);
mWorld->raycast(rayBackward, &mCallback);
test(mCallback.isHit);
test(mCallback.raycastInfo.body == mTriangleBody);
@ -1060,7 +1060,7 @@ class TestRaycast : public Test {
test(approxEqual(mCallback.raycastInfo.worldNormal.z, -hitNormal.z, epsilon));
mCallback.reset();
mTriangleShape->setRaycastTestType(FRONT_AND_BACK);
mTriangleShape->setRaycastTestType(TriangleRaycastSide::FRONT_AND_BACK);
mWorld->raycast(ray, &mCallback);
test(mCallback.isHit);
test(mCallback.raycastInfo.body == mTriangleBody);
@ -1074,7 +1074,7 @@ class TestRaycast : public Test {
test(approxEqual(mCallback.raycastInfo.worldNormal.z, hitNormal.z, epsilon));
mCallback.reset();
mTriangleShape->setRaycastTestType(FRONT_AND_BACK);
mTriangleShape->setRaycastTestType(TriangleRaycastSide::FRONT_AND_BACK);
mWorld->raycast(rayBackward, &mCallback);
test(mCallback.isHit);
test(mCallback.raycastInfo.body == mTriangleBody);
@ -1087,7 +1087,7 @@ class TestRaycast : public Test {
test(approxEqual(mCallback.raycastInfo.worldNormal.y, -hitNormal.y, epsilon));
test(approxEqual(mCallback.raycastInfo.worldNormal.z, -hitNormal.z, epsilon));
mTriangleShape->setRaycastTestType(FRONT);
mTriangleShape->setRaycastTestType(TriangleRaycastSide::FRONT);
// Correct category filter mask
mCallback.reset();
@ -1157,7 +1157,7 @@ class TestRaycast : public Test {
test(!mCallback.isHit);
// Test backward ray against front triangles (not hit should occur)
mTriangleShape->setRaycastTestType(FRONT);
mTriangleShape->setRaycastTestType(TriangleRaycastSide::FRONT);
test(!mTriangleBody->raycast(ray4Back, raycastInfo3));
test(!mTriangleProxyShape->raycast(ray4Back, raycastInfo3));
@ -1178,7 +1178,7 @@ class TestRaycast : public Test {
test(!mCallback.isHit);
// Test front ray against back triangles (not hit should occur)
mTriangleShape->setRaycastTestType(BACK);
mTriangleShape->setRaycastTestType(TriangleRaycastSide::BACK);
test(!mTriangleBody->raycast(ray4, raycastInfo3));
test(!mTriangleProxyShape->raycast(ray4, raycastInfo3));
@ -1201,7 +1201,7 @@ class TestRaycast : public Test {
// ----- Test raycast hits ----- //
// Test front ray against front triangles
mTriangleShape->setRaycastTestType(FRONT);
mTriangleShape->setRaycastTestType(TriangleRaycastSide::FRONT);
test(mTriangleBody->raycast(ray4, raycastInfo3));
test(mTriangleProxyShape->raycast(ray4, raycastInfo3));
@ -1229,7 +1229,7 @@ class TestRaycast : public Test {
mWorld->raycast(Ray(ray6.point1, ray6.point2, decimal(0.8)), &mCallback);
// Test back ray against back triangles
mTriangleShape->setRaycastTestType(BACK);
mTriangleShape->setRaycastTestType(TriangleRaycastSide::BACK);
test(mTriangleBody->raycast(ray4Back, raycastInfo3));
test(mTriangleProxyShape->raycast(ray4Back, raycastInfo3));
@ -1257,7 +1257,7 @@ class TestRaycast : public Test {
mWorld->raycast(Ray(ray6Back.point1, ray6Back.point2, decimal(0.8)), &mCallback);
// Test front ray against front-back triangles
mTriangleShape->setRaycastTestType(FRONT_AND_BACK);
mTriangleShape->setRaycastTestType(TriangleRaycastSide::FRONT_AND_BACK);
test(mTriangleBody->raycast(ray4, raycastInfo3));
test(mTriangleProxyShape->raycast(ray4, raycastInfo3));
@ -1285,7 +1285,7 @@ class TestRaycast : public Test {
mWorld->raycast(Ray(ray6.point1, ray6.point2, decimal(0.8)), &mCallback);
// Test back ray against front-back triangles
mTriangleShape->setRaycastTestType(FRONT_AND_BACK);
mTriangleShape->setRaycastTestType(TriangleRaycastSide::FRONT_AND_BACK);
test(mTriangleBody->raycast(ray4Back, raycastInfo3));
test(mTriangleProxyShape->raycast(ray4Back, raycastInfo3));

8
testbed/common/ConcaveMesh.cpp
View File

@ -53,8 +53,8 @@ ConcaveMesh::ConcaveMesh(const openglframework::Vector3 &position,
rp3d::TriangleVertexArray* vertexArray =
new rp3d::TriangleVertexArray(getNbVertices(), &(mVertices[0]), sizeof(openglframework::Vector3),
getNbFaces(i), &(mIndices[i][0]), sizeof(int),
rp3d::TriangleVertexArray::VERTEX_FLOAT_TYPE,
rp3d::TriangleVertexArray::INDEX_INTEGER_TYPE);
rp3d::TriangleVertexArray::VertexDataType::VERTEX_FLOAT_TYPE,
rp3d::TriangleVertexArray::IndexDataType::INDEX_INTEGER_TYPE);
// Add the triangle vertex array of the subpart to the triangle mesh
mPhysicsTriangleMesh.addSubpart(vertexArray);
@ -110,8 +110,8 @@ ConcaveMesh::ConcaveMesh(const openglframework::Vector3 &position, float mass,
rp3d::TriangleVertexArray* vertexArray =
new rp3d::TriangleVertexArray(getNbVertices(), &(mVertices[0]), sizeof(openglframework::Vector3),
getNbFaces(i), &(mIndices[i][0]), sizeof(int),
rp3d::TriangleVertexArray::VERTEX_FLOAT_TYPE,
rp3d::TriangleVertexArray::INDEX_INTEGER_TYPE);
rp3d::TriangleVertexArray::VertexDataType::VERTEX_FLOAT_TYPE,
rp3d::TriangleVertexArray::IndexDataType::INDEX_INTEGER_TYPE);
// Add the triangle vertex array of the subpart to the triangle mesh
mPhysicsTriangleMesh.addSubpart(vertexArray);

8
testbed/common/ConvexMesh.cpp
View File

@ -51,8 +51,8 @@ ConvexMesh::ConvexMesh(const openglframework::Vector3 &position,
mPhysicsTriangleVertexArray =
new rp3d::TriangleVertexArray(getNbVertices(), &(mVertices[0]), sizeof(openglframework::Vector3),
getNbFaces(0), &(mIndices[0][0]), sizeof(int),
rp3d::TriangleVertexArray::VERTEX_FLOAT_TYPE,
rp3d::TriangleVertexArray::INDEX_INTEGER_TYPE);
rp3d::TriangleVertexArray::VertexDataType::VERTEX_FLOAT_TYPE,
rp3d::TriangleVertexArray::IndexDataType::INDEX_INTEGER_TYPE);
// Create the collision shape for the rigid body (convex mesh shape) and
// do not forget to delete it at the end
@ -101,8 +101,8 @@ ConvexMesh::ConvexMesh(const openglframework::Vector3 &position, float mass,
mPhysicsTriangleVertexArray =
new rp3d::TriangleVertexArray(getNbVertices(), &(mVertices[0]), sizeof(openglframework::Vector3),
getNbFaces(0), &(mIndices[0][0]), sizeof(int),
rp3d::TriangleVertexArray::VERTEX_FLOAT_TYPE,
rp3d::TriangleVertexArray::INDEX_INTEGER_TYPE);
rp3d::TriangleVertexArray::VertexDataType::VERTEX_FLOAT_TYPE,
rp3d::TriangleVertexArray::IndexDataType::INDEX_INTEGER_TYPE);
// Create the collision shape for the rigid body (convex mesh shape) and do
// not forget to delete it at the end

4
testbed/common/HeightField.cpp
View File

@ -49,7 +49,7 @@ HeightField::HeightField(const openglframework::Vector3 &position,
// Create the collision shape for the rigid body (convex mesh shape) and
// do not forget to delete it at the end
mHeightFieldShape = new rp3d::HeightFieldShape(NB_POINTS_WIDTH, NB_POINTS_LENGTH, mMinHeight, mMaxHeight,
mHeightData, rp3d::HeightFieldShape::HEIGHT_FLOAT_TYPE);
mHeightData, rp3d::HeightFieldShape::HeightDataType::HEIGHT_FLOAT_TYPE);
// Initial position and orientation of the rigid body
rp3d::Vector3 initPosition(position.x, position.y, position.z);
@ -92,7 +92,7 @@ HeightField::HeightField(const openglframework::Vector3 &position, float mass,
// Create the collision shape for the rigid body (convex mesh shape) and
// do not forget to delete it at the end
mHeightFieldShape = new rp3d::HeightFieldShape(NB_POINTS_WIDTH, NB_POINTS_LENGTH, mMinHeight, mMaxHeight,
mHeightData, rp3d::HeightFieldShape::HEIGHT_FLOAT_TYPE);
mHeightData, rp3d::HeightFieldShape::HeightDataType::HEIGHT_FLOAT_TYPE);
// Initial position and orientation of the rigid body
rp3d::Vector3 initPosition(position.x, position.y, position.z);

2
testbed/scenes/collisionshapes/CollisionShapesScene.cpp
View File

@ -245,7 +245,7 @@ CollisionShapesScene::CollisionShapesScene(const std::string& name)
mFloor->setSleepingColor(mGreyColorDemo);
// The floor must be a static rigid body
mFloor->getRigidBody()->setType(rp3d::STATIC);
mFloor->getRigidBody()->setType(rp3d::BodyType::STATIC);
// Change the material properties of the rigid body
rp3d::Material& material = mFloor->getRigidBody()->getMaterial();

2
testbed/scenes/concavemesh/ConcaveMeshScene.cpp
View File

@ -83,7 +83,7 @@ ConcaveMeshScene::ConcaveMeshScene(const std::string& name)
mConcaveMesh = new ConcaveMesh(position, mass, mDynamicsWorld, meshFolderPath + "city.obj");
// Set the mesh as beeing static
mConcaveMesh->getRigidBody()->setType(rp3d::STATIC);
mConcaveMesh->getRigidBody()->setType(rp3d::BodyType::STATIC);
// Set the box color
mConcaveMesh->setColor(mGreyColorDemo);

2
testbed/scenes/cubes/CubesScene.cpp
View File

@ -82,7 +82,7 @@ CubesScene::CubesScene(const std::string& name)
mFloor->setSleepingColor(mGreyColorDemo);
// The floor must be a static rigid body
mFloor->getRigidBody()->setType(rp3d::STATIC);
mFloor->getRigidBody()->setType(rp3d::BodyType::STATIC);
// Change the material properties of the floor rigid body
rp3d::Material& material = mFloor->getRigidBody()->getMaterial();

2
testbed/scenes/heightfield/HeightFieldScene.cpp
View File

@ -78,7 +78,7 @@ HeightFieldScene::HeightFieldScene(const std::string& name) : SceneDemo(name, SC
mHeightField = new HeightField(position, mass, mDynamicsWorld);
// Set the mesh as beeing static
mHeightField->getRigidBody()->setType(rp3d::STATIC);
mHeightField->getRigidBody()->setType(rp3d::BodyType::STATIC);
// Set the color
mHeightField->setColor(mGreyColorDemo);

6
testbed/scenes/joints/JointsScene.cpp
View File

@ -274,7 +274,7 @@ void JointsScene::createBallAndSocketJoints() {
// The fist box cannot move (static body)
if (i == 0) {
mBallAndSocketJointChainBoxes[i]->getRigidBody()->setType(rp3d::STATIC);
mBallAndSocketJointChainBoxes[i]->getRigidBody()->setType(rp3d::BodyType::STATIC);
}
// Add some angular velocity damping
@ -322,7 +322,7 @@ void JointsScene::createSliderJoint() {
mSliderJointBottomBox->setSleepingColor(mRedColorDemo);
// The fist box cannot move
mSliderJointBottomBox->getRigidBody()->setType(rp3d::STATIC);
mSliderJointBottomBox->getRigidBody()->setType(rp3d::BodyType::STATIC);
// Change the material properties of the rigid body
rp3d::Material& material1 = mSliderJointBottomBox->getRigidBody()->getMaterial();
@ -476,7 +476,7 @@ void JointsScene::createFloor() {
mFloor->setSleepingColor(mGreyColorDemo);
// The floor must be a static rigid body
mFloor->getRigidBody()->setType(rp3d::STATIC);
mFloor->getRigidBody()->setType(rp3d::BodyType::STATIC);
// Change the material properties of the rigid body
rp3d::Material& material = mFloor->getRigidBody()->getMaterial();