@nebula-spatial/viewer 0.2.4 → 0.4.0

package/dist/session-CGaj14lM.js

@@ -0,0 +1,93 @@
+import { Quaternion as y, Vector3 as M, Group as P, Box3 as T } from "three";
+import { DRACOLoader as x } from "three/examples/jsm/loaders/DRACOLoader.js";
+import { GLTFLoader as D } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { S as E, d as w } from "./stage-BxROW_dP.js";
+const G = new y().setFromAxisAngle(new M(1, 0, 0), Math.PI / 2), R = new y();
+function S(r) {
+  return r === "y" ? G : R;
+}
+function b(r, n) {
+  const t = S(n);
+  return t.equals(r.quaternion) ? !1 : (r.quaternion.copy(t), r.updateMatrixWorld(!0), !0);
+}
+function z(r, n) {
+  let t = !1, i = null, e = null, d = "z", f;
+  const l = new x(), p = new D(), m = () => {
+    t = !0;
+  }, a = (async () => {
+    d = n.options.upAxis ?? "z", n.options.dracoDecoderPath && l.setDecoderPath(n.options.dracoDecoderPath), p.setDRACOLoader(l);
+    let o = null;
+    try {
+      if (t || n.signal.aborted) throw h();
+      const s = await p.loadAsync(r.url ?? await r.resolve(r.entryPath ?? ""));
+      o = new P(), o.name = "viewer-model-root";
+      const u = s.scenes.filter((c) => c !== s.scene);
+      if (o.add(s.scene), t || n.signal.aborted) {
+        for (const c of u) o.add(c);
+        throw h();
+      }
+      b(o, d), g(o);
+      const A = new E(o, n.options.simulationTheme, void 0, "model");
+      i = o, e = A, o = null;
+    } finally {
+      o && w(o), l.dispose();
+    }
+  })();
+  return a.catch(() => {
+  }), {
+    id: `model-${Math.random().toString(36).slice(2)}`,
+    opened: a,
+    get root() {
+      return (e == null ? void 0 : e.root) ?? null;
+    },
+    getFitBounds() {
+      return (e == null ? void 0 : e.getModelBounds()) ?? null;
+    },
+    beforeRender(o, s, u) {
+      return e == null ? void 0 : e.beforeRender(o, s, u);
+    },
+    capabilities: { canPlay: !1, canPause: !1, canReset: !1, hasPhysics: !1, canReorientUpAxis: !0, canToggleGround: !0 },
+    // Session presentation overrides are only consulted for `interactionMode`
+    // and `fitPolicy`; the UI group comes from the loader descriptor. Keep the
+    // two in sync so the override never reads as a contradictory value.
+    presentation: { preferredViewMode: "3d", interactionMode: "object", uiProfile: "model", fitPolicy: "fit-on-ready" },
+    getUpAxis() {
+      return i ? d : null;
+    },
+    setTheme(o) {
+      e == null || e.setTheme(o);
+    },
+    setGroundVisible(o) {
+      e == null || e.setGroundVisible(o);
+    },
+    getGroundVisible() {
+      return (e == null ? void 0 : e.getGroundVisible()) ?? !0;
+    },
+    setUpAxis(o) {
+      if (t || !i || !e || !b(i, o)) return;
+      d = o, e.reseatGround();
+      const s = e.getModelBounds();
+      n.requestRender(), n.fit(s, { padding: 1.15 });
+    },
+    beginDispose: m,
+    dispose() {
+      return m(), f ?? (f = a.catch(() => {
+      }).then(() => {
+        e == null || e.dispose(), e = null, i && w(i), i = null;
+      })), f;
+    }
+  };
+}
+function g(r) {
+  r.updateMatrixWorld(!0);
+  const n = new T().setFromObject(r);
+  if (n.isEmpty()) throw new Error("模型不包含可显示的几何内容。");
+  const t = n.getSize(new M()), i = Math.max(t.x, t.y, t.z);
+  if (!Number.isFinite(i) || i <= 0) throw new Error("模型尺寸无效。");
+}
+function h() {
+  return Object.assign(new Error("Model load aborted."), { name: "AbortError", code: "E_ABORTED" });
+}
+export {
+  z as createModelSession
+};

package/dist/stage-BxROW_dP.js

@@ -0,0 +1,421 @@
+var v = Object.defineProperty;
+var y = (c, e, t) => e in c ? v(c, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : c[e] = t;
+var a = (c, e, t) => y(c, typeof e != "symbol" ? e + "" : e, t);
+import * as o from "three";
+import { V as p } from "./index-Lsk3kHNe.js";
+const x = 1, b = (
+  /* glsl */
+  `
+  uniform mat4 textureMatrix;
+  varying vec4 vReflectionUv;
+  varying vec3 vWorldPosition;
+
+  void main() {
+    vec4 worldPosition = modelMatrix * vec4(position, 1.0);
+    vWorldPosition = worldPosition.xyz;
+    vReflectionUv = textureMatrix * vec4(position, 1.0);
+    // Match Three.js built-in materials: transform to view space before projection.
+    vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
+    gl_Position = projectionMatrix * mvPosition;
+  }
+`
+), M = (
+  /* glsl */
+  `
+  uniform sampler2D tDiffuse;
+  uniform vec2 resolution;
+  uniform vec3 fineGridColor;
+  uniform vec3 coarseGridColor;
+  uniform float blurIntensity;
+  uniform float reflectionMix;
+  uniform float gridOpacity;
+  uniform float gridScale;
+  uniform vec2 groundCenter;
+  uniform float maxRadius;
+  uniform float fadeSoftness;
+
+  varying vec4 vReflectionUv;
+  varying vec3 vWorldPosition;
+
+  vec4 blur9(sampler2D image, vec2 uv, vec2 res, float radius) {
+    vec4 color = vec4(0.0);
+    vec2 stepSize = radius / res;
+    color += texture2D(image, uv + vec2(-stepSize.x, -stepSize.y)) * 0.0625;
+    color += texture2D(image, uv + vec2(0.0, -stepSize.y)) * 0.125;
+    color += texture2D(image, uv + vec2(stepSize.x, -stepSize.y)) * 0.0625;
+    color += texture2D(image, uv + vec2(-stepSize.x, 0.0)) * 0.125;
+    color += texture2D(image, uv) * 0.25;
+    color += texture2D(image, uv + vec2(stepSize.x, 0.0)) * 0.125;
+    color += texture2D(image, uv + vec2(-stepSize.x, stepSize.y)) * 0.0625;
+    color += texture2D(image, uv + vec2(0.0, stepSize.y)) * 0.125;
+    color += texture2D(image, uv + vec2(stepSize.x, stepSize.y)) * 0.0625;
+    return color;
+  }
+
+  float gridLine(vec2 position, float scale) {
+    vec2 coordinate = position / scale;
+    vec2 width = max(fwidth(coordinate), vec2(0.0001));
+    vec2 distanceToLine = abs(fract(coordinate - 0.5) - 0.5) / width;
+    return 1.0 - min(min(distanceToLine.x, distanceToLine.y), 1.0);
+  }
+
+  void main() {
+    vec2 groundPosition = vWorldPosition.xy;
+    float edgeDistance = length(groundPosition - groundCenter);
+    float edgeFade = 1.0 - smoothstep(maxRadius - fadeSoftness, maxRadius, edgeDistance);
+
+    float fineLine = gridLine(groundPosition, gridScale);
+    float coarseLine = gridLine(groundPosition, gridScale * 10.0);
+    float gridAlpha = max(fineLine * 0.16, coarseLine * 0.42) * gridOpacity * edgeFade;
+    vec3 gridColor = mix(fineGridColor, coarseGridColor, coarseLine);
+
+    vec2 reflectionUv = vReflectionUv.xy / vReflectionUv.w;
+    bool validReflection = reflectionUv.x >= 0.0 && reflectionUv.x <= 1.0
+      && reflectionUv.y >= 0.0 && reflectionUv.y <= 1.0;
+    vec4 reflection = validReflection
+      ? blur9(tDiffuse, reflectionUv, resolution, blurIntensity)
+      : vec4(0.0);
+    float reflectionAlpha = reflectionMix * edgeFade * (validReflection ? 1.0 : 0.0);
+
+    float alpha = reflectionAlpha + gridAlpha * (1.0 - reflectionAlpha);
+    if (alpha <= 0.001) discard;
+    vec3 color = mix(reflection.rgb, gridColor, gridAlpha / max(alpha, 0.001));
+    gl_FragColor = vec4(color, alpha);
+    #include <tonemapping_fragment>
+    #include <colorspace_fragment>
+  }
+`
+);
+class w extends o.Mesh {
+  constructor({ size: t = 20, textureWidth: i = 512, textureHeight: r = 512 } = {}) {
+    const s = new o.Matrix4(), n = new o.WebGLRenderTarget(i, r, {
+      type: o.HalfFloatType,
+      minFilter: o.LinearFilter,
+      magFilter: o.LinearFilter,
+      format: o.RGBAFormat,
+      depthBuffer: !0,
+      samples: 0
+    }), l = new o.ShaderMaterial({
+      uniforms: {
+        tDiffuse: { value: n.texture },
+        textureMatrix: { value: s },
+        resolution: { value: new o.Vector2(i, r) },
+        fineGridColor: { value: new o.Color(2502702) },
+        coarseGridColor: { value: new o.Color(7897726) },
+        blurIntensity: { value: 1.7 },
+        reflectionMix: { value: 0.07 },
+        gridOpacity: { value: 1 },
+        gridScale: { value: 0.2 },
+        groundCenter: { value: new o.Vector2() },
+        maxRadius: { value: t * 0.5 },
+        fadeSoftness: { value: t * 0.325 }
+      },
+      vertexShader: b,
+      fragmentShader: M,
+      transparent: !0,
+      depthWrite: !1,
+      toneMapped: !0,
+      fog: !1
+    });
+    super(new o.PlaneGeometry(t, t), l);
+    a(this, "renderTarget");
+    a(this, "textureMatrix");
+    a(this, "virtualCamera");
+    a(this, "clipBias");
+    a(this, "reflectorPlane");
+    a(this, "normal");
+    a(this, "reflectorWorldPosition");
+    a(this, "cameraWorldPosition");
+    a(this, "rotationMatrix");
+    a(this, "lookAtPosition");
+    a(this, "clipPlane");
+    a(this, "view");
+    a(this, "target");
+    a(this, "q");
+    this.renderTarget = n, this.textureMatrix = s, this.virtualCamera = new o.PerspectiveCamera(), this.virtualCamera.layers.set(x), this.clipBias = 3e-3, this.frustumCulled = !1, this.renderOrder = 1, this.position.z = 2e-3, this.reflectorPlane = new o.Plane(), this.normal = new o.Vector3(), this.reflectorWorldPosition = new o.Vector3(), this.cameraWorldPosition = new o.Vector3(), this.rotationMatrix = new o.Matrix4(), this.lookAtPosition = new o.Vector3(0, 0, -1), this.clipPlane = new o.Vector4(), this.view = new o.Vector3(), this.target = new o.Vector3(), this.q = new o.Vector4();
+  }
+  renderReflection(t, i, r) {
+    if (this.reflectorWorldPosition.setFromMatrixPosition(this.matrixWorld), this.cameraWorldPosition.setFromMatrixPosition(r.matrixWorld), this.rotationMatrix.extractRotation(this.matrixWorld), this.normal.set(0, 0, 1).applyMatrix4(this.rotationMatrix), this.view.subVectors(this.reflectorWorldPosition, this.cameraWorldPosition), this.view.dot(this.normal) > 0) return;
+    this.view.reflect(this.normal).negate().add(this.reflectorWorldPosition), this.rotationMatrix.extractRotation(r.matrixWorld), this.lookAtPosition.set(0, 0, -1).applyMatrix4(this.rotationMatrix).add(this.cameraWorldPosition), this.target.subVectors(this.reflectorWorldPosition, this.lookAtPosition).reflect(this.normal).negate().add(this.reflectorWorldPosition), this.virtualCamera.position.copy(this.view), this.virtualCamera.up.set(0, 1, 0).applyMatrix4(this.rotationMatrix).reflect(this.normal), this.virtualCamera.lookAt(this.target), this.virtualCamera.near = r.near, this.virtualCamera.far = r.far, this.virtualCamera.updateMatrixWorld(), this.virtualCamera.projectionMatrix.copy(r.projectionMatrix), this.textureMatrix.set(
+      0.5,
+      0,
+      0,
+      0.5,
+      0,
+      0.5,
+      0,
+      0.5,
+      0,
+      0,
+      0.5,
+      0.5,
+      0,
+      0,
+      0,
+      1
+    ).multiply(this.virtualCamera.projectionMatrix).multiply(this.virtualCamera.matrixWorldInverse).multiply(this.matrixWorld), this.reflectorPlane.setFromNormalAndCoplanarPoint(this.normal, this.reflectorWorldPosition).applyMatrix4(this.virtualCamera.matrixWorldInverse), this.clipPlane.set(
+      this.reflectorPlane.normal.x,
+      this.reflectorPlane.normal.y,
+      this.reflectorPlane.normal.z,
+      this.reflectorPlane.constant
+    );
+    const s = this.virtualCamera.projectionMatrix;
+    this.q.set(
+      (Math.sign(this.clipPlane.x) + s.elements[8]) / s.elements[0],
+      (Math.sign(this.clipPlane.y) + s.elements[9]) / s.elements[5],
+      -1,
+      (1 + s.elements[10]) / s.elements[14]
+    ), this.clipPlane.multiplyScalar(2 / this.clipPlane.dot(this.q)), s.elements[2] = this.clipPlane.x, s.elements[6] = this.clipPlane.y, s.elements[10] = this.clipPlane.z + 1 - this.clipBias, s.elements[14] = this.clipPlane.w, this.virtualCamera.projectionMatrixInverse.copy(s).invert();
+    const n = t.getRenderTarget(), l = t.xr.enabled, u = t.shadowMap.autoUpdate, d = t.shadowMap.enabled;
+    try {
+      t.xr.enabled = !1, t.shadowMap.enabled = !1, t.shadowMap.autoUpdate = !1, t.setRenderTarget(this.renderTarget), t.state.buffers.depth.setMask(!0), t.clear(), t.render(i, this.virtualCamera);
+    } finally {
+      t.setRenderTarget(n), t.xr.enabled = l, t.shadowMap.enabled = d, t.shadowMap.autoUpdate = u;
+    }
+  }
+  setRenderSize(t, i) {
+    this.renderTarget.setSize(t, i), this.material.uniforms.resolution.value.set(t, i);
+  }
+  // Radius is in world units; the outer 65% fades before the square mesh edge.
+  setRadius(t, i, r = this.material.uniforms.groundCenter.value) {
+    this.scale.setScalar(t * 2 / this.geometry.parameters.width), this.position.x = r.x, this.position.y = r.y, this.material.uniforms.groundCenter.value.set(r.x, r.y), this.material.uniforms.gridScale.value = i, this.material.uniforms.maxRadius.value = t, this.material.uniforms.fadeSoftness.value = t * 0.65;
+  }
+}
+const g = {
+  light: {
+    background: p.light,
+    fineGrid: 5859168,
+    coarseGrid: 3427136,
+    gridOpacity: 0.85,
+    reflectionMix: 0.06
+  },
+  dark: {
+    background: p.dark,
+    fineGrid: 7375236,
+    coarseGrid: 5552554,
+    gridOpacity: 0.9,
+    reflectionMix: 0.06
+  }
+}, P = {
+  simulation: 0.68,
+  model: 1.4
+};
+function C(c) {
+  const e = /* @__PURE__ */ new Set(), t = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set();
+  c.traverse((s) => {
+    var l;
+    const n = s;
+    n.geometry && e.add(n.geometry);
+    for (const u of Array.isArray(n.material) ? n.material : [n.material])
+      if (u) {
+        t.add(u);
+        for (const d of Object.values(u)) {
+          if (!S(d)) continue;
+          i.add(d);
+          const h = (l = d.source) == null ? void 0 : l.data;
+          h && typeof h.close == "function" && r.add(h);
+        }
+      }
+  });
+  for (const s of e) s.dispose();
+  for (const s of t) s.dispose();
+  for (const s of i) s.dispose();
+  for (const s of r) s.close();
+}
+function S(c) {
+  return !!(c && typeof c == "object" && c.isTexture);
+}
+const f = 2213822, G = 6000111, R = 6;
+function L(c, e, t) {
+  e.updateMatrixWorld();
+  const i = new o.Vector3();
+  return e.getWorldDirection(i).normalize(), c.setFromNormalAndCoplanarPoint(i, t);
+}
+class F {
+  constructor(e, t = "dark", i, r = "simulation") {
+    a(this, "root", new o.Group());
+    a(this, "reflector", new w({ size: 100, textureWidth: 256, textureHeight: 256 }));
+    a(this, "values");
+    a(this, "fog");
+    a(this, "raycaster", new o.Raycaster());
+    a(this, "pointer", new o.Vector2());
+    a(this, "dragPlane", new o.Plane());
+    a(this, "dragTarget", new o.Vector3());
+    a(this, "dragIntersection", new o.Vector3());
+    a(this, "dragOffset", new o.Vector3());
+    a(this, "bodyGroups", /* @__PURE__ */ new Map());
+    a(this, "auxiliaries", /* @__PURE__ */ new Set());
+    a(this, "forceLine");
+    a(this, "forceBoosted", !1);
+    a(this, "grabCanvas", null);
+    a(this, "previousCursor", "");
+    a(this, "size", "");
+    a(this, "groundVisible");
+    a(this, "disposed", !1);
+    this.model = e, this.runtime = i, this.presentation = r, this.values = g[t];
+    const s = this.values, n = new o.Box3().setFromObject(e), l = Math.max(...n.getSize(new o.Vector3()).toArray());
+    if (!Number.isFinite(l) || l <= 0) throw new Error("Empty simulation geometry.");
+    this.root.add(e), this.forceLine = this.createForceLine(), this.root.add(this.forceLine), e.traverse((m) => {
+      m instanceof o.Mesh && m.layers.enable(x);
+    }), this.root.add(this.reflector);
+    const u = Math.max(n.getSize(new o.Vector3()).length() * 0.5, 0.02), d = this.reflector.material.uniforms;
+    d.fineGridColor.value.setHex(s.fineGrid), d.coarseGridColor.value.setHex(s.coarseGrid), d.gridOpacity.value = s.gridOpacity, d.reflectionMix.value = s.reflectionMix, this.layoutGround(n, u), this.groundVisible = r === "simulation", this.setGroundVisible(this.groundVisible);
+    const h = u / Math.sin(o.MathUtils.degToRad(38) / 2) * 1.25;
+    this.fog = new o.Fog(s.background, h * 2.5, h * 8);
+  }
+  setTheme(e) {
+    if (this.disposed) return;
+    const t = this.values = g[e], i = this.reflector.material.uniforms;
+    i.fineGridColor.value.setHex(t.fineGrid), i.coarseGridColor.value.setHex(t.coarseGrid), i.gridOpacity.value = t.gridOpacity, i.reflectionMix.value = t.reflectionMix, this.fog.color.setHex(t.background);
+  }
+  layoutGround(e, t) {
+    this.reflector.setRadius(t * 8, Math.pow(10, Math.floor(Math.log10(Math.max(t, 0.01)))), e.getCenter(new o.Vector3()));
+  }
+  /**
+   * Re-fits the ground disc and reflection to the model's current world bounds.
+   * Model previews call this after re-orienting the asset's authored up axis:
+   * an axis-aligned bounding box is not rotation invariant, so the floor that
+   * was sized to a wide-flat footprint can end up clipping an upright model.
+   */
+  reseatGround() {
+    if (this.disposed) return;
+    this.root.updateMatrixWorld(!0);
+    const e = new o.Box3().setFromObject(this.model);
+    e.isEmpty() || this.layoutGround(e, Math.max(e.getSize(new o.Vector3()).length() * 0.5, 0.02));
+  }
+  createForceLine() {
+    const e = new o.BufferGeometry().setFromPoints([
+      new o.Vector3(),
+      new o.Vector3()
+    ]), t = new o.LineBasicMaterial({
+      color: f,
+      depthTest: !1,
+      transparent: !0
+    }), i = new o.Line(e, t);
+    return i.renderOrder = 1e3, i.visible = !1, i;
+  }
+  findBodyGroup(e) {
+    var i;
+    let t = e;
+    for (; t && t !== this.model && t !== this.root; ) {
+      if (typeof ((i = t.userData) == null ? void 0 : i.bodyId) == "number") return t;
+      t = t.parent;
+    }
+    return null;
+  }
+  getBodyGroup(e) {
+    let t = this.bodyGroups.get(e);
+    return t || this.model.traverse((i) => {
+      var r;
+      ((r = i.userData) == null ? void 0 : r.bodyId) === e && (t = i, this.bodyGroups.set(e, i));
+    }), t;
+  }
+  pointerRay(e, t, i) {
+    const r = i.getBoundingClientRect();
+    this.pointer.set(
+      (e.clientX - r.left) / r.width * 2 - 1,
+      -((e.clientY - r.top) / r.height) * 2 + 1
+    ), this.raycaster.setFromCamera(this.pointer, t);
+  }
+  setForceBoost(e) {
+    var t;
+    !((t = this.runtime) != null && t.grab) || e === this.forceBoosted || (this.forceBoosted = e, this.runtime.updateGrabStrength(e ? R : 1), this.forceLine.material.color.setHex(e ? G : f));
+  }
+  beginGrab(e, t, i) {
+    if (!this.runtime || this.disposed) return !1;
+    this.pointerRay(e, t, i);
+    const r = this.raycaster.intersectObject(this.model, !0).find((u) => u.object.isMesh);
+    if (!r) return !1;
+    const s = this.findBodyGroup(r.object);
+    if (!s) return !1;
+    const n = s.worldToLocal(r.point.clone());
+    this.dragTarget.copy(r.point), L(this.dragPlane, t, r.point), this.dragOffset.set(0, 0, 0);
+    const l = this.root.worldToLocal(r.point.clone());
+    return this.bodyGroups.set(s.userData.bodyId, s), this.runtime.beginGrab({
+      bodyId: s.userData.bodyId,
+      localPoint: [n.x, n.y, n.z],
+      target: [l.x, l.y, l.z]
+    }), this.forceBoosted = !1, this.setForceBoost(e.shiftKey), this.forceLine.visible = !0, this.updateForceLine(), this.grabCanvas = i, i != null && i.style && (this.previousCursor = i.style.cursor, i.style.cursor = "grabbing"), !0;
+  }
+  moveGrab(e, t, i) {
+    var s;
+    if (!((s = this.runtime) != null && s.grab)) return;
+    if (this.pointerRay(e, t, i), this.setForceBoost(e.shiftKey), i != null && i.style && i.style.cursor !== "grabbing" && (i.style.cursor = "grabbing"), this.raycaster.ray.intersectPlane(this.dragPlane, this.dragIntersection))
+      this.dragTarget.copy(this.dragIntersection).add(this.dragOffset);
+    else
+      return;
+    const r = this.root.worldToLocal(this.dragTarget.clone());
+    this.runtime.updateGrabTarget([r.x, r.y, r.z]), this.updateForceLine();
+  }
+  endGrab() {
+    var e;
+    this.runtime && (this.runtime.endGrab(), this.forceBoosted = !1, this.forceLine.visible = !1, this.forceLine.material.color.setHex(f), (e = this.grabCanvas) != null && e.style && (this.grabCanvas.style.cursor = this.previousCursor), this.grabCanvas = null);
+  }
+  updateForceLine() {
+    var l;
+    const e = (l = this.runtime) == null ? void 0 : l.grab;
+    if (!e) return;
+    const t = this.getBodyGroup(e.bodyId);
+    if (!t) return;
+    const i = new o.Vector3().fromArray(e.localPoint), r = t.localToWorld(i), s = this.root.worldToLocal(r), n = this.forceLine.geometry.attributes.position;
+    n.setXYZ(0, s.x, s.y, s.z), n.setXYZ(1, e.target[0], e.target[1], e.target[2]), n.needsUpdate = !0;
+  }
+  beforeRender(e, t, i) {
+    var n;
+    const r = {
+      tone: e.toneMapping,
+      exposure: e.toneMappingExposure,
+      color: e.outputColorSpace,
+      environment: t.environment,
+      fog: t.fog,
+      background: t.background
+    }, s = () => {
+      e.toneMapping = r.tone, e.toneMappingExposure = r.exposure, e.outputColorSpace = r.color, t.environment = r.environment, t.fog = r.fog, t.background = r.background;
+    };
+    if (this.disposed) return s;
+    try {
+      (n = this.runtime) != null && n.grab && this.updateForceLine(), e.toneMapping = o.ACESFilmicToneMapping, e.toneMappingExposure = P[this.presentation], e.outputColorSpace = o.SRGBColorSpace, t.background = new o.Color(this.values.background), t.fog = this.fog;
+      const l = e.getSize(new o.Vector2()), u = `${l.x}:${l.y}`;
+      return u !== this.size && (this.size = u, this.reflector.setRenderSize(Math.max(1, Math.floor(l.x * 0.35)), Math.max(1, Math.floor(l.y * 0.35)))), t.updateMatrixWorld(!0), i.updateMatrixWorld(!0), this.groundVisible && i instanceof o.PerspectiveCamera && this.reflector.renderReflection(e, t, i), s;
+    } catch (l) {
+      throw s(), l;
+    }
+  }
+  /**
+   * The reflector mesh carries both the grid lines and the reflection. Hiding
+   * it also skips the reflection render pass, which only feeds its shader.
+   */
+  setGroundVisible(e) {
+    this.groundVisible = e, this.reflector.visible = e;
+  }
+  getGroundVisible() {
+    return this.groundVisible;
+  }
+  /**
+   * Adds a debug/auxiliary object next to the model rather than inside it.
+   * The model subtree is what the reflector pass and `getModelBounds` measure,
+   * so nesting hidden aids (collision meshes, which are far larger than the
+   * visual shell) would inflate both the reflection extent and the camera fit.
+   */
+  attachAuxiliary(e) {
+    this.auxiliaries.add(e), this.root.add(e);
+  }
+  getModelBounds() {
+    this.root.updateMatrixWorld(!0);
+    const e = new o.Box3().setFromObject(this.model);
+    if (!e.isEmpty()) return e;
+    const t = new o.Box3();
+    return t.min.set(-5e3, -5e3, -5e3), t.max.set(5e3, 5e3, 5e3), t;
+  }
+  dispose() {
+    if (!this.disposed) {
+      this.disposed = !0, this.endGrab(), this.model.removeFromParent();
+      for (const e of this.auxiliaries) e.removeFromParent();
+      this.auxiliaries.clear(), this.root.removeFromParent(), this.reflector.renderTarget.dispose(), C(this.root);
+    }
+  }
+}
+export {
+  F as S,
+  C as d
+};

package/dist/types.d.ts

@@ -1,7 +1,17 @@
 import type { Box3, ColorRepresentation, Object3D, Vector3 } from 'three';
-import type { CadViewerCapability, CameraStateStore, ViewerUiOptions } from './cad/types';
-export type { CadBlockModel, CadDocumentHandle, CadFontResolver, CadResolvedTextFont, CadHudModel, CadInspectorModel, CadLayerModel, CadLoadSource, CadOpenOptions, CadSessionLoadTiming, CadTextDetails, CadTextSelection, CadTextSelectionId, CadViewerCapability, ResolveTextFont, CadViewerEventMap, CameraStateStore, ViewerUiOptions, ViewerUiParts, ViewerUiPreset, ViewerUiTheme, } from './cad/types';
+import type { CadViewerCapability, CameraStateStore, ViewerUiOptions, ViewerUiTheme } from './cad/types';
+import type { AssetChangeEvent, AssetControlChangeEvent, AssetErrorEvent, AssetPreview, AssetSource, OpenAssetOptions, ViewerAssetOptions } from './assets/types';
+export type { CadBlockModel, CadDocumentHandle, CadDocumentUnits, CadFontResolver, CadFontRequest, CadResolvedFont, CadResolvedTextFont, CadTextWarmupOptions, CadHudModel, CadHudSnapshot, CadInspectorModel, CadInspectorSnapshot, CadLayerModel, CadLayerRow, CadBlockUsageRow, CadSessionPhase, CadWorldBounds, CadScaleRulerState, CadInsertDetails, CadInsertSelection, CadInsertSelectionId, CadTextDetails, CadTextSelection, CadTextSelectionId, CadSelection, CadHit, CadViewerSnapshot, CadLoadProgress, CadViewerErrorCode, CadViewerErrorEvent, CadLoadSource, CadOpenOptions, CadSessionLoadTiming, RenderDebugBreakdownEntry, SplitBlockLayerDetail, CadViewerCapability, ResolveTextFont, CadViewerEventMap, CameraStateStore, ViewerCadUiKeyboardOptions, ViewerUiOptions, ViewerCadUiParts, ViewerCadUiOptions, ViewerUiPreset, ViewerCadUiStateStore, ViewerUiTheme, ViewerUiTokens, } from './cad/types';
 export type ViewerViewMode = '2d' | '3d';
+export type CadInteractionMode = 'managed' | 'manual' | 'disabled';
+/**
+ * Which 3D navigation implementation the runtime drives.
+ * `viewer` is the CAD path; `preview` is the model/simulation particle viewer
+ * matching sim-studio. Kept as its own union so the viewer's public surface
+ * does not re-export the runtime package's type.
+ */
+export type ViewerNavigationPolicy = 'legacy' | 'viewer' | 'preview';
+export type CameraChangeReason = 'pointer' | 'wheel' | 'fit' | 'restore' | 'api' | 'view-mode';
 export type ViewerEnvironment = 'room' | {
     /** Load an external equirectangular HDR texture for image-based lighting. */
     readonly type: 'hdr';
@@ -50,10 +60,28 @@ export interface ViewerOptions {
     environment?: ViewerEnvironment;
     autoSelectOnPick?: boolean;
     pointerPick?: boolean;
+    /** CAD click policy. Defaults to managed. */
+    cadInteraction?: CadInteractionMode;
+    cadInteractionStyle?: {
+        hover?: {
+            color?: ColorRepresentation;
+            fillOpacity?: number;
+            edgeOpacity?: number;
+            enabled?: boolean;
+        };
+        selected?: {
+            color?: ColorRepresentation;
+            fillOpacity?: number;
+            edgeOpacity?: number;
+            enabled?: boolean;
+        };
+    };
     cameraStateStore?: CameraStateStore | false;
     /** Max delay for merged viewport demands while the interaction is active. Default 160ms. */
     viewportDemandCoalesceMs?: number;
     ui?: ViewerUiOptions;
+    assets?: ViewerAssetOptions;
+    onCleanupError?: (event: AssetErrorEvent) => void;
 }
 export interface ViewerFitViewOptions {
     padding?: number;
@@ -75,6 +103,10 @@ export interface ViewerPickResult {
 export interface ViewerHighlightOptions {
     color?: ColorRepresentation;
 }
+export interface ViewerObjectOptions {
+    /** Viewer only mounts the object; the caller retains responsibility for GPU resource disposal. */
+    readonly ownership?: 'borrowed';
+}
 export interface ViewerRenderStats {
     readonly drawCalls: number;
     readonly submittedVertexRefs: number;
@@ -104,6 +136,9 @@ export interface ViewerEventMap {
     'view-mode-change': {
         viewMode: ViewerViewMode;
     };
+    'theme-change': {
+        theme: ViewerUiTheme;
+    };
     resize: {
         resized: boolean;
     };
@@ -121,7 +156,22 @@ export interface ViewerEventMap {
     };
     'camera-change': {
         viewMode: ViewerViewMode;
+        reason: CameraChangeReason;
+        interaction: 'active' | 'idle';
+    };
+    'ui-layout-change': {
+        contentInsets: {
+            readonly top: number;
+            readonly right: number;
+            readonly bottom: number;
+            readonly left: number;
+        };
+        layerPanelOpen: boolean;
+        propertyPanelOpen: boolean;
     };
+    'asset-change': AssetChangeEvent;
+    'asset-error': AssetErrorEvent;
+    'asset-control-change': AssetControlChangeEvent;
 }
 export interface Viewer {
     readonly viewport: HTMLElement;
@@ -131,13 +181,37 @@ export interface Viewer {
     readonly highlightedObject: Object3D | null;
     readonly isDisposed: boolean;
     readonly cad: CadViewerCapability;
-    addObject(object: Object3D): void;
+    readonly overlays: {
+        set(key: string, object: Object3D, options?: {
+            owned?: boolean;
+        }): void;
+        remove(key: string, options?: {
+            dispose?: boolean;
+        }): Object3D | null;
+    };
+    readonly camera: {
+        getState(): ViewerCameraSnapshot | null;
+        /** Applies a validated snapshot immediately. Animated transitions are not part of the current contract. */
+        setState(snapshot: ViewerCameraSnapshot): boolean;
+        reset(): boolean;
+    };
+    readonly plugins: import('./plugins').ViewerPluginRegistry;
+    readonly commands: {
+        execute(id: string, args?: unknown): boolean;
+        has(id: string): boolean;
+    };
+    openAsset(source: AssetSource, options?: OpenAssetOptions): AssetPreview;
+    closeAsset(): Promise<void>;
+    addObject(object: Object3D, options?: ViewerObjectOptions): void;
     removeObject(object: Object3D): boolean;
     setVisible(object: Object3D, visible: boolean): void;
     setViewMode(mode: ViewerViewMode, options?: {
         preserveOrbit?: boolean;
     }): void;
+    /** Switches the UI and active preview stage theme at runtime. */
+    setTheme(theme: ViewerUiTheme): boolean;
     fitView(target?: Object3D | Box3, options?: ViewerFitViewOptions): boolean;
+    fitAll(options?: ViewerFitViewOptions): boolean;
     screenToWorldOnPlane(clientX: number, clientY: number, planeZ?: number): Vector3 | null;
     pick(clientX: number, clientY: number, options?: ViewerPickOptions): ViewerPickResult | null;
     setSelection(object: Object3D | null): void;
@@ -145,5 +219,10 @@ export interface Viewer {
     on<K extends keyof ViewerEventMap>(type: K, listener: (event: ViewerEventMap[K]) => void): () => void;
     resize(): boolean;
     requestRender(): void;
+    getActiveCamera(): import('three').Camera;
+    setNavigationEnabled(enabled: boolean): void;
     dispose(): void;
+    use(plugins: readonly import('./plugins').ViewerPlugin[], options?: {
+        replace?: boolean;
+    }): void;
 }