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

Fix warnings

Browse Source
This commit is contained in:
Daniel Chappuis 2021-11-12 16:54:39 +01:00
parent b9f123ff8a
commit 2545e5f702
18 changed files with 79 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/reactphysics3d/collision/CollisionCallback.h
View File

@ -297,7 +297,7 @@ class CollisionCallback {
* @return The number of contact pairs
*/
RP3D_FORCE_INLINE uint32 CollisionCallback::CallbackData::getNbContactPairs() const {
return mContactPairsIndices.size() + mLostContactPairsIndices.size();
return static_cast<uint32>(mContactPairsIndices.size() + mLostContactPairsIndices.size());
}
// Return the number of contact points in the contact pair

8
include/reactphysics3d/collision/HalfEdgeStructure.h
View File

@ -132,7 +132,7 @@ class HalfEdgeStructure {
RP3D_FORCE_INLINE uint32 HalfEdgeStructure::addVertex(uint32 vertexPointIndex) {
Vertex vertex(vertexPointIndex);
mVertices.add(vertex);
return mVertices.size() - 1;
return static_cast<uint32>(mVertices.size()) - 1;
}
// Add a face
@ -152,7 +152,7 @@ RP3D_FORCE_INLINE void HalfEdgeStructure::addFace(Array<uint32> faceVertices) {
* @return The number of faces in the polyhedron
*/
RP3D_FORCE_INLINE uint32 HalfEdgeStructure::getNbFaces() const {
return mFaces.size();
return static_cast<uint32>(mFaces.size());
}
// Return the number of edges
@ -160,7 +160,7 @@ RP3D_FORCE_INLINE uint32 HalfEdgeStructure::getNbFaces() const {
* @return The number of edges in the polyhedron
*/
RP3D_FORCE_INLINE uint32 HalfEdgeStructure::getNbHalfEdges() const {
return mEdges.size();
return static_cast<uint32>(mEdges.size());
}
// Return the number of vertices
@ -168,7 +168,7 @@ RP3D_FORCE_INLINE uint32 HalfEdgeStructure::getNbHalfEdges() const {
* @return The number of vertices in the polyhedron
*/
RP3D_FORCE_INLINE uint32 HalfEdgeStructure::getNbVertices() const {
return mVertices.size();
return static_cast<uint32>(mVertices.size());
}
// Return a given face

2
include/reactphysics3d/collision/OverlapCallback.h
View File

@ -186,7 +186,7 @@ class OverlapCallback {
// Return the number of overlapping pairs of bodies
RP3D_FORCE_INLINE uint32 OverlapCallback::CallbackData::getNbOverlappingPairs() const {
return mContactPairsIndices.size() + mLostContactPairsIndices.size();
return static_cast<uint32>(mContactPairsIndices.size() + mLostContactPairsIndices.size());
}
// Return a given overlapping pair of bodies

2
include/reactphysics3d/collision/TriangleMesh.h
View File

@ -97,7 +97,7 @@ RP3D_FORCE_INLINE TriangleVertexArray* TriangleMesh::getSubpart(uint32 indexSubp
* @return The number of sub-parts of the mesh
*/
RP3D_FORCE_INLINE uint32 TriangleMesh::getNbSubparts() const {
return mTriangleArrays.size();
return static_cast<uint32>(mTriangleArrays.size());
}
}

2
include/reactphysics3d/collision/narrowphase/NarrowPhaseInfoBatch.h
View File

@ -146,7 +146,7 @@ struct NarrowPhaseInfoBatch {
/// Return the number of objects in the batch
RP3D_FORCE_INLINE uint32 NarrowPhaseInfoBatch::getNbObjects() const {
return narrowPhaseInfos.size();
return static_cast<uint32>(narrowPhaseInfos.size());
}
// Add shapes to be tested during narrow-phase collision detection into the batch

12
include/reactphysics3d/engine/Islands.h
View File

@ -99,17 +99,17 @@ struct Islands {
/// Return the number of islands
uint32 getNbIslands() const {
return contactManifoldsIndices.size();
return static_cast<uint32>(contactManifoldsIndices.size());
}
/// Add an island and return its index
uint32 addIsland(uint32 contactManifoldStartIndex) {
const uint32 islandIndex = contactManifoldsIndices.size();
const uint32 islandIndex = static_cast<uint32>(contactManifoldsIndices.size());
contactManifoldsIndices.add(contactManifoldStartIndex);
nbContactManifolds.add(0);
startBodyEntitiesIndex.add(bodyEntities.size());
startBodyEntitiesIndex.add(static_cast<uint32>(bodyEntities.size()));
nbBodiesInIsland.add(0);
if (islandIndex > 0 && nbBodiesInIsland[islandIndex-1] > mNbMaxBodiesInIslandCurrentFrame) {
@ -121,7 +121,7 @@ struct Islands {
void addBodyToIsland(Entity bodyEntity) {
const uint32 islandIndex = contactManifoldsIndices.size();
const uint32 islandIndex = static_cast<uint32>(contactManifoldsIndices.size());
assert(islandIndex > 0);
bodyEntities.add(bodyEntity);
@ -142,7 +142,7 @@ struct Islands {
/// Clear all the islands
void clear() {
const uint32 nbIslands = nbContactManifolds.size();
const uint32 nbIslands = static_cast<uint32>(nbContactManifolds.size());
if (nbIslands > 0 && nbBodiesInIsland[nbIslands-1] > mNbMaxBodiesInIslandCurrentFrame) {
mNbMaxBodiesInIslandCurrentFrame = nbBodiesInIsland[nbIslands-1];
@ -151,7 +151,7 @@ struct Islands {
mNbMaxBodiesInIslandPreviousFrame = mNbMaxBodiesInIslandCurrentFrame;
mNbIslandsPreviousFrame = nbIslands;
mNbMaxBodiesInIslandCurrentFrame = 0;
mNbBodyEntitiesPreviousFrame = bodyEntities.size();
mNbBodyEntitiesPreviousFrame = static_cast<uint32>(bodyEntities.size());
contactManifoldsIndices.clear(true);
nbContactManifolds.clear(true);

4
include/reactphysics3d/engine/PhysicsWorld.h
View File

@ -685,7 +685,7 @@ RP3D_FORCE_INLINE void PhysicsWorld::setEventListener(EventListener* eventListen
* @return The number of collision bodies in the physics world
*/
RP3D_FORCE_INLINE uint32 PhysicsWorld::getNbCollisionBodies() const {
return mCollisionBodies.size();
return static_cast<uint32>(mCollisionBodies.size());
}
// Return the number of RigidBody in the physics world
@ -693,7 +693,7 @@ RP3D_FORCE_INLINE uint32 PhysicsWorld::getNbCollisionBodies() const {
* @return The number of rigid bodies in the physics world
*/
RP3D_FORCE_INLINE uint32 PhysicsWorld::getNbRigidBodies() const {
return mRigidBodies.size();
return static_cast<uint32>(mRigidBodies.size());
}
// Return true if the debug rendering is enabled

6
include/reactphysics3d/mathematics/mathematics_functions.h
View File

@ -266,7 +266,7 @@ RP3D_FORCE_INLINE Array<Vector3> clipSegmentWithPlanes(const Vector3& segA, cons
inputVertices.add(segB);
// For each clipping plane
const uint32 nbPlanesPoints = planesPoints.size();
const uint32 nbPlanesPoints = static_cast<uint32>(planesPoints.size());
for (uint32 p=0; p < nbPlanesPoints; p++) {
// If there is no more vertices, stop
@ -332,7 +332,7 @@ RP3D_FORCE_INLINE Array<Vector3> clipSegmentWithPlanes(const Vector3& segA, cons
RP3D_FORCE_INLINE void clipPolygonWithPlane(const Array<Vector3>& polygonVertices, const Vector3& planePoint,
const Vector3& planeNormal, Array<Vector3>& outClippedPolygonVertices) {
uint32 nbInputVertices = polygonVertices.size();
uint32 nbInputVertices = static_cast<uint32>(polygonVertices.size());
assert(outClippedPolygonVertices.size() == 0);
@ -408,7 +408,7 @@ RP3D_FORCE_INLINE bool isPowerOfTwo(uint64 number) {
}
/// Return the next power of two larger than the number in parameter
RP3D_FORCE_INLINE uint32 nextPowerOfTwo64Bits(uint64 number) {
RP3D_FORCE_INLINE uint64 nextPowerOfTwo64Bits(uint64 number) {
number--;
number |= number >> 1;
number |= number >> 2;

4
include/reactphysics3d/utils/DebugRenderer.h
View File

@ -264,7 +264,7 @@ class DebugRenderer : public EventListener {
* @return The number of lines in the array of lines to draw
*/
RP3D_FORCE_INLINE uint32 DebugRenderer::getNbLines() const {
return mLines.size();
return static_cast<uint32>(mLines.size());
}
// Return a reference to the array of lines
@ -288,7 +288,7 @@ RP3D_FORCE_INLINE const DebugRenderer::DebugLine* DebugRenderer::getLinesArray()
* @return The number of triangles in the array of triangles to draw
*/
RP3D_FORCE_INLINE uint32 DebugRenderer::getNbTriangles() const {
return mTriangles.size();
return static_cast<uint32>(mTriangles.size());
}
// Return a reference to the array of triangles

10
src/body/CollisionBody.cpp
View File

@ -132,7 +132,7 @@ Collider* CollisionBody::addCollider(CollisionShape* collisionShape, const Trans
* @return The number of colliders associated with this body
*/
uint32 CollisionBody::getNbColliders() const {
return mWorld.mCollisionBodyComponents.getColliders(mEntity).size();
return static_cast<uint32>(mWorld.mCollisionBodyComponents.getColliders(mEntity).size());
}
// Return a const pointer to a given collider of the body
@ -223,7 +223,7 @@ void CollisionBody::updateBroadPhaseState() const {
// For all the colliders of the body
const Array<Entity>& colliderEntities = mWorld.mCollisionBodyComponents.getColliders(mEntity);
const uint32 nbColliderEntities = colliderEntities.size();
const uint32 nbColliderEntities = static_cast<uint32>(colliderEntities.size());
for (uint32 i=0; i < nbColliderEntities; i++) {
// Update the local-to-world transform of the collider
@ -293,7 +293,7 @@ void CollisionBody::askForBroadPhaseCollisionCheck() const {
// For all the colliders of the body
const Array<Entity>& colliderEntities = mWorld.mCollisionBodyComponents.getColliders(mEntity);
const uint32 nbColliderEntities = colliderEntities.size();
const uint32 nbColliderEntities = static_cast<uint32>(colliderEntities.size());
for (uint32 i=0; i < nbColliderEntities; i++) {
Collider* collider = mWorld.mCollidersComponents.getCollider(colliderEntities[i]);
@ -341,7 +341,7 @@ bool CollisionBody::raycast(const Ray& ray, RaycastInfo& raycastInfo) {
// For each collider of the body
const Array<Entity>& colliderEntities = mWorld.mCollisionBodyComponents.getColliders(mEntity);
const uint32 nbColliderEntities = colliderEntities.size();
const uint32 nbColliderEntities = static_cast<uint32>(colliderEntities.size());
for (uint32 i=0; i < nbColliderEntities; i++) {
Collider* collider = mWorld.mCollidersComponents.getCollider(colliderEntities[i]);
@ -373,7 +373,7 @@ AABB CollisionBody::getAABB() const {
collider->getCollisionShape()->computeAABB(bodyAABB, transform * collider->getLocalToBodyTransform());
// For each collider of the body
const uint32 nbColliderEntities = colliderEntities.size();
const uint32 nbColliderEntities = static_cast<uint32>(colliderEntities.size());
for (uint32 i=1; i < nbColliderEntities; i++) {
Collider* collider = mWorld.mCollidersComponents.getCollider(colliderEntities[i]);

12
src/collision/narrowphase/SAT/SATAlgorithm.cpp
View File

@ -429,7 +429,7 @@ bool SATAlgorithm::computeCapsulePolyhedronFaceContactPoints(uint32 referenceFac
bool contactFound = false;
// For each of the two clipped points
const uint32 nbClipSegments = clipSegment.size();
const uint32 nbClipSegments = static_cast<uint32>(clipSegment.size());
for (uint32 i = 0; i < nbClipSegments; i++) {
// Compute the penetration depth of the two clipped points (to filter out the points that does not correspond to the penetration depth)
@ -924,8 +924,8 @@ bool SATAlgorithm::computePolyhedronVsPolyhedronFaceContactPoints(bool isMinPene
// Get the incident face
const HalfEdgeStructure::Face& incidentFace = incidentPolyhedron->getFace(incidentFaceIndex);
const uint32 nbIncidentFaceVertices = incidentFace.faceVertices.size();
const uint32 nbMaxElements = nbIncidentFaceVertices * 2 * referenceFace.faceVertices.size();
const uint32 nbIncidentFaceVertices = static_cast<uint32>(incidentFace.faceVertices.size());
const uint32 nbMaxElements = nbIncidentFaceVertices * 2 * static_cast<uint32>(referenceFace.faceVertices.size());
Array<Vector3> verticesTemp1(mMemoryAllocator, nbMaxElements);
Array<Vector3> verticesTemp2(mMemoryAllocator, nbMaxElements);
@ -976,11 +976,11 @@ bool SATAlgorithm::computePolyhedronVsPolyhedronFaceContactPoints(bool isMinPene
// Clear the input array of vertices before the next loop
if (areVertices1Input) {
verticesTemp1.clear();
nbOutputVertices = verticesTemp2.size();
nbOutputVertices = static_cast<uint32>(verticesTemp2.size());
}
else {
verticesTemp2.clear();
nbOutputVertices = verticesTemp1.size();
nbOutputVertices = static_cast<uint32>(verticesTemp1.size());
}
} while (currentEdgeIndex != firstEdgeIndex && nbOutputVertices > 0);
@ -991,7 +991,7 @@ bool SATAlgorithm::computePolyhedronVsPolyhedronFaceContactPoints(bool isMinPene
// We only keep the clipped points that are below the reference face
const Vector3 referenceFaceVertex = referencePolyhedron->getVertexPosition(referencePolyhedron->getHalfEdge(firstEdgeIndex).vertexIndex);
bool contactPointsFound = false;
const uint32 nbClipPolygonVertices = clippedPolygonVertices.size();
const uint32 nbClipPolygonVertices = static_cast<uint32>(clippedPolygonVertices.size());
for (uint32 i=0; i < nbClipPolygonVertices; i++) {
// Compute the penetration depth of this contact point (can be different from the minPenetration depth which is

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

@ -96,7 +96,7 @@ void CollisionShape::computeAABB(AABB& aabb, const Transform& transform) const {
/// Notify all the assign colliders that the size of the collision shape has changed
void CollisionShape::notifyColliderAboutChangedSize() {
const uint32 nbColliders = mColliders.size();
const uint32 nbColliders = static_cast<uint32>(mColliders.size());
for (uint32 i=0; i < nbColliders; i++) {
mColliders[i]->setHasCollisionShapeChangedSize(true);
}

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

@ -142,7 +142,7 @@ void ConcaveMeshShape::computeOverlappingTriangles(const AABB& localAABB, Array<
Array<int> overlappingNodes(allocator, 64);
mDynamicAABBTree.reportAllShapesOverlappingWithAABB(aabb, overlappingNodes);
const uint32 nbOverlappingNodes = overlappingNodes.size();
const uint32 nbOverlappingNodes = static_cast<uint32>(overlappingNodes.size());
// Add space in the array of triangles vertices/normals for the new triangles
triangleVertices.addWithoutInit(nbOverlappingNodes * 3);

2
src/engine/EntityManager.cpp
View File

@ -53,7 +53,7 @@ Entity EntityManager::createEntity() {
mGenerations.add(0);
// Create a new indice
index = mGenerations.size() - 1;
index = static_cast<uint32>(mGenerations.size()) - 1;
assert(index < (uint32(1) << Entity::ENTITY_INDEX_BITS));
}

4
src/engine/OverlappingPairs.cpp
View File

@ -81,7 +81,7 @@ void OverlappingPairs::removePair(uint64 pairIndex, bool isConvexVsConvex) {
if (isConvexVsConvex) {
const uint32 nbConvexPairs = mConvexPairs.size();
const uint64 nbConvexPairs = mConvexPairs.size();
assert(pairIndex < nbConvexPairs);
@ -106,7 +106,7 @@ void OverlappingPairs::removePair(uint64 pairIndex, bool isConvexVsConvex) {
}
else {
const uint32 nbConcavePairs = mConcavePairs.size();
const uint64 nbConcavePairs = mConcavePairs.size();
assert(pairIndex < nbConcavePairs);

16
src/engine/PhysicsWorld.cpp
View File

@ -123,7 +123,9 @@ PhysicsWorld::~PhysicsWorld() {
"Physics World: Physics world " + mName + " has been destroyed", __FILE__, __LINE__);
// Destroy all the collision bodies that have not been removed
for (int i=mCollisionBodies.size() - 1 ; i >= 0; i--) {
uint32 i = static_cast<uint32>(mCollisionBodies.size());
while (i != 0) {
i--;
destroyCollisionBody(mCollisionBodies[i]);
}
@ -141,7 +143,9 @@ PhysicsWorld::~PhysicsWorld() {
}
// Destroy all the rigid bodies that have not been removed
for (int i=mRigidBodies.size() - 1; i >= 0; i--) {
i = static_cast<uint32>(mRigidBodies.size());
while (i != 0) {
i--;
destroyRigidBody(mRigidBodies[i]);
}
@ -244,7 +248,7 @@ void PhysicsWorld::setBodyDisabled(Entity bodyEntity, bool isDisabled) {
// For each collider of the body
const Array<Entity>& collidersEntities = mCollisionBodyComponents.getColliders(bodyEntity);
const uint32 nbColliderEntities = collidersEntities.size();
const uint32 nbColliderEntities = static_cast<uint32>(collidersEntities.size());
for (uint32 i=0; i < nbColliderEntities; i++) {
mCollidersComponents.setIsEntityDisabled(collidersEntities[i], isDisabled);
@ -832,7 +836,7 @@ void PhysicsWorld::createIslands() {
// If the body is involved in contacts with other bodies
// For each contact pair in which the current body is involded
const uint32 nbBodyContactPairs = mRigidBodyComponents.mContactPairs[bodyToVisitIndex].size();
const uint32 nbBodyContactPairs = static_cast<uint32>(mRigidBodyComponents.mContactPairs[bodyToVisitIndex].size());
for (uint32 p=0; p < nbBodyContactPairs; p++) {
const uint32 contactPairIndex = mRigidBodyComponents.mContactPairs[bodyToVisitIndex][p];
@ -873,7 +877,7 @@ void PhysicsWorld::createIslands() {
// For each joint in which the current body is involved
const Array<Entity>& joints = mRigidBodyComponents.getJoints(rigidBodyToVisit->getEntity());
const uint32 nbBodyJoints = joints.size();
const uint32 nbBodyJoints = static_cast<uint32>(joints.size());
for (uint32 i=0; i < nbBodyJoints; i++) {
const uint32 jointComponentIndex = mJointsComponents.getEntityIndex(joints[i]);
@ -901,7 +905,7 @@ void PhysicsWorld::createIslands() {
// Reset the isAlreadyIsland variable of the static bodies so that they
// can also be included in the other islands
const uint32 nbStaticBodiesAddedToIsland = staticBodiesAddedToIsland.size();
const uint32 nbStaticBodiesAddedToIsland = static_cast<uint32>(staticBodiesAddedToIsland.size());
for (uint32 j=0; j < nbStaticBodiesAddedToIsland; j++) {
assert(mRigidBodyComponents.getBodyType(staticBodiesAddedToIsland[j]) == BodyType::STATIC);

60
src/systems/CollisionDetectionSystem.cpp
View File

@ -191,7 +191,7 @@ void CollisionDetectionSystem::addLostContactPair(OverlappingPairs::OverlappingP
const bool isTrigger = isCollider1Trigger || isCollider2Trigger;
// Create a lost contact pair
ContactPair lostContactPair(overlappingPair.pairID, body1Entity, body2Entity, overlappingPair.collider1, overlappingPair.collider2, mLostContactPairs.size(),
ContactPair lostContactPair(overlappingPair.pairID, body1Entity, body2Entity, overlappingPair.collider1, overlappingPair.collider2, static_cast<uint32>(mLostContactPairs.size()),
true, isTrigger);
mLostContactPairs.add(lostContactPair);
}
@ -202,7 +202,7 @@ void CollisionDetectionSystem::updateOverlappingPairs(const Array<Pair<int32, in
RP3D_PROFILE("CollisionDetectionSystem::updateOverlappingPairs()", mProfiler);
// For each overlapping pair of nodes
const uint32 nbOverlappingNodes = overlappingNodes.size();
const uint32 nbOverlappingNodes = static_cast<uint32>(overlappingNodes.size());
for (uint32 i=0; i < nbOverlappingNodes; i++) {
Pair<int32, int32> nodePair = overlappingNodes[i];
@ -402,7 +402,7 @@ void CollisionDetectionSystem::computeMiddlePhaseCollisionSnapshot(Array<uint64>
}
// For each possible convex vs concave pair of bodies
const uint32 nbConcavePairs = concavePairs.size();
const uint32 nbConcavePairs = static_cast<uint32>(concavePairs.size());
for (uint32 p=0; p < nbConcavePairs; p++) {
const uint64 pairId = concavePairs[p];
@ -480,7 +480,7 @@ void CollisionDetectionSystem::computeConvexVsConcaveMiddlePhase(OverlappingPair
}
// For each overlapping triangle
const uint32 nbShapeIds = shapeIds.size();
const uint32 nbShapeIds = static_cast<uint32>(shapeIds.size());
for (uint32 i=0; i < nbShapeIds; i++) {
// Create a triangle collision shape (the allocated memory for the TriangleShape will be released in the
@ -619,7 +619,7 @@ void CollisionDetectionSystem::computeNarrowPhase() {
// Add the contact pairs to the corresponding bodies
void CollisionDetectionSystem::addContactPairsToBodies() {
const uint32 nbContactPairs = mCurrentContactPairs->size();
const uint32 nbContactPairs = static_cast<uint32>(mCurrentContactPairs->size());
for (uint32 p=0 ; p < nbContactPairs; p++) {
ContactPair& contactPair = (*mCurrentContactPairs)[p];
@ -648,7 +648,7 @@ void CollisionDetectionSystem::addContactPairsToBodies() {
void CollisionDetectionSystem::computeMapPreviousContactPairs() {
mPreviousMapPairIdToContactPairIndex.clear();
const uint32 nbCurrentContactPairs = mCurrentContactPairs->size();
const uint32 nbCurrentContactPairs = static_cast<uint32>(mCurrentContactPairs->size());
for (uint32 i=0; i < nbCurrentContactPairs; i++) {
mPreviousMapPairIdToContactPairIndex.add(Pair<uint64, uint>((*mCurrentContactPairs)[i].pairId, i));
}
@ -707,7 +707,7 @@ void CollisionDetectionSystem::notifyOverlappingPairsToTestOverlap(Collider* col
// Get the overlapping pairs involved with this collider
Array<uint64>& overlappingPairs = mCollidersComponents.getOverlappingPairs(collider->getEntity());
const uint32 nbPairs = overlappingPairs.size();
const uint32 nbPairs = static_cast<uint32>(overlappingPairs.size());
for (uint32 i=0; i < nbPairs; i++) {
// Notify that the overlapping pair needs to be testbed for overlap
@ -742,7 +742,7 @@ void CollisionDetectionSystem::computeOverlapSnapshotContactPairs(NarrowPhaseInf
const bool isTrigger = mCollidersComponents.mIsTrigger[collider1Index] || mCollidersComponents.mIsTrigger[collider2Index];
// Create a new contact pair
ContactPair contactPair(narrowPhaseInfoBatch.narrowPhaseInfos[i].overlappingPairId, body1Entity, body2Entity, collider1Entity, collider2Entity, contactPairs.size(), isTrigger, false);
ContactPair contactPair(narrowPhaseInfoBatch.narrowPhaseInfos[i].overlappingPairId, body1Entity, body2Entity, collider1Entity, collider2Entity, static_cast<uint32>(contactPairs.size()), isTrigger, false);
contactPairs.add(contactPair);
setOverlapContactPairId.add(narrowPhaseInfoBatch.narrowPhaseInfos[i].overlappingPairId);
@ -832,16 +832,16 @@ void CollisionDetectionSystem::createContacts() {
// Process the contact pairs in the order defined by the islands such that the contact manifolds and
// contact points of a given island are packed together in the array of manifolds and contact points
const uint32 nbContactPairsToProcess = mWorld->mProcessContactPairsOrderIslands.size();
const uint32 nbContactPairsToProcess = static_cast<uint32>(mWorld->mProcessContactPairsOrderIslands.size());
for (uint32 p=0; p < nbContactPairsToProcess; p++) {
uint32 contactPairIndex = mWorld->mProcessContactPairsOrderIslands[p];
ContactPair& contactPair = (*mCurrentContactPairs)[contactPairIndex];
contactPair.contactManifoldsIndex = mCurrentContactManifolds->size();
contactPair.contactManifoldsIndex = static_cast<uint32>(mCurrentContactManifolds->size());
contactPair.nbContactManifolds = contactPair.nbPotentialContactManifolds;
contactPair.contactPointsIndex = mCurrentContactPoints->size();
contactPair.contactPointsIndex = static_cast<uint32>(mCurrentContactPoints->size());
// For each potential contact manifold of the pair
for (uint32 m=0; m < contactPair.nbPotentialContactManifolds; m++) {
@ -849,7 +849,7 @@ void CollisionDetectionSystem::createContacts() {
ContactManifoldInfo& potentialManifold = mPotentialContactManifolds[contactPair.potentialContactManifoldsIndices[m]];
// Start index and number of contact points for this manifold
const uint32 contactPointsIndex = mCurrentContactPoints->size();
const uint32 contactPointsIndex = static_cast<uint32>(mCurrentContactPoints->size());
const int8 nbContactPoints = static_cast<int8>(potentialManifold.nbPotentialContactPoints);
contactPair.nbToTalContactPoints += nbContactPoints;
@ -880,8 +880,8 @@ void CollisionDetectionSystem::createContacts() {
mPreviousContactManifolds->clear();
mPreviousContactPairs->clear();
mNbPreviousPotentialContactManifolds = mPotentialContactManifolds.capacity();
mNbPreviousPotentialContactPoints = mPotentialContactPoints.capacity();
mNbPreviousPotentialContactManifolds = static_cast<uint32>(mPotentialContactManifolds.capacity());
mNbPreviousPotentialContactPoints = static_cast<uint32>(mPotentialContactPoints.capacity());
// Reset the potential contacts
mPotentialContactPoints.clear(true);
@ -899,7 +899,7 @@ void CollisionDetectionSystem::createContacts() {
void CollisionDetectionSystem::computeLostContactPairs() {
// For each convex pair
const uint32 nbConvexPairs = mOverlappingPairs.mConvexPairs.size();
const uint32 nbConvexPairs = static_cast<uint32>(mOverlappingPairs.mConvexPairs.size());
for (uint32 i=0; i < nbConvexPairs; i++) {
// If the two colliders of the pair were colliding in the previous frame but not in the current one
@ -915,7 +915,7 @@ void CollisionDetectionSystem::computeLostContactPairs() {
}
// For each convex pair
const uint32 nbConcavePairs = mOverlappingPairs.mConcavePairs.size();
const uint32 nbConcavePairs = static_cast<uint32>(mOverlappingPairs.mConcavePairs.size());
for (uint32 i=0; i < nbConcavePairs; i++) {
// If the two colliders of the pair were colliding in the previous frame but not in the current one
@ -944,15 +944,15 @@ void CollisionDetectionSystem::createSnapshotContacts(Array<ContactPair>& contac
contactPoints.reserve(contactManifolds.size());
// For each contact pair
const uint32 nbContactPairs = contactPairs.size();
const uint32 nbContactPairs = static_cast<uint32>(contactPairs.size());
for (uint32 p=0; p < nbContactPairs; p++) {
ContactPair& contactPair = contactPairs[p];
assert(contactPair.nbPotentialContactManifolds > 0);
contactPair.contactManifoldsIndex = contactManifolds.size();
contactPair.contactManifoldsIndex = static_cast<uint32>(contactManifolds.size());
contactPair.nbContactManifolds = contactPair.nbPotentialContactManifolds;
contactPair.contactPointsIndex = contactPoints.size();
contactPair.contactPointsIndex = static_cast<uint32>(contactPoints.size());
// For each potential contact manifold of the pair
for (uint32 m=0; m < contactPair.nbPotentialContactManifolds; m++) {
@ -960,7 +960,7 @@ void CollisionDetectionSystem::createSnapshotContacts(Array<ContactPair>& contac
ContactManifoldInfo& potentialManifold = potentialContactManifolds[contactPair.potentialContactManifoldsIndices[m]];
// Start index and number of contact points for this manifold
const uint32 contactPointsIndex = contactPoints.size();
const uint32 contactPointsIndex = static_cast<uint32>(contactPoints.size());
const uint8 nbContactPoints = potentialManifold.nbPotentialContactPoints;
contactPair.nbToTalContactPoints += nbContactPoints;
@ -991,7 +991,7 @@ void CollisionDetectionSystem::initContactsWithPreviousOnes() {
const decimal persistentContactDistThresholdSqr = mWorld->mConfig.persistentContactDistanceThreshold * mWorld->mConfig.persistentContactDistanceThreshold;
// For each contact pair of the current frame
const uint32 nbCurrentContactPairs = mCurrentContactPairs->size();
const uint32 nbCurrentContactPairs = static_cast<uint32>(mCurrentContactPairs->size());
for (uint32 i=0; i < nbCurrentContactPairs; i++) {
ContactPair& currentContactPair = (*mCurrentContactPairs)[i];
@ -1168,7 +1168,7 @@ void CollisionDetectionSystem::processPotentialContacts(NarrowPhaseInfoBatch& na
assert(!mWorld->mCollisionBodyComponents.getIsEntityDisabled(body1Entity) || !mWorld->mCollisionBodyComponents.getIsEntityDisabled(body2Entity));
const uint32 newContactPairIndex = contactPairs->size();
const uint32 newContactPairIndex = static_cast<uint32>(contactPairs->size());
contactPairs->emplace(pairId, body1Entity, body2Entity, collider1Entity, collider2Entity,
newContactPairIndex, overlappingPair->collidingInPreviousFrame, isTrigger);
@ -1216,7 +1216,7 @@ void CollisionDetectionSystem::processPotentialContacts(NarrowPhaseInfoBatch& na
assert(!mWorld->mCollisionBodyComponents.getIsEntityDisabled(body1Entity) || !mWorld->mCollisionBodyComponents.getIsEntityDisabled(body2Entity));
const uint32 newContactPairIndex = contactPairs->size();
const uint32 newContactPairIndex = static_cast<uint32>(contactPairs->size());
contactPairs->emplace(pairId, body1Entity, body2Entity, collider1Entity, collider2Entity,
newContactPairIndex, overlappingPair->collidingInPreviousFrame , isTrigger);
pairContact = &((*contactPairs)[newContactPairIndex]);
@ -1239,7 +1239,7 @@ void CollisionDetectionSystem::processPotentialContacts(NarrowPhaseInfoBatch& na
const ContactPointInfo& contactPoint = narrowPhaseInfoBatch.narrowPhaseInfos[i].contactPoints[j];
// Add the contact point to the array of potential contact points
const uint32 contactPointIndex = potentialContactPoints.size();
const uint32 contactPointIndex = static_cast<uint32>(potentialContactPoints.size());
potentialContactPoints.add(contactPoint);
@ -1276,7 +1276,7 @@ void CollisionDetectionSystem::processPotentialContacts(NarrowPhaseInfoBatch& na
if (!similarManifoldFound && pairContact->nbPotentialContactManifolds < NB_MAX_POTENTIAL_CONTACT_MANIFOLDS) {
// Create a new potential contact manifold for the overlapping pair
uint32 contactManifoldIndex = potentialContactManifolds.size();
uint32 contactManifoldIndex = static_cast<uint32>(potentialContactManifolds.size());
potentialContactManifolds.emplace(pairId);
ContactManifoldInfo& contactManifoldInfo = potentialContactManifolds[contactManifoldIndex];
@ -1309,7 +1309,7 @@ void CollisionDetectionSystem::reducePotentialContactManifolds(Array<ContactPair
RP3D_PROFILE("CollisionDetectionSystem::reducePotentialContactManifolds()", mProfiler);
// Reduce the number of potential contact manifolds in a contact pair
const uint32 nbContactPairs = contactPairs->size();
const uint32 nbContactPairs = static_cast<uint32>(contactPairs->size());
for (uint32 i=0; i < nbContactPairs; i++) {
ContactPair& contactPair = (*contactPairs)[i];
@ -1804,7 +1804,7 @@ void CollisionDetectionSystem::testCollision(CollisionCallback& callback) {
void CollisionDetectionSystem::filterOverlappingPairs(Entity bodyEntity, Array<uint64>& convexPairs, Array<uint64>& concavePairs) const {
// For each convex pairs
const uint32 nbConvexPairs = mOverlappingPairs.mConvexPairs.size();
const uint32 nbConvexPairs = static_cast<uint32>(mOverlappingPairs.mConvexPairs.size());
for (uint32 i=0; i < nbConvexPairs; i++) {
if (mCollidersComponents.getBody(mOverlappingPairs.mConvexPairs[i].collider1) == bodyEntity ||
@ -1815,7 +1815,7 @@ void CollisionDetectionSystem::filterOverlappingPairs(Entity bodyEntity, Array<u
}
// For each concave pairs
const uint32 nbConcavePairs = mOverlappingPairs.mConcavePairs.size();
const uint32 nbConcavePairs = static_cast<uint32>(mOverlappingPairs.mConcavePairs.size());
for (uint32 i=0; i < nbConcavePairs; i++) {
if (mCollidersComponents.getBody(mOverlappingPairs.mConcavePairs[i].collider1) == bodyEntity ||
@ -1830,7 +1830,7 @@ void CollisionDetectionSystem::filterOverlappingPairs(Entity bodyEntity, Array<u
void CollisionDetectionSystem::filterOverlappingPairs(Entity body1Entity, Entity body2Entity, Array<uint64>& convexPairs, Array<uint64>& concavePairs) const {
// For each convex pair
const uint32 nbConvexPairs = mOverlappingPairs.mConvexPairs.size();
const uint32 nbConvexPairs = static_cast<uint32>(mOverlappingPairs.mConvexPairs.size());
for (uint32 i=0; i < nbConvexPairs; i++) {
const Entity collider1Body = mCollidersComponents.getBody(mOverlappingPairs.mConvexPairs[i].collider1);
@ -1844,7 +1844,7 @@ void CollisionDetectionSystem::filterOverlappingPairs(Entity body1Entity, Entity
}
// For each concave pair
const uint32 nbConcavePairs = mOverlappingPairs.mConcavePairs.size();
const uint32 nbConcavePairs = static_cast<uint32>(mOverlappingPairs.mConcavePairs.size());
for (uint32 i=0; i < nbConcavePairs; i++) {
const Entity collider1Body = mCollidersComponents.getBody(mOverlappingPairs.mConcavePairs[i].collider1);

4
src/systems/ContactSolverSystem.cpp
View File

@ -71,8 +71,8 @@ void ContactSolverSystem::init(Array<ContactManifold>* contactManifolds, Array<C
mTimeStep = timeStep;
const uint32 nbContactManifolds = mAllContactManifolds->size();
const uint32 nbContactPoints = mAllContactPoints->size();
const uint32 nbContactManifolds = static_cast<uint32>(mAllContactManifolds->size());
const uint32 nbContactPoints = static_cast<uint32>(mAllContactPoints->size());
mNbContactManifolds = 0;
mNbContactPoints = 0;