Fix warnings

include/reactphysics3d/collision/CollisionCallback.h

@@ -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

include/reactphysics3d/collision/HalfEdgeStructure.h

@@ -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

include/reactphysics3d/collision/OverlapCallback.h

@@ -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

include/reactphysics3d/collision/TriangleMesh.h

@@ -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());
 }
 
 }

include/reactphysics3d/collision/narrowphase/NarrowPhaseInfoBatch.h

@@ -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

include/reactphysics3d/engine/Islands.h

@@ -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);

include/reactphysics3d/engine/PhysicsWorld.h

@@ -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

include/reactphysics3d/mathematics/mathematics_functions.h

@@ -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;

include/reactphysics3d/utils/DebugRenderer.h

@@ -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

src/body/CollisionBody.cpp

@@ -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]);

src/collision/narrowphase/SAT/SATAlgorithm.cpp

@@ -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 nbIncidentFaceVertices = static_cast<uint32>(incidentFace.faceVertices.size());
-    const uint32 nbMaxElements = nbIncidentFaceVertices * 2 * referenceFace.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

src/collision/shapes/CollisionShape.cpp

@@ -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);
     }

src/collision/shapes/ConcaveMeshShape.cpp

@@ -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);

src/engine/EntityManager.cpp

@@ -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));
     }

src/engine/OverlappingPairs.cpp

@@ -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);
 

src/engine/PhysicsWorld.cpp

@@ -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);

src/systems/CollisionDetectionSystem.cpp

@@ -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();
+    mNbPreviousPotentialContactManifolds = static_cast<uint32>(mPotentialContactManifolds.capacity());
-    mNbPreviousPotentialContactPoints = mPotentialContactPoints.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);

src/systems/ContactSolverSystem.cpp

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