ris-framework 0.2.0-dev.14 → 0.2.0-dev.16

package/dist/index.js

@@ -1,4 +1,4 @@
-import { vec4, vec3, mat4, vec2, quat } from "gl-matrix";
+import { vec4, vec3, quat, mat4, mat3, vec2 } from "gl-matrix";
 var RenderingBackend = /* @__PURE__ */ ((RenderingBackend2) => {
   RenderingBackend2[RenderingBackend2["DEFAULT"] = 0] = "DEFAULT";
   RenderingBackend2[RenderingBackend2["WEB_GPU"] = 1] = "WEB_GPU";
@@ -35,7 +35,7 @@ class IFrameworkConfiguration {
   backBufferSize;
   /** The texture filtering to configure */
   textureFiltering;
-  /** The texture color space to use by default. By default, it is {@link ColorSpace.SRGB}. */
+  /** The texture color space to use by default. By default, it is {@link ColorSpace.LINEAR}. */
   textureColorSpace;
   /**
   * The HTMLCanvasElement to use for rendering.
@@ -1052,6 +1052,7 @@ class TextureUtilities {
     [TextureFormat.BC7_RGBA_UNORM]: m.BC7_RGBA,
     [TextureFormat.ETC2_RGBA8_UNORM]: m.ETC2_RGBA,
     [TextureFormat.PVRTC_4BPPV1_RGBA]: m.PVRTC1_4_RGBA,
+    [TextureFormat.PVRTC_4BPPV1_RGB]: m.PVRTC1_4_RGB,
     // Basis transcodes to the same blocks for sRGB; only the GPU format differs.
     [TextureFormat.RGBA_8_UNORM_SRGB]: m.RGBA32,
     [TextureFormat.ASTC_4X4_RGBA_SRGB]: m.ASTC_4X4_RGBA,
@@ -1185,6 +1186,18 @@ class TextureUtilities {
   static isSrgbFormat(textureFormat) {
     return this._srgbFormats.includes(textureFormat);
   }
+  /**
+   * Returns the requested format if it is the file's format or its sRGB/linear variant.
+   * @param fileFormat The format the data is stored in.
+   * @param requested The explicitly requested format.
+   * @throws If the requested format cannot reinterpret the data.
+   */
+  static resolveExplicitFormat(fileFormat, requested) {
+    if (requested == fileFormat || requested == TextureUtilities.convertToSrgbVariant(fileFormat) || requested == TextureUtilities.convertToLinearVariant(fileFormat)) {
+      return requested;
+    }
+    throw new Error(`Texture format ${requested} is not compatible with the file's format ${fileFormat}; only its sRGB or linear variant can be used.`);
+  }
 }
 var BufferUsage = /* @__PURE__ */ ((BufferUsage2) => {
   BufferUsage2[BufferUsage2["NONE"] = 0] = "NONE";
@@ -1643,48 +1656,23 @@ let SamplerDescriptor$1 = class SamplerDescriptor {
    */
   mipMapFilter = MipMapSamplerFilter.NONE;
 };
-var PrimitiveTopology = /* @__PURE__ */ ((PrimitiveTopology2) => {
-  PrimitiveTopology2[PrimitiveTopology2["LINE_LIST"] = 0] = "LINE_LIST";
-  PrimitiveTopology2[PrimitiveTopology2["LINE_STRIP"] = 1] = "LINE_STRIP";
-  PrimitiveTopology2[PrimitiveTopology2["POINT_LIST"] = 2] = "POINT_LIST";
-  PrimitiveTopology2[PrimitiveTopology2["TRIANGLE_LIST"] = 3] = "TRIANGLE_LIST";
-  PrimitiveTopology2[PrimitiveTopology2["TRIANGLE_STRIP"] = 4] = "TRIANGLE_STRIP";
-  return PrimitiveTopology2;
-})(PrimitiveTopology || {});
-var CullMode = /* @__PURE__ */ ((CullMode2) => {
-  CullMode2[CullMode2["NONE"] = 0] = "NONE";
-  CullMode2[CullMode2["BACK"] = 1] = "BACK";
-  CullMode2[CullMode2["FRONT"] = 2] = "FRONT";
-  return CullMode2;
-})(CullMode || {});
-var FrontFace = /* @__PURE__ */ ((FrontFace2) => {
-  FrontFace2[FrontFace2["CW"] = 0] = "CW";
-  FrontFace2[FrontFace2["CCW"] = 1] = "CCW";
-  return FrontFace2;
-})(FrontFace || {});
-class PrimitiveStateDescriptor {
-  /**
-   * The topology of the primitive.
-   * By default, it is set to TRIANGLE_LIST.
-   */
-  topology = PrimitiveTopology.TRIANGLE_LIST;
-  /**
-   * The culling mode.
-   * By default, it is set to BACK.
-   */
-  cullFace = CullMode.BACK;
-  /**
-   * The front face.
-   * By default, it is set to CCW(counter clock-wise).
-   */
-  frontFace = FrontFace.CCW;
-}
 var PowerPreferenceType = /* @__PURE__ */ ((PowerPreferenceType2) => {
   PowerPreferenceType2["DEFAULT"] = "default";
   PowerPreferenceType2["LOW_POWER"] = "low-power";
   PowerPreferenceType2["HIGH_PERFORMANCE"] = "high-performance";
   return PowerPreferenceType2;
 })(PowerPreferenceType || {});
+var Culling = /* @__PURE__ */ ((Culling2) => {
+  Culling2[Culling2["None"] = 0] = "None";
+  Culling2[Culling2["Back"] = 1] = "Back";
+  Culling2[Culling2["Front"] = 2] = "Front";
+  return Culling2;
+})(Culling || {});
+var ColorSpace = /* @__PURE__ */ ((ColorSpace2) => {
+  ColorSpace2["LINEAR"] = "LINEAR";
+  ColorSpace2["SRGB"] = "SRGB";
+  return ColorSpace2;
+})(ColorSpace || {});
 class MathHelper {
   /**
    * The value of half PI.
@@ -1887,9 +1875,272 @@ class MathHelper {
     throw new Error("Not implemented");
   }
 }
+class Node {
+  _children = [];
+  _parent;
+  /** The child nodes of this node. */
+  get children() {
+    return this._children;
+  }
+  /** The parent node of this node, if any. */
+  get parent() {
+    return this._parent;
+  }
+  /**
+   * Adds a child. It is removed from its previous parent first. Adding an existing child does nothing.
+   * @param child The child to add.
+   * @throws Error when adding the node to itself or to one of its descendants.
+   */
+  addChild(child) {
+    if (child._parent === this) {
+      return;
+    }
+    for (let n2 = this; n2; n2 = n2._parent) {
+      if (n2 === child) {
+        throw new Error("Node.addChild: a node cannot be added to itself or to one of its descendants.");
+      }
+    }
+    child._parent?.removeChild(child);
+    child._parent = this;
+    this._children.push(child);
+  }
+  /**
+   * Removes a child.
+   * @param child The child to remove.
+   * @returns True when it was a child of this node.
+   */
+  removeChild(child) {
+    const index = this._children.indexOf(child);
+    if (index < 0) {
+      return false;
+    }
+    this._children.splice(index, 1);
+    child._parent = void 0;
+    return true;
+  }
+}
+class TransformNode extends Node {
+  _rotationQuat = quat.create();
+  _localMatrix = mat4.create();
+  _worldMatrix = mat4.create();
+  // Cached copies to detect in-place edits; NaN forces the first computation.
+  _lastPosition = vec3.fromValues(NaN, NaN, NaN);
+  _lastRotation = vec3.create();
+  _lastScale = vec3.create();
+  /**
+   * The constructor.
+   */
+  constructor() {
+    super();
+    this.position = vec3.fromValues(0, 0, 0);
+    this.rotation = vec3.fromValues(0, 0, 0);
+    this.scale = vec3.fromValues(1, 1, 1);
+  }
+  /** Position relative to the parent (the world, without one). Defaults to the origin. In-place edits are detected. */
+  position;
+  /**
+   * Euler rotation in radians, applied in Y, X, Z order (yaw, pitch, roll): `R = Ry * Rx * Rz`.
+   * Defaults to (0, 0, 0). In-place edits are detected.
+   */
+  rotation;
+  /** Scale. Defaults to (1, 1, 1). In-place edits are detected. */
+  scale;
+  /** The local matrix `T * R * S`, recomputed only when position, rotation or scale changed. */
+  get localMatrix() {
+    if (!vec3.exactEquals(this._lastPosition, this.position) || !vec3.exactEquals(this._lastRotation, this.rotation) || !vec3.exactEquals(this._lastScale, this.scale)) {
+      vec3.copy(this._lastPosition, this.position);
+      vec3.copy(this._lastRotation, this.rotation);
+      vec3.copy(this._lastScale, this.scale);
+      const q = quat.identity(this._rotationQuat);
+      quat.rotateY(q, q, this.rotation[1]);
+      quat.rotateX(q, q, this.rotation[0]);
+      quat.rotateZ(q, q, this.rotation[2]);
+      mat4.fromRotationTranslationScale(this._localMatrix, q, this.position, this.scale);
+    }
+    return this._localMatrix;
+  }
+  /**
+   * The model (world) matrix: {@link localMatrix}, or `parent.modelMatrix * localMatrix` when the parent is a
+   * `TransformNode`. Always the same matrix object for a node without a parent transform.
+   */
+  get modelMatrix() {
+    const parent = this.parent;
+    if (parent instanceof TransformNode) {
+      return mat4.multiply(this._worldMatrix, parent.modelMatrix, this.localMatrix);
+    }
+    return this.localMatrix;
+  }
+  /**
+   * Updates the node and its transform children, recomputing the matrices if needed.
+   * Called by `Scene.update` for scene nodes; optional otherwise.
+   * @param gameTime The {@link GameTime}
+   */
+  update(gameTime) {
+    void this.modelMatrix;
+    for (const child of this.children) {
+      if (child instanceof TransformNode) {
+        child.update(gameTime);
+      }
+    }
+  }
+}
+const _f = vec3.create();
+const _x = vec3.create();
+const _y = vec3.create();
+const _z = vec3.create();
+const _u = vec3.create();
+const _m = mat4.create();
+const _n = mat3.create();
+const _p = vec3.create();
+const _t = vec3.create();
+class CameraTransformUtilities {
+  /**
+   * Writes the view matrix `inverse(T * R)` from a world matrix, ignoring scale.
+   * @param out The view matrix.
+   * @param world The camera's world matrix (`transform.modelMatrix`).
+   */
+  static viewFromWorld(out, world) {
+    mat4.copy(out, world);
+    for (let c2 = 0; c2 < 3; c2++) {
+      const i2 = c2 * 4;
+      const length = Math.hypot(out[i2], out[i2 + 1], out[i2 + 2]) || 1;
+      out[i2] /= length;
+      out[i2 + 1] /= length;
+      out[i2 + 2] /= length;
+    }
+    return mat4.invert(out, out) ?? mat4.identity(out);
+  }
+  /**
+   * Writes the Euler rotation (the transform's Y-X-Z order) that makes a camera at `position` look at `target`
+   * with `up` as the up hint (a non-vertical up rolls the camera). When `up` is parallel to the view direction,
+   * the world axis least aligned with the view direction is used instead. Leaves `out` unchanged when the points are equal.
+   * @param out The rotation.
+   * @param position The camera position.
+   * @param target The point to look at.
+   * @param up The up hint. By default, world +Y.
+   */
+  static lookAtRotation(out, position, target, up = [0, 1, 0]) {
+    vec3.sub(_f, target, position);
+    if (vec3.sqrLen(_f) === 0) {
+      return out;
+    }
+    vec3.normalize(_f, _f);
+    vec3.negate(_z, _f);
+    vec3.cross(_x, up, _z);
+    if (vec3.sqrLen(_x) < 1e-12) {
+      const ax = Math.abs(_f[0]), ay = Math.abs(_f[1]), az = Math.abs(_f[2]);
+      vec3.set(_u, 0, 0, 0);
+      _u[ay <= ax && ay <= az ? 1 : az <= ax ? 2 : 0] = 1;
+      vec3.cross(_x, _u, _z);
+    }
+    vec3.normalize(_x, _x);
+    vec3.cross(_y, _z, _x);
+    const m23 = _z[1];
+    out[0] = Math.asin(Math.max(-1, Math.min(1, -m23)));
+    if (Math.abs(m23) < 0.9999999) {
+      out[1] = Math.atan2(_z[0], _z[2]);
+      out[2] = Math.atan2(_x[1], _y[1]);
+    } else {
+      out[1] = Math.atan2(-_x[2], _x[0]);
+      out[2] = 0;
+    }
+    return out;
+  }
+  /**
+   * Writes the camera's forward direction (unit length) from a world matrix.
+   * @param out The direction.
+   * @param world The camera's world matrix.
+   */
+  static forwardFromWorld(out, world) {
+    vec3.set(out, -world[8], -world[9], -world[10]);
+    return vec3.normalize(out, out);
+  }
+  /**
+   * Rotates a camera transform to look at a world-space point with a world-space up hint.
+   * When the transform has a `TransformNode` parent, the target and up are converted into the parent's space.
+   * @param transform The camera transform.
+   * @param target The world point.
+   * @param up The world up hint.
+   */
+  static aimTransform(transform, target, up) {
+    const parent = transform.parent;
+    if (parent instanceof TransformNode) {
+      mat4.invert(_m, parent.modelMatrix);
+      vec3.transformMat4(_t, target, _m);
+      mat3.fromMat4(_n, _m);
+      vec3.transformMat3(_p, up, _n);
+      CameraTransformUtilities.lookAtRotation(transform.rotation, transform.position, _t, _p);
+    } else {
+      CameraTransformUtilities.lookAtRotation(transform.rotation, transform.position, target, up);
+    }
+  }
+  /**
+   * Writes a world position into `transform.position`, converting into the parent's space when it has a `TransformNode` parent.
+   */
+  static setWorldPosition(transform, world) {
+    const parent = transform.parent;
+    if (parent instanceof TransformNode) {
+      mat4.invert(_m, parent.modelMatrix);
+      vec3.transformMat4(transform.position, world, _m);
+    } else {
+      vec3.copy(transform.position, world);
+    }
+  }
+}
+class CameraAim {
+  constructor(_transform) {
+    this._transform = _transform;
+  }
+  _transform;
+  _target = vec3.create();
+  _hasTarget = false;
+  _up = vec3.fromValues(0, 1, 0);
+  setEye(eye) {
+    CameraTransformUtilities.setWorldPosition(this._transform(), eye);
+    if (this._hasTarget) {
+      this.aim();
+    }
+  }
+  getEye(out = vec3.create()) {
+    const m2 = this._transform().modelMatrix;
+    return vec3.set(out, m2[12], m2[13], m2[14]);
+  }
+  setTarget(target) {
+    vec3.copy(this._target, target);
+    this._hasTarget = true;
+    this.aim();
+  }
+  getTarget(out = vec3.create()) {
+    if (this._hasTarget) {
+      return vec3.copy(out, this._target);
+    }
+    const m2 = this._transform().modelMatrix;
+    CameraTransformUtilities.forwardFromWorld(_f, m2);
+    return vec3.set(out, m2[12] + _f[0], m2[13] + _f[1], m2[14] + _f[2]);
+  }
+  setUp(up) {
+    vec3.copy(this._up, up);
+    if (this._hasTarget) {
+      this.aim();
+    }
+  }
+  getUp(out = vec3.create()) {
+    return vec3.copy(out, this._up);
+  }
+  /** One-shot look-at with the current up; forgets the stored target. */
+  lookAt(target) {
+    this._hasTarget = false;
+    CameraTransformUtilities.aimTransform(this._transform(), target, this._up);
+  }
+  /** Re-aims at the stored target. */
+  aim() {
+    CameraTransformUtilities.aimTransform(this._transform(), this._target, this._up);
+  }
+}
 class PerspectiveCamera {
   _framework;
-  _tempVec3 = vec3.create();
+  _lastWorld = mat4.fromValues(NaN, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  _positionData = [0, 0, 0, 0];
   _projectionMatrix = mat4.create();
   _viewMatrix = mat4.create();
   _projectionViewMatrix = mat4.create();
@@ -1911,15 +2162,11 @@ class PerspectiveCamera {
     this.aspectRatio = descriptor?.aspectRatio ?? 1;
     this.nearPlane = descriptor?.near ?? 0.01;
     this.farPlane = descriptor?.far ?? 100;
-    if (descriptor?.eye) {
-      vec3.copy(this.eye, descriptor.eye);
-    }
-    if (descriptor?.target) {
-      vec3.copy(this.target, descriptor.target);
-    }
+    vec3.copy(this.transform.position, descriptor?.position ?? descriptor?.eye ?? [0, 0, -3]);
     if (descriptor?.up) {
-      vec3.copy(this.up, descriptor.up);
+      this.setUp(descriptor.up);
     }
+    this.setTarget(descriptor?.target ?? [0, 0, 0]);
     if (scene) {
       scene.add(this);
     }
@@ -1978,21 +2225,47 @@ class PerspectiveCamera {
     return this._positionBuffer;
   }
   /**
-   * The eye position of the camera.
-   */
-  eye = vec3.fromValues(0, 0, 3);
-  /**
-   * The target position of the camera.
+   * The camera transform: the single source of the view. The camera looks down its local -Z axis;
+   * the view matrix is `inverse(T * R)` of `transform.modelMatrix` (scale is ignored).
+   * By default, at (0, 0, -3) looking at the origin.
    */
-  target = vec3.create();
+  transform = new TransformNode();
+  /** The unit direction the camera looks in, from the transform. */
+  get direction() {
+    return CameraTransformUtilities.forwardFromWorld(this._direction, this.transform.modelMatrix);
+  }
+  _aim = new CameraAim(() => this.transform);
   /**
-   * The up vector of the camera.
+   * Rotates the transform once so the camera looks at a world point, using the current up ({@link getUp}).
+   * Forgets the target stored by {@link setTarget}, so a later {@link setEye} does not re-aim.
+   * @param target The point to look at.
    */
-  up = vec3.fromValues(0, 1, 0);
-  /** The direction of a camera. */
-  get direction() {
-    vec3.sub(this._direction, this.target, this.eye);
-    return this._direction;
+  lookAt(target) {
+    this._aim.lookAt(target);
+  }
+  /** @inheritDoc */
+  setEye(eye) {
+    this._aim.setEye(eye);
+  }
+  /** @inheritDoc */
+  getEye(out) {
+    return this._aim.getEye(out);
+  }
+  /** @inheritDoc */
+  setTarget(target) {
+    this._aim.setTarget(target);
+  }
+  /** @inheritDoc */
+  getTarget(out) {
+    return this._aim.getTarget(out);
+  }
+  /** @inheritDoc */
+  setUp(up) {
+    this._aim.setUp(up);
+  }
+  /** @inheritDoc */
+  getUp(out) {
+    return this._aim.getUp(out);
   }
   /**
    * The field of view of the camera.
@@ -2022,22 +2295,24 @@ class PerspectiveCamera {
     this._projectionBuffer = this._framework.bufferFactory.createUniformBuffer(this.projectionMatrix, bufferUsage);
     this._viewBuffer = this._framework.bufferFactory.createUniformBuffer(this.viewMatrix, bufferUsage);
   }
-  /**
-   * The eye in world space, as used by the view matrix: z is flipped for the right-handed look-at.
-   * This is what {@link positionBuffer} holds, std140 `vec3` (padded to 16 bytes).
-   */
+  /** The world position, std140 `vec3` (padded to 16 bytes). This is what {@link positionBuffer} holds. */
   _worldEye() {
-    return [this.eye[0], this.eye[1], -this.eye[2], 0];
+    const m2 = this.transform.modelMatrix;
+    this._positionData[0] = m2[12];
+    this._positionData[1] = m2[13];
+    this._positionData[2] = m2[14];
+    return this._positionData;
   }
   /**
    * Updates the camera matrices.
    */
   _updateMatrices() {
     mat4.perspectiveNO(this._projectionMatrix, this.fieldOfView, this.aspectRatio, this.nearPlane, this.farPlane);
-    this._tempVec3[0] = this.eye[0];
-    this._tempVec3[1] = this.eye[1];
-    this._tempVec3[2] = -this.eye[2];
-    mat4.lookAt(this.viewMatrix, this._tempVec3, this.target, this.up);
+    const world = this.transform.modelMatrix;
+    if (!mat4.exactEquals(this._lastWorld, world)) {
+      mat4.copy(this._lastWorld, world);
+      CameraTransformUtilities.viewFromWorld(this.viewMatrix, world);
+    }
     mat4.multiply(this.projectionViewMatrix, this.projectionMatrix, this.viewMatrix);
   }
   /** @inheritDoc */
@@ -2414,8 +2689,8 @@ class OrbitCamera {
     this.supportedInputTypes = supportedInputTypes;
     this._coreCamera = coreCamera;
     this._inputManager = inputManager;
-    this.eye = vec3.fromValues(0, 0, -3);
-    this.target = vec3.fromValues(0, 0, 0);
+    vec3.set(this._coreCamera.transform.position, 0, 0, 3);
+    this._syncFromTransform();
     void this.POSITIVE_179_DEG;
     void this.findTarget;
   }
@@ -2431,6 +2706,7 @@ class OrbitCamera {
   _coreCamera;
   _inputManager;
   /** The rotation around the vertical axis. */
+  _target = vec3.create();
   _yaw = 0;
   /** The tilt of the camera.*/
   _pitch = 0;
@@ -2443,7 +2719,6 @@ class OrbitCamera {
   /** The speed of pinch.*/
   pinchSpeed = 1;
   /** The up vector. */
-  up = vec3.fromValues(0, 1, 0);
   /** The clamp values of pitch axis */
   pitchClamp = vec2.fromValues(-this.POSITIVE_89_DEG, this.POSITIVE_89_DEG);
   /** @inheritDoc */
@@ -2484,33 +2759,56 @@ class OrbitCamera {
   }
   /** Orbit controls can be used if this button is pressed. */
   orbitButton = MouseButton.LEFT;
-  /**
-   * The eye position of the camera.
-   */
-  get eye() {
-    return this._coreCamera.eye;
+  /** The orbit camera's transform: the core camera's transform. Its position is the eye; the rotation is set each update to look at {@link target}. */
+  get transform() {
+    return this._coreCamera.transform;
   }
   /**
-   * The eye position of the camera.
+   * Sets the point the camera orbits around and looks at (the core camera's target). By default, the origin.
+   * @param target The world point.
    */
-  set eye(value) {
-    this._coreCamera.eye = value;
-    this._setPitchAndYawFromDirection(this._coreCamera.direction);
+  setTarget(target) {
+    vec3.copy(this._target, target);
+    this._syncFromTransform();
   }
-  /**
-   * The eye position of the camera.
-   */
-  get target() {
-    return this._coreCamera.target;
+  /** @inheritDoc */
+  getTarget(out = vec3.create()) {
+    return vec3.copy(out, this._target);
   }
   /**
-   * The eye position of the camera.
+   * Moves the camera to a world position and re-derives the orbit (pitch, yaw, distance) around the target.
+   * @param eye The world position.
    */
-  set target(value) {
-    this._coreCamera.target = value;
-    this._setPitchAndYawFromDirection(this._coreCamera.direction);
+  setEye(eye) {
+    CameraTransformUtilities.setWorldPosition(this._coreCamera.transform, eye);
+    this._syncFromTransform();
+  }
+  /** @inheritDoc */
+  getEye(out) {
+    return this._coreCamera.getEye(out);
+  }
+  /** Sets the up vector the core camera aims with (the orbit angles stay around world +Y, so this rolls the view). */
+  setUp(up) {
+    this._coreCamera.setUp(up);
+    this._coreCamera.setTarget(this._target);
+  }
+  /** @inheritDoc */
+  getUp(out) {
+    return this._coreCamera.getUp(out);
+  }
+  /** The eye: `transform.position` (world space). */
+  get _eye() {
+    return this._coreCamera.transform.position;
+  }
+  /** Re-derives pitch and yaw from the eye and target, and aims the core camera at the target. */
+  _syncFromTransform() {
+    vec3.sub(this._tempDirection, this._target, this._eye);
+    if (vec3.sqrLen(this._tempDirection) === 0) {
+      return;
+    }
+    this._setPitchAndYawFromDirection(this._tempDirection);
+    this._coreCamera.setTarget(this._target);
   }
-  /** Gets the core camera.*/
   get coreCamera() {
     return this._coreCamera;
   }
@@ -2539,11 +2837,11 @@ class OrbitCamera {
     vec3.normalize(lookDirection, lookDirection);
     const y2 = MathHelper.clamp(lookDirection[1], -1, 1);
     this._pitch = -this._pitchClamp(Math.asin(y2));
-    this._yaw = -Math.atan2(lookDirection[0], lookDirection[2]);
+    this._yaw = -Math.atan2(lookDirection[0], 0 - lookDirection[2]);
   }
   _calculateOrbitMovement() {
     this._pitch = this._pitchClamp(this._pitch);
-    vec3.sub(this._tempVec3, this._coreCamera.target, this._coreCamera.eye);
+    vec3.sub(this._tempVec3, this._target, this._eye);
     const radius = vec3.len(this._tempVec3);
     const sinPitch = Math.sin(this._pitch);
     const cosPitch = Math.cos(this._pitch);
@@ -2552,8 +2850,9 @@ class OrbitCamera {
     const z = radius * cosPitch * Math.cos(this._yaw);
     this._tempVec3[0] = x2;
     this._tempVec3[1] = y2;
-    this._tempVec3[2] = -z;
-    vec3.add(this._coreCamera.eye, this._coreCamera.target, this._tempVec3);
+    this._tempVec3[2] = z;
+    vec3.add(this._eye, this._target, this._tempVec3);
+    this._coreCamera.setTarget(this._target);
   }
   /**
    * Handles the mouse movement for orbit camera.
@@ -2605,9 +2904,9 @@ class OrbitCamera {
     if (diff == 0) {
       return;
     }
-    vec3.copy(this._tempDirection, this.direction);
+    vec3.sub(this._tempDirection, this._target, this._eye);
     vec3.normalize(this._tempDirection, this._tempDirection);
-    vec3.copy(this._tempNextEye, this.eye);
+    vec3.copy(this._tempNextEye, this._eye);
     if (diff < 0) {
       vec3.scale(this._tempVec3, this._tempDirection, this.pinchSpeed * deltaTime);
       vec3.sub(this._tempNextEye, this._tempNextEye, this._tempVec3);
@@ -2615,16 +2914,16 @@ class OrbitCamera {
       vec3.scale(this._tempVec3, this._tempDirection, this.pinchSpeed * deltaTime);
       vec3.add(this._tempNextEye, this._tempNextEye, this._tempVec3);
     }
-    vec3.sub(this._tempNextDirection, this.target, this._tempNextEye);
-    const nextLength = this._tempNextDirection.length;
+    vec3.sub(this._tempNextDirection, this._target, this._tempNextEye);
+    const nextLength = vec3.len(this._tempNextDirection);
     vec3.normalize(this._tempNextDirection, this._tempNextDirection);
     vec3.sub(this._tempVec3, this._tempNextDirection, this._tempDirection);
     const lenSq = vec3.sqrLen(this._tempVec3);
     if (nextLength < this._coreCamera.nearPlane || nextLength > this._coreCamera.farPlane || lenSq > 0.1) {
       return;
     }
-    vec3.copy(this._coreCamera.eye, this._tempNextEye);
-    this._setPitchAndYawFromDirection(this._coreCamera.direction);
+    vec3.copy(this._eye, this._tempNextEye);
+    this._syncFromTransform();
   }
   /** Handles forward/backward movement */
   _handleMouseForwardBackwardMovement(mouseState, deltaTime) {
@@ -2632,7 +2931,7 @@ class OrbitCamera {
     if (mouseScrollPos == 0) {
       return;
     }
-    vec3.copy(this._tempDirection, this.direction);
+    vec3.sub(this._tempDirection, this._target, this._eye);
     const distance = vec3.len(this._tempDirection);
     const step = MathHelper.map(
       distance,
@@ -2646,7 +2945,7 @@ class OrbitCamera {
       trueScrollSpeed = this.maxScrollSpeed;
     }
     vec3.normalize(this._tempDirection, this._tempDirection);
-    vec3.copy(this._tempNextEye, this.eye);
+    vec3.copy(this._tempNextEye, this._eye);
     if (mouseScrollPos > 0) {
       vec3.scale(this._tempVec3, this._tempDirection, trueScrollSpeed * deltaTime);
       vec3.sub(this._tempNextEye, this._tempNextEye, this._tempVec3);
@@ -2654,16 +2953,16 @@ class OrbitCamera {
       vec3.scale(this._tempVec3, this._tempDirection, trueScrollSpeed * deltaTime);
       vec3.add(this._tempNextEye, this._tempNextEye, this._tempVec3);
     }
-    vec3.sub(this._tempNextDirection, this.target, this._tempNextEye);
-    const nextLength = this._tempNextDirection.length;
+    vec3.sub(this._tempNextDirection, this._target, this._tempNextEye);
+    const nextLength = vec3.len(this._tempNextDirection);
     vec3.normalize(this._tempNextDirection, this._tempNextDirection);
     vec3.sub(this._tempVec3, this._tempNextDirection, this._tempDirection);
     const lenSq = vec3.sqrLen(this._tempVec3);
     if (nextLength < this._coreCamera.nearPlane || nextLength > this._coreCamera.farPlane || lenSq > 0.01) {
       return;
     }
-    vec3.copy(this._coreCamera.eye, this._tempNextEye);
-    this._setPitchAndYawFromDirection(this._coreCamera.direction);
+    vec3.copy(this._eye, this._tempNextEye);
+    this._syncFromTransform();
   }
   /** @inheritDoc */
   update(time) {
@@ -2681,6 +2980,7 @@ class OrbitCamera {
         this._handleMouseForwardBackwardMovement(mouseState, deltaTime);
       }
     }
+    this._coreCamera.setTarget(this._target);
     this._coreCamera.update(time);
   }
   /** @inheritDoc */
@@ -2689,12 +2989,11 @@ class OrbitCamera {
   }
 }
 class OrthographicCamera {
-  static UP_VECTOR = vec3.fromValues(0, 1, 0);
   _framework;
   /** @ts-ignore */
   _zSpaceLength;
-  _eye;
-  _target;
+  _lastWorld = mat4.fromValues(NaN, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  _direction = vec3.create();
   _left;
   _right;
   _top;
@@ -2705,9 +3004,49 @@ class OrthographicCamera {
   _projectionMatrix = mat4.create();
   _viewMatrix = mat4.create();
   _projectionViewMatrix = mat4.create();
-  position = vec3.create();
-  target = vec3.create();
-  direction = vec3.create();
+  /**
+   * The camera transform: the single source of the view. The camera looks down its local -Z axis;
+   * the view matrix is `inverse(T * R)` of `transform.modelMatrix` (scale is ignored).
+   * By default, at (0, 0, 1) looking down -Z at the origin.
+   */
+  transform = new TransformNode();
+  /** The unit direction the camera looks in, from the transform. */
+  get direction() {
+    return CameraTransformUtilities.forwardFromWorld(this._direction, this.transform.modelMatrix);
+  }
+  _aim = new CameraAim(() => this.transform);
+  /**
+   * Rotates the transform once so the camera looks at a world point, using the current up ({@link getUp}).
+   * Forgets the target stored by {@link setTarget}, so a later {@link setEye} does not re-aim.
+   * @param target The point to look at.
+   */
+  lookAt(target) {
+    this._aim.lookAt(target);
+  }
+  /** @inheritDoc */
+  setEye(eye) {
+    this._aim.setEye(eye);
+  }
+  /** @inheritDoc */
+  getEye(out) {
+    return this._aim.getEye(out);
+  }
+  /** @inheritDoc */
+  setTarget(target) {
+    this._aim.setTarget(target);
+  }
+  /** @inheritDoc */
+  getTarget(out) {
+    return this._aim.getTarget(out);
+  }
+  /** @inheritDoc */
+  setUp(up) {
+    this._aim.setUp(up);
+  }
+  /** @inheritDoc */
+  getUp(out) {
+    return this._aim.getUp(out);
+  }
   _projectionBuffer = null;
   _viewBuffer = null;
   _projectionViewBuffer = null;
@@ -2732,8 +3071,7 @@ class OrthographicCamera {
     this._bottom = bottom;
     this._near = near;
     this._far = far;
-    this._eye = vec3.fromValues(0, 0, 1);
-    this._target = vec3.fromValues(0, 0, 0);
+    vec3.set(this.transform.position, 0, 0, 1);
     this._zSpaceLength = 2;
     this._updateMatrices();
   }
@@ -2804,17 +3142,6 @@ class OrthographicCamera {
     this._isDirty = true;
   }
   /** @inheritDoc */
-  get eye() {
-    return this._eye;
-  }
-  /** @inheritDoc */
-  set eye(value) {
-    if (this._eye === value)
-      return;
-    this._eye = value;
-    this._isDirty = true;
-  }
-  /** @inheritDoc */
   get projectionMatrix() {
     return this._projectionMatrix;
   }
@@ -2842,18 +3169,25 @@ class OrthographicCamera {
   get positionBuffer() {
     return this._positionBuffer;
   }
-  /** Writes the world-space eye into the std140 position data (no z flip: the look-at uses the eye as is). */
+  /** Writes the transform's world position into the std140 position data. */
   _updatePositionData() {
-    this._positionData[0] = this._eye[0];
-    this._positionData[1] = this._eye[1];
-    this._positionData[2] = this._eye[2];
+    const m2 = this.transform.modelMatrix;
+    this._positionData[0] = m2[12];
+    this._positionData[1] = m2[13];
+    this._positionData[2] = m2[14];
     return this._positionData;
   }
+  /** True when the transform's world matrix changed since the view was last built. */
+  _transformChanged() {
+    return !mat4.exactEquals(this._lastWorld, this.transform.modelMatrix);
+  }
   /**
    * Updates the camera matrices.
    */
   _updateMatrices() {
-    mat4.lookAt(this._viewMatrix, this._eye, this._target, OrthographicCamera.UP_VECTOR);
+    const world = this.transform.modelMatrix;
+    mat4.copy(this._lastWorld, world);
+    CameraTransformUtilities.viewFromWorld(this._viewMatrix, world);
     mat4.orthoNO(this._projectionMatrix, this._left, this._right, this._bottom, this._top, this._near, this._far);
     mat4.multiply(this._projectionViewMatrix, this._projectionMatrix, this._viewMatrix);
   }
@@ -2890,7 +3224,7 @@ class OrthographicCamera {
   }
   /** @inheritDoc */
   update(_2) {
-    if (!this._isDirty)
+    if (!this._isDirty && !this._transformChanged())
       return;
     this.updateBuffers();
     this._isDirty = false;
@@ -2975,6 +3309,25 @@ class ContentConfig {
    */
   keepDataCached = false;
 }
+var CullMode = /* @__PURE__ */ ((CullMode2) => {
+  CullMode2[CullMode2["NONE"] = 0] = "NONE";
+  CullMode2[CullMode2["BACK"] = 1] = "BACK";
+  CullMode2[CullMode2["FRONT"] = 2] = "FRONT";
+  return CullMode2;
+})(CullMode || {});
+var FrontFace = /* @__PURE__ */ ((FrontFace2) => {
+  FrontFace2[FrontFace2["CW"] = 0] = "CW";
+  FrontFace2[FrontFace2["CCW"] = 1] = "CCW";
+  return FrontFace2;
+})(FrontFace || {});
+var PrimitiveTopology = /* @__PURE__ */ ((PrimitiveTopology2) => {
+  PrimitiveTopology2[PrimitiveTopology2["LINE_LIST"] = 0] = "LINE_LIST";
+  PrimitiveTopology2[PrimitiveTopology2["LINE_STRIP"] = 1] = "LINE_STRIP";
+  PrimitiveTopology2[PrimitiveTopology2["POINT_LIST"] = 2] = "POINT_LIST";
+  PrimitiveTopology2[PrimitiveTopology2["TRIANGLE_LIST"] = 3] = "TRIANGLE_LIST";
+  PrimitiveTopology2[PrimitiveTopology2["TRIANGLE_STRIP"] = 4] = "TRIANGLE_STRIP";
+  return PrimitiveTopology2;
+})(PrimitiveTopology || {});
 class RawImageData {
   /**
    * The constructor.
@@ -3603,16 +3956,6 @@ class Mesh {
 class RenderableMesh extends Mesh {
   _subMeshes = [];
   _parent;
-  // Transform; only used on the root.
-  _position = vec3.create();
-  _rotation = vec3.create();
-  _scale = vec3.fromValues(1, 1, 1);
-  _modelMatrix = mat4.create();
-  _rotationQuat = quat.create();
-  // Cached copies to detect in-place edits; NaN forces the first computation.
-  _lastPosition = vec3.fromValues(NaN, NaN, NaN);
-  _lastRotation = vec3.create();
-  _lastScale = vec3.create();
   _modelBuffer;
   /** The matrix last uploaded to the model buffer. */
   _uploadedMatrix = mat4.create();
@@ -3622,6 +3965,14 @@ class RenderableMesh extends Mesh {
   indexStart;
   /** @inheritDoc */
   indexCount;
+  _transform = new TransformNode();
+  /** @inheritDoc A sub mesh returns (and sets) the root's transform. */
+  get transform() {
+    return this._root._transform;
+  }
+  set transform(value) {
+    this._root._transform = value;
+  }
   /**
    * The constructor.
    * @param framework The framework.
@@ -3672,45 +4023,6 @@ class RenderableMesh extends Mesh {
   get _defaultGeometryFormat() {
     return this.material?.geometryFormat;
   }
-  /** @inheritDoc */
-  get position() {
-    return this._root._position;
-  }
-  set position(value) {
-    this._root._position = value;
-  }
-  /** @inheritDoc */
-  get rotation() {
-    return this._root._rotation;
-  }
-  set rotation(value) {
-    this._root._rotation = value;
-  }
-  /** @inheritDoc */
-  get scale() {
-    return this._root._scale;
-  }
-  set scale(value) {
-    this._root._scale = value;
-  }
-  /** @inheritDoc */
-  get modelMatrix() {
-    const root = this._root;
-    if (root !== this) {
-      return root.modelMatrix;
-    }
-    if (!vec3.exactEquals(this._lastPosition, this._position) || !vec3.exactEquals(this._lastRotation, this._rotation) || !vec3.exactEquals(this._lastScale, this._scale)) {
-      vec3.copy(this._lastPosition, this._position);
-      vec3.copy(this._lastRotation, this._rotation);
-      vec3.copy(this._lastScale, this._scale);
-      const q = quat.identity(this._rotationQuat);
-      quat.rotateY(q, q, this._rotation[1]);
-      quat.rotateX(q, q, this._rotation[0]);
-      quat.rotateZ(q, q, this._rotation[2]);
-      mat4.fromRotationTranslationScale(this._modelMatrix, q, this._position, this._scale);
-    }
-    return this._modelMatrix;
-  }
   /** @inheritDoc Created on first access and disposed with the root mesh. */
   get modelBuffer() {
     const root = this._root;
@@ -3718,7 +4030,7 @@ class RenderableMesh extends Mesh {
       return root.modelBuffer;
     }
     if (!this._modelBuffer) {
-      mat4.copy(this._uploadedMatrix, this.modelMatrix);
+      mat4.copy(this._uploadedMatrix, this.transform.modelMatrix);
       this._modelBuffer = this._framework.bufferFactory.createUniformBuffer(
         this._uploadedMatrix,
         BufferUsage.UNIFORM | BufferUsage.COPY_DST,
@@ -3731,7 +4043,7 @@ class RenderableMesh extends Mesh {
   _updateModelBuffer() {
     const root = this._root;
     const buffer = root.modelBuffer;
-    const matrix = root.modelMatrix;
+    const matrix = root.transform.modelMatrix;
     if (!mat4.exactEquals(root._uploadedMatrix, matrix)) {
       mat4.copy(root._uploadedMatrix, matrix);
       buffer.update(root._uploadedMatrix);
@@ -4422,11 +4734,11 @@ class InspectTextureMipsMaterial {
     this._fragmentDataBuffer.dispose();
   }
 }
-class UnlitMaterialDescriptor {
-  /** The primitive state. */
-  primitiveState;
-  /** The camera used to render this material. */
-  camera;
+function resolveUnlitMaterialDescriptor(desc) {
+  return {
+    primitiveState: desc?.primitiveState,
+    camera: desc?.camera
+  };
 }
 class UnlitMaterial {
   _framework;
@@ -4448,16 +4760,17 @@ class UnlitMaterial {
   /**
    * The constructor.
    * @param framework The framework.
-   * @param config The optional material descriptor. A projection view buffer passed here is shared and is not disposed by this material.
+   * @param descriptor The optional material descriptor. A projection view buffer passed here is shared and is not disposed by this material.
    */
-  constructor(framework, config) {
+  constructor(framework, descriptor) {
+    const config = resolveUnlitMaterialDescriptor(descriptor);
     this._framework = framework;
     const usage = BufferUsage.UNIFORM | BufferUsage.COPY_DST;
-    this._camera = config?.camera;
-    this._ownsProjectionViewBuffer = !config?.camera?.projectionViewBuffer;
-    this._projectionViewBuffer = config?.camera?.projectionViewBuffer ?? framework.bufferFactory.createUniformBuffer(mat4.create(), usage);
+    this._camera = config.camera;
+    this._ownsProjectionViewBuffer = !config.camera?.projectionViewBuffer;
+    this._projectionViewBuffer = config.camera?.projectionViewBuffer ?? framework.bufferFactory.createUniformBuffer(mat4.create(), usage);
     this._materialBuffer = framework.bufferFactory.createUniformBuffer(this._materialData, usage);
-    this._primitiveState = config?.primitiveState;
+    this._primitiveState = config.primitiveState;
   }
   /** Creates the pipeline with the current bindings. */
   _createPipeline(modelBuffer) {
@@ -4595,6 +4908,8 @@ class UnlitMaterial {
   }
 }
 class SpriteMaterial {
+  /** The camera. Stored only: sprites render in screen space and use no camera buffers. */
+  camera;
   _renderPipeline;
   /**
    * The constructor.
@@ -4666,9 +4981,6 @@ class MaterialFactory {
     return new ForwardBlinnPhongMaterial(this._framework, descriptor);
   }
 }
-function isCameraMaterial(material) {
-  return !!material && "camera" in material;
-}
 function isLightsMaterial(material) {
   return !!material && "directionalLights" in material && "pointLights" in material && "ambientLight" in material;
 }
@@ -4689,6 +5001,8 @@ class AmbientLight {
     this.intensity = descriptor?.intensity ?? 1;
     scene?.add(this);
   }
+  /** The transform. It has no effect on an ambient light. */
+  transform = new TransformNode();
   /** The unique id of this light. */
   id;
   /** The optional name for a light. */
@@ -4698,6 +5012,7 @@ class AmbientLight {
   /** Multiplies {@link color} when written to the lights buffer. */
   intensity;
 }
+const _target = vec3.create();
 class DirectionalLight {
   /**
    * The constructor.
@@ -4710,7 +5025,7 @@ class DirectionalLight {
     this.name = descriptor?.name;
     this.color = descriptor?.color?.copy() ?? Color.white();
     this.intensity = descriptor?.intensity ?? 1;
-    this.direction = descriptor?.direction ? vec3.clone(descriptor.direction) : vec3.fromValues(0, -1, 0);
+    this.setDirection(descriptor?.direction ?? [0, -1, 0]);
     scene?.add(this);
   }
   /** The unique id of this light. */
@@ -4721,8 +5036,25 @@ class DirectionalLight {
   color;
   /** Multiplies {@link color} when written to the lights buffer. */
   intensity;
-  /** The direction in which the light travels. */
-  direction;
+  /** The transform. Its world rotation sets the direction (forward is -Z). */
+  transform = new TransformNode();
+  /**
+   * Rotates the transform so the light travels along a world-space direction (converted into the parent's space
+   * when parented). A zero vector leaves the rotation unchanged.
+   * @param direction The world direction; it does not need to be normalized.
+   */
+  setDirection(direction) {
+    const m2 = this.transform.modelMatrix;
+    vec3.set(_target, m2[12] + direction[0], m2[13] + direction[1], m2[14] + direction[2]);
+    CameraTransformUtilities.aimTransform(this.transform, _target, [0, 1, 0]);
+  }
+  /**
+   * Gets the world-space direction in which the light travels (unit length), derived from the transform.
+   * @param out The optional output vector.
+   */
+  getDirection(out = vec3.create()) {
+    return CameraTransformUtilities.forwardFromWorld(out, this.transform.modelMatrix);
+  }
 }
 class PointLight {
   /** The default constant attenuation. */
@@ -4742,7 +5074,7 @@ class PointLight {
     this.name = descriptor?.name;
     this.color = descriptor?.color?.copy() ?? Color.white();
     this.intensity = descriptor?.intensity ?? 1;
-    this.position = descriptor?.position ? vec3.clone(descriptor.position) : vec3.create();
+    vec3.copy(this.transform.position, descriptor?.position ?? [0, 0, 0]);
     this.constant = descriptor?.constant ?? PointLight.DEFAULT_CONSTANT;
     this.linear = descriptor?.linear ?? PointLight.DEFAULT_LINEAR;
     this.quadratic = descriptor?.quadratic ?? PointLight.DEFAULT_QUADRATIC;
@@ -4756,8 +5088,23 @@ class PointLight {
   color;
   /** Multiplies {@link color} when written to the lights buffer. */
   intensity;
-  /** World-space position of the light. */
-  position;
+  /** The transform. Its world position is the light position. */
+  transform = new TransformNode();
+  /**
+   * Moves the light to a world position (converted into the parent's space when parented).
+   * @param position The world position.
+   */
+  setPosition(position) {
+    CameraTransformUtilities.setWorldPosition(this.transform, position);
+  }
+  /**
+   * Gets the world position of the light, read from the transform.
+   * @param out The optional output vector.
+   */
+  getPosition(out = vec3.create()) {
+    const m2 = this.transform.modelMatrix;
+    return vec3.set(out, m2[12], m2[13], m2[14]);
+  }
   /** Constant attenuation term. */
   constant;
   /** Linear attenuation term. */
@@ -4816,6 +5163,7 @@ class SceneMesh {
 }
 class Scene {
   _sceneMeshes = [];
+  _nodes = [];
   _directionalLights = [];
   _pointLights = [];
   /** The directional light slots (matches the Blinn-Phong material). */
@@ -4855,6 +5203,10 @@ class Scene {
   get sceneMeshes() {
     return this._sceneMeshes;
   }
+  /** The scene objects (anything with a transform, including root meshes), in the order they were added. */
+  get nodes() {
+    return this._nodes;
+  }
   /** The root meshes in this scene, in the order they were added. */
   get meshes() {
     return this._sceneMeshes.map((s2) => s2.mesh);
@@ -4879,23 +5231,32 @@ class Scene {
     this._activeAmbientLight = value;
   }
   /**
-   * Adds a mesh, a light or a camera. Adding an item that is already in the scene does nothing.
-   * - Renderable mesh or {@link SceneMesh}: drawn by {@link render}; its materials get the scene camera and lights.
-   *   A mesh is wrapped in a `SceneMesh`, so {@link dispose} also disposes its materials.
-   * - Ambient light: added to {@link ambientLights} (use {@link activeAmbientLight} to make it the lit one).
-   * - Directional / point light: added to {@link directionalLights} / {@link pointLights}.
-   * - Camera: becomes the scene {@link camera}.
-   * Constructors given a scene (lights, the perspective camera) call this themselves.
-   * @param item The item to add.
-   * @throws Error when all slots for a light kind are in use (3 directional, 5 point), or for an unsupported item.
-   */
+      * Adds a mesh, a light or a camera. Adding an item that is already in the scene does nothing.
+      * - Renderable mesh or {@link SceneMesh}: drawn by {@link render}; its materials get the scene camera and lights.
+      *   A mesh is wrapped in a `SceneMesh`, so {@link dispose} also disposes its materials.
+      *   The mesh is also added to {@link nodes}.
+      * - {@link ISceneObject} (anything with a `transform`): added to {@link nodes}; {@link update} updates its transform.
+      * - Lights are also added to {@link nodes} (they are scene objects).
+  * - Ambient light: added to {@link ambientLights} (use {@link activeAmbientLight} to make it the lit one).
+      * - Directional / point light: added to {@link directionalLights} / {@link pointLights}.
+      * - Camera: becomes the scene {@link camera} and is added to {@link nodes} (cameras are scene objects).
+      *   Checked before the generic scene object case.
+      * Constructors given a scene (lights, the perspective camera) call this themselves.
+      * @param item The item to add.
+      * @throws Error when all slots for a light kind are in use (3 directional, 5 point), or for an unsupported item.
+      */
   add(item) {
     if (item instanceof AmbientLight) {
       this._addAmbientLight(item);
+      this._addNode(item);
     } else if (item instanceof DirectionalLight || item instanceof PointLight) {
       this._addLight(item);
+      this._addNode(item);
     } else if (Scene._isCamera(item)) {
       this.camera = item;
+      if (Scene._isSceneObject(item)) {
+        this._addNode(item);
+      }
     } else if (item instanceof SceneMesh || Scene._isMesh(item)) {
       const mesh = item instanceof SceneMesh ? item.mesh : item;
       if (!this._sceneMeshes.some((s2) => s2.mesh === mesh)) {
@@ -4903,15 +5264,18 @@ class Scene {
         this._sceneMeshes.push(sceneMesh);
         this._bind(sceneMesh);
       }
+      this._addNode(mesh);
+    } else if (Scene._isSceneObject(item)) {
+      this._addNode(item);
     } else {
-      throw new Error("Scene.add: expected a mesh, an AmbientLight, DirectionalLight, PointLight or a camera.");
+      throw new Error("Scene.add: expected a mesh, a scene object, an AmbientLight, DirectionalLight, PointLight or a camera.");
     }
   }
   /**
    * Removes a mesh (or scene mesh), a light or a camera. The mesh and its materials are not disposed.
    * Removing the active camera clears {@link camera}.
    * @param item The item to remove.
-   * @returns True when the item was in the scene (for a camera: was the active camera).
+   * @returns True when the item was in the scene.
    * @throws Error when removing the active ambient light (set another {@link activeAmbientLight} first), or for an unsupported item.
    */
   remove(item) {
@@ -4919,14 +5283,17 @@ class Scene {
       if (item === this._activeAmbientLight) {
         throw new Error("Scene.remove: cannot remove the active ambient light; set scene.activeAmbientLight to another light first.");
       }
+      Scene._removeFrom(this._nodes, item);
       return Scene._removeFrom(this.ambientLights, item);
     }
     if (item instanceof DirectionalLight || item instanceof PointLight) {
+      Scene._removeFrom(this._nodes, item);
       return item instanceof DirectionalLight ? Scene._removeFrom(this._directionalLights, item) : Scene._removeFrom(this._pointLights, item);
     }
     if (Scene._isCamera(item)) {
+      const wasNode = Scene._removeFrom(this._nodes, item);
       if (item !== this._activeCamera) {
-        return false;
+        return wasNode;
       }
       this._activeCamera = void 0;
       return true;
@@ -4934,13 +5301,17 @@ class Scene {
     if (item instanceof SceneMesh || Scene._isMesh(item)) {
       const mesh = item instanceof SceneMesh ? item.mesh : item;
       const index = this._sceneMeshes.findIndex((s2) => s2.mesh === mesh);
+      Scene._removeFrom(this._nodes, mesh);
       if (index < 0) {
         return false;
       }
       this._sceneMeshes.splice(index, 1);
       return true;
     }
-    throw new Error("Scene.remove: expected a mesh, an AmbientLight, DirectionalLight, PointLight or a camera.");
+    if (Scene._isSceneObject(item)) {
+      return Scene._removeFrom(this._nodes, item);
+    }
+    throw new Error("Scene.remove: expected a mesh, a scene object, an AmbientLight, DirectionalLight, PointLight or a camera.");
   }
   /**
    * Adds a directional or point light.
@@ -4986,18 +5357,30 @@ class Scene {
     const camera = item;
     return typeof camera === "object" && camera !== null && "projectionViewBuffer" in camera && "viewMatrix" in camera && typeof camera.updateBuffers === "function";
   }
+  /** Scene objects have a TransformNode as transform. */
+  static _isSceneObject(item) {
+    return typeof item === "object" && item !== null && item.transform instanceof TransformNode;
+  }
+  _addNode(node) {
+    if (!this._nodes.includes(node)) {
+      this._nodes.push(node);
+    }
+  }
   /** Renderable meshes have render() and sub meshes. */
   static _isMesh(item) {
     const mesh = item;
     return typeof mesh === "object" && mesh !== null && typeof mesh.render === "function" && "subMeshes" in mesh;
   }
   /**
-   * Updates the scene: assigns {@link camera}, the active ambient light and the light lists to the mesh materials.
+   * Updates the scene: updates the transforms of {@link nodes}, assigns {@link camera}, the active ambient light and the light lists to the mesh materials.
    * Each lights material uploads its lights buffer when drawn, only if the lights changed.
    * @param _time The game time.
    * @public
    */
   update(_time) {
+    for (const node of this._nodes) {
+      node.transform.update(_time);
+    }
     for (const sceneMesh of this._sceneMeshes) {
       this._bind(sceneMesh);
     }
@@ -5026,7 +5409,7 @@ class Scene {
       return;
     }
     for (const material of sceneMesh.materials) {
-      if (isCameraMaterial(material) && material.camera !== camera) {
+      if (material.camera !== camera) {
         material.camera = camera;
       }
     }
@@ -5049,6 +5432,7 @@ class Scene {
       sceneMesh.dispose();
     }
     this._sceneMeshes.length = 0;
+    this._nodes.length = 0;
   }
 }
 var Key = /* @__PURE__ */ ((Key2) => {
@@ -5324,6 +5708,7 @@ class CpuImageProcessor {
     return promise;
   }
 }
+const _v = vec3.create();
 class WebGlLightsBuffer {
   /** Floats for the ambient light: vec3 padded to 16 bytes. */
   static AMBIENT_FLOAT_COUNT = 4;
@@ -5465,9 +5850,14 @@ class WebGlLightsBuffer {
       const light = this._directionalLights[i2];
       this._writeColor(offset, light?.color, light?.intensity ?? 0);
       this._data[offset + 3] = 0;
-      this._data[offset + 4] = light ? light.direction[0] : 0;
-      this._data[offset + 5] = light ? light.direction[1] : 0;
-      this._data[offset + 6] = light ? light.direction[2] : 0;
+      if (light) {
+        light.getDirection(_v);
+      } else {
+        vec3.zero(_v);
+      }
+      this._data[offset + 4] = _v[0];
+      this._data[offset + 5] = _v[1];
+      this._data[offset + 6] = _v[2];
       this._data[offset + 7] = 0;
     }
     const pointLightsStart = WebGlLightsBuffer.AMBIENT_FLOAT_COUNT + this.maxDirectionalLights * WebGlLightsBuffer.DIRECTIONAL_LIGHT_FLOAT_COUNT;
@@ -5476,9 +5866,14 @@ class WebGlLightsBuffer {
       const light = this._pointLights[i2];
       this._writeColor(offset, light?.color, light?.intensity ?? 0);
       this._data[offset + 3] = light ? light.constant : 1;
-      this._data[offset + 4] = light ? light.position[0] : 0;
-      this._data[offset + 5] = light ? light.position[1] : 0;
-      this._data[offset + 6] = light ? light.position[2] : 0;
+      if (light) {
+        light.getPosition(_v);
+      } else {
+        vec3.zero(_v);
+      }
+      this._data[offset + 4] = _v[0];
+      this._data[offset + 5] = _v[1];
+      this._data[offset + 6] = _v[2];
       this._data[offset + 7] = light ? light.linear : 0;
       this._data[offset + 8] = light ? light.quadratic : 0;
       this._data[offset + 9] = 0;
@@ -5709,7 +6104,8 @@ function resolveTextureDescriptor(desc) {
     label: desc?.label ?? null,
     data: desc?.data,
     generateMipmaps: desc?.generateMipmaps ?? false,
-    blockSize: desc?.blockSize
+    blockSize: desc?.blockSize,
+    preferredColorSpace: desc?.preferredColorSpace
   };
 }
 const KTX2_EXTENSION = ".ktx2";
@@ -5766,7 +6162,7 @@ class ContentManager {
       }
       return tex;
     }
-    let format = this._framework.renderer.preferredTextureFormat;
+    let format = desc.preferredColorSpace ? desc.preferredColorSpace == ColorSpace.SRGB ? TextureFormat.RGBA_8_UNORM_SRGB : TextureFormat.RGBA_8_UNORM : this._framework.renderer.preferredTextureFormat;
     if (desc.textureFormat != TextureFormat.UNDEFINED) {
       format = desc.textureFormat;
     }
@@ -5777,8 +6173,8 @@ class ContentManager {
       data.baseHeight,
       data.getData(0),
       data.channels,
-      path,
-      TextureUsage.TEXTURE_BINDING | TextureUsage.COPY_SRC,
+      desc.label ?? path,
+      textureDescriptor?.textureUsage ?? TextureUsage.TEXTURE_BINDING | TextureUsage.COPY_SRC,
       format,
       desc.generateMipmaps
     );
@@ -5786,7 +6182,7 @@ class ContentManager {
   /** @inheritDoc */
   loadTexture2DFromPixels(width, height, pixels) {
     const view = new Uint8Array(pixels);
-    return this._framework.textureFactory.create(width, height, view);
+    return this._framework.textureFactory.create(width, height, view, 4, void 0, void 0, TextureFormat.RGBA_8_UNORM);
   }
   /** @inheritDoc */
   async loadMeshAsync(path, geometryFormat) {
@@ -5814,17 +6210,6 @@ class ContentManager {
     });
   }
 }
-var Culling = /* @__PURE__ */ ((Culling2) => {
-  Culling2[Culling2["None"] = 0] = "None";
-  Culling2[Culling2["Back"] = 1] = "Back";
-  Culling2[Culling2["Front"] = 2] = "Front";
-  return Culling2;
-})(Culling || {});
-var ColorSpace = /* @__PURE__ */ ((ColorSpace2) => {
-  ColorSpace2["LINEAR"] = "LINEAR";
-  ColorSpace2["SRGB"] = "SRGB";
-  return ColorSpace2;
-})(ColorSpace || {});
 class ARenderer {
   _framework;
   /**
@@ -5838,6 +6223,7 @@ class ARenderer {
   _swapChainRequiresResize = false;
   _mainRenderPassDirty = true;
   _clearColor = Color.lightPink();
+  _colorSpace;
   _mainRenderTargetRequiresResize = false;
   _swapChain = null;
   _mainRenderTarget = null;
@@ -5863,9 +6249,24 @@ class ARenderer {
     throw new Error("Method not implemented.");
   }
   /** @inheritdoc */
-  preferredTextureFormat;
+  get preferredTextureFormat() {
+    return this._colorSpace == ColorSpace.SRGB ? TextureFormat.RGBA_8_UNORM_SRGB : TextureFormat.RGBA_8_UNORM;
+  }
+  /** @inheritDoc */
+  get colorSpace() {
+    return this._colorSpace;
+  }
   /** @inheritDoc */
-  preferredColorSpace;
+  set colorSpace(colorSpace) {
+    if (colorSpace == this._colorSpace) {
+      return;
+    }
+    this._colorSpace = colorSpace;
+    if (this._mainRenderTargetPipeline) {
+      this._mainRenderTargetPipeline.colorSpace = colorSpace;
+      this._mainRenderTargetRequiresResize = true;
+    }
+  }
   /** @inheritdoc */
   get preferredDepthStencilFormat() {
     return this._preferredDepthStencilFormat;
@@ -5899,8 +6300,7 @@ class ARenderer {
     this._windowManager = framework.windowManager;
     this._currentBackBufferSize[0] = this._windowManager.canvas.width;
     this._currentBackBufferSize[1] = this._windowManager.canvas.height;
-    this.preferredColorSpace = configuration.textureColorSpace;
-    this.preferredTextureFormat = configuration.textureColorSpace == ColorSpace.SRGB ? TextureFormat.RGBA_8_UNORM_SRGB : TextureFormat.RGBA_8_UNORM;
+    this._colorSpace = configuration.textureColorSpace;
   }
   backend = RenderingBackend.WEB_GL;
   /** @inheritDoc */
@@ -5958,6 +6358,7 @@ class ARenderer {
       this.preferredDepthStencilFormat
     );
     this._mainRenderTargetPipeline = this._framework.renderPipelineFactory.createMainFrameBufferPipeline(this._mainRenderTarget);
+    this._mainRenderTargetPipeline.colorSpace = this._colorSpace;
     this._createMainRenderPass();
     this._mainRenderTargetRequiresResize = false;
   }
@@ -7113,6 +7514,7 @@ class WebGlTextureUtilities {
     if (useTexStorage) {
       gl.texStorage2D(gl.TEXTURE_2D, mipLevels, internalFormat, baseWidth, baseHeight);
     }
+    gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
     if (data && data.length > 0) {
       let width = baseWidth;
       let height = baseHeight;
@@ -7122,9 +7524,7 @@ class WebGlTextureUtilities {
           if (useTexStorage) {
             gl.compressedTexSubImage2D(gl.TEXTURE_2D, i2, 0, 0, width, height, internalFormat, mipLevelData, 0);
           } else {
-            const alignedWidth = AlignUtilities.align(width, blockSize[0]);
-            const alignedHeight = AlignUtilities.align(height, blockSize[1]);
-            gl.compressedTexImage2D(gl.TEXTURE_2D, i2, internalFormat, alignedWidth, alignedHeight, 0, mipLevelData, 0);
+            gl.compressedTexImage2D(gl.TEXTURE_2D, i2, internalFormat, width, height, 0, mipLevelData, 0);
           }
         } else {
           throw new Error("unsupported data type");
@@ -7133,6 +7533,7 @@ class WebGlTextureUtilities {
         height = Math.max(1, Math.floor(height / 2));
       }
     }
+    gl.pixelStorei(gl.UNPACK_ALIGNMENT, 4);
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
     if (anisotropy > 1) {
@@ -8034,6 +8435,13 @@ class AGraphicsDevice {
     this._defaultBlendState.dispose();
   }
 }
+function resolvePrimitiveStateDescriptor(desc) {
+  return {
+    topology: desc?.topology ?? PrimitiveTopology.TRIANGLE_LIST,
+    cullFace: desc?.cullFace ?? CullMode.BACK,
+    frontFace: desc?.frontFace ?? FrontFace.CCW
+  };
+}
 class WebGlPrimitiveState {
   _cullingEnabled;
   _glPrimitiveType;
@@ -8042,12 +8450,13 @@ class WebGlPrimitiveState {
   /**
    * The constructor.
    * @param _gl The WebGL2 Rendering Context.
-   * @param descriptor The descriptor of the primitive state.
+   * @param descriptor The descriptor of the primitive state; missing fields use the defaults.
    */
   constructor(_gl, descriptor) {
-    this.topology = descriptor.topology;
-    this.cullFace = descriptor.cullFace;
-    this.frontFace = descriptor.frontFace;
+    const resolved = resolvePrimitiveStateDescriptor(descriptor);
+    this.topology = resolved.topology;
+    this.cullFace = resolved.cullFace;
+    this.frontFace = resolved.frontFace;
     this._cullingEnabled = this.cullFace != CullMode.NONE;
     this._glPrimitiveType = WebGlConverter.convertPrimitiveType(this.topology);
     this._glCullFace = WebGlConverter.convertCullFace(this.cullFace);
@@ -8281,7 +8690,6 @@ class WebGlGraphicsDevice extends AGraphicsDevice {
   }
   /** @inheritdoc */
   createPrimitiveState(descriptor) {
-    descriptor = descriptor ?? new PrimitiveStateDescriptor();
     return new WebGlPrimitiveState(this._gl, descriptor);
   }
 }
@@ -8986,28 +9394,28 @@ class WebGlTextureFactory {
     let transcodeFormat = m.NO_SELECTION;
     let textureFormat = desc.textureFormat;
     const gpuFeatures = this._framework.graphicsDevice.features;
-    const srgb = ktxTexture.oetf == u.SRGB;
-    const preferSrgb = this._framework.renderer.preferredColorSpace == ColorSpace.SRGB;
+    const preferSrgb = (descriptor?.preferredColorSpace ?? this._framework.renderer.colorSpace) == ColorSpace.SRGB;
+    const userSpecifiedTextureFormat = desc.textureFormat != TextureFormat.UNDEFINED;
     if (ktxTexture.needsTranscoding && vkFormat == n.UNDEFINED) {
       if (desc.textureFormat == TextureFormat.UNDEFINED) {
         if (gpuFeatures.supportsTextureCompressionBC) {
           transcodeFormat = m.BC7_RGBA;
-          textureFormat = srgb ? TextureFormat.BC7_RGBA_SRGB : TextureFormat.BC7_RGBA_UNORM;
+          textureFormat = preferSrgb ? TextureFormat.BC7_RGBA_SRGB : TextureFormat.BC7_RGBA_UNORM;
         } else if (gpuFeatures.supportsTextureCompressionASTC) {
           transcodeFormat = m.ASTC_4X4_RGBA;
-          textureFormat = srgb ? TextureFormat.ASTC_4X4_RGBA_SRGB : TextureFormat.ASTC_4X4_RGBA_UNORM;
+          textureFormat = preferSrgb ? TextureFormat.ASTC_4X4_RGBA_SRGB : TextureFormat.ASTC_4X4_RGBA_UNORM;
         } else if (gpuFeatures.supportsTextureCompressionS3TC) {
           transcodeFormat = m.BC3_RGBA;
-          textureFormat = srgb ? TextureFormat.BC3_RGBA_SRGB : TextureFormat.BC3_RGBA_UNORM;
+          textureFormat = preferSrgb ? TextureFormat.BC3_RGBA_SRGB : TextureFormat.BC3_RGBA_UNORM;
         } else if (gpuFeatures.supportsTextureCompressionETC2) {
           transcodeFormat = m.ETC2_RGBA;
-          textureFormat = srgb ? TextureFormat.ETC2_RGBA8_SRGB : TextureFormat.ETC2_RGBA8_UNORM;
+          textureFormat = preferSrgb ? TextureFormat.ETC2_RGBA8_SRGB : TextureFormat.ETC2_RGBA8_UNORM;
         } else if (gpuFeatures.supportsTextureCompressionPVRTC) {
           transcodeFormat = m.PVRTC1_4_RGBA;
           textureFormat = TextureFormat.PVRTC_4BPPV1_RGBA;
         } else {
           transcodeFormat = m.RGBA32;
-          textureFormat = srgb ? TextureFormat.RGBA_8_UNORM_SRGB : TextureFormat.RGBA_8_UNORM;
+          textureFormat = preferSrgb ? TextureFormat.RGBA_8_UNORM_SRGB : TextureFormat.RGBA_8_UNORM;
         }
       } else {
         transcodeFormat = TextureUtilities.convertTextureFormatToKtxTranscodeFormat(textureFormat);
@@ -9015,10 +9423,14 @@ class WebGlTextureFactory {
       ktxTexture.transcodeBasis(transcodeFormat, i.HIGH_QUALITY);
     } else {
       textureFormat = TextureUtilities.convertVkFormatToTextureFormat(vkFormat);
-      if (!srgb && preferSrgb && !TextureUtilities.isSrgbFormat(textureFormat)) {
-        textureFormat = TextureUtilities.convertToSrgbVariant(textureFormat);
-      } else if (srgb && !preferSrgb && TextureUtilities.isSrgbFormat(textureFormat)) {
-        textureFormat = TextureUtilities.convertToLinearVariant(textureFormat);
+      if (userSpecifiedTextureFormat) {
+        textureFormat = TextureUtilities.resolveExplicitFormat(textureFormat, desc.textureFormat);
+      } else {
+        if (preferSrgb && !TextureUtilities.isSrgbFormat(textureFormat)) {
+          textureFormat = TextureUtilities.convertToSrgbVariant(textureFormat);
+        } else if (!preferSrgb && TextureUtilities.isSrgbFormat(textureFormat)) {
+          textureFormat = TextureUtilities.convertToLinearVariant(textureFormat);
+        }
       }
     }
     const blockSize = ktxTexture.getTextureFormatInfo(ktxTexture.vkFormat);
@@ -9042,7 +9454,10 @@ class WebGlTextureFactory {
     return texture;
   }
   /** @inheritdoc */
-  create(width, height, data, channels = 4, label = null, textureUsage = TextureUsage.COPY_DST | TextureUsage.TEXTURE_BINDING, textureFormat = TextureFormat.RGBA_8_UNORM, useMipMaps = false) {
+  create(width, height, data, channels = 4, label = null, textureUsage = TextureUsage.COPY_DST | TextureUsage.TEXTURE_BINDING, textureFormat = TextureFormat.UNDEFINED, useMipMaps = false) {
+    if (textureFormat == TextureFormat.UNDEFINED) {
+      textureFormat = this._framework.renderer.preferredTextureFormat;
+    }
     if (!data) {
       throw new Error("Data must not be null.");
     }
@@ -9282,6 +9697,7 @@ class WebGlMainRenderTargetRenderPipeline extends AWebGlRenderPipeline {
   _indexBuffer = null;
   _mainRenderTarget = null;
   _colorConversionUniformLocation = null;
+  /** The shader's `u_colorConversion`: 1 encodes linear to sRGB on output, 0 passes through. */
   _colorSpaceValue = 0;
   /**
    * The constructor.
@@ -9295,6 +9711,16 @@ class WebGlMainRenderTargetRenderPipeline extends AWebGlRenderPipeline {
       this._colorSpaceValue = 1;
     }
   }
+  /**
+   * The color space. With SRGB the main render target is sRGB (sampled back as linear) and the shader
+   * encodes to sRGB for the screen; with LINEAR the values are passed through. Takes effect on the next frame.
+   */
+  get colorSpace() {
+    return this._colorSpaceValue == 1 ? ColorSpace.SRGB : ColorSpace.LINEAR;
+  }
+  set colorSpace(value) {
+    this._colorSpaceValue = value == ColorSpace.SRGB ? 1 : 0;
+  }
   /** @inheritDoc */
   geometryFormat = GeometryFormat.POS3_COLOR4_TEXTURECOORDS2;
   /** @inheritdoc */
@@ -11238,9 +11664,10 @@ class WebGpuPrimitiveState {
    * @param descriptor The primitive state descriptor.
    */
   constructor(descriptor) {
-    this.topology = descriptor.topology;
-    this.cullFace = descriptor.cullFace;
-    this.frontFace = descriptor.frontFace;
+    const resolved = resolvePrimitiveStateDescriptor(descriptor);
+    this.topology = resolved.topology;
+    this.cullFace = resolved.cullFace;
+    this.frontFace = resolved.frontFace;
     this.gpuTopology = WebGpuConverter.convertTopology(this.topology);
     this.gpuCullMode = WebGpuConverter.convertCullMode(this.cullFace);
     this.gpuFrontFace = WebGpuConverter.convertFrontFace(this.frontFace);
@@ -11372,7 +11799,7 @@ class WebGpuGraphicsDevice extends AGraphicsDevice {
   }
   /** @inheritDoc */
   createPrimitiveState(descriptor) {
-    return new WebGpuPrimitiveState(descriptor ?? new PrimitiveStateDescriptor());
+    return new WebGpuPrimitiveState(descriptor);
   }
   /** @inheritDoc */
   setupDebugCallback() {
@@ -11453,7 +11880,7 @@ class WebGpuTextureFactory {
     throw new Error("createFromKtx2 is not implemented for WebGPU.");
   }
   /** @inheritDoc */
-  create(width, height, data, channels = 4, label = null, textureUsage = TextureUsage.COPY_DST | TextureUsage.TEXTURE_BINDING, textureFormat = TextureFormat.RGBA_8_UNORM, useMipMaps = false) {
+  create(width, height, data, channels = 4, label = null, textureUsage = TextureUsage.COPY_DST | TextureUsage.TEXTURE_BINDING, textureFormat = TextureFormat.UNDEFINED, useMipMaps = false) {
     if (!data) {
       throw new Error("Data must not be null.");
     }
@@ -11647,6 +12074,10 @@ class WebGpuMainRenderTargetRenderPipeline extends AWebGpuRenderPipeline {
       this._graphicsDevice.swapChain?.textureFormat ?? this._framework.renderer.preferredTextureFormat
     );
   }
+  /**
+   * The color space. Stored only; it has no effect on WebGPU yet.
+   */
+  colorSpace = ColorSpace.LINEAR;
   _getBindGroup() {
     if (!this._bindGroup) {
       this._bindGroup = this._graphicsDevice.device.createBindGroup({
@@ -12371,7 +12802,7 @@ class Framework {
       textureFiltering: this._configuration.textureFiltering ?? TextureSamplerFilteringPreset.BILINEAR,
       alpha: this._configuration.alpha ?? false,
       powerPreference: this._configuration.powerPreference ?? PowerPreferenceType.DEFAULT,
-      textureColorSpace: this._configuration.textureColorSpace ?? ColorSpace.SRGB
+      textureColorSpace: this._configuration.textureColorSpace ?? ColorSpace.LINEAR
     };
     let backend = this._configuration.renderingBackend ?? RenderingBackend.WEB_GL;
     if (backend === RenderingBackend.DEFAULT) {
@@ -12602,9 +13033,11 @@ export {
   Button,
   CameraFactory,
   Color,
+  ColorSpace,
   ContentConfig,
   CpuImageProcessor,
   CullMode,
+  Culling,
   DEFAULT_DIRECTIONAL_LIGHTS_COUNT,
   DEFAULT_POINT_LIGHTS_COUNT,
   DirectionalLight,
@@ -12633,6 +13066,7 @@ export {
   MipMapSamplerFilter,
   MouseButton,
   MouseState,
+  Node,
   ObjLoader,
   ObjMaterialDefinition,
   ObjParser,
@@ -12641,7 +13075,6 @@ export {
   PerspectiveCamera,
   PointLight,
   PowerPreferenceType,
-  PrimitiveStateDescriptor,
   PrimitiveTopology,
   QuadMesh,
   RawImageData,
@@ -12673,12 +13106,11 @@ export {
   TouchLocation,
   TouchLocationState,
   TouchPanelCapabilities,
+  TransformNode,
   UnlitMaterial,
-  UnlitMaterialDescriptor,
   VertexAttribute,
   VertexFormat,
   VertexStepMode,
   WindowBounds,
-  isCameraMaterial,
   isLightsMaterial
 };