From f5ade0f52d2bc27c461fc19d8cc4514fc9148eb9 Mon Sep 17 00:00:00 2001
From: Daniel Chappuis <chappuis.daniel@gmail.com>
Date: Fri, 8 Jul 2016 07:25:37 +0200
Subject: [PATCH] Fix virtual constructors, use c++11 scoped enums, use c++11
delete methods instead of private constructors
---
src/body/Body.h | 14 ++++-----
src/body/CollisionBody.cpp | 2 +-
src/body/CollisionBody.h | 16 +++++-----
src/body/RigidBody.cpp | 18 +++++------
src/body/RigidBody.h | 18 +++++------
src/collision/CollisionDetection.cpp | 14 +++++----
src/collision/CollisionDetection.h | 14 ++++-----
src/collision/ContactManifold.h | 12 ++++----
src/collision/ProxyShape.h | 16 +++++-----
src/collision/RaycastInfo.h | 14 ++++-----
src/collision/TriangleVertexArray.h | 4 +--
.../broadphase/BroadPhaseAlgorithm.h | 17 ++++++-----
src/collision/broadphase/DynamicAABBTree.h | 5 ++++
.../narrowphase/ConcaveVsConvexAlgorithm.cpp | 6 ++--
.../narrowphase/ConcaveVsConvexAlgorithm.h | 3 ++
.../narrowphase/DefaultCollisionDispatch.cpp | 2 +-
src/collision/narrowphase/EPA/EPAAlgorithm.h | 12 ++++----
src/collision/narrowphase/EPA/TriangleEPA.h | 14 ++++-----
.../narrowphase/EPA/TrianglesStore.h | 16 +++++-----
src/collision/narrowphase/GJK/GJKAlgorithm.h | 12 ++++----
src/collision/narrowphase/GJK/Simplex.h | 12 ++++----
.../narrowphase/NarrowPhaseAlgorithm.h | 16 +++++-----
.../narrowphase/SphereVsSphereAlgorithm.h | 14 ++++-----
src/collision/shapes/BoxShape.cpp | 2 +-
src/collision/shapes/BoxShape.h | 12 ++++----
src/collision/shapes/CapsuleShape.cpp | 2 +-
src/collision/shapes/CapsuleShape.h | 12 ++++----
src/collision/shapes/CollisionShape.h | 16 +++++-----
src/collision/shapes/ConcaveMeshShape.cpp | 20 ++++++-------
src/collision/shapes/ConcaveMeshShape.h | 14 ++++-----
src/collision/shapes/ConcaveShape.cpp | 2 +-
src/collision/shapes/ConcaveShape.h | 15 ++++++----
src/collision/shapes/ConeShape.cpp | 2 +-
src/collision/shapes/ConeShape.h | 12 ++++----
src/collision/shapes/ConvexMeshShape.cpp | 14 ++++-----
src/collision/shapes/ConvexMeshShape.h | 12 ++++----
src/collision/shapes/ConvexShape.h | 12 ++++----
src/collision/shapes/CylinderShape.cpp | 2 +-
src/collision/shapes/CylinderShape.h | 12 ++++----
src/collision/shapes/HeightFieldShape.cpp | 2 +-
src/collision/shapes/HeightFieldShape.h | 22 +++++++-------
src/collision/shapes/SphereShape.cpp | 2 +-
src/collision/shapes/SphereShape.h | 12 ++++----
src/collision/shapes/TriangleShape.cpp | 20 ++++++-------
src/collision/shapes/TriangleShape.h | 14 ++++-----
src/configuration.h | 4 +--
src/constraint/BallAndSocketJoint.cpp | 8 ++---
src/constraint/BallAndSocketJoint.h | 14 ++++-----
src/constraint/ContactPoint.h | 14 ++++-----
src/constraint/FixedJoint.cpp | 14 ++++-----
src/constraint/FixedJoint.h | 14 ++++-----
src/constraint/HingeJoint.cpp | 18 +++++------
src/constraint/HingeJoint.h | 18 +++++------
src/constraint/Joint.h | 18 +++++------
src/constraint/SliderJoint.cpp | 18 +++++------
src/constraint/SliderJoint.h | 18 +++++------
src/engine/CollisionWorld.h | 12 ++++----
src/engine/ContactSolver.cpp | 4 +--
src/engine/DynamicsWorld.cpp | 16 +++++-----
src/engine/DynamicsWorld.h | 16 +++++-----
src/engine/EventListener.h | 2 +-
src/engine/Impulse.h | 8 ++---
src/engine/Island.h | 14 ++++-----
src/engine/OverlappingPair.h | 14 ++++-----
src/engine/Timer.h | 16 +++++-----
test/tests/collision/TestRaycast.h | 30 +++++++++----------
testbed/common/ConcaveMesh.cpp | 8 ++---
testbed/common/ConvexMesh.cpp | 8 ++---
testbed/common/HeightField.cpp | 4 +--
.../collisionshapes/CollisionShapesScene.cpp | 2 +-
.../scenes/concavemesh/ConcaveMeshScene.cpp | 2 +-
testbed/scenes/cubes/CubesScene.cpp | 2 +-
.../scenes/heightfield/HeightFieldScene.cpp | 2 +-
testbed/scenes/joints/JointsScene.cpp | 6 ++--
74 files changed, 412 insertions(+), 416 deletions(-)
diff --git a/src/body/Body.h b/src/body/Body.h
index 4d1f9bf4..c5f011fb 100644
--- a/src/body/Body.h
+++ b/src/body/Body.h
@@ -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();
diff --git a/src/body/CollisionBody.cpp b/src/body/CollisionBody.cpp
index 83052131..daa4a71e 100644
--- a/src/body/CollisionBody.cpp
+++ b/src/body/CollisionBody.cpp
@@ -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) {
}
diff --git a/src/body/CollisionBody.h b/src/body/CollisionBody.h
index 2c88d155..c5658b58 100644
--- a/src/body/CollisionBody.h
+++ b/src/body/CollisionBody.h
@@ -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();
diff --git a/src/body/RigidBody.cpp b/src/body/RigidBody.cpp
index ff7fc8dd..a34df2bd 100644
--- a/src/body/RigidBody.cpp
+++ b/src/body/RigidBody.cpp
@@ -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) {
diff --git a/src/body/RigidBody.h b/src/body/RigidBody.h
index fd1c18b7..b3c96c52 100644
--- a/src/body/RigidBody.h
+++ b/src/body/RigidBody.h
@@ -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) {
diff --git a/src/collision/CollisionDetection.cpp b/src/collision/CollisionDetection.cpp
index 5e895c7f..ed721343 100644
--- a/src/collision/CollisionDetection.cpp
+++ b/src/collision/CollisionDetection.cpp
@@ -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;
diff --git a/src/collision/CollisionDetection.h b/src/collision/CollisionDetection.h
index 4bc4f319..e02b129f 100644
--- a/src/collision/CollisionDetection.h
+++ b/src/collision/CollisionDetection.h
@@ -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
diff --git a/src/collision/ContactManifold.h b/src/collision/ContactManifold.h
index e34bb449..eb7716df 100644
--- a/src/collision/ContactManifold.h
+++ b/src/collision/ContactManifold.h
@@ -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;
diff --git a/src/collision/ProxyShape.h b/src/collision/ProxyShape.h
index b91252de..d7c81621 100644
--- a/src/collision/ProxyShape.h
+++ b/src/collision/ProxyShape.h
@@ -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;
diff --git a/src/collision/RaycastInfo.h b/src/collision/RaycastInfo.h
index 753353f3..d693f02c 100644
--- a/src/collision/RaycastInfo.h
+++ b/src/collision/RaycastInfo.h
@@ -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
diff --git a/src/collision/TriangleVertexArray.h b/src/collision/TriangleVertexArray.h
index 3cf45723..f4403092 100644
--- a/src/collision/TriangleVertexArray.h
+++ b/src/collision/TriangleVertexArray.h
@@ -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:
diff --git a/src/collision/broadphase/BroadPhaseAlgorithm.h b/src/collision/broadphase/BroadPhaseAlgorithm.h
index 7f48f8fd..413a3d47 100644
--- a/src/collision/broadphase/BroadPhaseAlgorithm.h
+++ b/src/collision/broadphase/BroadPhaseAlgorithm.h
@@ -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);
diff --git a/src/collision/broadphase/DynamicAABBTree.h b/src/collision/broadphase/DynamicAABBTree.h
index e8232e96..67999d0a 100644
--- a/src/collision/broadphase/DynamicAABBTree.h
+++ b/src/collision/broadphase/DynamicAABBTree.h
@@ -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
diff --git a/src/collision/narrowphase/ConcaveVsConvexAlgorithm.cpp b/src/collision/narrowphase/ConcaveVsConvexAlgorithm.cpp
index 96c67531..ab07c629 100644
--- a/src/collision/narrowphase/ConcaveVsConvexAlgorithm.cpp
+++ b/src/collision/narrowphase/ConcaveVsConvexAlgorithm.cpp
@@ -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);
diff --git a/src/collision/narrowphase/ConcaveVsConvexAlgorithm.h b/src/collision/narrowphase/ConcaveVsConvexAlgorithm.h
index e44b71c2..4fe2aec0 100644
--- a/src/collision/narrowphase/ConcaveVsConvexAlgorithm.h
+++ b/src/collision/narrowphase/ConcaveVsConvexAlgorithm.h
@@ -72,6 +72,9 @@ class ConvexVsTriangleCallback : public TriangleCallback {
public:
+ /// Destructor
+ virtual ~ConvexVsTriangleCallback() {}
+
/// Set the collision detection pointer
void setCollisionDetection(CollisionDetection* collisionDetection) {
mCollisionDetection = collisionDetection;
diff --git a/src/collision/narrowphase/DefaultCollisionDispatch.cpp b/src/collision/narrowphase/DefaultCollisionDispatch.cpp
index 0b0df8d7..bc48c001 100644
--- a/src/collision/narrowphase/DefaultCollisionDispatch.cpp
+++ b/src/collision/narrowphase/DefaultCollisionDispatch.cpp
@@ -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
diff --git a/src/collision/narrowphase/EPA/EPAAlgorithm.h b/src/collision/narrowphase/EPA/EPAAlgorithm.h
index 1d4b527a..3461f466 100644
--- a/src/collision/narrowphase/EPA/EPAAlgorithm.h
+++ b/src/collision/narrowphase/EPA/EPAAlgorithm.h
@@ -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);
diff --git a/src/collision/narrowphase/EPA/TriangleEPA.h b/src/collision/narrowphase/EPA/TriangleEPA.h
index e2a8ce26..4cb40f38 100644
--- a/src/collision/narrowphase/EPA/TriangleEPA.h
+++ b/src/collision/narrowphase/EPA/TriangleEPA.h
@@ -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);
diff --git a/src/collision/narrowphase/EPA/TrianglesStore.h b/src/collision/narrowphase/EPA/TrianglesStore.h
index 82f6b6a9..840fdcbc 100644
--- a/src/collision/narrowphase/EPA/TrianglesStore.h
+++ b/src/collision/narrowphase/EPA/TrianglesStore.h
@@ -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();
diff --git a/src/collision/narrowphase/GJK/GJKAlgorithm.h b/src/collision/narrowphase/GJK/GJKAlgorithm.h
index 23ebc789..96cdbf8a 100644
--- a/src/collision/narrowphase/GJK/GJKAlgorithm.h
+++ b/src/collision/narrowphase/GJK/GJKAlgorithm.h
@@ -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);
diff --git a/src/collision/narrowphase/GJK/Simplex.h b/src/collision/narrowphase/GJK/Simplex.h
index 1388a161..f55213fb 100644
--- a/src/collision/narrowphase/GJK/Simplex.h
+++ b/src/collision/narrowphase/GJK/Simplex.h
@@ -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;
diff --git a/src/collision/narrowphase/NarrowPhaseAlgorithm.h b/src/collision/narrowphase/NarrowPhaseAlgorithm.h
index e8efaaa6..b765dbf3 100644
--- a/src/collision/narrowphase/NarrowPhaseAlgorithm.h
+++ b/src/collision/narrowphase/NarrowPhaseAlgorithm.h
@@ -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);
diff --git a/src/collision/narrowphase/SphereVsSphereAlgorithm.h b/src/collision/narrowphase/SphereVsSphereAlgorithm.h
index 0c73d57a..44190a22 100644
--- a/src/collision/narrowphase/SphereVsSphereAlgorithm.h
+++ b/src/collision/narrowphase/SphereVsSphereAlgorithm.h
@@ -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,
diff --git a/src/collision/shapes/BoxShape.cpp b/src/collision/shapes/BoxShape.cpp
index fe1f5693..764918c7 100644
--- a/src/collision/shapes/BoxShape.cpp
+++ b/src/collision/shapes/BoxShape.cpp
@@ -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);
diff --git a/src/collision/shapes/BoxShape.h b/src/collision/shapes/BoxShape.h
index f581baa0..bfe702fb 100644
--- a/src/collision/shapes/BoxShape.h
+++ b/src/collision/shapes/BoxShape.h
@@ -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;
diff --git a/src/collision/shapes/CapsuleShape.cpp b/src/collision/shapes/CapsuleShape.cpp
index 110fbd30..a8b231f5 100644
--- a/src/collision/shapes/CapsuleShape.cpp
+++ b/src/collision/shapes/CapsuleShape.cpp
@@ -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));
}
diff --git a/src/collision/shapes/CapsuleShape.h b/src/collision/shapes/CapsuleShape.h
index 56269d04..b4d4755b 100644
--- a/src/collision/shapes/CapsuleShape.h
+++ b/src/collision/shapes/CapsuleShape.h
@@ -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;
diff --git a/src/collision/shapes/CollisionShape.h b/src/collision/shapes/CollisionShape.h
index cd89255d..2c50dac9 100644
--- a/src/collision/shapes/CollisionShape.h
+++ b/src/collision/shapes/CollisionShape.h
@@ -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
diff --git a/src/collision/shapes/ConcaveMeshShape.cpp b/src/collision/shapes/ConcaveMeshShape.cpp
index 317a1c65..dfec3ba2 100644
--- a/src/collision/shapes/ConcaveMeshShape.cpp
+++ b/src/collision/shapes/ConcaveMeshShape.cpp
@@ -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;
diff --git a/src/collision/shapes/ConcaveMeshShape.h b/src/collision/shapes/ConcaveMeshShape.h
index 015c8159..f440f4b2 100644
--- a/src/collision/shapes/ConcaveMeshShape.h
+++ b/src/collision/shapes/ConcaveMeshShape.h
@@ -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;
diff --git a/src/collision/shapes/ConcaveShape.cpp b/src/collision/shapes/ConcaveShape.cpp
index 65a0c8b4..017a277a 100644
--- a/src/collision/shapes/ConcaveShape.cpp
+++ b/src/collision/shapes/ConcaveShape.cpp
@@ -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) {
}
diff --git a/src/collision/shapes/ConcaveShape.h b/src/collision/shapes/ConcaveShape.h
index 9c1418df..1476e4b0 100644
--- a/src/collision/shapes/ConcaveShape.h
+++ b/src/collision/shapes/ConcaveShape.h
@@ -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;
diff --git a/src/collision/shapes/ConeShape.cpp b/src/collision/shapes/ConeShape.cpp
index cc956c73..fc166895 100644
--- a/src/collision/shapes/ConeShape.cpp
+++ b/src/collision/shapes/ConeShape.cpp
@@ -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));
diff --git a/src/collision/shapes/ConeShape.h b/src/collision/shapes/ConeShape.h
index b693f386..d9499823 100644
--- a/src/collision/shapes/ConeShape.h
+++ b/src/collision/shapes/ConeShape.h
@@ -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;
diff --git a/src/collision/shapes/ConvexMeshShape.cpp b/src/collision/shapes/ConvexMeshShape.cpp
index 5d0b651c..aedab6d1 100644
--- a/src/collision/shapes/ConvexMeshShape.cpp
+++ b/src/collision/shapes/ConvexMeshShape.cpp
@@ -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) {
}
diff --git a/src/collision/shapes/ConvexMeshShape.h b/src/collision/shapes/ConvexMeshShape.h
index d23e91b0..cd309f9a 100644
--- a/src/collision/shapes/ConvexMeshShape.h
+++ b/src/collision/shapes/ConvexMeshShape.h
@@ -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;
diff --git a/src/collision/shapes/ConvexShape.h b/src/collision/shapes/ConvexShape.h
index a3cd3131..93a11b81 100644
--- a/src/collision/shapes/ConvexShape.h
+++ b/src/collision/shapes/ConvexShape.h
@@ -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;
diff --git a/src/collision/shapes/CylinderShape.cpp b/src/collision/shapes/CylinderShape.cpp
index fd3da01c..c65047e8 100644
--- a/src/collision/shapes/CylinderShape.cpp
+++ b/src/collision/shapes/CylinderShape.cpp
@@ -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));
diff --git a/src/collision/shapes/CylinderShape.h b/src/collision/shapes/CylinderShape.h
index 71e4f9ae..819a1154 100644
--- a/src/collision/shapes/CylinderShape.h
+++ b/src/collision/shapes/CylinderShape.h
@@ -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;
diff --git a/src/collision/shapes/HeightFieldShape.cpp b/src/collision/shapes/HeightFieldShape.cpp
index 88224e2d..720619e8 100644
--- a/src/collision/shapes/HeightFieldShape.cpp
+++ b/src/collision/shapes/HeightFieldShape.cpp
@@ -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) {
diff --git a/src/collision/shapes/HeightFieldShape.h b/src/collision/shapes/HeightFieldShape.h
index 49adff48..ae7b4c62 100644
--- a/src/collision/shapes/HeightFieldShape.h
+++ b/src/collision/shapes/HeightFieldShape.h
@@ -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;
}
}
diff --git a/src/collision/shapes/SphereShape.cpp b/src/collision/shapes/SphereShape.cpp
index 549a6359..50c2e94d 100644
--- a/src/collision/shapes/SphereShape.cpp
+++ b/src/collision/shapes/SphereShape.cpp
@@ -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));
}
diff --git a/src/collision/shapes/SphereShape.h b/src/collision/shapes/SphereShape.h
index a1316ae0..c8157952 100644
--- a/src/collision/shapes/SphereShape.h
+++ b/src/collision/shapes/SphereShape.h
@@ -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;
diff --git a/src/collision/shapes/TriangleShape.cpp b/src/collision/shapes/TriangleShape.cpp
index 24bd3fda..065b7526 100644
--- a/src/collision/shapes/TriangleShape.cpp
+++ b/src/collision/shapes/TriangleShape.cpp
@@ -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;
}
diff --git a/src/collision/shapes/TriangleShape.h b/src/collision/shapes/TriangleShape.h
index 1b9f3681..02757b88 100644
--- a/src/collision/shapes/TriangleShape.h
+++ b/src/collision/shapes/TriangleShape.h
@@ -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;
diff --git a/src/configuration.h b/src/configuration.h
index a39117cc..731071fd 100644
--- a/src/configuration.h
+++ b/src/configuration.h
@@ -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 ------------------- //
diff --git a/src/constraint/BallAndSocketJoint.cpp b/src/constraint/BallAndSocketJoint.cpp
index 275b5643..8883d3e7 100644
--- a/src/constraint/BallAndSocketJoint.cpp
+++ b/src/constraint/BallAndSocketJoint.cpp
@@ -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();
}
diff --git a/src/constraint/BallAndSocketJoint.h b/src/constraint/BallAndSocketJoint.h
index f4671e87..bc37b63e 100644
--- a/src/constraint/BallAndSocketJoint.h
+++ b/src/constraint/BallAndSocketJoint.h
@@ -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
diff --git a/src/constraint/ContactPoint.h b/src/constraint/ContactPoint.h
index 9b172e6c..b7fef547 100644
--- a/src/constraint/ContactPoint.h
+++ b/src/constraint/ContactPoint.h
@@ -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;
diff --git a/src/constraint/FixedJoint.cpp b/src/constraint/FixedJoint.cpp
index 57c8d8c6..f17d0b9e 100644
--- a/src/constraint/FixedJoint.cpp
+++ b/src/constraint/FixedJoint.cpp
@@ -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();
}
diff --git a/src/constraint/FixedJoint.h b/src/constraint/FixedJoint.h
index aa9f2798..974f1b79 100644
--- a/src/constraint/FixedJoint.h
+++ b/src/constraint/FixedJoint.h
@@ -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
diff --git a/src/constraint/HingeJoint.cpp b/src/constraint/HingeJoint.cpp
index e64cbde8..01563de4 100644
--- a/src/constraint/HingeJoint.cpp
+++ b/src/constraint/HingeJoint.cpp
@@ -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();
}
diff --git a/src/constraint/HingeJoint.h b/src/constraint/HingeJoint.h
index 662c7e5c..bebd19c8 100644
--- a/src/constraint/HingeJoint.h
+++ b/src/constraint/HingeJoint.h
@@ -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;
diff --git a/src/constraint/Joint.h b/src/constraint/Joint.h
index 66ed1f28..eb73f87f 100644
--- a/src/constraint/Joint.h
+++ b/src/constraint/Joint.h
@@ -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;
diff --git a/src/constraint/SliderJoint.cpp b/src/constraint/SliderJoint.cpp
index 99a5c834..a1904174 100644
--- a/src/constraint/SliderJoint.cpp
+++ b/src/constraint/SliderJoint.cpp
@@ -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();
}
diff --git a/src/constraint/SliderJoint.h b/src/constraint/SliderJoint.h
index c40526d4..a4f359da 100644
--- a/src/constraint/SliderJoint.h
+++ b/src/constraint/SliderJoint.h
@@ -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;
diff --git a/src/engine/CollisionWorld.h b/src/engine/CollisionWorld.h
index 91560935..77189e89 100644
--- a/src/engine/CollisionWorld.h
+++ b/src/engine/CollisionWorld.h
@@ -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();
diff --git a/src/engine/ContactSolver.cpp b/src/engine/ContactSolver.cpp
index f2ee0ef2..c3a0d0ef 100644
--- a/src/engine/ContactSolver.cpp
+++ b/src/engine/ContactSolver.cpp
@@ -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) {
diff --git a/src/engine/DynamicsWorld.cpp b/src/engine/DynamicsWorld.cpp
index b52e2378..2f601edd 100644
--- a/src/engine/DynamicsWorld.cpp
+++ b/src/engine/DynamicsWorld.cpp
@@ -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 ||
diff --git a/src/engine/DynamicsWorld.h b/src/engine/DynamicsWorld.h
index 71a5336a..a9bfc9d8 100644
--- a/src/engine/DynamicsWorld.h
+++ b/src/engine/DynamicsWorld.h
@@ -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 {
diff --git a/src/engine/EventListener.h b/src/engine/EventListener.h
index 4df79259..a2e9d868 100644
--- a/src/engine/EventListener.h
+++ b/src/engine/EventListener.h
@@ -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
/**
diff --git a/src/engine/Impulse.h b/src/engine/Impulse.h
index 8c2bef33..89e36429 100644
--- a/src/engine/Impulse.h
+++ b/src/engine/Impulse.h
@@ -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;
};
}
diff --git a/src/engine/Island.h b/src/engine/Island.h
index 6be38d5e..1b086939 100644
--- a/src/engine/Island.h
+++ b/src/engine/Island.h
@@ -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);
diff --git a/src/engine/OverlappingPair.h b/src/engine/OverlappingPair.h
index 995546c5..e40814ca 100644
--- a/src/engine/OverlappingPair.h
+++ b/src/engine/OverlappingPair.h
@@ -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;
diff --git a/src/engine/Timer.h b/src/engine/Timer.h
index ec673b67..9c59d033 100644
--- a/src/engine/Timer.h
+++ b/src/engine/Timer.h
@@ -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;
diff --git a/test/tests/collision/TestRaycast.h b/test/tests/collision/TestRaycast.h
index 89b38110..09e3ebd8 100644
--- a/test/tests/collision/TestRaycast.h
+++ b/test/tests/collision/TestRaycast.h
@@ -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));
diff --git a/testbed/common/ConcaveMesh.cpp b/testbed/common/ConcaveMesh.cpp
index 0f8d7cb1..68f7a56e 100644
--- a/testbed/common/ConcaveMesh.cpp
+++ b/testbed/common/ConcaveMesh.cpp
@@ -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);
diff --git a/testbed/common/ConvexMesh.cpp b/testbed/common/ConvexMesh.cpp
index ffdbca04..1ded48a2 100644
--- a/testbed/common/ConvexMesh.cpp
+++ b/testbed/common/ConvexMesh.cpp
@@ -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
diff --git a/testbed/common/HeightField.cpp b/testbed/common/HeightField.cpp
index e230c365..f65123ee 100644
--- a/testbed/common/HeightField.cpp
+++ b/testbed/common/HeightField.cpp
@@ -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);
diff --git a/testbed/scenes/collisionshapes/CollisionShapesScene.cpp b/testbed/scenes/collisionshapes/CollisionShapesScene.cpp
index bcf7c836..b1778398 100644
--- a/testbed/scenes/collisionshapes/CollisionShapesScene.cpp
+++ b/testbed/scenes/collisionshapes/CollisionShapesScene.cpp
@@ -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();
diff --git a/testbed/scenes/concavemesh/ConcaveMeshScene.cpp b/testbed/scenes/concavemesh/ConcaveMeshScene.cpp
index d8309cde..c8396712 100644
--- a/testbed/scenes/concavemesh/ConcaveMeshScene.cpp
+++ b/testbed/scenes/concavemesh/ConcaveMeshScene.cpp
@@ -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);
diff --git a/testbed/scenes/cubes/CubesScene.cpp b/testbed/scenes/cubes/CubesScene.cpp
index 2de04857..e0a04cee 100644
--- a/testbed/scenes/cubes/CubesScene.cpp
+++ b/testbed/scenes/cubes/CubesScene.cpp
@@ -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();
diff --git a/testbed/scenes/heightfield/HeightFieldScene.cpp b/testbed/scenes/heightfield/HeightFieldScene.cpp
index ab168b13..fd72c9bb 100644
--- a/testbed/scenes/heightfield/HeightFieldScene.cpp
+++ b/testbed/scenes/heightfield/HeightFieldScene.cpp
@@ -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);
diff --git a/testbed/scenes/joints/JointsScene.cpp b/testbed/scenes/joints/JointsScene.cpp
index ae006573..4b96096c 100644
--- a/testbed/scenes/joints/JointsScene.cpp
+++ b/testbed/scenes/joints/JointsScene.cpp
@@ -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();