@zylem/behaviors 0.2.0

package/dist/chunk-BXP4K7RF.js

@@ -0,0 +1,1205 @@
+import {
+  bufferGeometryToPlain,
+  buildFractureGeometryCacheKey,
+  buildNormalizedFractureSourceGeometry,
+  pinataFractureOptionsToPlain,
+  plainWorkerResultToTemplateParts
+} from "./chunk-HZMY3TT4.js";
+import {
+  defineBehavior
+} from "./chunk-EZNCCO4L.js";
+
+// src/lib/behaviors/destructible-3d/destructible-3d.descriptor.ts
+import {
+  ActiveCollisionTypes,
+  ColliderDesc,
+  RigidBodyDesc
+} from "@dimforge/rapier3d-compat";
+import {
+  DestructibleMesh,
+  FractureOptions as PinataFractureOptions
+} from "@dgreenheck/three-pinata";
+import {
+  Box3,
+  BufferAttribute,
+  Group,
+  Matrix4,
+  Quaternion as Quaternion2,
+  Vector2,
+  Vector3
+} from "three";
+import * as Comlink from "comlink";
+
+// src/lib/physics/physics-pose.ts
+import { Quaternion } from "three";
+var directBodyPoseHistory = /* @__PURE__ */ new WeakMap();
+var _previousQuaternion = new Quaternion();
+var _currentQuaternion = new Quaternion();
+var _renderQuaternion = new Quaternion();
+function clonePhysicsVector3(vector) {
+  return { x: vector.x, y: vector.y, z: vector.z };
+}
+function clonePhysicsQuaternion(rotation) {
+  return { x: rotation.x, y: rotation.y, z: rotation.z, w: rotation.w };
+}
+function clonePhysicsPose(pose) {
+  return {
+    position: clonePhysicsVector3(pose.position),
+    rotation: clonePhysicsQuaternion(pose.rotation)
+  };
+}
+function clampInterpolationAlpha(alpha) {
+  if (!Number.isFinite(alpha)) return 0;
+  return Math.max(0, Math.min(1, alpha));
+}
+function capturePhysicsPose(body) {
+  return {
+    position: clonePhysicsVector3(body.translation()),
+    rotation: clonePhysicsQuaternion(body.rotation())
+  };
+}
+function createCollapsedPhysicsPoseHistory(pose) {
+  const current = clonePhysicsPose(pose);
+  return {
+    previous: clonePhysicsPose(current),
+    current
+  };
+}
+function collapseDirectBodyPoseHistory(body) {
+  const pose = capturePhysicsPose(body);
+  const history = directBodyPoseHistory.get(body) ?? createCollapsedPhysicsPoseHistory(pose);
+  history.previous = clonePhysicsPose(pose);
+  history.current = clonePhysicsPose(pose);
+  directBodyPoseHistory.set(body, history);
+  return history;
+}
+function interpolatePhysicsPose(previous, current, alpha) {
+  const t = clampInterpolationAlpha(alpha);
+  _previousQuaternion.set(
+    previous.rotation.x,
+    previous.rotation.y,
+    previous.rotation.z,
+    previous.rotation.w
+  );
+  _currentQuaternion.set(
+    current.rotation.x,
+    current.rotation.y,
+    current.rotation.z,
+    current.rotation.w
+  );
+  _renderQuaternion.slerpQuaternions(
+    _previousQuaternion,
+    _currentQuaternion,
+    t
+  );
+  return {
+    position: {
+      x: previous.position.x + (current.position.x - previous.position.x) * t,
+      y: previous.position.y + (current.position.y - previous.position.y) * t,
+      z: previous.position.z + (current.position.z - previous.position.z) * t
+    },
+    rotation: {
+      x: _renderQuaternion.x,
+      y: _renderQuaternion.y,
+      z: _renderQuaternion.z,
+      w: _renderQuaternion.w
+    }
+  };
+}
+function getBodyRenderPose(body, alpha) {
+  if (isRenderPoseProvider(body)) {
+    return body.getRenderPose(alpha);
+  }
+  const history = directBodyPoseHistory.get(body);
+  if (!history) {
+    return capturePhysicsPose(body);
+  }
+  const latestPose = capturePhysicsPose(body);
+  if (!posesEqual(latestPose, history.current)) {
+    const collapsed = collapseDirectBodyPoseHistory(body);
+    return clonePhysicsPose(collapsed.current);
+  }
+  return interpolatePhysicsPose(history.previous, history.current, alpha);
+}
+function isRenderPoseProvider(value) {
+  return value != null && typeof value === "object" && typeof value.getPoseHistory === "function" && typeof value.getRenderPose === "function";
+}
+function posesEqual(a, b) {
+  return a.position.x === b.position.x && a.position.y === b.position.y && a.position.z === b.position.z && a.rotation.x === b.rotation.x && a.rotation.y === b.rotation.y && a.rotation.z === b.rotation.z && a.rotation.w === b.rotation.w;
+}
+
+// src/lib/behaviors/destructible-3d/destructible-3d.descriptor.ts
+var DESTRUCTIBLE_3D_BEHAVIOR_KEY = /* @__PURE__ */ Symbol.for(
+  "zylem:behavior:destructible-3d"
+);
+var DEFAULT_FRACTURE_OPTIONS = {
+  fractureMethod: "voronoi",
+  fragmentCount: 12,
+  voronoiOptions: {
+    mode: "3D"
+  },
+  fracturePlanes: {
+    x: true,
+    y: true,
+    z: true
+  },
+  textureScale: new Vector2(1, 1),
+  textureOffset: new Vector2(0, 0)
+};
+var DEFAULT_FRAGMENT_PHYSICS = {
+  mode: "compound",
+  inheritSourceVelocity: true,
+  outwardVelocity: 3,
+  angularVelocity: 1.5
+};
+var defaultOptions = {
+  fractureOptions: DEFAULT_FRACTURE_OPTIONS,
+  innerMaterial: null,
+  collider: {
+    shape: "convexHull",
+    sensor: false,
+    activeCollisionTypes: ActiveCollisionTypes.DEFAULT
+  },
+  fragmentPhysics: DEFAULT_FRAGMENT_PHYSICS
+};
+var runtimeStates = /* @__PURE__ */ new WeakMap();
+function getRuntimeState(ref) {
+  const existing = runtimeStates.get(ref);
+  if (existing) {
+    return existing;
+  }
+  const state = {
+    fragmentContainer: null,
+    fragmentEntities: [],
+    fragments: [],
+    prebakedFragments: [],
+    prebakedFractureKey: null,
+    createdRootGroup: false,
+    fractureMode: null,
+    isFractured: false,
+    originalMeshParent: null,
+    originalColliderDesc: void 0,
+    originalColliderDescs: [],
+    originalMeshVisible: true,
+    originalGroupVisible: true,
+    sourceBodySnapshot: null,
+    sourcePhysicsAttached: false
+  };
+  runtimeStates.set(ref, state);
+  return state;
+}
+var prebakeWorkerApis = /* @__PURE__ */ new Map();
+var prebakeAsyncInFlight = /* @__PURE__ */ new WeakMap();
+function resolvePrebakeWorkerHref(url) {
+  return typeof url === "string" ? url : url.href;
+}
+function getPrebakeWorkerApi(url) {
+  if (typeof Worker === "undefined") {
+    throw new Error(
+      "Destructible3D prebakeAsync requires a Web Worker-capable environment."
+    );
+  }
+  const key = resolvePrebakeWorkerHref(url);
+  let api = prebakeWorkerApis.get(key);
+  if (api) {
+    return api;
+  }
+  const worker = new Worker(key, { type: "module" });
+  api = Comlink.wrap(worker);
+  prebakeWorkerApis.set(key, api);
+  return api;
+}
+function requireEntity(ref) {
+  const entity = ref.__entity;
+  if (!entity) {
+    throw new Error(
+      "Destructible3DBehavior requires the entity to be registered on a stage before calling fracture() or repair()."
+    );
+  }
+  return entity;
+}
+function getBehaviorWorld(ref) {
+  return ref.__world ?? null;
+}
+function getBehaviorScene(ref) {
+  return ref.__scene ?? null;
+}
+function getBehaviorCreateEntity(ref) {
+  return ref.__createEntity ?? null;
+}
+function getBehaviorGlobals(ref) {
+  return ref.__getGlobals ?? null;
+}
+function cloneFractureOptionsInput(value) {
+  if (!value) {
+    return {};
+  }
+  if (value instanceof PinataFractureOptions) {
+    return {
+      fractureMethod: value.fractureMethod,
+      fragmentCount: value.fragmentCount,
+      voronoiOptions: value.voronoiOptions ? {
+        mode: value.voronoiOptions.mode,
+        seedPoints: value.voronoiOptions.seedPoints?.map((point) => point.clone()),
+        impactPoint: value.voronoiOptions.impactPoint?.clone(),
+        impactRadius: value.voronoiOptions.impactRadius,
+        projectionAxis: value.voronoiOptions.projectionAxis,
+        projectionNormal: value.voronoiOptions.projectionNormal?.clone(),
+        useApproximation: value.voronoiOptions.useApproximation,
+        approximationNeighborCount: value.voronoiOptions.approximationNeighborCount
+      } : void 0,
+      fracturePlanes: value.fracturePlanes ? { ...value.fracturePlanes } : void 0,
+      textureScale: value.textureScale?.clone(),
+      textureOffset: value.textureOffset?.clone(),
+      seed: value.seed
+    };
+  }
+  return {
+    ...value,
+    voronoiOptions: value.voronoiOptions ? {
+      ...value.voronoiOptions,
+      seedPoints: value.voronoiOptions.seedPoints?.map((point) => point.clone()),
+      impactPoint: value.voronoiOptions.impactPoint?.clone(),
+      projectionNormal: value.voronoiOptions.projectionNormal?.clone()
+    } : void 0,
+    fracturePlanes: value.fracturePlanes ? { ...value.fracturePlanes } : void 0,
+    textureScale: value.textureScale?.clone(),
+    textureOffset: value.textureOffset?.clone()
+  };
+}
+function resolveFractureOptions(baseValue, overrideValue) {
+  const base = cloneFractureOptionsInput(baseValue);
+  const override = cloneFractureOptionsInput(overrideValue);
+  const fractureMethod = override.fractureMethod ?? base.fractureMethod ?? DEFAULT_FRACTURE_OPTIONS.fractureMethod ?? "voronoi";
+  const voronoiOptions = fractureMethod === "voronoi" ? {
+    mode: override.voronoiOptions?.mode ?? base.voronoiOptions?.mode ?? DEFAULT_FRACTURE_OPTIONS.voronoiOptions?.mode ?? "3D",
+    seedPoints: override.voronoiOptions?.seedPoints ?? base.voronoiOptions?.seedPoints,
+    impactPoint: override.voronoiOptions?.impactPoint ?? base.voronoiOptions?.impactPoint,
+    impactRadius: override.voronoiOptions?.impactRadius ?? base.voronoiOptions?.impactRadius,
+    projectionAxis: override.voronoiOptions?.projectionAxis ?? base.voronoiOptions?.projectionAxis,
+    projectionNormal: override.voronoiOptions?.projectionNormal ?? base.voronoiOptions?.projectionNormal,
+    useApproximation: override.voronoiOptions?.useApproximation ?? base.voronoiOptions?.useApproximation,
+    approximationNeighborCount: override.voronoiOptions?.approximationNeighborCount ?? base.voronoiOptions?.approximationNeighborCount
+  } : void 0;
+  return new PinataFractureOptions({
+    fractureMethod,
+    fragmentCount: override.fragmentCount ?? base.fragmentCount ?? DEFAULT_FRACTURE_OPTIONS.fragmentCount ?? 12,
+    voronoiOptions,
+    fracturePlanes: {
+      x: override.fracturePlanes?.x ?? base.fracturePlanes?.x ?? DEFAULT_FRACTURE_OPTIONS.fracturePlanes?.x ?? true,
+      y: override.fracturePlanes?.y ?? base.fracturePlanes?.y ?? DEFAULT_FRACTURE_OPTIONS.fracturePlanes?.y ?? true,
+      z: override.fracturePlanes?.z ?? base.fracturePlanes?.z ?? DEFAULT_FRACTURE_OPTIONS.fracturePlanes?.z ?? true
+    },
+    textureScale: override.textureScale?.clone() ?? base.textureScale?.clone() ?? DEFAULT_FRACTURE_OPTIONS.textureScale?.clone() ?? new Vector2(1, 1),
+    textureOffset: override.textureOffset?.clone() ?? base.textureOffset?.clone() ?? DEFAULT_FRACTURE_OPTIONS.textureOffset?.clone() ?? new Vector2(0, 0),
+    seed: override.seed ?? base.seed
+  });
+}
+function resolveColliderOptions(input) {
+  return {
+    shape: input?.shape ?? defaultOptions.collider?.shape ?? "convexHull",
+    sensor: input?.sensor ?? defaultOptions.collider?.sensor ?? false,
+    collisionGroups: input?.collisionGroups,
+    activeCollisionTypes: input?.activeCollisionTypes ?? defaultOptions.collider?.activeCollisionTypes ?? ActiveCollisionTypes.DEFAULT
+  };
+}
+function resolveFragmentPhysicsOptions(input) {
+  return {
+    mode: input?.mode ?? DEFAULT_FRAGMENT_PHYSICS.mode,
+    inheritSourceVelocity: input?.inheritSourceVelocity ?? DEFAULT_FRAGMENT_PHYSICS.inheritSourceVelocity,
+    outwardVelocity: input?.outwardVelocity ?? DEFAULT_FRAGMENT_PHYSICS.outwardVelocity,
+    angularVelocity: input?.angularVelocity ?? DEFAULT_FRAGMENT_PHYSICS.angularVelocity
+  };
+}
+function findFirstMesh(root) {
+  let resolved = null;
+  root?.traverse((child) => {
+    if (resolved) {
+      return;
+    }
+    if (child.isMesh) {
+      resolved = child;
+    }
+  });
+  return resolved;
+}
+function requireEntityMesh(entity) {
+  if (entity.mesh?.geometry) {
+    return entity.mesh;
+  }
+  const mesh = findFirstMesh(entity.group);
+  if (!mesh?.geometry) {
+    throw new Error(
+      "Destructible3DBehavior requires the entity to have a primary mesh geometry."
+    );
+  }
+  entity.mesh = mesh;
+  if (!entity.materials?.length) {
+    if (Array.isArray(mesh.material)) {
+      entity.materials = [...mesh.material];
+    } else if (mesh.material) {
+      entity.materials = [mesh.material];
+    }
+  }
+  return mesh;
+}
+function getPrimaryMaterial(mesh) {
+  if (Array.isArray(mesh.material)) {
+    const material = mesh.material[0];
+    if (material) {
+      return material;
+    }
+  } else if (mesh.material) {
+    return mesh.material;
+  }
+  throw new Error(
+    "Destructible3DBehavior requires the entity mesh to have a material."
+  );
+}
+function ensureRootGroup(entity, state) {
+  if (entity.group) {
+    state.createdRootGroup = false;
+    return entity.group;
+  }
+  const originalMesh = requireEntityMesh(entity);
+  const parent = originalMesh.parent;
+  const root = new Group();
+  root.name = `${entity.name ?? entity.uuid}-destructible-root`;
+  root.position.copy(originalMesh.position);
+  root.quaternion.copy(originalMesh.quaternion);
+  root.scale.copy(originalMesh.scale);
+  originalMesh.position.set(0, 0, 0);
+  originalMesh.quaternion.identity();
+  originalMesh.scale.set(1, 1, 1);
+  if (parent) {
+    parent.remove(originalMesh);
+    parent.add(root);
+  }
+  root.add(originalMesh);
+  entity.group = root;
+  state.createdRootGroup = true;
+  return root;
+}
+function createFractureSourceMesh(mesh, root, innerMaterial) {
+  const geometry = buildNormalizedFractureSourceGeometry(mesh, root);
+  const outerMaterial = getPrimaryMaterial(mesh);
+  return new DestructibleMesh(
+    geometry,
+    outerMaterial,
+    innerMaterial ?? outerMaterial
+  );
+}
+function createPrebakedFragmentTemplates(fragments) {
+  return fragments.map((fragment) => {
+    const geometry = fragment.geometry.clone();
+    geometry.computeBoundingBox();
+    geometry.computeBoundingSphere();
+    return {
+      geometry,
+      position: fragment.position.clone(),
+      quaternion: fragment.quaternion.clone(),
+      scale: fragment.scale.clone()
+    };
+  });
+}
+function disposePrebakedFragmentTemplates(templates) {
+  for (const template of templates) {
+    template.geometry.dispose();
+  }
+}
+function cachePrebakedFragments(state, cacheKey, fragments) {
+  if (state.prebakedFractureKey === cacheKey && state.prebakedFragments.length > 0) {
+    return;
+  }
+  disposePrebakedFragmentTemplates(state.prebakedFragments);
+  state.prebakedFragments = createPrebakedFragmentTemplates(fragments);
+  state.prebakedFractureKey = cacheKey;
+}
+function installPrebakedTemplateParts(state, cacheKey, parts) {
+  if (state.prebakedFractureKey === cacheKey && state.prebakedFragments.length > 0) {
+    for (const part of parts) {
+      part.geometry.dispose();
+    }
+    return;
+  }
+  disposePrebakedFragmentTemplates(state.prebakedFragments);
+  state.prebakedFragments = parts.map((part) => ({
+    geometry: part.geometry,
+    position: part.position.clone(),
+    quaternion: part.quaternion.clone(),
+    scale: part.scale.clone()
+  }));
+  state.prebakedFractureKey = cacheKey;
+}
+function instantiatePrebakedFragments(mesh, innerMaterial, templates) {
+  const outerMaterial = getPrimaryMaterial(mesh);
+  return templates.map((template) => {
+    const fragment = new DestructibleMesh(
+      template.geometry.clone(),
+      outerMaterial,
+      innerMaterial ?? outerMaterial
+    );
+    fragment.position.copy(template.position);
+    fragment.quaternion.copy(template.quaternion);
+    fragment.scale.copy(template.scale);
+    return fragment;
+  });
+}
+function tagConvexHullCollider(colliderDesc, vertices) {
+  colliderDesc.__zylemShapeData = {
+    shape: "convexHull",
+    vertices: Array.from(vertices)
+  };
+  return colliderDesc;
+}
+function tagTrimeshCollider(colliderDesc, vertices, indices) {
+  colliderDesc.__zylemShapeData = {
+    shape: "trimesh",
+    vertices: Array.from(vertices),
+    indices: Array.from(indices)
+  };
+  return colliderDesc;
+}
+function getFragmentVertices(fragment) {
+  const position = fragment.geometry.getAttribute("position");
+  if (!(position instanceof BufferAttribute)) {
+    throw new Error("Fragment geometry is missing a position attribute.");
+  }
+  return new Float32Array(position.array);
+}
+function getFragmentIndices(fragment) {
+  const geometryIndex = fragment.geometry.getIndex();
+  if (geometryIndex) {
+    return new Uint32Array(geometryIndex.array);
+  }
+  const position = fragment.geometry.getAttribute("position");
+  if (!(position instanceof BufferAttribute)) {
+    return new Uint32Array();
+  }
+  return Uint32Array.from({ length: position.count }, (_value, index) => index);
+}
+function createCuboidCollider(fragment) {
+  const bounds = fragment.geometry.boundingBox ?? new Box3();
+  if (!fragment.geometry.boundingBox) {
+    fragment.geometry.computeBoundingBox();
+  }
+  bounds.copy(fragment.geometry.boundingBox ?? bounds);
+  const size = bounds.getSize(new Vector3());
+  return ColliderDesc.cuboid(
+    Math.max(size.x / 2, 1e-3),
+    Math.max(size.y / 2, 1e-3),
+    Math.max(size.z / 2, 1e-3)
+  );
+}
+function createFragmentColliderDesc(fragment, options, translation) {
+  const resolved = resolveColliderOptions(options);
+  const vertices = getFragmentVertices(fragment);
+  let colliderDesc = null;
+  if (resolved.shape === "convexHull") {
+    colliderDesc = ColliderDesc.convexHull(vertices);
+    if (colliderDesc) {
+      colliderDesc = tagConvexHullCollider(colliderDesc, vertices);
+    }
+  }
+  if (!colliderDesc && resolved.shape === "trimesh") {
+    const indices = getFragmentIndices(fragment);
+    colliderDesc = tagTrimeshCollider(
+      ColliderDesc.trimesh(vertices, indices),
+      vertices,
+      indices
+    );
+  }
+  if (!colliderDesc) {
+    colliderDesc = createCuboidCollider(fragment);
+  }
+  if (translation) {
+    colliderDesc.setTranslation(
+      translation.x,
+      translation.y,
+      translation.z
+    );
+  }
+  colliderDesc.setSensor(resolved.sensor);
+  if (resolved.collisionGroups !== void 0) {
+    colliderDesc.setCollisionGroups(resolved.collisionGroups);
+  }
+  colliderDesc.activeCollisionTypes = resolved.activeCollisionTypes;
+  return colliderDesc;
+}
+function snapshotBody(entity) {
+  if (!entity.body) {
+    return null;
+  }
+  const translation = entity.body.translation();
+  const rotation = entity.body.rotation();
+  const linearVelocity = entity.body.linvel();
+  const angularVelocity = entity.body.angvel();
+  return {
+    translation: { ...translation },
+    rotation: { ...rotation },
+    linearVelocity: { ...linearVelocity },
+    angularVelocity: { ...angularVelocity }
+  };
+}
+function restoreBodySnapshot(entity, snapshot) {
+  if (!snapshot || !entity.body) {
+    return;
+  }
+  entity.body.setTranslation(snapshot.translation, true);
+  entity.body.setRotation(snapshot.rotation, true);
+  entity.body.setLinvel(snapshot.linearVelocity, true);
+  entity.body.setAngvel(snapshot.angularVelocity, true);
+}
+function attachEntityPhysics(ref, entity, snapshot) {
+  const world = getBehaviorWorld(ref);
+  if (!world || !entity.colliderDesc) {
+    return;
+  }
+  if (entity.physicsAttached) {
+    world.destroyEntity(entity);
+  }
+  world.addEntity(entity);
+  restoreBodySnapshot(entity, snapshot);
+}
+function detachEntityPhysics(ref, entity) {
+  const world = getBehaviorWorld(ref);
+  if (!world || !entity.physicsAttached) {
+    return;
+  }
+  world.destroyEntity(entity);
+}
+function disposeFragments(fragments) {
+  for (const fragment of fragments) {
+    fragment.removeFromParent();
+    fragment.geometry.dispose();
+  }
+}
+function syncRuntimeFragmentEntityTransform(entity, interpolationAlpha) {
+  const target = entity.group ?? entity.mesh;
+  if (!target) {
+    return;
+  }
+  const wasmPose = entity.getPose?.();
+  if (wasmPose && entity.runtimeHandle >= 0) {
+    target.position.set(wasmPose.position.x, wasmPose.position.y, wasmPose.position.z);
+    target.quaternion.set(wasmPose.rotation.x, wasmPose.rotation.y, wasmPose.rotation.z, wasmPose.rotation.w);
+    return;
+  }
+  if (!entity.body) {
+    return;
+  }
+  const pose = getBodyRenderPose(entity.body, interpolationAlpha);
+  target.position.set(pose.position.x, pose.position.y, pose.position.z);
+  target.quaternion.set(pose.rotation.x, pose.rotation.y, pose.rotation.z, pose.rotation.w);
+}
+function bakeScaleIntoFragmentGeometry(fragment, scale) {
+  if (Math.abs(scale.x - 1) < 1e-6 && Math.abs(scale.y - 1) < 1e-6 && Math.abs(scale.z - 1) < 1e-6) {
+    return;
+  }
+  fragment.geometry.applyMatrix4(
+    new Matrix4().makeScale(scale.x, scale.y, scale.z)
+  );
+  fragment.geometry.computeBoundingBox();
+  fragment.geometry.computeBoundingSphere();
+}
+function getRootWorldPosition(root) {
+  root.updateMatrixWorld(true);
+  return root.getWorldPosition(new Vector3());
+}
+function getImpactPointWorld(root, fractureOptions) {
+  const localImpactPoint = fractureOptions.voronoiOptions?.impactPoint;
+  if (!localImpactPoint) {
+    return null;
+  }
+  root.updateMatrixWorld(true);
+  return localImpactPoint.clone().applyMatrix4(root.matrixWorld);
+}
+function computeFragmentWorldPose(root, fragment) {
+  root.updateMatrixWorld(true);
+  fragment.updateMatrix();
+  const worldMatrix = new Matrix4().copy(root.matrixWorld).multiply(fragment.matrix);
+  const position = new Vector3();
+  const rotation = new Quaternion2();
+  const scale = new Vector3();
+  worldMatrix.decompose(position, rotation, scale);
+  return {
+    position,
+    rotation,
+    scale
+  };
+}
+function pseudoRandomSigned(index, salt) {
+  const value = Math.sin((index + 1) * 12.9898 + salt * 78.233) * 43758.5453;
+  return (value - Math.floor(value)) * 2 - 1;
+}
+function computeFragmentAngularVelocity(index, magnitude) {
+  if (magnitude <= 0) {
+    return { x: 0, y: 0, z: 0 };
+  }
+  const axis = new Vector3(
+    pseudoRandomSigned(index, 0.13),
+    pseudoRandomSigned(index, 0.47),
+    pseudoRandomSigned(index, 0.91)
+  );
+  if (axis.lengthSq() <= 1e-6) {
+    axis.set(0.35, 1, 0.2);
+  }
+  axis.normalize().multiplyScalar(magnitude);
+  return {
+    x: axis.x,
+    y: axis.y,
+    z: axis.z
+  };
+}
+function computeFragmentLinearVelocity(fragmentWorldPosition, rootWorldPosition, impactPointWorld, physicsOptions, sourceVelocity) {
+  const velocity = new Vector3();
+  if (physicsOptions.inheritSourceVelocity && sourceVelocity) {
+    velocity.set(
+      sourceVelocity.x,
+      sourceVelocity.y,
+      sourceVelocity.z
+    );
+  }
+  if (physicsOptions.outwardVelocity <= 0) {
+    return {
+      x: velocity.x,
+      y: velocity.y,
+      z: velocity.z
+    };
+  }
+  const direction = fragmentWorldPosition.clone().sub(
+    impactPointWorld ?? rootWorldPosition
+  );
+  if (direction.lengthSq() <= 1e-6) {
+    direction.copy(fragmentWorldPosition).sub(rootWorldPosition);
+  }
+  if (direction.lengthSq() <= 1e-6) {
+    direction.set(0, 1, 0);
+  }
+  direction.normalize().multiplyScalar(physicsOptions.outwardVelocity);
+  velocity.add(direction);
+  return {
+    x: velocity.x,
+    y: velocity.y,
+    z: velocity.z
+  };
+}
+function createRuntimeFragmentEntity(createEntity, parentEntity, fragment, index, colliderOptions, position, rotation) {
+  const entity = createEntity({
+    name: `${parentEntity.name ?? parentEntity.uuid}-fragment-${index}`
+  });
+  entity.onCleanup(() => {
+    fragment.removeFromParent();
+    fragment.geometry.dispose();
+  });
+  entity.create();
+  entity.mesh = fragment;
+  if (Array.isArray(fragment.material)) {
+    entity.materials = [...fragment.material];
+  } else if (fragment.material) {
+    entity.materials = [fragment.material];
+  }
+  entity.colliderDesc = createFragmentColliderDesc(fragment, colliderOptions);
+  entity.colliderDescs = [entity.colliderDesc];
+  entity.bodyDesc = RigidBodyDesc.dynamic().setTranslation(position.x, position.y, position.z).setCanSleep(false).setCcdEnabled(true);
+  fragment.position.set(0, 0, 0);
+  fragment.quaternion.identity();
+  fragment.scale.set(1, 1, 1);
+  entity.bodyDesc.setRotation({
+    x: rotation.x,
+    y: rotation.y,
+    z: rotation.z,
+    w: rotation.w
+  });
+  return entity;
+}
+function unlockIndependentFragmentPhysicsBody(entity) {
+  const body = entity.body;
+  if (!body?.lockTranslations || !body.lockRotations) {
+    return;
+  }
+  body.lockTranslations(false, true);
+  body.lockRotations(false, true);
+}
+function destroyRuntimeFragmentEntities(ref, state) {
+  const world = getBehaviorWorld(ref);
+  const scene = getBehaviorScene(ref);
+  const handledFragments = /* @__PURE__ */ new Set();
+  for (const fragmentEntity of state.fragmentEntities) {
+    const fragmentMesh = fragmentEntity.mesh;
+    if (fragmentMesh) {
+      handledFragments.add(fragmentMesh);
+    }
+    try {
+      fragmentEntity.nodeDestroy({
+        me: fragmentEntity,
+        globals: getBehaviorGlobals(ref)?.() ?? {}
+      });
+    } catch {
+    }
+    if (world && fragmentEntity.physicsAttached) {
+      world.destroyEntity(fragmentEntity);
+    }
+    const target = fragmentEntity.group ?? fragmentEntity.mesh;
+    if (target) {
+      target.removeFromParent();
+      scene?.scene.remove(target);
+    }
+  }
+  for (const fragment of state.fragments) {
+    if (handledFragments.has(fragment)) {
+      continue;
+    }
+    fragment.removeFromParent();
+    fragment.geometry.dispose();
+  }
+  state.fragmentEntities = [];
+}
+function restoreOriginalMesh(entity, state) {
+  if (!entity.mesh) {
+    return;
+  }
+  if (state.createdRootGroup && entity.group) {
+    const root = entity.group;
+    const parent2 = root.parent;
+    entity.mesh.position.copy(root.position);
+    entity.mesh.quaternion.copy(root.quaternion);
+    entity.mesh.scale.copy(root.scale);
+    entity.mesh.removeFromParent();
+    if (parent2) {
+      parent2.remove(root);
+      parent2.add(entity.mesh);
+    }
+    entity.group = void 0;
+    return;
+  }
+  const parent = state.originalMeshParent ?? entity.group;
+  if (parent && entity.mesh.parent !== parent) {
+    parent.add(entity.mesh);
+  }
+}
+function restoreRuntimeState(ref, refreshPhysics) {
+  const state = getRuntimeState(ref);
+  if (!state.isFractured) {
+    return;
+  }
+  const entity = requireEntity(ref);
+  if (state.fractureMode === "independent") {
+    destroyRuntimeFragmentEntities(ref, state);
+  } else {
+    state.fragmentContainer?.removeFromParent();
+    state.fragmentContainer?.clear();
+    disposeFragments(state.fragments);
+  }
+  state.fragmentContainer = null;
+  state.fragments = [];
+  restoreOriginalMesh(entity, state);
+  if (entity.mesh) {
+    entity.mesh.visible = state.originalMeshVisible;
+  }
+  if (entity.group) {
+    entity.group.visible = state.originalGroupVisible;
+  }
+  entity.colliderDesc = state.originalColliderDesc;
+  entity.colliderDescs = [...state.originalColliderDescs];
+  if (!entity.colliderDesc && entity.colliderDescs.length > 0) {
+    entity.colliderDesc = entity.colliderDescs[0];
+  }
+  if (refreshPhysics && state.sourcePhysicsAttached) {
+    attachEntityPhysics(ref, entity, state.sourceBodySnapshot);
+  }
+  state.createdRootGroup = false;
+  state.fractureMode = null;
+  state.originalMeshParent = null;
+  state.originalColliderDesc = void 0;
+  state.originalColliderDescs = [];
+  state.originalMeshVisible = true;
+  state.originalGroupVisible = true;
+  state.sourceBodySnapshot = null;
+  state.sourcePhysicsAttached = false;
+  state.isFractured = false;
+}
+function disposeRuntimeState(state) {
+  disposePrebakedFragmentTemplates(state.prebakedFragments);
+  state.prebakedFragments = [];
+  state.prebakedFractureKey = null;
+}
+function fractureCompoundEntity(ref, entity, root, fragments, state) {
+  const fragmentContainer = new Group();
+  fragmentContainer.name = `${entity.name ?? entity.uuid}-fracture-fragments`;
+  for (const fragment of fragments) {
+    fragmentContainer.add(fragment);
+  }
+  entity.mesh?.removeFromParent();
+  root.add(fragmentContainer);
+  state.fragmentContainer = fragmentContainer;
+  state.fractureMode = "compound";
+  const colliderDescs = fragments.map((fragment) => createFragmentColliderDesc(
+    fragment,
+    ref.options.collider,
+    fragment.position
+  ));
+  if (colliderDescs.length > 0) {
+    entity.colliderDescs = colliderDescs;
+    entity.colliderDesc = colliderDescs[0];
+    if (state.sourcePhysicsAttached) {
+      attachEntityPhysics(ref, entity, state.sourceBodySnapshot);
+    }
+  }
+}
+function fractureIndependentEntity(ref, entity, root, fractureOptions, fragments, state) {
+  const world = getBehaviorWorld(ref);
+  const scene = getBehaviorScene(ref);
+  if (!world || !scene) {
+    throw new Error(
+      "Destructible3DBehavior independent fragments require an active scene and physics world."
+    );
+  }
+  const createEntity = getBehaviorCreateEntity(ref);
+  if (!createEntity) {
+    throw new Error(
+      "Destructible3DBehavior independent fragments require a host entity factory (BehaviorSystemContext.createEntity)."
+    );
+  }
+  const physicsOptions = resolveFragmentPhysicsOptions(ref.options.fragmentPhysics);
+  const rootWorldPosition = getRootWorldPosition(root);
+  const impactPointWorld = getImpactPointWorld(root, fractureOptions);
+  const sourceVelocity = state.sourceBodySnapshot?.linearVelocity ?? null;
+  if (entity.mesh) {
+    entity.mesh.visible = false;
+  }
+  if (state.sourcePhysicsAttached) {
+    detachEntityPhysics(ref, entity);
+  }
+  const fragmentEntities = [];
+  for (const [index, fragment] of fragments.entries()) {
+    const fragmentWorldPose = computeFragmentWorldPose(root, fragment);
+    bakeScaleIntoFragmentGeometry(fragment, fragmentWorldPose.scale);
+    const fragmentEntity = createRuntimeFragmentEntity(
+      createEntity,
+      entity,
+      fragment,
+      index,
+      ref.options.collider,
+      fragmentWorldPose.position,
+      fragmentWorldPose.rotation
+    );
+    world.addEntity(fragmentEntity);
+    unlockIndependentFragmentPhysicsBody(fragmentEntity);
+    const linearVelocity = computeFragmentLinearVelocity(
+      fragmentWorldPose.position,
+      rootWorldPosition,
+      impactPointWorld,
+      physicsOptions,
+      sourceVelocity
+    );
+    fragmentEntity.body?.setLinvel(linearVelocity, true);
+    fragmentEntity.body?.setAngvel(
+      computeFragmentAngularVelocity(
+        index,
+        physicsOptions.angularVelocity
+      ),
+      true
+    );
+    syncRuntimeFragmentEntityTransform(
+      fragmentEntity,
+      world.interpolationAlpha ?? 0
+    );
+    const target = fragmentEntity.group ?? fragmentEntity.mesh;
+    if (target) {
+      target.removeFromParent();
+      scene.scene.add(target);
+    }
+    fragmentEntities.push(fragmentEntity);
+  }
+  state.fragmentEntities = fragmentEntities;
+  state.fractureMode = "independent";
+}
+function fractureEntity(ref, overrideOptions) {
+  const entity = requireEntity(ref);
+  if (entity.isInstanced) {
+    throw new Error(
+      "Destructible3DBehavior does not support entities using instanced rendering."
+    );
+  }
+  const state = getRuntimeState(ref);
+  if (state.isFractured) {
+    restoreRuntimeState(ref, true);
+  }
+  const sourceMesh = requireEntityMesh(entity);
+  const fractureOptions = resolveFractureOptions(
+    ref.options.fractureOptions,
+    overrideOptions
+  );
+  const cacheKey = buildFractureGeometryCacheKey(fractureOptions);
+  const root = ensureRootGroup(entity, state);
+  state.originalMeshParent = sourceMesh.parent;
+  state.originalColliderDesc = entity.colliderDesc;
+  state.originalColliderDescs = entity.colliderDescs.length > 0 ? [...entity.colliderDescs] : entity.colliderDesc ? [entity.colliderDesc] : [];
+  state.originalMeshVisible = sourceMesh.visible;
+  state.originalGroupVisible = entity.group?.visible ?? true;
+  state.sourceBodySnapshot = snapshotBody(entity);
+  state.sourcePhysicsAttached = entity.physicsAttached;
+  const usePrebakedFragments = state.prebakedFractureKey === cacheKey && state.prebakedFragments.length > 0;
+  const source = usePrebakedFragments ? null : createFractureSourceMesh(
+    sourceMesh,
+    root,
+    ref.options.innerMaterial
+  );
+  try {
+    const fragmentPhysics = resolveFragmentPhysicsOptions(
+      ref.options.fragmentPhysics
+    );
+    const fragments = usePrebakedFragments ? instantiatePrebakedFragments(
+      sourceMesh,
+      ref.options.innerMaterial,
+      state.prebakedFragments
+    ) : source.fracture(fractureOptions);
+    cachePrebakedFragments(state, cacheKey, fragments);
+    state.fragments = [...fragments];
+    state.isFractured = true;
+    if (fragmentPhysics.mode === "independent") {
+      fractureIndependentEntity(
+        ref,
+        entity,
+        root,
+        fractureOptions,
+        fragments,
+        state
+      );
+    } else {
+      fractureCompoundEntity(
+        ref,
+        entity,
+        root,
+        fragments,
+        state
+      );
+    }
+    return fragments;
+  } catch (error) {
+    restoreRuntimeState(ref, true);
+    throw error;
+  } finally {
+    source?.geometry.dispose();
+  }
+}
+function prebakeEntityGeometryOnly(ref, overrideOptions) {
+  const entity = requireEntity(ref);
+  if (entity.isInstanced) {
+    throw new Error(
+      "Destructible3DBehavior does not support entities using instanced rendering."
+    );
+  }
+  const state = getRuntimeState(ref);
+  if (state.isFractured) {
+    return;
+  }
+  const fractureOptions = resolveFractureOptions(
+    ref.options.fractureOptions,
+    overrideOptions
+  );
+  const cacheKey = buildFractureGeometryCacheKey(fractureOptions);
+  if (state.prebakedFractureKey === cacheKey && state.prebakedFragments.length > 0) {
+    return;
+  }
+  const sourceMesh = requireEntityMesh(entity);
+  const root = ensureRootGroup(entity, state);
+  const createdRootGroup = state.createdRootGroup;
+  const source = createFractureSourceMesh(
+    sourceMesh,
+    root,
+    ref.options.innerMaterial
+  );
+  try {
+    const fragments = source.fracture(fractureOptions);
+    cachePrebakedFragments(state, cacheKey, fragments);
+    for (const fragment of fragments) {
+      fragment.geometry.dispose();
+    }
+  } finally {
+    source.geometry.dispose();
+  }
+  if (createdRootGroup) {
+    restoreOriginalMesh(entity, state);
+    state.createdRootGroup = false;
+  }
+}
+async function prebakeEntityAsync(ref, overrideOptions) {
+  const workerUrl = ref.options.prebakeWorkerUrl;
+  if (!workerUrl) {
+    prebakeEntityGeometryOnly(ref, overrideOptions);
+    return;
+  }
+  const existing = prebakeAsyncInFlight.get(ref);
+  if (existing) {
+    await existing;
+    return;
+  }
+  const job = (async () => {
+    const entity = requireEntity(ref);
+    if (entity.isInstanced) {
+      throw new Error(
+        "Destructible3DBehavior does not support entities using instanced rendering."
+      );
+    }
+    const state = getRuntimeState(ref);
+    if (state.isFractured) {
+      return;
+    }
+    const fractureOptions = resolveFractureOptions(
+      ref.options.fractureOptions,
+      overrideOptions
+    );
+    const cacheKey = buildFractureGeometryCacheKey(fractureOptions);
+    if (state.prebakedFractureKey === cacheKey && state.prebakedFragments.length > 0) {
+      return;
+    }
+    const sourceMesh = requireEntityMesh(entity);
+    const root = ensureRootGroup(entity, state);
+    const createdRootGroup = state.createdRootGroup;
+    const normalizedGeometry = buildNormalizedFractureSourceGeometry(
+      sourceMesh,
+      root
+    );
+    if (createdRootGroup) {
+      restoreOriginalMesh(entity, state);
+      state.createdRootGroup = false;
+    }
+    const { payload, transferables } = bufferGeometryToPlain(normalizedGeometry);
+    normalizedGeometry.dispose();
+    const plainOptions = pinataFractureOptionsToPlain(fractureOptions);
+    const api = getPrebakeWorkerApi(workerUrl);
+    const request = Comlink.transfer(
+      { geometry: payload, options: plainOptions },
+      transferables
+    );
+    const response = await api.prebake(request);
+    const parts = plainWorkerResultToTemplateParts(response);
+    installPrebakedTemplateParts(state, cacheKey, parts);
+  })();
+  prebakeAsyncInFlight.set(ref, job);
+  try {
+    await job;
+  } finally {
+    if (prebakeAsyncInFlight.get(ref) === job) {
+      prebakeAsyncInFlight.delete(ref);
+    }
+  }
+}
+function prebakeEntity(ref, overrideOptions) {
+  prebakeEntityGeometryOnly(ref, overrideOptions);
+}
+function createDestructible3DHandle(ref) {
+  return {
+    fracture: (overrideOptions) => fractureEntity(ref, overrideOptions),
+    prebake: (overrideOptions) => {
+      prebakeEntity(ref, overrideOptions);
+    },
+    prebakeAsync: (overrideOptions) => prebakeEntityAsync(ref, overrideOptions),
+    repair: () => restoreRuntimeState(ref, true),
+    isFractured: () => getRuntimeState(ref).isFractured,
+    getFragments: () => getRuntimeState(ref).fragments
+  };
+}
+var Destructible3DSystem = class {
+  constructor(world, scene, getBehaviorLinks, createEntity, getGlobals) {
+    this.world = world;
+    this.scene = scene;
+    this.getBehaviorLinks = getBehaviorLinks;
+    this.createEntity = createEntity;
+    this.getGlobals = getGlobals;
+    this.primeLinks();
+  }
+  world;
+  scene;
+  getBehaviorLinks;
+  createEntity;
+  getGlobals;
+  attach(link) {
+    if (link.ref?.descriptor?.key !== DESTRUCTIBLE_3D_BEHAVIOR_KEY) {
+      return;
+    }
+    this.primeLink(link);
+  }
+  update(_ecs, _delta) {
+    this.primeLinks();
+    const links = this.getBehaviorLinks?.(DESTRUCTIBLE_3D_BEHAVIOR_KEY);
+    if (!links) {
+      return;
+    }
+    const interpolationAlpha = this.world?.interpolationAlpha ?? 0;
+    for (const link of links) {
+      const state = getRuntimeState(
+        link.ref
+      );
+      for (const fragmentEntity of state.fragmentEntities) {
+        syncRuntimeFragmentEntityTransform(
+          fragmentEntity,
+          interpolationAlpha
+        );
+      }
+    }
+  }
+  destroy(_ecs) {
+    const links = this.getBehaviorLinks?.(DESTRUCTIBLE_3D_BEHAVIOR_KEY);
+    if (!links) {
+      return;
+    }
+    for (const link of links) {
+      const ref = link.ref;
+      restoreRuntimeState(ref, false);
+      disposeRuntimeState(getRuntimeState(ref));
+    }
+  }
+  primeLinks() {
+    const links = this.getBehaviorLinks?.(DESTRUCTIBLE_3D_BEHAVIOR_KEY);
+    if (!links) {
+      return;
+    }
+    for (const link of links) {
+      this.primeLink(link);
+    }
+  }
+  primeLink(link) {
+    const ref = link.ref;
+    const entity = link.entity;
+    ref.__entity = entity;
+    ref.__world = this.world;
+    ref.__scene = this.scene;
+    ref.__createEntity = this.createEntity;
+    ref.__getGlobals = this.getGlobals;
+    if (!ref.__cleanupRegistered) {
+      entity.onCleanup(() => {
+        restoreRuntimeState(ref, false);
+        disposeRuntimeState(getRuntimeState(ref));
+      });
+      ref.__cleanupRegistered = true;
+    }
+  }
+};
+var Destructible3DBehavior = defineBehavior({
+  name: "destructible-3d",
+  defaultOptions,
+  systemFactory: (ctx) => new Destructible3DSystem(
+    ctx.world,
+    ctx.scene,
+    ctx.getBehaviorLinks,
+    ctx.createEntity,
+    ctx.getGlobals
+  ),
+  createHandle: createDestructible3DHandle
+});
+
+// src/lib/behaviors/destructible-3d/index.ts
+import {
+  DestructibleMesh as DestructibleMesh2,
+  FractureOptions
+} from "@dgreenheck/three-pinata";
+
+export {
+  Destructible3DBehavior,
+  DestructibleMesh2 as DestructibleMesh,
+  FractureOptions
+};
+//# sourceMappingURL=chunk-BXP4K7RF.js.map