@series-inc/rundot-syncplay 6.0.0-rc.13 → 6.0.0-rc.14

package/core/native/physics/capsule_triangle_native.inc

@@ -239,7 +239,7 @@ Collision observeGeometry(SolverOperation& operation,const Body& capsule,const B
       if(node.count<6)throw TriangleNativeFailure{tp::Failure::InvalidInput};const auto base=std::size_t(node.offset)*3;const auto countValue=payload[base+17];
       if(!finite(countValue)||countValue<1||countValue>node.count/6||std::floor(countValue)!=countValue)throw TriangleNativeFailure{tp::Failure::InvalidInput};
       const auto count=std::uint32_t(countValue);std::uint32_t previousEnd=count*6;
-      for(std::uint32_t child=0;child<count;++child){work(operation);const auto at=base+std::size_t(child)*18;
+      for(std::uint32_t child=0;child<count;++child){const auto at=base+std::size_t(child)*18;
         auto code=[&](unsigned lane){const auto value=payload[at+lane];if(!finite(value)||value<0||value>std::numeric_limits<std::uint32_t>::max()||std::floor(value)!=value)throw TriangleNativeFailure{tp::Failure::InvalidInput};return std::uint32_t(value);};
         const auto kind=code(0),offset=code(13),size=code(14),format=code(15);
         if(kind>11||(payload[at+16]!=0.&&payload[at+16]!=1.)||code(17)!=count)throw TriangleNativeFailure{tp::Failure::InvalidInput};
@@ -247,6 +247,18 @@ Collision observeGeometry(SolverOperation& operation,const Body& capsule,const B
         if(complex){if(offset<previousEnd||offset>node.count||size>node.count-offset)throw TriangleNativeFailure{tp::Failure::InvalidInput};previousEnd=offset+size;}
         else if(offset||size||format)throw TriangleNativeFailure{tp::Failure::InvalidInput};
         const Vec3 translation{sum(operation,{node.translation.x,payload[at+1]}),sum(operation,{node.translation.y,payload[at+2]}),sum(operation,{node.translation.z,payload[at+3]})};
+        if(!complex){
+          const auto translated=rotateByOrientation(geometry,translation);
+          const double cX=geometry.x+geometry.shapeOffsetX+translated.x-(capsule.x+capsule.shapeOffsetX);
+          const double cY=geometry.y+geometry.shapeOffsetY+translated.y-(capsule.y+capsule.shapeOffsetY);
+          const double cZ=geometry.z+geometry.shapeOffsetZ+translated.z-(capsule.z+capsule.shapeOffsetZ);
+          const double p0=payload[at+4],p1=payload[at+5],p2=payload[at+6];
+          const double childRadius=kind==static_cast<std::uint32_t>(ShapeKind::Box)?std::sqrt(p0*p0+p1*p1+p2*p2):(kind==static_cast<std::uint32_t>(ShapeKind::Sphere)?p0:(p0+p1));
+          const double capsuleRadius=capsule.shape0+capsule.shape1;
+          const double maxDist=childRadius+capsuleRadius;
+          if(cX*cX+cY*cY+cZ*cZ>maxDist*maxDist)continue;
+        }
+        work(operation);
         if(child>std::uint32_t(std::numeric_limits<std::int32_t>::max()))throw TriangleNativeFailure{tp::Failure::FeatureCapacity};
         append(operation,pending,Node{ShapeKind(kind),complex?node.offset+offset:node.offset+child*6,size,format,translation,{payload[at+4],payload[at+5],payload[at+6]},node.outerChild<0?std::int32_t(child):node.outerChild});
       }continue;
@@ -257,6 +269,11 @@ Collision observeGeometry(SolverOperation& operation,const Body& capsule,const B
       const auto translated=rotateByOrientation(geometry,node.translation);
       child.x=sum(operation,{geometry.x,geometry.shapeOffsetX,translated.x,-capsule.x,-capsule.shapeOffsetX});child.y=sum(operation,{geometry.y,geometry.shapeOffsetY,translated.y,-capsule.y,-capsule.shapeOffsetY});child.z=sum(operation,{geometry.z,geometry.shapeOffsetZ,translated.z,-capsule.z,-capsule.shapeOffsetZ});
       child.shapeOffsetX=child.shapeOffsetY=child.shapeOffsetZ=0.;
+      const double p0=child.shape0,p1=child.shape1,p2=child.shape2;
+      const double childRadius=child.shape==ShapeKind::Box?std::sqrt(p0*p0+p1*p1+p2*p2):(child.shape==ShapeKind::Sphere?p0:(p0+p1));
+      const double capsuleRadius=capsule.shape0+capsule.shape1;
+      const double maxDist=childRadius+capsuleRadius;
+      if(child.x*child.x+child.y*child.y+child.z*child.z>maxDist*maxDist)continue;
       auto collision=node.kind==ShapeKind::Sphere?capsuleSphere(localCapsule,child):node.kind==ShapeKind::Box?capsuleBox(localCapsule,child):capsuleCapsule(localCapsule,child);
       if(collision.hit){if(!collision.pointCount){collision.pointCount=1;collision.points[0]={collision.pointX,collision.pointY,collision.pointZ};}
         auto& basis=collision.coordinates.emplace<TriangleManifoldBasis>();collision.geometryChildIndex=node.outerChild;basis.anchor={capsule.x,capsule.y,capsule.z};basis.shapeOffset={capsule.shapeOffsetX,capsule.shapeOffsetY,capsule.shapeOffsetZ};

package/core/native/physics/physics.cpp

@@ -2006,13 +2006,7 @@ Collision geometryBox(SolverOperation& operation, const Body& geometry, const Bo
   }
   if (geometry.shape == ShapeKind::Compound
     && (geometry.geometryFormat == 4 || geometry.geometryFormat == 5 || geometry.geometryFormat == 6)) {
-    Collision best;
-    for (std::uint32_t child = 0; child < compoundChildCount(operation, geometry); child += 1) {
-      const Body childBody = compoundChildBody(operation, geometry, child);
-      const Collision candidate = collide(operation, childBody, box);
-      if (candidate.hit && (!best.hit || candidate.penetration > best.penetration)) best = candidate;
-    }
-    return best;
+    return collide(operation, geometry, box);
   }
   if (geometry.shape == ShapeKind::Compound && geometry.geometryFormat == 1) {
     Collision best;
@@ -3748,11 +3742,128 @@ Collision capsuleBox(const Body& capsule, const Body& box) {
 #include "capsule_triangle_native.inc"
 
 Collision collide(SolverOperation& operation, const Body& a, const Body& b) {
+
   if (operation.materialMotionEpochs != nullptr) return collideMaterialCurrent(operation, a, b);
   const auto triangleGeometry=[](const Body& body){return body.shape==ShapeKind::Mesh||body.shape==ShapeKind::Heightfield
     ||(body.shape==ShapeKind::Compound&&body.geometryFormat==5);};
   if(a.shape==ShapeKind::Capsule&&triangleGeometry(b))return triangle_adapter_private::observeGeometry(operation,a,b);
   if(b.shape==ShapeKind::Capsule&&triangleGeometry(a))return flipCollision(triangle_adapter_private::observeGeometry(operation,b,a));
+  if (a.shape == ShapeKind::Compound && (a.geometryFormat == 4 || a.geometryFormat == 5 || a.geometryFormat == 6)) {
+    const BroadphaseBounds boundsA = queryProxyBounds(operation, a);
+    const BroadphaseBounds boundsB = queryProxyBounds(operation, b);
+    if (!boundsOverlap(boundsA, boundsB)) return {};
+
+    Collision best;
+    std::int32_t bestChild = -1;
+    struct CandidateContact {
+      std::uint32_t childIndex = 0;
+      Collision collision;
+    };
+    std::vector<CandidateContact> candidates;
+    candidates.reserve(32);
+
+    for (std::uint32_t child = 0; child < compoundChildCount(operation, a); child += 1) {
+      const Body childBody = compoundChildBody(operation, a, child);
+      const BroadphaseBounds childBounds = queryProxyBounds(operation, childBody);
+      if (!boundsOverlap(childBounds, boundsB)) continue;
+      const Collision candidate = collide(operation, childBody, b);
+      if (candidate.hit) {
+        if (!best.hit || candidate.penetration > best.penetration) {
+          best = candidate;
+          bestChild = static_cast<std::int32_t>(child);
+        }
+        candidates.push_back({child, candidate});
+      }
+    }
+    if (!best.hit) return {};
+    if (bestChild >= 0) best.geometryChildIndex = bestChild;
+    if (candidates.size() <= 1) return best;
+
+    const Vec3 primaryNormal{best.nx, best.ny, best.nz};
+    struct MergedPoint {
+      std::array<double, 3> pt;
+      std::uint32_t featureId;
+      double depth;
+      std::uint32_t childIndex;
+    };
+    std::vector<MergedPoint> collected;
+    collected.reserve(64);
+
+    for (std::size_t cIdx = 0; cIdx < candidates.size(); cIdx += 1) {
+      const auto& entry = candidates[cIdx];
+      const Collision& c = entry.collision;
+      const Vec3 cNormal{c.nx, c.ny, c.nz};
+      if (dotVec3(primaryNormal, cNormal) < 0.98) continue;
+
+      const std::uint32_t pCount = (c.pointCount == 0) ? 1u : std::min<std::uint32_t>(c.pointCount, 4u);
+      for (std::uint32_t p = 0; p < pCount; p += 1) {
+        std::array<double, 3> pos{};
+        if (c.pointCount > 0) {
+          pos = c.points[p];
+        } else {
+          pos = {c.pointX, c.pointY, c.pointZ};
+        }
+        const std::uint32_t rawFeature = (c.pointCount > 0) ? c.featureIds[p] : 0u;
+        const std::uint32_t namespacedFeature = (rawFeature * 16777619u) ^ ((entry.childIndex + 1u) * 2166136261u) ^ (p * 374761393u);
+        collected.push_back({pos, namespacedFeature, c.penetration, entry.childIndex});
+      }
+    }
+
+    if (collected.size() <= 1) return best;
+
+    std::array<std::uint32_t, 4> selectedIndices{};
+    std::vector<std::uint8_t> used(collected.size(), 0);
+    std::uint32_t selectedCount = 0;
+
+    while (selectedCount < std::min<std::uint32_t>(4, static_cast<std::uint32_t>(collected.size()))) {
+      std::uint32_t bestIdx = 0;
+      double bestScore = -1.0;
+      bool found = false;
+      for (std::uint32_t index = 0; index < collected.size(); index += 1) {
+        if (used[index] != 0) continue;
+        double score = collected[index].depth * collected[index].depth;
+        if (selectedCount != 0) {
+          score = std::numeric_limits<double>::infinity();
+          const Vec3 ptA{collected[index].pt[0], collected[index].pt[1], collected[index].pt[2]};
+          for (std::uint32_t chosen = 0; chosen < selectedCount; chosen += 1) {
+            const auto& sel = collected[selectedIndices[chosen]];
+            const Vec3 ptB{sel.pt[0], sel.pt[1], sel.pt[2]};
+            const Vec3 delta = subtractVec3(ptA, ptB);
+            score = std::min(score, dotVec3(delta, delta));
+          }
+        }
+        if (!found || score > bestScore
+          || (score == bestScore
+            && collected[index].featureId < collected[bestIdx].featureId)) {
+          bestIdx = index;
+          bestScore = score;
+          found = true;
+        }
+      }
+      selectedIndices[selectedCount++] = bestIdx;
+      used[bestIdx] = 1;
+    }
+
+    best.pointCount = selectedCount;
+    double avgX = 0.0, avgY = 0.0, avgZ = 0.0;
+    for (std::uint32_t s = 0; s < selectedCount; s += 1) {
+      best.points[s] = collected[selectedIndices[s]].pt;
+      best.featureIds[s] = collected[selectedIndices[s]].featureId;
+      avgX += collected[selectedIndices[s]].pt[0];
+      avgY += collected[selectedIndices[s]].pt[1];
+      avgZ += collected[selectedIndices[s]].pt[2];
+    }
+    const double invCount = 1.0 / static_cast<double>(selectedCount);
+    best.pointX = avgX * invCount;
+    best.pointY = avgY * invCount;
+    best.pointZ = avgZ * invCount;
+
+    return best;
+  }
+  if (b.shape == ShapeKind::Compound && (b.geometryFormat == 4 || b.geometryFormat == 5 || b.geometryFormat == 6)) {
+    const Collision result = collide(operation, b, a);
+    return flipCollision(result);
+  }
   if (a.shape == ShapeKind::Sphere && b.shape == ShapeKind::Sphere) {
     return sphereSphere(a, b);
   }
@@ -3812,25 +3923,7 @@ Collision collide(SolverOperation& operation, const Body& a, const Body& b) {
   if (a.shape == ShapeKind::Box && b.shape == ShapeKind::Box) {
     return boxBox(a, b);
   }
-  if (a.shape == ShapeKind::Compound && (a.geometryFormat == 4 || a.geometryFormat == 5 || a.geometryFormat == 6)) {
-    const BroadphaseBounds boundsA = queryProxyBounds(operation, a);
-    const BroadphaseBounds boundsB = queryProxyBounds(operation, b);
-    if (!boundsOverlap(boundsA, boundsB)) return {};
 
-    Collision best;
-    for (std::uint32_t child = 0; child < compoundChildCount(operation, a); child += 1) {
-      const Body childBody = compoundChildBody(operation, a, child);
-      const BroadphaseBounds childBounds = queryProxyBounds(operation, childBody);
-      if (!boundsOverlap(childBounds, boundsB)) continue;
-      const Collision candidate = collide(operation, childBody, b);
-      if (candidate.hit && (!best.hit || candidate.penetration > best.penetration)) best = candidate;
-    }
-    return best;
-  }
-  if (b.shape == ShapeKind::Compound && (b.geometryFormat == 4 || b.geometryFormat == 5 || b.geometryFormat == 6)) {
-    const Collision result = collide(operation, b, a);
-    return flipCollision(result);
-  }
   if (!robustConvexBodiesOverlap(operation, a, b)) return {};
   return convexSupportCollision(operation, a, b);
 }
@@ -7520,7 +7613,7 @@ ContactPassPolicy contactPassPolicy(ContactPass pass) {
     case ContactPass::StandaloneLaterSubstep:
       return {false, true, false, false, true, true};
     case ContactPass::LegacyJointContinueVelocity:
-      return {false, false, true, false, true, true};
+      return {false, false, false, false, false, true};
   }
   std::terminate();
 }
@@ -7818,7 +7911,7 @@ void resolveSoAContacts(SolverOperation& operation, Body* bodies, std::uint32_t
           forEachCollectedSweepPair(operation, solveCollectedPair);
         }
       } else {
-        solvePreparedConstraints(iteration != 0);
+        solvePreparedConstraints(iteration != 0 || pass == ContactPass::LegacyJointContinueVelocity);
       }
       if (solveVelocity && (beginSubstep || preparedSubstep) && iteration == 0) {
         std::sort(operation.storage.contactConstraints.begin(),
@@ -7852,7 +7945,7 @@ void resolveSoAContacts(SolverOperation& operation, Body* bodies, std::uint32_t
         operation.storage.broadphaseTree->forEachCollectedPair(solveCollectedPair);
       }
     } else {
-      solvePreparedConstraints(iteration != 0);
+      solvePreparedConstraints(iteration != 0 || pass == ContactPass::LegacyJointContinueVelocity);
     }
     if (solveVelocity && (beginSubstep || preparedSubstep) && iteration == 0) {
       std::sort(operation.storage.contactConstraints.begin(),