@series-inc/rundot-syncplay 5.26.0-beta.9 → 5.27.0

package/core/native/physics/physics.cpp

@@ -1890,6 +1890,7 @@ struct QueryHit {
   double distance = 0.0;
   Vec3 point{};
   Vec3 normal{};
+  std::int32_t childIndex = -1;
 };
 QueryHit gQueryHits[kQueryCapacity];
 double gQueryResultData[kQueryCapacity * kQueryResultStride];
@@ -3764,6 +3765,7 @@ struct RayHit {
   double distance = 0.0;
   Vec3 point{};
   Vec3 normal{};
+  std::int32_t childIndex = -1;
 };
 
 RayHit rayAabb(
@@ -3859,6 +3861,125 @@ RayHit raySphere(const Body& body, const Vec3& origin, const Vec3& direction, do
   };
 }
 
+RayHit rayCapsule(const Body& body, const Vec3& origin, const Vec3& direction, double maxDistance) {
+  const Vec3 center{body.x + body.shapeOffsetX, body.y + body.shapeOffsetY, body.z + body.shapeOffsetZ};
+  const Vec3 localOrigin = inverseRotateByOrientation(body, subtractVec3(origin, center));
+  const Vec3 localDirection = inverseRotateByOrientation(body, direction);
+  const double radius = body.shape0;
+  const double halfHeight = body.shape1;
+
+  const double clampedY = std::max(-halfHeight, std::min(halfHeight, localOrigin.y));
+  const double deltaY = localOrigin.y - clampedY;
+  const double distSq = localOrigin.x * localOrigin.x + deltaY * deltaY + localOrigin.z * localOrigin.z;
+  if (distSq <= radius * radius) {
+    return {
+      true,
+      0.0,
+      origin,
+      scaleVec3(direction, -1.0),
+      -1,
+    };
+  }
+
+  double bestDistance = maxDistance + 1.0;
+  Vec3 bestLocalNormal{};
+  bool hitFound = false;
+
+  // 1. Test vertical cylinder along Y: x^2 + z^2 = radius^2, y in [-halfHeight, halfHeight]
+  const double a = localDirection.x * localDirection.x + localDirection.z * localDirection.z;
+  const double b = 2.0 * (localOrigin.x * localDirection.x + localOrigin.z * localDirection.z);
+  const double c = localOrigin.x * localOrigin.x + localOrigin.z * localOrigin.z - radius * radius;
+
+  if (a > 1e-18) {
+    const double discriminant = b * b - 4.0 * a * c;
+    if (discriminant >= 0.0) {
+      const double root = std::sqrt(discriminant);
+      const double t0 = (-b - root) / (2.0 * a);
+      const double t1 = (-b + root) / (2.0 * a);
+      for (const double t : {t0, t1}) {
+        if (t >= 0.0 && t <= maxDistance) {
+          const double hitY = localOrigin.y + localDirection.y * t;
+          if (hitY >= -halfHeight && hitY <= halfHeight) {
+            if (t < bestDistance) {
+              bestDistance = t;
+              bestLocalNormal = scaleVec3({localOrigin.x + localDirection.x * t, 0.0, localOrigin.z + localDirection.z * t}, 1.0 / radius);
+              hitFound = true;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // 2. Test bottom sphere: center (0, -halfHeight, 0), radius
+  {
+    const Vec3 capCenter{0.0, -halfHeight, 0.0};
+    const Vec3 offset = subtractVec3(localOrigin, capCenter);
+    const double sb = 2.0 * dotVec3(offset, localDirection);
+    const double sc = dotVec3(offset, offset) - radius * radius;
+    const double sdisc = sb * sb - 4.0 * sc;
+    if (sdisc >= 0.0) {
+      const double root = std::sqrt(sdisc);
+      const double t0 = (-sb - root) / 2.0;
+      const double t1 = (-sb + root) / 2.0;
+      for (const double t : {t0, t1}) {
+        if (t >= 0.0 && t <= maxDistance) {
+          const double hitY = localOrigin.y + localDirection.y * t;
+          if (hitY <= -halfHeight) {
+            if (t < bestDistance) {
+              bestDistance = t;
+              const Vec3 hitPt = addVec3(localOrigin, scaleVec3(localDirection, t));
+              const Vec3 nDelta = subtractVec3(hitPt, capCenter);
+              const double nLen = solverSqrt(dotVec3(nDelta, nDelta));
+              bestLocalNormal = nLen > 1e-18 ? scaleVec3(nDelta, 1.0 / nLen) : Vec3{0.0, -1.0, 0.0};
+              hitFound = true;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // 3. Test top sphere: center (0, halfHeight, 0), radius
+  {
+    const Vec3 capCenter{0.0, halfHeight, 0.0};
+    const Vec3 offset = subtractVec3(localOrigin, capCenter);
+    const double sb = 2.0 * dotVec3(offset, localDirection);
+    const double sc = dotVec3(offset, offset) - radius * radius;
+    const double sdisc = sb * sb - 4.0 * sc;
+    if (sdisc >= 0.0) {
+      const double root = std::sqrt(sdisc);
+      const double t0 = (-sb - root) / 2.0;
+      const double t1 = (-sb + root) / 2.0;
+      for (const double t : {t0, t1}) {
+        if (t >= 0.0 && t <= maxDistance) {
+          const double hitY = localOrigin.y + localDirection.y * t;
+          if (hitY >= halfHeight) {
+            if (t < bestDistance) {
+              bestDistance = t;
+              const Vec3 hitPt = addVec3(localOrigin, scaleVec3(localDirection, t));
+              const Vec3 nDelta = subtractVec3(hitPt, capCenter);
+              const double nLen = solverSqrt(dotVec3(nDelta, nDelta));
+              bestLocalNormal = nLen > 1e-18 ? scaleVec3(nDelta, 1.0 / nLen) : Vec3{0.0, 1.0, 0.0};
+              hitFound = true;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  if (!hitFound) return {};
+
+  return {
+    true,
+    bestDistance,
+    addVec3(origin, scaleVec3(direction, bestDistance)),
+    rotateByOrientation(body, bestLocalNormal),
+    -1,
+  };
+}
+
 RayHit rayTriangle(
     const Vec3& origin,
     const Vec3& direction,
@@ -3990,6 +4111,7 @@ BroadphaseBounds queryProxyBounds(const Body& body);
 RayHit rayBody(const Body& body, const Vec3& origin, const Vec3& direction, double maxDistance) {
   if (body.shape == ShapeKind::Sphere) return raySphere(body, origin, direction, maxDistance);
   if (body.shape == ShapeKind::Box) return rayBox(body, origin, direction, maxDistance);
+  if (body.shape == ShapeKind::Capsule) return rayCapsule(body, origin, direction, maxDistance);
   if (body.shape == ShapeKind::Mesh || body.shape == ShapeKind::Heightfield) {
     if (body.shape == ShapeKind::Mesh && body.geometryCount % 3 != 0) {
       return rayAabb(queryProxyBounds(body), origin, direction, maxDistance);
@@ -4000,8 +4122,11 @@ RayHit rayBody(const Body& body, const Vec3& origin, const Vec3& direction, doub
     && (body.geometryFormat == 4 || body.geometryFormat == 5)) {
     RayHit best;
     for (std::uint32_t child = 0; child < compoundChildCount(body); child += 1) {
-      const RayHit candidate = rayBody(compoundChildBody(body, child), origin, direction, maxDistance);
-      if (candidate.hit && (!best.hit || candidate.distance < best.distance)) best = candidate;
+      RayHit candidate = rayBody(compoundChildBody(body, child), origin, direction, maxDistance);
+      if (candidate.hit && (!best.hit || candidate.distance < best.distance)) {
+        candidate.childIndex = static_cast<std::int32_t>(child);
+        best = candidate;
+      }
     }
     if (best.hit) return best;
   }
@@ -4103,7 +4228,7 @@ bool validQueryInput(const double* queryData, std::uint32_t queryValues) {
 
 void appendQueryHit(std::uint32_t bodyIndex, const RayHit& hit) {
   if (!hit.hit || gQueryResultCount >= kQueryCapacity) return;
-  gQueryHits[gQueryResultCount++] = {bodyIndex, hit.distance, hit.point, hit.normal};
+  gQueryHits[gQueryResultCount++] = {bodyIndex, hit.distance, hit.point, hit.normal, hit.childIndex};
 }
 
 void finalizeQueryResults(bool quantizeQueryDistance) {
@@ -4124,6 +4249,7 @@ void finalizeQueryResults(bool quantizeQueryDistance) {
     gQueryResultData[offset + 5] = hit.normal.x == 0.0 ? 0.0 : hit.normal.x;
     gQueryResultData[offset + 6] = hit.normal.y == 0.0 ? 0.0 : hit.normal.y;
     gQueryResultData[offset + 7] = hit.normal.z == 0.0 ? 0.0 : hit.normal.z;
+    gQueryResultData[offset + 8] = static_cast<double>(hit.childIndex);
   }
 }
 

package/core/native/physics/physics.hpp

@@ -14,7 +14,7 @@ constexpr std::uint32_t kContactTelemetryStride = 9;
 constexpr std::uint32_t kJointTelemetryStride = 5;
 constexpr std::uint32_t kForceStride = 6;
 constexpr std::uint32_t kQueryInputStride = 21;
-constexpr std::uint32_t kQueryResultStride = 8;
+constexpr std::uint32_t kQueryResultStride = 9;
 constexpr std::uint32_t kMotionKindMask = 0b11;
 constexpr std::uint32_t kMotionTrigger = 0b100;
 constexpr std::uint32_t kMotionSensor = 0b1000;

package/core/physics.d.ts

@@ -387,6 +387,7 @@ export function raycastPhysicsDetailed(world: KinetixPhysicsWorld, query: Kineti
   readonly point: KinetixPhysicsVec3;
   readonly normal: KinetixPhysicsVec3;
   readonly penetration: number;
+  readonly childIndex?: number;
 })[];
 export function overlapPhysics(world: KinetixPhysicsWorld, query: KinetixPhysicsOverlapQuery): readonly string[];
 export function shapeCastPhysics(world: KinetixPhysicsWorld, query: KinetixPhysicsShapeCastQuery): readonly KinetixPhysicsHit[];

package/core/scripts/build-wasm-physics.mjs

@@ -124,7 +124,7 @@ export function buildWasmPhysics({ check = false } = {}) {
     contactTelemetryStride: 9,
     jointTelemetryStride: 5,
     queryInputStride: 21,
-    queryResultStride: 8,
+    queryResultStride: 9,
     compiler: compiler.command,
     emccVersion: compiler.version,
     compilerVersion: compiler.version,

package/core/src/physics/index.mjs

@@ -62,7 +62,7 @@ const PHYSICS_BODY_STRIDE = 44;
 const PHYSICS_JOINT_STRIDE = 48;
 const PHYSICS_JOINT_TELEMETRY_STRIDE = 5;
 const PHYSICS_QUERY_INPUT_STRIDE = 21;
-const PHYSICS_QUERY_RESULT_STRIDE = 8;
+const PHYSICS_QUERY_RESULT_STRIDE = 9;
 const PHYSICS_ARENA_ALIGNMENT = 16;
 const PHYSICS_ARENA_GUARD_BYTES = 64;
 const PHYSICS_MIN_PROXY_HALF_EXTENT = 1e-9;
@@ -1848,7 +1848,8 @@ function nativeQuery(world, query, kind) {
     const offset = index * PHYSICS_QUERY_RESULT_STRIDE;
     const body = bodies[values[offset]];
     if (body === undefined) fail('KINETIX_PHYSICS_QUERY_BODY_MISSING');
-    return {
+    const childIndexRaw = values[offset + 8];
+    const hitObj = {
       bodyId: body.id,
       distance: kind === 'shapeCast' ? quantizeDistance(values[offset + 1]) : values[offset + 1],
       point: {
@@ -1862,6 +1863,10 @@ function nativeQuery(world, query, kind) {
         z: values[offset + 7],
       },
     };
+    if (Number.isFinite(childIndexRaw) && childIndexRaw >= 0) {
+      hitObj.childIndex = childIndexRaw;
+    }
+    return hitObj;
   });
 }
 
@@ -2628,13 +2633,19 @@ export function raycastPhysics(world, query) {
 export function raycastPhysicsDetailed(world, query) {
   const normalized = normalizedRayQuery(query);
   if (physicsInstance !== null) {
-    return deepFreeze(nativeQuery(world, normalized, 'raycast').map((hit) => ({
-      bodyId: hit.bodyId,
-      distance: hit.distance,
-      point: hit.point,
-      normal: hit.normal,
-      penetration: 0,
-    })));
+    return deepFreeze(nativeQuery(world, normalized, 'raycast').map((hit) => {
+      const detailed = {
+        bodyId: hit.bodyId,
+        distance: hit.distance,
+        point: hit.point,
+        normal: hit.normal,
+        penetration: 0,
+      };
+      if (hit.childIndex !== undefined) {
+        detailed.childIndex = hit.childIndex;
+      }
+      return detailed;
+    }));
   }
   return deepFreeze(raycastPhysics(world, normalized).map((hit) => {
     const body = world.bodies.find((candidate) => candidate.id === hit.bodyId);