@shopware-ag/dive 3.1.0 → 4.0.1

package/build/chunks/collectAnimations-BgYCN1le.mjs

@@ -0,0 +1,35 @@
+import { PropertyBinding as s } from "three/webgpu";
+const a = (r) => "isDIVENode" in r, u = (r, i) => {
+  for (const t of r) {
+    const n = s.findNode(
+      t,
+      i
+    );
+    if (n) return n;
+  }
+  return null;
+}, f = (r, i) => {
+  const t = r.clone();
+  return t.tracks.forEach((n) => {
+    const { nodeName: o } = s.parseTrackName(n.name);
+    if (!o) return;
+    const e = u(i, o);
+    e && (n.name = e.uuid + n.name.slice(o.length));
+  }), t;
+};
+function m(r) {
+  const i = [], t = (n, o) => {
+    var e;
+    (e = n.animations) == null || e.forEach(
+      (c) => i.push(f(c, o))
+    );
+  };
+  return r.traverse((n) => {
+    t(n, [n]), a(n) && n.components.forEach(
+      (o) => t(o, o.contributions)
+    );
+  }), i;
+}
+export {
+  m as c
+};

package/build/chunks/collectAnimations-C3HfZHte.cjs

@@ -0,0 +1 @@
+"use strict";const s=require("three/webgpu"),u=t=>"isDIVENode"in t,a=(t,i)=>{for(const r of t){const n=s.PropertyBinding.findNode(r,i);if(n)return n}return null},f=(t,i)=>{const r=t.clone();return r.tracks.forEach(n=>{const{nodeName:o}=s.PropertyBinding.parseTrackName(n.name);if(!o)return;const e=a(i,o);e&&(n.name=e.uuid+n.name.slice(o.length))}),r};function d(t){const i=[],r=(n,o)=>{var e;(e=n.animations)==null||e.forEach(c=>i.push(f(c,o)))};return t.traverse(n=>{r(n,[n]),u(n)&&n.components.forEach(o=>r(o,o.contributions))}),i}exports.collectAnimations=d;

package/build/chunks/contributesToBounds-C1mva__U.cjs

@@ -0,0 +1 @@
+"use strict";function _(A){return(A.layers.mask&16)!==0}exports.COORDINATE_LAYER_MASK=2;exports.DEFAULT_LAYER_MASK=1;exports.FLOOR_LAYER_MASK=32;exports.HELPER_LAYER_MASK=8;exports.PRODUCT_LAYER_MASK=16;exports.PROXY_LAYER_MASK=64;exports.UI_LAYER_MASK=4;exports.contributesToBounds=_;

package/build/chunks/contributesToBounds-DYmHYES4.mjs

@@ -0,0 +1,14 @@
+const A = 1, _ = 2, R = 4, n = 8, o = 16, t = 32, E = 64;
+function a(s) {
+  return (s.layers.mask & 16) !== 0;
+}
+export {
+  _ as C,
+  A as D,
+  t as F,
+  n as H,
+  o as P,
+  R as U,
+  E as a,
+  a as c
+};

package/build/chunks/detachTransformControls-B4iRF1bw.mjs

@@ -0,0 +1,209 @@
+var p = Object.defineProperty;
+var w = (n, s, e) => s in n ? p(n, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[s] = e;
+var r = (n, s, e) => w(n, typeof s != "symbol" ? s + "" : s, e);
+import { AmbientLight as C, PointLight as f, MeshBasicMaterial as G, FrontSide as S, Mesh as m, SphereGeometry as u, MeshStandardMaterial as y, BufferGeometry as h, CylinderGeometry as M, BufferAttribute as c, BoxGeometry as l, ConeGeometry as A } from "three/webgpu";
+import { f as _, M as P, g } from "./FileTypes-D3Dxr2dj.mjs";
+import { a as E, P as L } from "./contributesToBounds-DYmHYES4.mjs";
+class H extends _ {
+  constructor() {
+    super(new C(16777215, 1));
+    r(this, "isAmbientLightComponent", !0);
+    this.name = "AmbientLightComponent";
+  }
+}
+const b = 0.1, o = 0.8, d = 512;
+class D extends _ {
+  constructor() {
+    super(new f(16777215, 1));
+    r(this, "isPointLightComponent", !0);
+    r(this, "_handle");
+    r(this, "_handleMaterial");
+    this.name = "PointLightComponent";
+    const e = this._light;
+    e.castShadow = !0, e.shadow.mapSize.width = d, e.shadow.mapSize.height = d, this._handleMaterial = new G({
+      color: this._light.color,
+      transparent: !0,
+      opacity: o,
+      side: S
+    }), this._handle = new m(
+      new u(b, 32, 32),
+      this._handleMaterial
+    ), this._handle.layers.mask = E, this.contribute(this._handle);
+  }
+  /**
+   * The editor handle standing in for this light.
+   */
+  get handle() {
+    return this._handle;
+  }
+  setColor(e) {
+    super.setColor(e), this._handleMaterial.color = e;
+  }
+  setIntensity(e) {
+    super.setIntensity(e), this._handleMaterial.opacity = Math.min(
+      e * o,
+      o
+    );
+  }
+  dispose() {
+    super.dispose(), this._handle.geometry.dispose(), this._handleMaterial.dispose();
+  }
+}
+const x = 64, B = 32;
+class N extends P {
+  constructor() {
+    super();
+    r(this, "isPrimitiveComponent", !0);
+    /**
+     * The shape this component was last built from.
+     *
+     * Kept because the built `BufferGeometry` cannot be handed to a clone -- both
+     * would dispose it -- while the descriptor rebuilds it for free.
+     */
+    r(this, "_geometry", null);
+    this.name = "PrimitiveComponent", this._material = new y(), this._mesh = new m(new h(), this._material), this._mesh.name = "PrimitiveMesh", this._mesh.layers.mask = L, this._mesh.castShadow = !0, this._mesh.receiveShadow = !0, this.contribute(this._mesh);
+  }
+  /** The shape this component was last built from, if any. */
+  get geometry() {
+    return this._geometry;
+  }
+  /**
+   * Rebuilds the geometry from a descriptor.
+   *
+   * @param geometry - The shape to build.
+   */
+  setGeometry(e) {
+    const t = this._assembleGeometry(e);
+    t && (this._geometry = e, t.computeVertexNormals(), t.computeBoundingBox(), t.computeBoundingSphere(), this._mesh.geometry.dispose(), this._mesh.geometry = t);
+  }
+  /**
+   * Rebuilds the source's shape, rather than sharing the geometry it built.
+   *
+   * @param source - The component to copy from.
+   */
+  copy(e) {
+    return super.copy(e), e.geometry && this.setGeometry(e.geometry), this;
+  }
+  _assembleGeometry(e) {
+    switch (this._material.flatShading = !1, e.name.toLowerCase()) {
+      case "cylinder":
+        return this._createCylinderGeometry(e);
+      case "sphere":
+        return this._createSphereGeometry(e);
+      case "pyramid":
+        return this._material.flatShading = !0, this._createPyramidGeometry(e);
+      case "cube":
+      case "box":
+      case "plane":
+        return this._createBoxGeometry(e);
+      case "cone":
+        return this._createConeGeometry(e);
+      case "wall":
+        return this._createWallGeometry(e);
+      default:
+        return console.warn(
+          "PrimitiveComponent.setGeometry: Invalid geometry type:",
+          e.name.toLowerCase()
+        ), null;
+    }
+  }
+  _createCylinderGeometry(e) {
+    const t = new M(
+      e.width / 2,
+      e.width / 2,
+      e.height,
+      64
+    );
+    return t.translate(0, e.height / 2, 0), t;
+  }
+  _createSphereGeometry(e) {
+    return new u(
+      e.width / 2,
+      x,
+      B
+    );
+  }
+  _createPyramidGeometry(e) {
+    const t = new Float32Array([
+      -e.width / 2,
+      0,
+      -e.depth / 2,
+      // 0
+      e.width / 2,
+      0,
+      -e.depth / 2,
+      // 1
+      e.width / 2,
+      0,
+      e.depth / 2,
+      // 2
+      -e.width / 2,
+      0,
+      e.depth / 2,
+      // 3
+      0,
+      e.height,
+      0
+    ]), i = new Uint16Array([
+      0,
+      1,
+      2,
+      0,
+      2,
+      3,
+      0,
+      4,
+      1,
+      1,
+      4,
+      2,
+      2,
+      4,
+      3,
+      3,
+      4,
+      0
+    ]), a = new h();
+    return a.setAttribute(
+      "position",
+      new c(t, 3)
+    ), a.setIndex(new c(i, 1)), a;
+  }
+  _createBoxGeometry(e) {
+    const t = new l(
+      e.width,
+      e.height,
+      e.depth
+    );
+    return t.translate(0, e.height / 2, 0), t;
+  }
+  _createConeGeometry(e) {
+    const t = new A(e.width / 2, e.height, 256);
+    return t.translate(0, e.height / 2, 0), t;
+  }
+  _createWallGeometry(e) {
+    const t = new l(
+      e.width,
+      e.height,
+      e.depth || 0.05,
+      16
+    );
+    return t.translate(0, e.height / 2, 0), t;
+  }
+}
+const O = (n) => {
+  const s = g(n);
+  s && s.children.find((e) => {
+    const t = e;
+    if (t.isTransformControlsRoot && t.controls)
+      return t.controls.detach(), !0;
+    const i = e;
+    return i.isTransformControls && i.detach ? (i.detach(), !0) : !1;
+  });
+};
+export {
+  H as A,
+  D as P,
+  N as a,
+  O as d
+};

package/build/chunks/detachTransformControls-CZ2cd5hx.cjs

@@ -0,0 +1 @@
+"use strict";var d=Object.defineProperty;var u=(i,r,e)=>r in i?d(i,r,{enumerable:!0,configurable:!0,writable:!0,value:e}):i[r]=e;var s=(i,r,e)=>u(i,typeof r!="symbol"?r+"":r,e);const n=require("three/webgpu"),h=require("./FileTypes-B-MjfMGd.cjs"),m=require("./contributesToBounds-C1mva__U.cjs");class p extends h.DIVELightComponent{constructor(){super(new n.AmbientLight(16777215,1));s(this,"isAmbientLightComponent",!0);this.name="AmbientLightComponent"}}const _=.1,c=.8,l=512;class w extends h.DIVELightComponent{constructor(){super(new n.PointLight(16777215,1));s(this,"isPointLightComponent",!0);s(this,"_handle");s(this,"_handleMaterial");this.name="PointLightComponent";const e=this._light;e.castShadow=!0,e.shadow.mapSize.width=l,e.shadow.mapSize.height=l,this._handleMaterial=new n.MeshBasicMaterial({color:this._light.color,transparent:!0,opacity:c,side:n.FrontSide}),this._handle=new n.Mesh(new n.SphereGeometry(_,32,32),this._handleMaterial),this._handle.layers.mask=m.PROXY_LAYER_MASK,this.contribute(this._handle)}get handle(){return this._handle}setColor(e){super.setColor(e),this._handleMaterial.color=e}setIntensity(e){super.setIntensity(e),this._handleMaterial.opacity=Math.min(e*c,c)}dispose(){super.dispose(),this._handle.geometry.dispose(),this._handleMaterial.dispose()}}const C=64,G=32;class y extends h.MeshComponent{constructor(){super();s(this,"isPrimitiveComponent",!0);s(this,"_geometry",null);this.name="PrimitiveComponent",this._material=new n.MeshStandardMaterial,this._mesh=new n.Mesh(new n.BufferGeometry,this._material),this._mesh.name="PrimitiveMesh",this._mesh.layers.mask=m.PRODUCT_LAYER_MASK,this._mesh.castShadow=!0,this._mesh.receiveShadow=!0,this.contribute(this._mesh)}get geometry(){return this._geometry}setGeometry(e){const t=this._assembleGeometry(e);t&&(this._geometry=e,t.computeVertexNormals(),t.computeBoundingBox(),t.computeBoundingSphere(),this._mesh.geometry.dispose(),this._mesh.geometry=t)}copy(e){return super.copy(e),e.geometry&&this.setGeometry(e.geometry),this}_assembleGeometry(e){switch(this._material.flatShading=!1,e.name.toLowerCase()){case"cylinder":return this._createCylinderGeometry(e);case"sphere":return this._createSphereGeometry(e);case"pyramid":return this._material.flatShading=!0,this._createPyramidGeometry(e);case"cube":case"box":case"plane":return this._createBoxGeometry(e);case"cone":return this._createConeGeometry(e);case"wall":return this._createWallGeometry(e);default:return console.warn("PrimitiveComponent.setGeometry: Invalid geometry type:",e.name.toLowerCase()),null}}_createCylinderGeometry(e){const t=new n.CylinderGeometry(e.width/2,e.width/2,e.height,64);return t.translate(0,e.height/2,0),t}_createSphereGeometry(e){return new n.SphereGeometry(e.width/2,C,G)}_createPyramidGeometry(e){const t=new Float32Array([-e.width/2,0,-e.depth/2,e.width/2,0,-e.depth/2,e.width/2,0,e.depth/2,-e.width/2,0,e.depth/2,0,e.height,0]),o=new Uint16Array([0,1,2,0,2,3,0,4,1,1,4,2,2,4,3,3,4,0]),a=new n.BufferGeometry;return a.setAttribute("position",new n.BufferAttribute(t,3)),a.setIndex(new n.BufferAttribute(o,1)),a}_createBoxGeometry(e){const t=new n.BoxGeometry(e.width,e.height,e.depth);return t.translate(0,e.height/2,0),t}_createConeGeometry(e){const t=new n.ConeGeometry(e.width/2,e.height,256);return t.translate(0,e.height/2,0),t}_createWallGeometry(e){const t=new n.BoxGeometry(e.width,e.height,e.depth||.05,16);return t.translate(0,e.height/2,0),t}}const f=i=>{const r=h.findSceneRecursive(i);r&&r.children.find(e=>{const t=e;if(t.isTransformControlsRoot&&t.controls)return t.controls.detach(),!0;const o=e;return o.isTransformControls&&o.detach?(o.detach(),!0):!1})};exports.AmbientLightComponent=p;exports.PointLightComponent=w;exports.PrimitiveComponent=y;exports.detachTransformControls=f;

package/build/chunks/{isFileTypeSupported-BBU39V4u.cjs → isFileExtensionSupported-B1q2eWs7.cjs}

@@ -1 +1 @@
-"use strict";const n=require("./FileTypes-Cgyf8ocm.cjs");function o(e){var t;const i=(e.split("/").pop()||"").split(/[?#]/)[0];return!i.includes(".")||i.endsWith(".")?"":((t=i.split(".").pop())==null?void 0:t.toLowerCase())||""}function r(e){return e.toLowerCase()in n.FILE_TYPES}exports.getFileTypeFromUri=o;exports.isFileTypeSupported=r;
+"use strict";const n=require("./FileTypes-B-MjfMGd.cjs");function o(e){var t;const i=(e.split("/").pop()||"").split(/[?#]/)[0];return!i.includes(".")||i.endsWith(".")?"":((t=i.split(".").pop())==null?void 0:t.toLowerCase())||""}function s(e){return e.toLowerCase()in n.FILE_TYPES}exports.getFileTypeFromUri=o;exports.isFileExtensionSupported=s;

package/build/chunks/{isFileTypeSupported-9h8lrIuG.mjs → isFileExtensionSupported-BqOqU3-h.mjs}

@@ -1,4 +1,4 @@
-import { F as n } from "./FileTypes-DiYB3WBp.mjs";
+import { F as n } from "./FileTypes-D3Dxr2dj.mjs";
 function r(e) {
   var i;
   const t = (e.split("/").pop() || "").split(/[?#]/)[0];

package/build/chunks/isVisibleInHierarchy-D9JcLqR5.cjs

@@ -0,0 +1 @@
+"use strict";function n(e,r){return e?e[r]===!0:!1}function i(e,r){if(e)return n(e,r)?e:i(e.parent,r)}function t(e){if(!e)return!1;let r=e;for(;r;){if(!r.visible)return!1;r=r.parent}return!0}exports.findInterface=i;exports.implementsInterface=n;exports.isVisibleInHierarchy=t;

package/build/chunks/isVisibleInHierarchy-KzVGvDEw.mjs

@@ -0,0 +1,21 @@
+function n(r, e) {
+  return r ? r[e] === !0 : !1;
+}
+function i(r, e) {
+  if (r)
+    return n(r, e) ? r : i(r.parent, e);
+}
+function f(r) {
+  if (!r) return !1;
+  let e = r;
+  for (; e; ) {
+    if (!e.visible) return !1;
+    e = e.parent;
+  }
+  return !0;
+}
+export {
+  f as a,
+  i as f,
+  n as i
+};

package/build/components/boundingbox/BoundingBoxComponent.d.ts

@@ -0,0 +1,100 @@
+import { LineSegments, Mesh, Vector3, Box3, ColorRepresentation, Sphere } from 'three/webgpu';
+import { BoundingBox } from '../../engine/boundingbox/BoundingBox.ts';
+import { DIVEComponent } from '../../engine/component/Component.ts';
+import { DIVENode } from '../../engine/node/Node.ts';
+/**
+ * Keeps a {@link BoundingBox} around the node it is attached to, and can draw it.
+ *
+ * The measurement itself is `BoundingBox`, which knows nothing about nodes. What
+ * this adds is the node: it always encloses its owner, and it watches that owner
+ * so the numbers are never behind the scene.
+ *
+ * Watched, and therefore free:
+ *
+ * - a child node or a contributed object arriving or leaving (`childadded` /
+ *   `childremoved`), which is how a finished asset load reaches this -- the
+ *   loader contributes the file's roots to the node
+ * - a component arriving or leaving (`componentadded` / `componentremoved`)
+ * - the node moving, turning or scaling (`object-transform`), whatever moved it
+ *
+ * Not watched, because nothing announces it: geometry swapped in place on a mesh
+ * that is already there. Call {@link refresh} after that.
+ *
+ * An event only marks the box stale; the measurement happens when someone reads
+ * it. That matters because a glTF with fifty root nodes arrives as fifty
+ * `childadded` events, and re-measuring per event would traverse the subtree
+ * fifty times for one load.
+ *
+ * @module
+ */
+export declare class BoundingBoxComponent extends DIVEComponent {
+    readonly isBoundingBoxComponent: true;
+    private _boundingBox;
+    private _oriented;
+    private _stale;
+    private _boxHelper;
+    private _sphereHelper;
+    private _invalidate;
+    constructor();
+    /** The measurement, current as of this read. */
+    get boundingBox(): BoundingBox;
+    /** The box itself, in the frame it was measured in. */
+    get box(): Box3;
+    /** Width, height and depth, in the frame the box was measured in. */
+    get size(): Vector3;
+    /** The centre of the box, in world space. */
+    get center(): Vector3;
+    /** The sphere around the box, in world space. */
+    get sphere(): Sphere;
+    /** The radius of that sphere. */
+    get radius(): number;
+    /** Whether the box is aligned to its owner rather than to the world axes. */
+    get oriented(): boolean;
+    /**
+     * The wireframe box, for anyone that wants to style or inspect it.
+     *
+     * Measures first, like every other read: a helper handed out unplaced would
+     * be a matrix from before whatever last changed the node.
+     */
+    get boxHelper(): LineSegments;
+    /** The wireframe sphere, placed the same way. */
+    get sphereHelper(): Mesh;
+    /**
+     * Chooses between a world-aligned and an owner-aligned box.
+     *
+     * @param oriented - Whether to align the box to the owner.
+     */
+    setOriented(oriented: boolean): this;
+    /**
+     * Marks the box stale, so the next read measures again.
+     *
+     * Only needed for changes nothing announces -- a geometry swapped in place on
+     * a mesh that is already in the node. Everything that goes through the node's
+     * own API arrives here as an event.
+     */
+    refresh(): this;
+    /**
+     * @param visible - Whether the box wireframe is drawn.
+     */
+    setBoxHelperVisible(visible: boolean): void;
+    /**
+     * @param visible - Whether the sphere wireframe is drawn.
+     */
+    setSphereHelperVisible(visible: boolean): void;
+    /**
+     * @param color - The helper colour.
+     */
+    setHelperColor(color: ColorRepresentation): void;
+    /** Keeps a drawn box glued to the node while anything moves it. */
+    tick(): void;
+    protected onAttach(owner: DIVENode): void;
+    protected onDetach(previousOwner: DIVENode): void;
+    /** Re-encloses the owner if anything has happened since the last read. */
+    private _measure;
+    /** Puts the helpers where the measurement says they belong. */
+    private _place;
+    /** Ticks only while there is something drawn to keep up to date. */
+    private _refreshTick;
+    copy(source: this): this;
+    dispose(): void;
+}

package/build/components/boundingbox/index.d.ts

@@ -0,0 +1 @@
+export * from './BoundingBoxComponent.ts';

package/build/components/camera/CameraComponent.d.ts

@@ -0,0 +1,75 @@
+import { Camera, Vector3Like } from 'three/webgpu';
+import { DIVEComponent } from '../../engine/component/Component.ts';
+export declare abstract class DIVECameraComponent extends DIVEComponent {
+    readonly isDIVECameraComponent: true;
+    /**
+     * Everything a camera can show.
+     *
+     * Deliberately every layer, including `DEFAULT_LAYER_MASK` — three puts an
+     * object on layer 0 unless someone says otherwise, and the transform gizmo is
+     * one of them, so an editor that left it out would hide whatever never picked
+     * a layer.
+     *
+     * `COORDINATE_LAYER_MASK` is the one left out. The orientation display adds its
+     * axes to the same scene and draws them with its own camera in the corner;
+     * having that bit here would draw them a second time in the middle of the
+     * viewport.
+     */
+    static readonly EDITOR_VIEW_LAYER_MASK: number;
+    /**
+     * What an end user sees: the content and the ground it stands on.
+     *
+     * A short list on purpose, and one that has to be opted into. Everything that
+     * exists to help build a scene stays out — the gizmo, the helper lines, the
+     * proxies for entities without geometry — and so does `DEFAULT_LAYER_MASK`,
+     * because it is the catch-all: anything that never chose a layer is a thing
+     * nobody decided to show an end user.
+     */
+    static readonly LIVE_VIEW_LAYER_MASK: number;
+    /** Told whenever {@link setCameraLayer} changed what is visible. */
+    onSetCameraLayer: (mask: number) => void;
+    protected _camera: Camera;
+    /**
+     * @param camera - The three camera this component owns.
+     */
+    constructor(camera: Camera);
+    /** The three camera this component owns. */
+    get camera(): Camera;
+    /**
+     * Switches between what an editor shows and what an end user sees.
+     *
+     * @param layer - Which of the two.
+     */
+    setCameraLayer(layer: 'LIVE' | 'EDITOR'): void;
+    /**
+     * Turns the node this camera sits on to face a point.
+     *
+     * Not `owner.lookAt`: three's `Object3D.lookAt` swaps eye and target unless the
+     * object reports `isCamera`, so a plain node comes out oriented 180 degrees the
+     * other way -- its `+Z` at the target instead of its `-Z`. What follows is the
+     * camera branch, applied to the node.
+     *
+     * @param target - The point to face, in world space.
+     */
+    lookAt(target: Vector3Like): void;
+    /**
+     * Takes on what the source camera is allowed to see.
+     *
+     * The layer mask only; `onSetCameraLayer` is wiring a caller installed, not
+     * state, and a clone that inherited the callback would report to a listener
+     * that never asked for it.
+     *
+     * @param source - The component to copy from.
+     */
+    copy(source: this): this;
+    /**
+     * Fits the camera to a new viewport.
+     *
+     * Abstract because what a viewport means differs: a perspective camera changes
+     * its aspect, an orthographic one its extents.
+     *
+     * @param width - Viewport width in pixels.
+     * @param height - Viewport height in pixels.
+     */
+    abstract onResize(width: number, height: number): void;
+}

package/build/components/camera/index.d.ts

@@ -0,0 +1,2 @@
+export * from './CameraComponent.ts';
+export * from './perspective/PerspectiveCameraComponent.ts';

package/build/components/camera/perspective/PerspectiveCameraComponent.d.ts

@@ -0,0 +1,39 @@
+import { PerspectiveCamera } from 'three/webgpu';
+import { DIVECameraComponent } from '../CameraComponent.ts';
+export type DIVEPerspectiveCameraSettings = {
+    /** Field of view in degrees */
+    fov: number;
+    /** Near clipping plane */
+    near: number;
+    /** Far clipping plane */
+    far: number;
+};
+export declare const DIVEPerspectiveCameraDefaultSettings: Required<DIVEPerspectiveCameraSettings>;
+/**
+ * Gives a node a perspective view of the scene.
+ *
+ * Settings arrive through {@link applySettings} rather than the constructor, which
+ * takes no arguments: `Object3D.clone()` calls `new this.constructor()`, so a
+ * required parameter would make cloning a node throw.
+ *
+ * @module
+ */
+export declare class PerspectiveCameraComponent extends DIVECameraComponent {
+    readonly isPerspectiveCameraComponent: true;
+    constructor();
+    get camera(): PerspectiveCamera;
+    /**
+     * Applies whatever the settings carry, leaving the rest as it is.
+     *
+     * @param settings - Field of view, near and far plane.
+     */
+    applySettings(settings: Partial<DIVEPerspectiveCameraSettings>): void;
+    /**
+     * Takes on the source's settings. Aspect is left out: it comes from the
+     * viewport through {@link onResize}, not from whoever configured the camera.
+     *
+     * @param source - The component to copy from.
+     */
+    copy(source: this): this;
+    onResize(width: number, height: number): void;
+}

package/build/components/grid/GridComponent.d.ts

@@ -0,0 +1,50 @@
+import { Mesh } from 'three/webgpu';
+import { DIVEComponent } from '../../engine/component/Component.ts';
+/**
+ * An infinite shader-based grid that follows the camera.
+ *
+ * Draws anti-aliased minor and major grid lines with a radial distance fade. The
+ * plane is finite and snaps to the camera in whole cells, which is what makes it
+ * look endless: the fade hides the edge, and snapping keeps the lines from
+ * crawling as the camera moves.
+ *
+ * The camera comes from `onBeforeRender` on the contributed mesh, which is the
+ * sanctioned way for a component to get one -- `tick` has no view context, and
+ * the grid has to react to whichever camera is rendering rather than to time.
+ *
+ * Visibility lives on the mesh rather than on a node, so hiding the grid never
+ * touches whatever else its node carries.
+ *
+ * @module
+ */
+export declare class GridComponent extends DIVEComponent {
+    readonly isGridComponent: true;
+    private _mesh;
+    private _material;
+    private _uniforms;
+    private _gridSize;
+    constructor();
+    /** The plane the grid is drawn on. */
+    get mesh(): Mesh;
+    /** Whether the grid is drawn. */
+    get visible(): boolean;
+    /** Distance between minor grid lines in meters. */
+    get gridSize(): number;
+    /** How many cells apart the thicker major lines are drawn. */
+    get majorLineEvery(): number;
+    /**
+     * @param visible - Whether the grid is drawn.
+     */
+    setVisibility(visible: boolean): this;
+    /**
+     * @param size - Distance between minor grid lines in meters. Also the step
+     * the plane snaps to, so the lines stay put as the camera moves.
+     */
+    setGridSize(size: number): this;
+    /**
+     * @param n - Draw a thicker major line every N cells.
+     */
+    setMajorLineEvery(n: number): this;
+    copy(source: this): this;
+    dispose(): void;
+}

package/build/components/index.d.ts

@@ -1,11 +1,7 @@
-export * from './floor/Floor.ts';
-export * from './gizmo/Gizmo.ts';
-export * from './grid/Grid.ts';
-export * from './group/Group.ts';
+export * from './camera/index.ts';
+export * from './grid/GridComponent.ts';
+export * from './line/index.ts';
 export * from './light/index.ts';
-export * from './model/Model.ts';
-export * from './node/Node.ts';
-export * from './primitive/Primitive.ts';
-export * from './root/Root.ts';
-export * from './spritetext/SpriteText.ts';
-export * from './boundingbox/BoundingBox.ts';
+export * from './mesh/index.ts';
+export * from './spritetext/SpriteTextComponent.ts';
+export * from './boundingbox/index.ts';

package/build/components/light/LightComponent.d.ts

@@ -0,0 +1,65 @@
+import { Color, Light } from 'three/webgpu';
+import { DIVEComponent } from '../../engine/component/Component.ts';
+/**
+ * Base class for every light a node can carry.
+ *
+ * Exists so callers never have to know *which* kind of light a node holds: a
+ * scene light is a node with a hemisphere and a directional component, and
+ * applying colour or intensity to it is the same loop as for a single point
+ * light. That is what keeps the state layer free of per-light-type branching.
+ *
+ * Takes constructor arguments, unlike concrete components: it is abstract and
+ * therefore never the target of `new this.constructor()` in `clone()`.
+ *
+ * @module
+ */
+export declare abstract class DIVELightComponent extends DIVEComponent {
+    readonly isDIVELightComponent: true;
+    protected _light: Light;
+    /**
+     * Scales the intensity handed to {@link setIntensity}.
+     *
+     * Lets a multi-light node keep its relative balance -- a scene light's
+     * directional part has always been brighter than its hemisphere part -- while
+     * callers still deal in a single value.
+     */
+    private _intensityFactor;
+    /**
+     * @param light - The three light this component owns.
+     * @param intensityFactor - Multiplier applied to the requested intensity.
+     */
+    constructor(light: Light, intensityFactor?: number);
+    /**
+     * The three light this component owns.
+     */
+    get light(): Light;
+    /**
+     * @param color - The light colour.
+     */
+    setColor(color: Color): void;
+    /**
+     * @param intensity - The light intensity, before the component's factor.
+     */
+    setIntensity(intensity: number): void;
+    /**
+     * @param enabled - Whether the light contributes to the scene.
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Takes on the source's colour, brightness, direction and on/off state.
+     *
+     * Goes through the setters rather than writing the light, so a subclass that
+     * mirrors them onto a proxy -- `PointLightComponent` and its handle -- keeps
+     * up. {@link setIntensity} applies the factor, so the stored value has to be
+     * divided back out first; both components are the same class and therefore
+     * carry the same factor.
+     *
+     * The light's position is direction rather than placement for a hemisphere or
+     * a directional light, and unused for the others, so copying it is right in
+     * every case.
+     *
+     * @param source - The component to copy from.
+     */
+    copy(source: this): this;
+    dispose(): void;
+}