@cavegiant/cave-world-r3f 1.0.0

package/dist/space/utils/polygon-boundary-geometry.js

@@ -0,0 +1,20 @@
+import { BufferGeometry as s, BoxGeometry as f, Quaternion as u, Vector3 as e, Matrix4 as w } from "three";
+import { mergeGeometries as x } from "three/examples/jsm/utils/BufferGeometryUtils.js";
+const c = /* @__PURE__ */ new w(), a = /* @__PURE__ */ new e(), l = /* @__PURE__ */ new u(), g = /* @__PURE__ */ new e(), d = /* @__PURE__ */ new e(0, 1, 0);
+function A(t, p, n = {}) {
+  if (t.length === 0) return new s();
+  const h = n.length ?? 0, m = n.height ?? 0, r = t.map((o) => {
+    const i = new f(
+      o.length + h * 2,
+      o.height + m * 2,
+      p
+    );
+    return l.setFromAxisAngle(d, o.yaw), a.set(o.position[0], o.position[1], o.position[2]), c.compose(a, l, g.set(1, 1, 1)), i.applyMatrix4(c), i;
+  }), y = x(r, !1);
+  for (const o of r) o.dispose();
+  return y ?? new s();
+}
+export {
+  A as buildPolygonBoundaryColliderGeometry
+};
+//# sourceMappingURL=polygon-boundary-geometry.js.map

package/dist/space/utils/polygon-boundary-geometry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon-boundary-geometry.js","sources":["../../../space/utils/polygon-boundary-geometry.ts"],"sourcesContent":["import { BoxGeometry, BufferGeometry, Matrix4, Quaternion, Vector3 } from 'three'\nimport { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js'\nimport type { PolygonBoundarySegment } from './polygon-boundary-segments'\n\nconst _matrix = /* @__PURE__ */ new Matrix4()\nconst _position = /* @__PURE__ */ new Vector3()\nconst _quaternion = /* @__PURE__ */ new Quaternion()\nconst _scale = /* @__PURE__ */ new Vector3()\nconst _yAxis = /* @__PURE__ */ new Vector3(0, 1, 0)\n\n/** Merge segment wall boxes into one static BufferGeometry for a single BVH body. */\nexport function buildPolygonBoundaryColliderGeometry(\n  segments: PolygonBoundarySegment[],\n  depth: number,\n  padding: { length?: number; height?: number } = {}\n): BufferGeometry {\n  if (segments.length === 0) return new BufferGeometry()\n\n  const lengthPad = padding.length ?? 0\n  const heightPad = padding.height ?? 0\n\n  const boxes = segments.map((segment) => {\n    const geometry = new BoxGeometry(\n      segment.length + lengthPad * 2,\n      segment.height + heightPad * 2,\n      depth\n    )\n    _quaternion.setFromAxisAngle(_yAxis, segment.yaw)\n    _position.set(segment.position[0], segment.position[1], segment.position[2])\n    _matrix.compose(_position, _quaternion, _scale.set(1, 1, 1))\n    geometry.applyMatrix4(_matrix)\n    return geometry\n  })\n\n  const merged = mergeGeometries(boxes, false)\n  for (const geometry of boxes) geometry.dispose()\n  return merged ?? new BufferGeometry()\n}\n"],"names":["_matrix","Matrix4","_position","Vector3","_quaternion","Quaternion","_scale","_yAxis","buildPolygonBoundaryColliderGeometry","segments","depth","padding","BufferGeometry","lengthPad","heightPad","boxes","segment","geometry","BoxGeometry","merged","mergeGeometries"],"mappings":";;AAIA,MAAMA,wBAA8BC,EAAA,GAC9BC,wBAAgCC,EAAA,GAChCC,wBAAkCC,EAAA,GAClCC,wBAA6BH,EAAA,GAC7BI,IAAyB,oBAAIJ,EAAQ,GAAG,GAAG,CAAC;AAG3C,SAASK,EACdC,GACAC,GACAC,IAAgD,CAAA,GAChC;AAChB,MAAIF,EAAS,WAAW,EAAG,QAAO,IAAIG,EAAA;AAEtC,QAAMC,IAAYF,EAAQ,UAAU,GAC9BG,IAAYH,EAAQ,UAAU,GAE9BI,IAAQN,EAAS,IAAI,CAACO,MAAY;AACtC,UAAMC,IAAW,IAAIC;AAAA,MACnBF,EAAQ,SAASH,IAAY;AAAA,MAC7BG,EAAQ,SAASF,IAAY;AAAA,MAC7BJ;AAAA,IAAA;AAEF,WAAAN,EAAY,iBAAiBG,GAAQS,EAAQ,GAAG,GAChDd,EAAU,IAAIc,EAAQ,SAAS,CAAC,GAAGA,EAAQ,SAAS,CAAC,GAAGA,EAAQ,SAAS,CAAC,CAAC,GAC3EhB,EAAQ,QAAQE,GAAWE,GAAaE,EAAO,IAAI,GAAG,GAAG,CAAC,CAAC,GAC3DW,EAAS,aAAajB,CAAO,GACtBiB;AAAA,EACT,CAAC,GAEKE,IAASC,EAAgBL,GAAO,EAAK;AAC3C,aAAWE,KAAYF,EAAO,CAAAE,EAAS,QAAA;AACvC,SAAOE,KAAU,IAAIP,EAAA;AACvB;"}

package/dist/space/utils/polygon-boundary-segments.d.ts

@@ -0,0 +1,50 @@
+import type { Vector3 } from '../../types/index.js';
+export interface PolygonBoundarySegment {
+    index: number;
+    /** Segment midpoint in baseLayer-local space */
+    position: Vector3;
+    /** Horizontal length along the ground plane (m) */
+    length: number;
+    /** Wall height (m) */
+    height: number;
+    /** Y-axis rotation in radians — aligns wall width with the segment direction */
+    yaw: number;
+    /** Ground elevation at segment midpoint (m) */
+    baseY: number;
+}
+/** Max horizontal distance (m) from player to a segment line to show the warning blob. */
+export declare const BOUNDARY_WARNING_PICK_RADIUS = 1.35;
+/**
+ * Build collision/visual segments from an open polyline (`points` are NOT auto-closed).
+ */
+export declare function buildPolygonBoundarySegments(points: Vector3[], height: number): PolygonBoundarySegment[];
+export interface SegmentWallProjection {
+    /** Contact anchor in segment-local plane space (meters, centered origin). */
+    localX: number;
+    localY: number;
+}
+export interface BoundaryContactAnchor extends SegmentWallProjection {
+    segmentIndex: number;
+    /** Horizontal distance (m) from player to the segment line — used for picking. */
+    lineDistance: number;
+}
+/**
+ * Project the player onto a vertical fence segment plane (baseLayer-local coords).
+ * Segment-local +X runs along the wall width, +Y is up.
+ */
+export declare function projectPlayerOntoSegmentWall(segment: PolygonBoundarySegment, player: {
+    x: number;
+    y: number;
+    z: number;
+}): SegmentWallProjection;
+/** Pick the nearest fence segment and wall-local anchor for the warning blob. */
+export declare function findBoundaryContactAnchor(points: Vector3[], height: number, player: {
+    x: number;
+    y: number;
+    z: number;
+}, segments?: PolygonBoundarySegment[], pickRadius?: number): BoundaryContactAnchor | null;
+/** Map a wall-local contact anchor to baseLayer-local world position. */
+export declare function boundaryContactAnchorToPosition(segment: PolygonBoundarySegment, anchor: SegmentWallProjection, target: {
+    set: (x: number, y: number, z: number) => void;
+}): void;
+//# sourceMappingURL=polygon-boundary-segments.d.ts.map

package/dist/space/utils/polygon-boundary-segments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon-boundary-segments.d.ts","sourceRoot":"","sources":["../../../space/utils/polygon-boundary-segments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAE1C,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,MAAM,CAAA;IACb,gDAAgD;IAChD,QAAQ,EAAE,OAAO,CAAA;IACjB,mDAAmD;IACnD,MAAM,EAAE,MAAM,CAAA;IACd,sBAAsB;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,gFAAgF;IAChF,GAAG,EAAE,MAAM,CAAA;IACX,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAA;CACd;AAGD,0FAA0F;AAC1F,eAAO,MAAM,4BAA4B,OAAO,CAAA;AAEhD;;GAEG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,OAAO,EAAE,EACjB,MAAM,EAAE,MAAM,GACb,sBAAsB,EAAE,CAyB1B;AAED,MAAM,WAAW,qBAAqB;IACpC,6EAA6E;IAC7E,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,qBAAsB,SAAQ,qBAAqB;IAClE,YAAY,EAAE,MAAM,CAAA;IACpB,kFAAkF;IAClF,YAAY,EAAE,MAAM,CAAA;CACrB;AAwBD;;;GAGG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,sBAAsB,EAC/B,MAAM,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC1C,qBAAqB,CAiBvB;AAED,iFAAiF;AACjF,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,OAAO,EAAE,EACjB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,EAC3C,QAAQ,GAAE,sBAAsB,EAAiD,EACjF,UAAU,SAA+B,GACxC,qBAAqB,GAAG,IAAI,CAsB9B;AAED,yEAAyE;AACzE,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,sBAAsB,EAC/B,MAAM,EAAE,qBAAqB,EAC7B,MAAM,EAAE;IAAE,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,GACzD,IAAI,CAQN"}

package/dist/space/utils/polygon-boundary-segments.js

@@ -0,0 +1,64 @@
+const x = 1.35;
+function r(n, t) {
+  if (n.length < 2 || t <= 0) return [];
+  const o = [];
+  for (let c = 0; c < n.length - 1; c += 1) {
+    const l = n[c], i = n[c + 1], s = i[0] - l[0], a = i[2] - l[2], h = Math.hypot(s, a);
+    if (h < 0.01) continue;
+    const e = (l[1] + i[1]) / 2;
+    o.push({
+      index: c,
+      position: [(l[0] + i[0]) / 2, e + t / 2, (l[2] + i[2]) / 2],
+      length: h,
+      height: t,
+      yaw: Math.atan2(-a, s),
+      baseY: e
+    });
+  }
+  return o;
+}
+function y(n, t, o, c, l, i) {
+  const s = l - o, a = i - c, h = s * s + a * a;
+  if (h < 1e-8)
+    return Math.hypot(n - o, t - c);
+  let e = ((n - o) * s + (t - c) * a) / h;
+  e = Math.max(0, Math.min(1, e));
+  const u = o + e * s, M = c + e * a;
+  return Math.hypot(n - u, t - M);
+}
+function N(n, t) {
+  const o = t.x - n.position[0], c = t.y - n.position[1], l = t.z - n.position[2], i = Math.cos(n.yaw), s = Math.sin(n.yaw), a = o * i - l * s, h = c, e = n.length / 2, u = n.height / 2;
+  return {
+    localX: Math.max(-e, Math.min(e, a)),
+    localY: Math.max(-u, Math.min(u, h))
+  };
+}
+function _(n, t, o, c = r(n, t), l = 1.35) {
+  if (c.length === 0) return null;
+  let i = null;
+  for (const s of c) {
+    const a = n[s.index], h = n[s.index + 1], e = Math.min(a[1], h[1]) - 0.5, u = Math.max(a[1], h[1]) + t + 0.5;
+    if (o.y < e || o.y > u) continue;
+    const M = y(o.x, o.z, a[0], a[2], h[0], h[2]);
+    if (M > l) continue;
+    const { localX: d, localY: f } = N(s, o);
+    (!i || M < i.lineDistance) && (i = { segmentIndex: s.index, localX: d, localY: f, lineDistance: M });
+  }
+  return i;
+}
+function I(n, t, o) {
+  const c = Math.cos(n.yaw), l = Math.sin(n.yaw);
+  o.set(
+    n.position[0] + t.localX * c,
+    n.position[1] + t.localY,
+    n.position[2] - t.localX * l
+  );
+}
+export {
+  x as BOUNDARY_WARNING_PICK_RADIUS,
+  I as boundaryContactAnchorToPosition,
+  r as buildPolygonBoundarySegments,
+  _ as findBoundaryContactAnchor,
+  N as projectPlayerOntoSegmentWall
+};
+//# sourceMappingURL=polygon-boundary-segments.js.map

package/dist/space/utils/polygon-boundary-segments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon-boundary-segments.js","sources":["../../../space/utils/polygon-boundary-segments.ts"],"sourcesContent":["import type { Vector3 } from '../../types'\n\nexport interface PolygonBoundarySegment {\n  index: number\n  /** Segment midpoint in baseLayer-local space */\n  position: Vector3\n  /** Horizontal length along the ground plane (m) */\n  length: number\n  /** Wall height (m) */\n  height: number\n  /** Y-axis rotation in radians — aligns wall width with the segment direction */\n  yaw: number\n  /** Ground elevation at segment midpoint (m) */\n  baseY: number\n}\n\nconst MIN_SEGMENT_LENGTH = 0.01\n/** Max horizontal distance (m) from player to a segment line to show the warning blob. */\nexport const BOUNDARY_WARNING_PICK_RADIUS = 1.35\n\n/**\n * Build collision/visual segments from an open polyline (`points` are NOT auto-closed).\n */\nexport function buildPolygonBoundarySegments(\n  points: Vector3[],\n  height: number\n): PolygonBoundarySegment[] {\n  if (points.length < 2 || height <= 0) return []\n\n  const segments: PolygonBoundarySegment[] = []\n\n  for (let i = 0; i < points.length - 1; i += 1) {\n    const p0 = points[i]\n    const p1 = points[i + 1]\n    const dx = p1[0] - p0[0]\n    const dz = p1[2] - p0[2]\n    const length = Math.hypot(dx, dz)\n    if (length < MIN_SEGMENT_LENGTH) continue\n\n    const baseY = (p0[1] + p1[1]) / 2\n    segments.push({\n      index: i,\n      position: [(p0[0] + p1[0]) / 2, baseY + height / 2, (p0[2] + p1[2]) / 2],\n      length,\n      height,\n      yaw: Math.atan2(-dz, dx),\n      baseY\n    })\n  }\n\n  return segments\n}\n\nexport interface SegmentWallProjection {\n  /** Contact anchor in segment-local plane space (meters, centered origin). */\n  localX: number\n  localY: number\n}\n\nexport interface BoundaryContactAnchor extends SegmentWallProjection {\n  segmentIndex: number\n  /** Horizontal distance (m) from player to the segment line — used for picking. */\n  lineDistance: number\n}\n\nfunction distancePointToSegmentXZ(\n  px: number,\n  pz: number,\n  x0: number,\n  z0: number,\n  x1: number,\n  z1: number\n): number {\n  const dx = x1 - x0\n  const dz = z1 - z0\n  const lengthSq = dx * dx + dz * dz\n  if (lengthSq < 1e-8) {\n    return Math.hypot(px - x0, pz - z0)\n  }\n\n  let t = ((px - x0) * dx + (pz - z0) * dz) / lengthSq\n  t = Math.max(0, Math.min(1, t))\n  const closestX = x0 + t * dx\n  const closestZ = z0 + t * dz\n  return Math.hypot(px - closestX, pz - closestZ)\n}\n\n/**\n * Project the player onto a vertical fence segment plane (baseLayer-local coords).\n * Segment-local +X runs along the wall width, +Y is up.\n */\nexport function projectPlayerOntoSegmentWall(\n  segment: PolygonBoundarySegment,\n  player: { x: number; y: number; z: number }\n): SegmentWallProjection {\n  const dx = player.x - segment.position[0]\n  const dy = player.y - segment.position[1]\n  const dz = player.z - segment.position[2]\n  const cos = Math.cos(segment.yaw)\n  const sin = Math.sin(segment.yaw)\n\n  const localX = dx * cos - dz * sin\n  const localY = dy\n\n  const halfLength = segment.length / 2\n  const halfHeight = segment.height / 2\n\n  return {\n    localX: Math.max(-halfLength, Math.min(halfLength, localX)),\n    localY: Math.max(-halfHeight, Math.min(halfHeight, localY))\n  }\n}\n\n/** Pick the nearest fence segment and wall-local anchor for the warning blob. */\nexport function findBoundaryContactAnchor(\n  points: Vector3[],\n  height: number,\n  player: { x: number; y: number; z: number },\n  segments: PolygonBoundarySegment[] = buildPolygonBoundarySegments(points, height),\n  pickRadius = BOUNDARY_WARNING_PICK_RADIUS\n): BoundaryContactAnchor | null {\n  if (segments.length === 0) return null\n\n  let best: BoundaryContactAnchor | null = null\n\n  for (const segment of segments) {\n    const p0 = points[segment.index]\n    const p1 = points[segment.index + 1]\n    const yMin = Math.min(p0[1], p1[1]) - 0.5\n    const yMax = Math.max(p0[1], p1[1]) + height + 0.5\n    if (player.y < yMin || player.y > yMax) continue\n\n    const lineDistance = distancePointToSegmentXZ(player.x, player.z, p0[0], p0[2], p1[0], p1[2])\n    if (lineDistance > pickRadius) continue\n\n    const { localX, localY } = projectPlayerOntoSegmentWall(segment, player)\n    if (!best || lineDistance < best.lineDistance) {\n      best = { segmentIndex: segment.index, localX, localY, lineDistance }\n    }\n  }\n\n  return best\n}\n\n/** Map a wall-local contact anchor to baseLayer-local world position. */\nexport function boundaryContactAnchorToPosition(\n  segment: PolygonBoundarySegment,\n  anchor: SegmentWallProjection,\n  target: { set: (x: number, y: number, z: number) => void }\n): void {\n  const cos = Math.cos(segment.yaw)\n  const sin = Math.sin(segment.yaw)\n  target.set(\n    segment.position[0] + anchor.localX * cos,\n    segment.position[1] + anchor.localY,\n    segment.position[2] - anchor.localX * sin\n  )\n}\n"],"names":["BOUNDARY_WARNING_PICK_RADIUS","buildPolygonBoundarySegments","points","height","segments","i","p0","p1","dx","dz","length","baseY","distancePointToSegmentXZ","px","pz","x0","z0","x1","z1","lengthSq","t","closestX","closestZ","projectPlayerOntoSegmentWall","segment","player","dy","cos","sin","localX","localY","halfLength","halfHeight","findBoundaryContactAnchor","pickRadius","best","yMin","yMax","lineDistance","boundaryContactAnchorToPosition","anchor","target"],"mappings":"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"}

package/dist/space/utils/rotation-compat.d.ts

@@ -0,0 +1,4 @@
+import type { Quaternion as QuatTuple, Vector3 } from '../../types/index.js';
+/** Legacy scene JSON used Euler `[x, y, z]`; current data uses quaternion `[x, y, z, w]`. */
+export declare function toQuaternionRotation(rotation: QuatTuple | Vector3 | readonly number[] | undefined): QuatTuple;
+//# sourceMappingURL=rotation-compat.d.ts.map

package/dist/space/utils/rotation-compat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rotation-compat.d.ts","sourceRoot":"","sources":["../../../space/utils/rotation-compat.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,IAAI,SAAS,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAKnE,6FAA6F;AAC7F,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,SAAS,GAAG,OAAO,GAAG,SAAS,MAAM,EAAE,GAAG,SAAS,GAC5D,SAAS,CAcX"}

package/dist/space/utils/rotation-compat.js

@@ -0,0 +1,9 @@
+import { Euler as r, Quaternion as l } from "three";
+const n = /* @__PURE__ */ new r(), u = /* @__PURE__ */ new l();
+function s(e) {
+  return e?.length ? e.length === 4 ? [e[0], e[1], e[2], e[3]] : e.length === 3 ? (n.set(e[0], e[1], e[2]), u.setFromEuler(n), [u.x, u.y, u.z, u.w]) : [0, 0, 0, 1] : [0, 0, 0, 1];
+}
+export {
+  s as toQuaternionRotation
+};
+//# sourceMappingURL=rotation-compat.js.map

package/dist/space/utils/rotation-compat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rotation-compat.js","sources":["../../../space/utils/rotation-compat.ts"],"sourcesContent":["import { Euler, Quaternion } from 'three'\nimport type { Quaternion as QuatTuple, Vector3 } from '../../types'\n\nconst _euler = /* @__PURE__ */ new Euler()\nconst _quat = /* @__PURE__ */ new Quaternion()\n\n/** Legacy scene JSON used Euler `[x, y, z]`; current data uses quaternion `[x, y, z, w]`. */\nexport function toQuaternionRotation(\n  rotation: QuatTuple | Vector3 | readonly number[] | undefined\n): QuatTuple {\n  if (!rotation?.length) return [0, 0, 0, 1]\n\n  if (rotation.length === 4) {\n    return [rotation[0], rotation[1], rotation[2], rotation[3]]\n  }\n\n  if (rotation.length === 3) {\n    _euler.set(rotation[0], rotation[1], rotation[2])\n    _quat.setFromEuler(_euler)\n    return [_quat.x, _quat.y, _quat.z, _quat.w]\n  }\n\n  return [0, 0, 0, 1]\n}\n"],"names":["_euler","Euler","_quat","Quaternion","toQuaternionRotation","rotation"],"mappings":";AAGA,MAAMA,wBAA6BC,EAAA,GAC7BC,wBAA4BC,EAAA;AAG3B,SAASC,EACdC,GACW;AACX,SAAKA,GAAU,SAEXA,EAAS,WAAW,IACf,CAACA,EAAS,CAAC,GAAGA,EAAS,CAAC,GAAGA,EAAS,CAAC,GAAGA,EAAS,CAAC,CAAC,IAGxDA,EAAS,WAAW,KACtBL,EAAO,IAAIK,EAAS,CAAC,GAAGA,EAAS,CAAC,GAAGA,EAAS,CAAC,CAAC,GAChDH,EAAM,aAAaF,CAAM,GAClB,CAACE,EAAM,GAAGA,EAAM,GAAGA,EAAM,GAAGA,EAAM,CAAC,KAGrC,CAAC,GAAG,GAAG,GAAG,CAAC,IAZY,CAAC,GAAG,GAAG,GAAG,CAAC;AAa3C;"}

package/dist/space/utils/select-splat-level.d.ts

@@ -0,0 +1,52 @@
+import type { BaseSceneRef } from '../../types/index.js';
+/**
+ * Soft upper bound on 3DGS point count that a typical desktop GPU can stream
+ * smoothly at 60fps. Used by {@link selectSplatLevel} to pick a LOD.
+ */
+export declare const DESKTOP_SPLAT_COUNT_CAP = 2500000;
+/**
+ * Soft upper bound on 3DGS point count for mobile / coarse-pointer devices.
+ */
+export declare const MOBILE_SPLAT_COUNT_CAP = 1200000;
+/**
+ * Detect whether the current device should be treated as mobile for LOD
+ * selection. Uses {@link isTouchPrimaryDevice} — same logic as explore touch
+ * controls, including WebViews that misreport `(pointer: coarse)`.
+ *
+ * The check is evaluated once per call (no React subscription) because the
+ * splat asset is loaded at most once per scene-mount and we don't want a
+ * resize / device-orientation change to trigger a re-download.
+ */
+export declare function isMobileDevice(): boolean;
+/**
+ * The point-count cap appropriate for the current device.
+ */
+export declare function getDeviceSplatCountCap(): number;
+/**
+ * Result of LOD selection: the URL that should actually be loaded, the chosen
+ * level's metadata (if it came from `splatLevels`), and the device cap that
+ * informed the decision. Returns `undefined` when the scene has no usable URL.
+ */
+export interface SelectedSplatLevel {
+    url: string;
+    splatCount?: number;
+    selectedFromLevels: boolean;
+    deviceCap: number;
+}
+/**
+ * Pick the splat asset URL to load for the current device.
+ *
+ * Rules (in order):
+ *
+ * 1. If `splatLevels` is present and non-empty:
+ *    a. Among entries with `splatCount <= deviceCap`, pick the one with the
+ *       LARGEST `splatCount` (the best quality the device can handle).
+ *    b. If none fit, pick the entry with the SMALLEST `splatCount` (the least
+ *       heavy variant — degraded quality but at least playable).
+ * 2. Otherwise fall back to `scene.url`. If `scene.splatCount` is also given
+ *    and exceeds the cap, log a warning so authors notice.
+ *
+ * Returns `undefined` when no URL is available.
+ */
+export declare function selectSplatLevel(scene: BaseSceneRef | undefined): SelectedSplatLevel | undefined;
+//# sourceMappingURL=select-splat-level.d.ts.map

package/dist/space/utils/select-splat-level.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-splat-level.d.ts","sourceRoot":"","sources":["../../../space/utils/select-splat-level.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAc,MAAM,aAAa,CAAA;AAK3D;;;GAGG;AACH,eAAO,MAAM,uBAAuB,UAAY,CAAA;AAEhD;;GAEG;AACH,eAAO,MAAM,sBAAsB,UAAY,CAAA;AAE/C;;;;;;;;GAQG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAExC;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,CAE/C;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,MAAM,CAAA;IACX,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,kBAAkB,EAAE,OAAO,CAAA;IAC3B,SAAS,EAAE,MAAM,CAAA;CAClB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG,SAAS,GAAG,kBAAkB,GAAG,SAAS,CAwChG"}

package/dist/space/utils/select-splat-level.js

@@ -0,0 +1,43 @@
+import { createLogger as i } from "../../core/logging/logger.js";
+import { isTouchPrimaryDevice as u } from "./touch-primary-device.js";
+const a = i("space:splat-lod"), p = 25e5, c = 12e5;
+function C() {
+  return u();
+}
+function f() {
+  return C() ? c : p;
+}
+function g(t) {
+  if (!t) return;
+  const l = f(), s = t.splatLevels;
+  if (s && s.length > 0) {
+    let o, r;
+    for (const e of s)
+      e.url && (e.splatCount <= l && (!o || e.splatCount > o.splatCount) && (o = e), (!r || e.splatCount < r.splatCount) && (r = e));
+    const n = o ?? r;
+    if (n)
+      return {
+        url: n.url,
+        splatCount: n.splatCount,
+        selectedFromLevels: !0,
+        deviceCap: l
+      };
+  }
+  if (t.url)
+    return t.splatCount != null && t.splatCount > l && a.warn(
+      `Scene declares ${t.splatCount.toLocaleString()} splats but this device's cap is ${l.toLocaleString()}. Provide \`splatLevels\` for smoother playback.`
+    ), {
+      url: t.url,
+      splatCount: t.splatCount,
+      selectedFromLevels: !1,
+      deviceCap: l
+    };
+}
+export {
+  p as DESKTOP_SPLAT_COUNT_CAP,
+  c as MOBILE_SPLAT_COUNT_CAP,
+  f as getDeviceSplatCountCap,
+  C as isMobileDevice,
+  g as selectSplatLevel
+};
+//# sourceMappingURL=select-splat-level.js.map

package/dist/space/utils/select-splat-level.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-splat-level.js","sources":["../../../space/utils/select-splat-level.ts"],"sourcesContent":["import { createLogger } from '../../core'\nimport type { BaseSceneRef, SplatLevel } from '../../types'\nimport { isTouchPrimaryDevice } from './touch-primary-device'\n\nconst logger = createLogger('space:splat-lod')\n\n/**\n * Soft upper bound on 3DGS point count that a typical desktop GPU can stream\n * smoothly at 60fps. Used by {@link selectSplatLevel} to pick a LOD.\n */\nexport const DESKTOP_SPLAT_COUNT_CAP = 2_500_000\n\n/**\n * Soft upper bound on 3DGS point count for mobile / coarse-pointer devices.\n */\nexport const MOBILE_SPLAT_COUNT_CAP = 1_200_000\n\n/**\n * Detect whether the current device should be treated as mobile for LOD\n * selection. Uses {@link isTouchPrimaryDevice} — same logic as explore touch\n * controls, including WebViews that misreport `(pointer: coarse)`.\n *\n * The check is evaluated once per call (no React subscription) because the\n * splat asset is loaded at most once per scene-mount and we don't want a\n * resize / device-orientation change to trigger a re-download.\n */\nexport function isMobileDevice(): boolean {\n  return isTouchPrimaryDevice()\n}\n\n/**\n * The point-count cap appropriate for the current device.\n */\nexport function getDeviceSplatCountCap(): number {\n  return isMobileDevice() ? MOBILE_SPLAT_COUNT_CAP : DESKTOP_SPLAT_COUNT_CAP\n}\n\n/**\n * Result of LOD selection: the URL that should actually be loaded, the chosen\n * level's metadata (if it came from `splatLevels`), and the device cap that\n * informed the decision. Returns `undefined` when the scene has no usable URL.\n */\nexport interface SelectedSplatLevel {\n  url: string\n  splatCount?: number\n  selectedFromLevels: boolean\n  deviceCap: number\n}\n\n/**\n * Pick the splat asset URL to load for the current device.\n *\n * Rules (in order):\n *\n * 1. If `splatLevels` is present and non-empty:\n *    a. Among entries with `splatCount <= deviceCap`, pick the one with the\n *       LARGEST `splatCount` (the best quality the device can handle).\n *    b. If none fit, pick the entry with the SMALLEST `splatCount` (the least\n *       heavy variant — degraded quality but at least playable).\n * 2. Otherwise fall back to `scene.url`. If `scene.splatCount` is also given\n *    and exceeds the cap, log a warning so authors notice.\n *\n * Returns `undefined` when no URL is available.\n */\nexport function selectSplatLevel(scene: BaseSceneRef | undefined): SelectedSplatLevel | undefined {\n  if (!scene) return undefined\n  const deviceCap = getDeviceSplatCountCap()\n\n  const levels = scene.splatLevels\n  if (levels && levels.length > 0) {\n    let bestFitting: SplatLevel | undefined\n    let lightest: SplatLevel | undefined\n    for (const level of levels) {\n      if (!level.url) continue\n      if (level.splatCount <= deviceCap) {\n        if (!bestFitting || level.splatCount > bestFitting.splatCount) bestFitting = level\n      }\n      if (!lightest || level.splatCount < lightest.splatCount) lightest = level\n    }\n    const chosen = bestFitting ?? lightest\n    if (chosen) {\n      return {\n        url: chosen.url,\n        splatCount: chosen.splatCount,\n        selectedFromLevels: true,\n        deviceCap\n      }\n    }\n    // No valid (non-empty url) entries — fall through to scene.url\n  }\n\n  if (!scene.url) return undefined\n  if (scene.splatCount != null && scene.splatCount > deviceCap) {\n    logger.warn(\n      `Scene declares ${scene.splatCount.toLocaleString()} splats but this device's cap is ` +\n        `${deviceCap.toLocaleString()}. Provide \\`splatLevels\\` for smoother playback.`\n    )\n  }\n  return {\n    url: scene.url,\n    splatCount: scene.splatCount,\n    selectedFromLevels: false,\n    deviceCap\n  }\n}\n"],"names":["logger","createLogger","DESKTOP_SPLAT_COUNT_CAP","MOBILE_SPLAT_COUNT_CAP","isMobileDevice","isTouchPrimaryDevice","getDeviceSplatCountCap","selectSplatLevel","scene","deviceCap","levels","bestFitting","lightest","level","chosen"],"mappings":";;AAIA,MAAMA,IAASC,EAAa,iBAAiB,GAMhCC,IAA0B,MAK1BC,IAAyB;AAW/B,SAASC,IAA0B;AACxC,SAAOC,EAAA;AACT;AAKO,SAASC,IAAiC;AAC/C,SAAOF,EAAA,IAAmBD,IAAyBD;AACrD;AA6BO,SAASK,EAAiBC,GAAiE;AAChG,MAAI,CAACA,EAAO;AACZ,QAAMC,IAAYH,EAAA,GAEZI,IAASF,EAAM;AACrB,MAAIE,KAAUA,EAAO,SAAS,GAAG;AAC/B,QAAIC,GACAC;AACJ,eAAWC,KAASH;AAClB,MAAKG,EAAM,QACPA,EAAM,cAAcJ,MAClB,CAACE,KAAeE,EAAM,aAAaF,EAAY,gBAAYA,IAAcE,KAE3E,CAACD,KAAYC,EAAM,aAAaD,EAAS,gBAAYA,IAAWC;AAEtE,UAAMC,IAASH,KAAeC;AAC9B,QAAIE;AACF,aAAO;AAAA,QACL,KAAKA,EAAO;AAAA,QACZ,YAAYA,EAAO;AAAA,QACnB,oBAAoB;AAAA,QACpB,WAAAL;AAAA,MAAA;AAAA,EAIN;AAEA,MAAKD,EAAM;AACX,WAAIA,EAAM,cAAc,QAAQA,EAAM,aAAaC,KACjDT,EAAO;AAAA,MACL,kBAAkBQ,EAAM,WAAW,eAAA,CAAgB,oCAC9CC,EAAU,gBAAgB;AAAA,IAAA,GAG5B;AAAA,MACL,KAAKD,EAAM;AAAA,MACX,YAAYA,EAAM;AAAA,MAClB,oBAAoB;AAAA,MACpB,WAAAC;AAAA,IAAA;AAEJ;"}

package/dist/space/utils/spark-performance.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Cap backing-store resolution for splat-heavy canvases.
+ *
+ * Splat blending cost scales with pixel count, so we clamp `devicePixelRatio`
+ * to keep GPU load (and heat) in check. This is renderer-version agnostic — it
+ * only feeds the R3F `<Canvas dpr>` / `gl.setPixelRatio()`.
+ * @see https://sparkjs.dev/docs/performance/
+ */
+export declare function getSparkCanvasDpr(): number;
+//# sourceMappingURL=spark-performance.d.ts.map

package/dist/space/utils/spark-performance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spark-performance.d.ts","sourceRoot":"","sources":["../../../space/utils/spark-performance.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAI1C"}

package/dist/space/utils/spark-performance.js

@@ -0,0 +1,10 @@
+import { isMobileDevice as i } from "./select-splat-level.js";
+function o() {
+  if (typeof window > "u") return 1;
+  const e = (i(), 2);
+  return Math.min(window.devicePixelRatio || 1, e);
+}
+export {
+  o as getSparkCanvasDpr
+};
+//# sourceMappingURL=spark-performance.js.map

package/dist/space/utils/spark-performance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spark-performance.js","sources":["../../../space/utils/spark-performance.ts"],"sourcesContent":["import { isMobileDevice } from './select-splat-level'\n\n/**\n * Cap backing-store resolution for splat-heavy canvases.\n *\n * Splat blending cost scales with pixel count, so we clamp `devicePixelRatio`\n * to keep GPU load (and heat) in check. This is renderer-version agnostic — it\n * only feeds the R3F `<Canvas dpr>` / `gl.setPixelRatio()`.\n * @see https://sparkjs.dev/docs/performance/\n */\nexport function getSparkCanvasDpr(): number {\n  if (typeof window === 'undefined') return 1\n  const cap = isMobileDevice() ? 2 : 2\n  return Math.min(window.devicePixelRatio || 1, cap)\n}\n"],"names":["getSparkCanvasDpr","cap","isMobileDevice"],"mappings":";AAUO,SAASA,IAA4B;AAC1C,MAAI,OAAO,SAAW,IAAa,QAAO;AAC1C,QAAMC,KAAMC,KAAmB;AAC/B,SAAO,KAAK,IAAI,OAAO,oBAAoB,GAAGD,CAAG;AACnD;"}

package/dist/space/utils/splat-collider-helper.d.ts

@@ -0,0 +1,5 @@
+import type { SparkSplatMesh } from '../splats/spark/splat-mesh.js';
+import * as THREE from 'three';
+export declare function createSplatCollider(splatMesh: SparkSplatMesh, maxPoints: number): THREE.Mesh;
+export declare function createSplatColliderByVoxel(splatMesh: SparkSplatMesh, voxelSize: number): THREE.Mesh;
+//# sourceMappingURL=splat-collider-helper.d.ts.map

package/dist/space/utils/splat-collider-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"splat-collider-helper.d.ts","sourceRoot":"","sources":["../../../space/utils/splat-collider-helper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAChE,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAQ9B,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,GAAG,KAAK,CAAC,IAAI,CA4N5F;AAED,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,cAAc,EACzB,SAAS,EAAE,MAAM,GAChB,KAAK,CAAC,IAAI,CAwQZ"}

package/dist/space/utils/splat-collider-helper.js

@@ -0,0 +1,162 @@
+import * as s from "three";
+function P(H, O) {
+  const x = [];
+  H.forEachSplat((e, t, c, E) => {
+    x.push({
+      center: t.clone(),
+      scales: c.clone(),
+      quaternion: E.clone()
+    });
+  });
+  const m = x.length;
+  if (m === 0)
+    return new s.Mesh(new s.BufferGeometry());
+  const d = [];
+  if (m <= O)
+    d.push(...x);
+  else {
+    const e = Array.from({ length: m }, (t, c) => c);
+    for (let t = 0; t < O; t++) {
+      const c = t + Math.floor(Math.random() * (m - t));
+      [e[t], e[c]] = [e[c], e[t]], d.push(x[e[t]]);
+    }
+  }
+  const b = new Float32Array([
+    -0.5,
+    -0.5,
+    0.5,
+    // 0: front-bottom-left
+    0.5,
+    -0.5,
+    0.5,
+    // 1: front-bottom-right
+    0.5,
+    0.5,
+    0.5,
+    // 2: front-top-right
+    -0.5,
+    0.5,
+    0.5,
+    // 3: front-top-left
+    -0.5,
+    -0.5,
+    -0.5,
+    // 4: back-bottom-left
+    -0.5,
+    0.5,
+    -0.5,
+    // 5: back-top-left
+    0.5,
+    0.5,
+    -0.5,
+    // 6: back-top-right
+    0.5,
+    -0.5,
+    -0.5
+    // 7: back-bottom-right
+  ]), L = new Uint16Array([
+    // Front face (z = 0.5)
+    0,
+    1,
+    2,
+    0,
+    2,
+    3,
+    // Back face (z = -0.5)
+    4,
+    5,
+    6,
+    4,
+    6,
+    7,
+    // Top face (y = 0.5)
+    3,
+    2,
+    6,
+    3,
+    6,
+    5,
+    // Bottom face (y = -0.5)
+    0,
+    7,
+    1,
+    0,
+    4,
+    7,
+    // Right face (x = 0.5)
+    1,
+    7,
+    6,
+    1,
+    6,
+    2,
+    // Left face (x = -0.5)
+    0,
+    3,
+    5,
+    0,
+    5,
+    4
+  ]), v = new Float32Array([
+    // Vertex normals (averaged from adjacent faces)
+    -0.577,
+    -0.577,
+    0.577,
+    // 0: left-bottom-front
+    0.577,
+    -0.577,
+    0.577,
+    // 1: right-bottom-front
+    0.577,
+    0.577,
+    0.577,
+    // 2: right-top-front
+    -0.577,
+    0.577,
+    0.577,
+    // 3: left-top-front
+    -0.577,
+    -0.577,
+    -0.577,
+    // 4: left-bottom-back
+    -0.577,
+    0.577,
+    -0.577,
+    // 5: left-top-back
+    0.577,
+    0.577,
+    -0.577,
+    // 6: right-top-back
+    0.577,
+    -0.577,
+    -0.577
+    // 7: right-bottom-back
+  ]), p = d.length, u = 8, M = 36, w = new Float32Array(p * u * 3), i = new Float32Array(p * u * 3), U = new Uint32Array(p * M), g = new s.Matrix4(), _ = new s.Vector3(), j = new s.Matrix3(), n = g.elements;
+  for (let e = 0; e < p; e++) {
+    const t = d[e], c = e * u * 3, E = e * M;
+    _.set(t.scales.x * 2, t.scales.y * 2, t.scales.z * 2), g.compose(t.center, t.quaternion, _), j.setFromMatrix4(g);
+    for (let a = 0; a < u; a++) {
+      const l = a * 3, o = c + l, I = b[l], S = b[l + 1], F = b[l + 2];
+      w[o] = n[0] * I + n[4] * S + n[8] * F + n[12], w[o + 1] = n[1] * I + n[5] * S + n[9] * F + n[13], w[o + 2] = n[2] * I + n[6] * S + n[10] * F + n[14];
+      const q = v[l], z = v[l + 1], G = v[l + 2], r = j.elements, h = r[0] * q + r[3] * z + r[6] * G, A = r[1] * q + r[4] * z + r[7] * G, B = r[2] * q + r[5] * z + r[8] * G, C = Math.sqrt(h * h + A * A + B * B);
+      if (C > 0) {
+        const V = 1 / C;
+        i[o] = h * V, i[o + 1] = A * V, i[o + 2] = B * V;
+      } else
+        i[o] = h, i[o + 1] = A, i[o + 2] = B;
+    }
+    const N = e * u;
+    for (let a = 0; a < M; a++)
+      U[E + a] = L[a] + N;
+  }
+  const f = new s.BufferGeometry();
+  f.setAttribute("position", new s.BufferAttribute(w, 3)), f.setAttribute("normal", new s.BufferAttribute(i, 3)), f.setIndex(new s.BufferAttribute(U, 1)), f.computeBoundingBox(), f.computeBoundingSphere();
+  const y = new s.Mesh(f);
+  return Array.isArray(y.material) ? y.material.forEach((e) => {
+    e.visible = !1;
+  }) : y.material.visible = !1, y;
+}
+export {
+  P as createSplatCollider
+};
+//# sourceMappingURL=splat-collider-helper.js.map

package/dist/space/utils/splat-collider-helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"splat-collider-helper.js","sources":["../../../space/utils/splat-collider-helper.ts"],"sourcesContent":["import type { SparkSplatMesh } from '../splats/spark/splat-mesh'\nimport * as THREE from 'three'\n\ninterface SplatData {\n  center: THREE.Vector3\n  scales: THREE.Vector3\n  quaternion: THREE.Quaternion\n}\n\nexport function createSplatCollider(splatMesh: SparkSplatMesh, maxPoints: number): THREE.Mesh {\n  // Step 1: Collect all splat data\n  const allSplats: SplatData[] = []\n  splatMesh.forEachSplat((_index, center, scales, quaternion) => {\n    allSplats.push({\n      center: center.clone(),\n      scales: scales.clone(),\n      quaternion: quaternion.clone()\n    })\n  })\n\n  // Step 2: Random sampling to downsample\n  const totalSplats = allSplats.length\n  if (totalSplats === 0) {\n    // Return empty mesh if no splats\n    return new THREE.Mesh(new THREE.BufferGeometry())\n  }\n\n  const sampledSplats: SplatData[] = []\n  if (totalSplats <= maxPoints) {\n    // If we have fewer splats than maxPoints, use all\n    sampledSplats.push(...allSplats)\n  } else {\n    // Optimized random sampling: Fisher-Yates shuffle approach\n    // Create array of indices and shuffle first maxPoints elements\n    const indices = Array.from({ length: totalSplats }, (_, i) => i)\n    for (let i = 0; i < maxPoints; i++) {\n      const j = i + Math.floor(Math.random() * (totalSplats - i))\n      ;[indices[i], indices[j]] = [indices[j], indices[i]]\n      sampledSplats.push(allSplats[indices[i]])\n    }\n  }\n\n  // Step 3: Directly build BufferGeometry by manipulating vertex data\n  // Define unit box vertices (8 vertices, centered at origin)\n  // Box from -0.5 to 0.5 in each axis\n  // Vertex order: front-bottom-left, front-bottom-right, front-top-right, front-top-left,\n  //               back-bottom-left, back-top-left, back-top-right, back-bottom-right\n  const unitBoxVertices = new Float32Array([\n    -0.5,\n    -0.5,\n    0.5, // 0: front-bottom-left\n    0.5,\n    -0.5,\n    0.5, // 1: front-bottom-right\n    0.5,\n    0.5,\n    0.5, // 2: front-top-right\n    -0.5,\n    0.5,\n    0.5, // 3: front-top-left\n    -0.5,\n    -0.5,\n    -0.5, // 4: back-bottom-left\n    -0.5,\n    0.5,\n    -0.5, // 5: back-top-left\n    0.5,\n    0.5,\n    -0.5, // 6: back-top-right\n    0.5,\n    -0.5,\n    -0.5 // 7: back-bottom-right\n  ])\n\n  // Define box indices (12 triangles = 6 faces * 2 triangles per face)\n  const unitBoxIndices = new Uint16Array([\n    // Front face (z = 0.5)\n    0, 1, 2, 0, 2, 3,\n    // Back face (z = -0.5)\n    4, 5, 6, 4, 6, 7,\n    // Top face (y = 0.5)\n    3, 2, 6, 3, 6, 5,\n    // Bottom face (y = -0.5)\n    0, 7, 1, 0, 4, 7,\n    // Right face (x = 0.5)\n    1, 7, 6, 1, 6, 2,\n    // Left face (x = -0.5)\n    0, 3, 5, 0, 5, 4\n  ])\n\n  // Define box normals per vertex (each vertex belongs to 3 faces, use average or face-specific)\n  // For simplicity, we'll use face-specific normals and duplicate vertices per face\n  // But for performance, we'll use per-vertex normals (average of adjacent faces)\n  const unitBoxNormals = new Float32Array([\n    // Vertex normals (averaged from adjacent faces)\n    -0.577,\n    -0.577,\n    0.577, // 0: left-bottom-front\n    0.577,\n    -0.577,\n    0.577, // 1: right-bottom-front\n    0.577,\n    0.577,\n    0.577, // 2: right-top-front\n    -0.577,\n    0.577,\n    0.577, // 3: left-top-front\n    -0.577,\n    -0.577,\n    -0.577, // 4: left-bottom-back\n    -0.577,\n    0.577,\n    -0.577, // 5: left-top-back\n    0.577,\n    0.577,\n    -0.577, // 6: right-top-back\n    0.577,\n    -0.577,\n    -0.577 // 7: right-bottom-back\n  ])\n\n  const numBoxes = sampledSplats.length\n  const verticesPerBox = 8\n  const indicesPerBox = 36 // 12 triangles * 3 indices\n\n  // Pre-allocate arrays for final geometry\n  const positions = new Float32Array(numBoxes * verticesPerBox * 3)\n  const normals = new Float32Array(numBoxes * verticesPerBox * 3)\n  const indices = new Uint32Array(numBoxes * indicesPerBox)\n\n  // Reusable objects for transformations\n  const matrix = new THREE.Matrix4()\n  const scale = new THREE.Vector3()\n  const quaternionMatrix = new THREE.Matrix3()\n  const matrixElements = matrix.elements\n\n  // Process each splat\n  for (let boxIndex = 0; boxIndex < numBoxes; boxIndex++) {\n    const splat = sampledSplats[boxIndex]\n    const vertexOffset = boxIndex * verticesPerBox * 3\n    const indexOffset = boxIndex * indicesPerBox\n\n    // Set scale\n    scale.set(splat.scales.x * 2, splat.scales.y * 2, splat.scales.z * 2)\n\n    // Build transformation matrix\n    matrix.compose(splat.center, splat.quaternion, scale)\n\n    // Extract rotation matrix for normals (normals should not be translated)\n    quaternionMatrix.setFromMatrix4(matrix)\n\n    // Transform vertices and normals\n    for (let v = 0; v < verticesPerBox; v++) {\n      const srcIdx = v * 3\n      const dstIdx = vertexOffset + srcIdx\n\n      // Transform vertex directly using matrix multiplication\n      const vx = unitBoxVertices[srcIdx]\n      const vy = unitBoxVertices[srcIdx + 1]\n      const vz = unitBoxVertices[srcIdx + 2]\n\n      // Apply matrix transformation: v' = M * v\n      positions[dstIdx] =\n        matrixElements[0] * vx +\n        matrixElements[4] * vy +\n        matrixElements[8] * vz +\n        matrixElements[12]\n      positions[dstIdx + 1] =\n        matrixElements[1] * vx +\n        matrixElements[5] * vy +\n        matrixElements[9] * vz +\n        matrixElements[13]\n      positions[dstIdx + 2] =\n        matrixElements[2] * vx +\n        matrixElements[6] * vy +\n        matrixElements[10] * vz +\n        matrixElements[14]\n\n      // Transform normal (only rotation, no translation)\n      const nx = unitBoxNormals[srcIdx]\n      const ny = unitBoxNormals[srcIdx + 1]\n      const nz = unitBoxNormals[srcIdx + 2]\n\n      // Apply rotation matrix and normalize\n      const rotElements = quaternionMatrix.elements\n      const ntx = rotElements[0] * nx + rotElements[3] * ny + rotElements[6] * nz\n      const nty = rotElements[1] * nx + rotElements[4] * ny + rotElements[7] * nz\n      const ntz = rotElements[2] * nx + rotElements[5] * ny + rotElements[8] * nz\n\n      // Normalize\n      const len = Math.sqrt(ntx * ntx + nty * nty + ntz * ntz)\n      if (len > 0) {\n        const invLen = 1 / len\n        normals[dstIdx] = ntx * invLen\n        normals[dstIdx + 1] = nty * invLen\n        normals[dstIdx + 2] = ntz * invLen\n      } else {\n        normals[dstIdx] = ntx\n        normals[dstIdx + 1] = nty\n        normals[dstIdx + 2] = ntz\n      }\n    }\n\n    // Copy indices with offset\n    const baseVertexIndex = boxIndex * verticesPerBox\n    for (let i = 0; i < indicesPerBox; i++) {\n      indices[indexOffset + i] = unitBoxIndices[i] + baseVertexIndex\n    }\n  }\n\n  // Create final BufferGeometry\n  const mergedGeometry = new THREE.BufferGeometry()\n  mergedGeometry.setAttribute('position', new THREE.BufferAttribute(positions, 3))\n  mergedGeometry.setAttribute('normal', new THREE.BufferAttribute(normals, 3))\n  mergedGeometry.setIndex(new THREE.BufferAttribute(indices, 1))\n  mergedGeometry.computeBoundingBox()\n  mergedGeometry.computeBoundingSphere()\n\n  // Step 4: Create and return mesh\n  const mesh = new THREE.Mesh(mergedGeometry)\n  if (Array.isArray(mesh.material)) {\n    mesh.material.forEach((material) => {\n      material.visible = false\n    })\n  } else {\n    mesh.material.visible = false\n  }\n\n  return mesh\n}\n\nexport function createSplatColliderByVoxel(\n  splatMesh: SparkSplatMesh,\n  voxelSize: number\n): THREE.Mesh {\n  // Step 1: Collect all splat centers and compute bounding box\n  const splatCenters: THREE.Vector3[] = []\n  const bbox = new THREE.Box3()\n  const tempCenter = new THREE.Vector3()\n\n  splatMesh.forEachSplat((_index, center) => {\n    tempCenter.copy(center)\n    splatCenters.push(tempCenter.clone())\n    bbox.expandByPoint(tempCenter)\n  })\n\n  if (splatCenters.length === 0 || bbox.isEmpty()) {\n    return new THREE.Mesh(new THREE.BufferGeometry())\n  }\n\n  const bboxSize = bbox.getSize(new THREE.Vector3())\n  const bboxMin = bbox.min.clone()\n\n  // Step 2: Calculate voxel grid dimensions\n  // Use the provided voxelSize directly\n  // Calculate grid dimensions based on bounding box size and voxel size\n  const gridX = Math.max(1, Math.ceil(bboxSize.x / voxelSize))\n  const gridY = Math.max(1, Math.ceil(bboxSize.y / voxelSize))\n  const gridZ = Math.max(1, Math.ceil(bboxSize.z / voxelSize))\n\n  // Use actual voxel sizes to ensure complete coverage\n  const actualVoxelSizeX = bboxSize.x / gridX\n  const actualVoxelSizeY = bboxSize.y / gridY\n  const actualVoxelSizeZ = bboxSize.z / gridZ\n\n  // Step 3: Assign splats to voxels\n  // Use Map with string key for voxel coordinates\n  const voxelMap = new Map<string, boolean>()\n\n  for (const center of splatCenters) {\n    // Calculate voxel grid coordinates\n    const voxelX = Math.floor((center.x - bboxMin.x) / actualVoxelSizeX)\n    const voxelY = Math.floor((center.y - bboxMin.y) / actualVoxelSizeY)\n    const voxelZ = Math.floor((center.z - bboxMin.z) / actualVoxelSizeZ)\n\n    // Clamp to valid range\n    const clampedX = Math.max(0, Math.min(gridX - 1, voxelX))\n    const clampedY = Math.max(0, Math.min(gridY - 1, voxelY))\n    const clampedZ = Math.max(0, Math.min(gridZ - 1, voxelZ))\n\n    // Mark voxel as occupied\n    const voxelKey = `${clampedX},${clampedY},${clampedZ}`\n    voxelMap.set(voxelKey, true)\n  }\n\n  const occupiedVoxels = Array.from(voxelMap.keys())\n\n  // Step 4: Generate box geometry for each occupied voxel\n  // Reuse unit box data from createSplatCollider\n  const unitBoxVertices = new Float32Array([\n    -0.5,\n    -0.5,\n    0.5, // 0: front-bottom-left\n    0.5,\n    -0.5,\n    0.5, // 1: front-bottom-right\n    0.5,\n    0.5,\n    0.5, // 2: front-top-right\n    -0.5,\n    0.5,\n    0.5, // 3: front-top-left\n    -0.5,\n    -0.5,\n    -0.5, // 4: back-bottom-left\n    -0.5,\n    0.5,\n    -0.5, // 5: back-top-left\n    0.5,\n    0.5,\n    -0.5, // 6: back-top-right\n    0.5,\n    -0.5,\n    -0.5 // 7: back-bottom-right\n  ])\n\n  const unitBoxIndices = new Uint16Array([\n    0,\n    1,\n    2,\n    0,\n    2,\n    3, // Front face\n    4,\n    5,\n    6,\n    4,\n    6,\n    7, // Back face\n    3,\n    2,\n    6,\n    3,\n    6,\n    5, // Top face\n    0,\n    7,\n    1,\n    0,\n    4,\n    7, // Bottom face\n    1,\n    7,\n    6,\n    1,\n    6,\n    2, // Right face\n    0,\n    3,\n    5,\n    0,\n    5,\n    4 // Left face\n  ])\n\n  const unitBoxNormals = new Float32Array([\n    -0.577,\n    -0.577,\n    0.577, // 0\n    0.577,\n    -0.577,\n    0.577, // 1\n    0.577,\n    0.577,\n    0.577, // 2\n    -0.577,\n    0.577,\n    0.577, // 3\n    -0.577,\n    -0.577,\n    -0.577, // 4\n    -0.577,\n    0.577,\n    -0.577, // 5\n    0.577,\n    0.577,\n    -0.577, // 6\n    0.577,\n    -0.577,\n    -0.577 // 7\n  ])\n\n  const numVoxels = occupiedVoxels.length\n  const verticesPerBox = 8\n  const indicesPerBox = 36\n\n  // Pre-allocate arrays\n  const positions = new Float32Array(numVoxels * verticesPerBox * 3)\n  const normals = new Float32Array(numVoxels * verticesPerBox * 3)\n  const indices = new Uint32Array(numVoxels * indicesPerBox)\n\n  // Reusable objects\n  const matrix = new THREE.Matrix4()\n  const scale = new THREE.Vector3()\n  const position = new THREE.Vector3()\n  const quaternionMatrix = new THREE.Matrix3()\n  const matrixElements = matrix.elements\n\n  // Process each occupied voxel\n  for (let voxelIndex = 0; voxelIndex < numVoxels; voxelIndex++) {\n    const voxelKey = occupiedVoxels[voxelIndex]\n    const [vx, vy, vz] = voxelKey.split(',').map(Number)\n\n    // Calculate voxel center position\n    position.set(\n      bboxMin.x + (vx + 0.5) * actualVoxelSizeX,\n      // bboxMin.y + (vy + 0.5) * actualVoxelSizeY,\n      bboxMin.y + (vy + 1) * actualVoxelSizeY, // 避免地板和脚底间隙，采用上边沿而非中心点对齐\n      bboxMin.z + (vz + 0.5) * actualVoxelSizeZ\n    )\n\n    // Voxel box size\n    scale.set(actualVoxelSizeX, actualVoxelSizeY, actualVoxelSizeZ)\n\n    // Build transformation matrix (no rotation, just translation and scale)\n    matrix.compose(position, new THREE.Quaternion(), scale)\n\n    // Extract rotation matrix for normals (identity for axis-aligned boxes)\n    quaternionMatrix.setFromMatrix4(matrix)\n\n    const vertexOffset = voxelIndex * verticesPerBox * 3\n    const indexOffset = voxelIndex * indicesPerBox\n\n    // Transform vertices and normals\n    for (let v = 0; v < verticesPerBox; v++) {\n      const srcIdx = v * 3\n      const dstIdx = vertexOffset + srcIdx\n\n      // Transform vertex\n      const vtx = unitBoxVertices[srcIdx]\n      const vty = unitBoxVertices[srcIdx + 1]\n      const vtz = unitBoxVertices[srcIdx + 2]\n\n      positions[dstIdx] =\n        matrixElements[0] * vtx +\n        matrixElements[4] * vty +\n        matrixElements[8] * vtz +\n        matrixElements[12]\n      positions[dstIdx + 1] =\n        matrixElements[1] * vtx +\n        matrixElements[5] * vty +\n        matrixElements[9] * vtz +\n        matrixElements[13]\n      positions[dstIdx + 2] =\n        matrixElements[2] * vtx +\n        matrixElements[6] * vty +\n        matrixElements[10] * vtz +\n        matrixElements[14]\n\n      // Transform normal (for axis-aligned boxes, normals don't change)\n      const nx = unitBoxNormals[srcIdx]\n      const ny = unitBoxNormals[srcIdx + 1]\n      const nz = unitBoxNormals[srcIdx + 2]\n\n      const rotElements = quaternionMatrix.elements\n      const ntx = rotElements[0] * nx + rotElements[3] * ny + rotElements[6] * nz\n      const nty = rotElements[1] * nx + rotElements[4] * ny + rotElements[7] * nz\n      const ntz = rotElements[2] * nx + rotElements[5] * ny + rotElements[8] * nz\n\n      const len = Math.sqrt(ntx * ntx + nty * nty + ntz * ntz)\n      if (len > 0) {\n        const invLen = 1 / len\n        normals[dstIdx] = ntx * invLen\n        normals[dstIdx + 1] = nty * invLen\n        normals[dstIdx + 2] = ntz * invLen\n      } else {\n        normals[dstIdx] = ntx\n        normals[dstIdx + 1] = nty\n        normals[dstIdx + 2] = ntz\n      }\n    }\n\n    // Copy indices with offset\n    const baseVertexIndex = voxelIndex * verticesPerBox\n    for (let i = 0; i < indicesPerBox; i++) {\n      indices[indexOffset + i] = unitBoxIndices[i] + baseVertexIndex\n    }\n  }\n\n  // Create final BufferGeometry\n  const mergedGeometry = new THREE.BufferGeometry()\n  mergedGeometry.setAttribute('position', new THREE.BufferAttribute(positions, 3))\n  mergedGeometry.setAttribute('normal', new THREE.BufferAttribute(normals, 3))\n  mergedGeometry.setIndex(new THREE.BufferAttribute(indices, 1))\n  mergedGeometry.computeBoundingBox()\n  mergedGeometry.computeBoundingSphere()\n\n  // Step 5: Create and return mesh\n  const mesh = new THREE.Mesh(mergedGeometry)\n  if (Array.isArray(mesh.material)) {\n    mesh.material.forEach((material) => {\n      material.visible = false\n    })\n  } else {\n    mesh.material.visible = false\n  }\n\n  return mesh\n}\n"],"names":["createSplatCollider","splatMesh","maxPoints","allSplats","_index","center","scales","quaternion","totalSplats","THREE","sampledSplats","indices","_","i","j","unitBoxVertices","unitBoxIndices","unitBoxNormals","numBoxes","verticesPerBox","indicesPerBox","positions","normals","matrix","scale","quaternionMatrix","matrixElements","boxIndex","splat","vertexOffset","indexOffset","v","srcIdx","dstIdx","vx","vy","vz","nx","ny","nz","rotElements","ntx","nty","ntz","len","invLen","baseVertexIndex","mergedGeometry","mesh","material"],"mappings":"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"}

package/dist/space/utils/touch-primary-device.d.ts

@@ -0,0 +1,16 @@
+/** Same media query as `@react-three/viverse` `useIsMobile`. */
+export declare const VIVERSE_MOBILE_MEDIA_QUERY = "(hover: none) and (pointer: coarse)";
+/**
+ * Whether the device should use on-screen joystick + touch look controls.
+ *
+ * viverse's `useIsMobile()` only matches `(hover: none) and (pointer: coarse)`.
+ * Some phone browsers / in-app WebViews (WeChat, etc.) report `pointer: fine`, so
+ * they get desktop pointer-lock bindings and `.mobile-only` UI stays hidden.
+ */
+export declare function isTouchPrimaryDevice(): boolean;
+/**
+ * Drop-in replacement for viverse `useIsMobile()` wherever touch locomotion UI
+ * is chosen (joystick, jump button, pointer-capture look).
+ */
+export declare function useTouchPrimaryDevice(): boolean;
+//# sourceMappingURL=touch-primary-device.d.ts.map

package/dist/space/utils/touch-primary-device.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"touch-primary-device.d.ts","sourceRoot":"","sources":["../../../space/utils/touch-primary-device.ts"],"names":[],"mappings":"AAEA,gEAAgE;AAChE,eAAO,MAAM,0BAA0B,wCAAwC,CAAA;AAa/E;;;;;;GAMG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAkC9C;AA4CD;;;GAGG;AACH,wBAAgB,qBAAqB,IAAI,OAAO,CAY/C"}

package/dist/space/utils/touch-primary-device.js

@@ -0,0 +1,52 @@
+import { useSyncExternalStore as c, useEffect as a } from "react";
+const i = "(hover: none) and (pointer: coarse)", u = [
+  i,
+  "(hover: none)",
+  "(hover: hover)",
+  "(pointer: fine)",
+  "(any-pointer: coarse)",
+  "(max-width: 1024px)"
+], r = "cave-world-touch-controls-style";
+function s() {
+  return typeof window > "u" || typeof window.matchMedia != "function" ? !1 : window.matchMedia(i).matches ? !0 : !((navigator.maxTouchPoints ?? 0) > 0 || "ontouchstart" in window) || window.matchMedia("(pointer: fine)").matches && window.matchMedia("(hover: hover)").matches ? !1 : !!(window.matchMedia("(max-width: 1024px)").matches || window.matchMedia("(hover: none)").matches || window.matchMedia("(any-pointer: coarse)").matches);
+}
+function d(e) {
+  if (typeof window > "u" || typeof window.matchMedia != "function")
+    return () => {
+    };
+  const n = u.map((t) => window.matchMedia(t)), o = () => e();
+  for (const t of n)
+    t.addEventListener("change", o);
+  return () => {
+    for (const t of n)
+      t.removeEventListener("change", o);
+  };
+}
+function h() {
+  return s();
+}
+function m() {
+  if (typeof document > "u" || document.getElementById(r))
+    return;
+  const e = document.createElement("style");
+  e.id = r, e.textContent = "html.cave-world-touch-controls .mobile-only{display:unset!important;}", document.head.appendChild(e);
+}
+function f(e) {
+  typeof document > "u" || (m(), document.documentElement.classList.toggle("cave-world-touch-controls", e));
+}
+function w() {
+  const e = c(
+    d,
+    h,
+    () => !1
+  );
+  return a(() => {
+    f(e);
+  }, [e]), e;
+}
+export {
+  i as VIVERSE_MOBILE_MEDIA_QUERY,
+  s as isTouchPrimaryDevice,
+  w as useTouchPrimaryDevice
+};
+//# sourceMappingURL=touch-primary-device.js.map