@aura3d/scene 1.3.3 → 1.4.1

package/src/PerspectiveCamera.ts

@@ -1,54 +0,0 @@
-import { ValidationError } from "@aura3d/core";
-import { perspectiveMat4, type Mat4 } from "./MathTypes.js";
-import { Camera } from "./Camera.js";
-
-export interface PerspectiveCameraOptions {
-  id?: string;
-  name?: string;
-  fovYRadians?: number;
-  aspect?: number;
-  near?: number;
-  far?: number;
-}
-
-export class PerspectiveCamera extends Camera {
-  fovYRadians: number;
-  aspect: number;
-  near: number;
-  far: number;
-
-  constructor(options: PerspectiveCameraOptions = {}) {
-    super(options.name ?? "PerspectiveCamera", options.id);
-    this.fovYRadians = options.fovYRadians ?? Math.PI / 3;
-    this.aspect = options.aspect ?? 1;
-    this.near = options.near ?? 0.1;
-    this.far = options.far ?? 1000;
-    this.projectionMatrix = this.computeProjectionMatrix();
-  }
-
-  computeProjectionMatrix(): Mat4 {
-    validatePerspectiveProjection(this.fovYRadians, this.aspect, this.near, this.far);
-    return perspectiveMat4(this.fovYRadians, this.aspect, this.near, this.far);
-  }
-
-  resize(width: number, height: number): void {
-    if (width <= 0 || height <= 0) throw new ValidationError("CAMERA_RESIZE", "Perspective resize dimensions must be positive.");
-    this.aspect = width / height;
-    this.updateCameraMatrices();
-  }
-}
-
-function validatePerspectiveProjection(fovYRadians: number, aspect: number, near: number, far: number): void {
-  if (!Number.isFinite(fovYRadians) || fovYRadians <= 0 || fovYRadians >= Math.PI) {
-    throw new ValidationError("CAMERA_FOV", "Perspective fovYRadians must be finite and greater than 0 and less than PI.");
-  }
-  if (!Number.isFinite(aspect) || aspect <= 0) {
-    throw new ValidationError("CAMERA_ASPECT", "Perspective aspect must be finite and positive.");
-  }
-  if (!Number.isFinite(near) || near <= 0) {
-    throw new ValidationError("CAMERA_NEAR", "Perspective near plane must be finite and positive.");
-  }
-  if (!Number.isFinite(far) || far <= near) {
-    throw new ValidationError("CAMERA_FAR", "Perspective far plane must be finite and greater than near.");
-  }
-}

package/src/PointLight.ts

@@ -1,25 +0,0 @@
-import { ValidationError } from "@aura3d/core";
-import { Bounds3 } from "./Bounds.js";
-import { Light } from "./Light.js";
-
-export class PointLight extends Light {
-  private currentRange = 10;
-
-  constructor(name = "PointLight", id?: string) {
-    super("point", name, id);
-  }
-
-  get range(): number {
-    return this.currentRange;
-  }
-
-  set range(value: number) {
-    if (!(value > 0) || !Number.isFinite(value)) throw new ValidationError("POINT_LIGHT_RANGE", "Point light range must be positive.");
-    this.currentRange = value;
-  }
-
-  getWorldBounds(): Bounds3 {
-    const p = this.transform.worldMatrix;
-    return Bounds3.fromCenterSize([p[12], p[13], p[14]], [this.range * 2, this.range * 2, this.range * 2]);
-  }
-}

package/src/Renderable.ts

@@ -1,71 +0,0 @@
-import { ValidationError } from "@aura3d/core";
-
-export interface RenderableDescriptor {
-  geometry: string;
-  material: string;
-  layerMask?: number;
-  castShadow?: boolean;
-  receiveShadow?: boolean;
-  skinning?: {
-    readonly jointCount: number;
-    readonly matrices: Float32Array;
-  };
-  morphWeights?: readonly number[];
-  instanceTransforms?: Float32Array | readonly number[];
-  instanceColors?: Float32Array | readonly number[];
-}
-
-export class Renderable {
-  readonly geometry: string;
-  readonly material: string;
-  layerMask: number;
-  castShadow: boolean;
-  receiveShadow: boolean;
-  skinning?: {
-    readonly jointCount: number;
-    readonly matrices: Float32Array;
-  };
-  morphWeights: number[];
-  instanceTransforms?: Float32Array;
-  instanceColors?: Float32Array;
-
-  constructor(descriptor: RenderableDescriptor) {
-    if (!descriptor.geometry) throw new ValidationError("RENDERABLE_GEOMETRY", "Renderable geometry handle is required.");
-    if (!descriptor.material) throw new ValidationError("RENDERABLE_MATERIAL", "Renderable material handle is required.");
-    this.geometry = descriptor.geometry;
-    this.material = descriptor.material;
-    this.layerMask = descriptor.layerMask ?? 1;
-    this.castShadow = descriptor.castShadow ?? true;
-    this.receiveShadow = descriptor.receiveShadow ?? true;
-    if (descriptor.skinning !== undefined) {
-      if (!Number.isInteger(descriptor.skinning.jointCount) || descriptor.skinning.jointCount <= 0 || descriptor.skinning.jointCount > 96) {
-        throw new ValidationError("RENDERABLE_SKINNING", "Renderable skinning jointCount must be an integer in [1, 96].");
-      }
-      if (descriptor.skinning.matrices.length !== descriptor.skinning.jointCount * 16 || !Array.from(descriptor.skinning.matrices).every(Number.isFinite)) {
-        throw new ValidationError("RENDERABLE_SKINNING", "Renderable skinning matrices must contain one finite mat4 per joint.");
-      }
-      this.skinning = {
-        jointCount: descriptor.skinning.jointCount,
-        matrices: new Float32Array(descriptor.skinning.matrices)
-      };
-    }
-    this.morphWeights = [...(descriptor.morphWeights ?? [])];
-    if (descriptor.instanceTransforms !== undefined) {
-      const values = Array.from(descriptor.instanceTransforms);
-      if (values.length === 0 || values.length % 16 !== 0 || !values.every(Number.isFinite)) {
-        throw new ValidationError("RENDERABLE_INSTANCES", "Renderable instanceTransforms must contain one or more finite mat4 values.");
-      }
-      this.instanceTransforms = new Float32Array(values);
-    }
-    if (descriptor.instanceColors !== undefined) {
-      const values = Array.from(descriptor.instanceColors);
-      if (values.length === 0 || values.length % 4 !== 0 || !values.every(Number.isFinite)) {
-        throw new ValidationError("RENDERABLE_INSTANCE_COLORS", "Renderable instanceColors must contain one or more finite vec4 values.");
-      }
-      if (this.instanceTransforms && values.length / 4 !== this.instanceTransforms.length / 16) {
-        throw new ValidationError("RENDERABLE_INSTANCE_COLORS", "Renderable instanceColors count must match instanceTransforms count.");
-      }
-      this.instanceColors = new Float32Array(values);
-    }
-  }
-}

package/src/Scene.ts

@@ -1,134 +0,0 @@
-import { ValidationError } from "@aura3d/core";
-import { Camera } from "./Camera.js";
-import { DirectionalLight } from "./DirectionalLight.js";
-import { Light } from "./Light.js";
-import { Group, InstancedMesh, Mesh, Object3D, SkinnedMesh, type MeshOptions, type Object3DOptions } from "./Object3D.js";
-import { OrthographicCamera } from "./OrthographicCamera.js";
-import { PerspectiveCamera } from "./PerspectiveCamera.js";
-import { PointLight } from "./PointLight.js";
-import { Renderable } from "./Renderable.js";
-import { collectRenderables, queryScene, type SceneQueryOptions } from "./SceneQuery.js";
-import { SceneMetadata } from "./SceneMetadata.js";
-import { SceneNode } from "./SceneNode.js";
-import { SpotLight } from "./SpotLight.js";
-
-export class Scene {
-  readonly root = new SceneNode({ id: "root", name: "root" });
-  readonly metadata = new SceneMetadata();
-  private readonly nodesById = new Map<string, SceneNode>([[this.root.id, this.root]]);
-
-  createNode(name?: string): SceneNode {
-    return this.register(new SceneNode({ name }));
-  }
-
-  createObject3D(options: Object3DOptions = {}): Object3D {
-    return this.register(new Object3D(options));
-  }
-
-  createGroup(options: Object3DOptions = {}): Group {
-    return this.register(new Group(options));
-  }
-
-  createMesh(options: MeshOptions = {}): Mesh {
-    return this.register(new Mesh(options));
-  }
-
-  createSkinnedMesh(options: MeshOptions = {}): SkinnedMesh {
-    return this.register(new SkinnedMesh(options));
-  }
-
-  createInstancedMesh(options: MeshOptions = {}): InstancedMesh {
-    return this.register(new InstancedMesh(options));
-  }
-
-  createPerspectiveCamera(options: ConstructorParameters<typeof PerspectiveCamera>[0] = {}): PerspectiveCamera {
-    return this.register(new PerspectiveCamera(options));
-  }
-
-  createOrthographicCamera(options: ConstructorParameters<typeof OrthographicCamera>[0] = {}): OrthographicCamera {
-    return this.register(new OrthographicCamera(options));
-  }
-
-  createLight(kind: "directional" | "point" | "spot", name?: string): DirectionalLight | PointLight | SpotLight {
-    const light = kind === "directional" ? new DirectionalLight(name) : kind === "point" ? new PointLight(name) : new SpotLight(name);
-    return this.register(light);
-  }
-
-  addRenderable(node: SceneNode, renderable: Renderable): void {
-    node.renderable = renderable;
-  }
-
-  getNodeById(id: string): SceneNode | undefined {
-    return this.nodesById.get(id);
-  }
-
-  findByName(name: string): SceneNode[] {
-    return this.query({ name });
-  }
-
-  query(options: SceneQueryOptions): SceneNode[] {
-    if (options.bounds) this.updateWorldBounds();
-    return queryScene(this.root, options);
-  }
-
-  updateWorldTransforms(): void {
-    this.root.updateWorldTransform();
-  }
-
-  updateWorldBounds(): void {
-    this.updateWorldTransforms();
-    this.root.updateWorldBounds();
-  }
-
-  update(): void {
-    this.updateWorldBounds();
-  }
-
-  traverse(visitor: (node: SceneNode) => void): void {
-    this.root.traverse(visitor);
-  }
-
-  collectRenderables(): { node: SceneNode; renderable: Renderable }[] {
-    return collectRenderables(this.root);
-  }
-
-  collectCameras(): Camera[] {
-    return this.query({ type: "camera" }).filter((node): node is Camera => node instanceof Camera);
-  }
-
-  collectLights(): Light[] {
-    return this.query({ type: "light" }).filter((node): node is Light => node instanceof Light);
-  }
-
-  removeNode(node: SceneNode): boolean {
-    if (node === this.root) return false;
-    const descendants: SceneNode[] = [];
-    node.traverse((descendant) => descendants.push(descendant));
-    const removed = node.removeFromParent();
-    for (const descendant of descendants) this.nodesById.delete(descendant.id);
-    return removed;
-  }
-
-  dispose(): void {
-    const descendants: SceneNode[] = [];
-    for (const child of [...this.root.children]) child.traverse((descendant) => descendants.push(descendant));
-    for (const child of [...this.root.children]) child.dispose();
-    for (const descendant of descendants) this.nodesById.delete(descendant.id);
-    this.root.children.length = 0;
-  }
-
-  registerSubtree(node: SceneNode): void {
-    node.traverse((descendant) => {
-      if (this.nodesById.has(descendant.id)) {
-        throw new ValidationError("DUPLICATE_SCENE_NODE", `Duplicate scene node id: ${descendant.id}`);
-      }
-      this.nodesById.set(descendant.id, descendant);
-    });
-  }
-
-  private register<T extends SceneNode>(node: T): T {
-    if (this.nodesById.has(node.id)) throw new ValidationError("DUPLICATE_SCENE_NODE", `Duplicate scene node id: ${node.id}`);
-    this.nodesById.set(node.id, node);
-    return node;
-  }
-}

package/src/SceneMetadata.ts

@@ -1,225 +0,0 @@
-import { ValidationError } from "@aura3d/core";
-
-export type SceneMetadataSeed = string | number;
-export type SceneMetadataPlanKind =
-  | "animation"
-  | "camera"
-  | "environment"
-  | "interaction"
-  | "lighting"
-  | "physics"
-  | "postprocess"
-  | "rendering";
-export type SceneMetadataCapabilityStatus = "supported" | "unsupported" | "approximation" | "route-local";
-
-export interface SceneAssetProvenance {
-  readonly id: string;
-  readonly uri?: string;
-  readonly source?: string;
-  readonly loader?: string;
-  readonly version?: string;
-  readonly digest?: string;
-  readonly license?: string;
-  readonly nodeIds?: readonly string[];
-  readonly materialIds?: readonly string[];
-  readonly notes?: string;
-}
-
-export interface SceneMaterialAssignment {
-  readonly nodeId: string;
-  readonly materialId: string;
-  readonly slot?: string | number;
-  readonly sourceMaterialId?: string;
-  readonly fallback?: boolean;
-  readonly unsupportedFeatures?: readonly string[];
-}
-
-export interface ScenePlanMetadata {
-  readonly id: string;
-  readonly kind: SceneMetadataPlanKind;
-  readonly description: string;
-  readonly owner?: string;
-  readonly nodeIds?: readonly string[];
-  readonly deterministicSeed?: SceneMetadataSeed;
-  readonly unsupportedFeatures?: readonly string[];
-  readonly evidence?: readonly string[];
-}
-
-export interface SceneCapabilityDisclosure {
-  readonly feature: string;
-  readonly status: SceneMetadataCapabilityStatus;
-  readonly reason?: string;
-  readonly owner?: string;
-  readonly evidence?: readonly string[];
-}
-
-export interface SceneRevisionMetadata {
-  readonly id?: string;
-  readonly parentRevisionId?: string;
-  readonly summary: string;
-  readonly author?: string;
-  readonly timestamp?: string;
-  readonly deterministicSeed?: SceneMetadataSeed;
-}
-
-export type SceneRevisionRecord = Required<Pick<SceneRevisionMetadata, "id" | "summary">> & SceneRevisionMetadata;
-
-export interface SceneMetadataOptions {
-  readonly deterministicSeed?: SceneMetadataSeed;
-  readonly assets?: readonly SceneAssetProvenance[];
-  readonly materialAssignments?: readonly SceneMaterialAssignment[];
-  readonly plans?: readonly ScenePlanMetadata[];
-  readonly capabilities?: readonly SceneCapabilityDisclosure[];
-  readonly revisions?: readonly SceneRevisionMetadata[];
-}
-
-export type SerializedSceneMetadata = SceneMetadataOptions;
-
-export class SceneMetadata {
-  deterministicSeed?: SceneMetadataSeed;
-  readonly assets: SceneAssetProvenance[] = [];
-  readonly materialAssignments: SceneMaterialAssignment[] = [];
-  readonly plans: ScenePlanMetadata[] = [];
-  readonly capabilities: SceneCapabilityDisclosure[] = [];
-  readonly revisions: SceneRevisionRecord[] = [];
-
-  constructor(options: SceneMetadataOptions = {}) {
-    this.replace(options);
-  }
-
-  replace(options: SceneMetadataOptions | SceneMetadata): this {
-    this.deterministicSeed = options.deterministicSeed;
-    this.assets.length = 0;
-    this.materialAssignments.length = 0;
-    this.plans.length = 0;
-    this.capabilities.length = 0;
-    this.revisions.length = 0;
-    for (const asset of options.assets ?? []) this.registerAsset(asset);
-    for (const assignment of options.materialAssignments ?? []) this.assignMaterial(assignment);
-    for (const plan of options.plans ?? []) this.addPlan(plan);
-    for (const capability of options.capabilities ?? []) this.discloseCapability(capability);
-    for (const revision of options.revisions ?? []) this.recordRevision(revision);
-    return this;
-  }
-
-  clone(): SceneMetadata {
-    return new SceneMetadata(this.toJSON());
-  }
-
-  get isEmpty(): boolean {
-    return this.deterministicSeed === undefined
-      && this.assets.length === 0
-      && this.materialAssignments.length === 0
-      && this.plans.length === 0
-      && this.capabilities.length === 0
-      && this.revisions.length === 0;
-  }
-
-  registerAsset(asset: SceneAssetProvenance): this {
-    requireNonEmpty(asset.id, "asset id");
-    upsertByKey(this.assets, cloneAsset(asset), (candidate) => candidate.id === asset.id);
-    return this;
-  }
-
-  assignMaterial(assignment: SceneMaterialAssignment): this {
-    requireNonEmpty(assignment.nodeId, "material assignment nodeId");
-    requireNonEmpty(assignment.materialId, "material assignment materialId");
-    const cloned = cloneMaterialAssignment(assignment);
-    upsertByKey(
-      this.materialAssignments,
-      cloned,
-      (candidate) => candidate.nodeId === cloned.nodeId && candidate.slot === cloned.slot
-    );
-    return this;
-  }
-
-  addPlan(plan: ScenePlanMetadata): this {
-    requireNonEmpty(plan.id, "plan id");
-    requireNonEmpty(plan.description, "plan description");
-    upsertByKey(this.plans, clonePlan(plan), (candidate) => candidate.id === plan.id);
-    return this;
-  }
-
-  discloseCapability(disclosure: SceneCapabilityDisclosure): this {
-    requireNonEmpty(disclosure.feature, "capability feature");
-    upsertByKey(this.capabilities, cloneCapability(disclosure), (candidate) => candidate.feature === disclosure.feature);
-    return this;
-  }
-
-  discloseUnsupportedFeature(
-    feature: string,
-    reason: string,
-    options: Omit<SceneCapabilityDisclosure, "feature" | "reason" | "status"> = {}
-  ): this {
-    return this.discloseCapability({ ...options, feature, reason, status: "unsupported" });
-  }
-
-  recordRevision(revision: SceneRevisionMetadata): this {
-    requireNonEmpty(revision.summary, "revision summary");
-    const id = revision.id ?? `revision-${this.revisions.length + 1}`;
-    upsertByKey(this.revisions, cloneRevision({ ...revision, id }), (candidate) => candidate.id === id);
-    return this;
-  }
-
-  unsupportedFeatures(): readonly SceneCapabilityDisclosure[] {
-    return this.capabilities.filter((capability) => capability.status === "unsupported");
-  }
-
-  toJSON(): SerializedSceneMetadata {
-    return {
-      ...(this.deterministicSeed !== undefined ? { deterministicSeed: this.deterministicSeed } : {}),
-      ...(this.assets.length > 0 ? { assets: this.assets.map(cloneAsset) } : {}),
-      ...(this.materialAssignments.length > 0 ? { materialAssignments: this.materialAssignments.map(cloneMaterialAssignment) } : {}),
-      ...(this.plans.length > 0 ? { plans: this.plans.map(clonePlan) } : {}),
-      ...(this.capabilities.length > 0 ? { capabilities: this.capabilities.map(cloneCapability) } : {}),
-      ...(this.revisions.length > 0 ? { revisions: this.revisions.map(cloneRevision) } : {})
-    };
-  }
-}
-
-function requireNonEmpty(value: string | undefined, label: string): void {
-  if (!value || value.trim().length === 0) {
-    throw new ValidationError("SCENE_METADATA", `Scene metadata ${label} must be a non-empty string.`);
-  }
-}
-
-function upsertByKey<T>(items: T[], value: T, matches: (candidate: T) => boolean): void {
-  const index = items.findIndex(matches);
-  if (index >= 0) items[index] = value;
-  else items.push(value);
-}
-
-function cloneAsset(asset: SceneAssetProvenance): SceneAssetProvenance {
-  return {
-    ...asset,
-    ...(asset.nodeIds ? { nodeIds: [...asset.nodeIds] } : {}),
-    ...(asset.materialIds ? { materialIds: [...asset.materialIds] } : {})
-  };
-}
-
-function cloneMaterialAssignment(assignment: SceneMaterialAssignment): SceneMaterialAssignment {
-  return {
-    ...assignment,
-    ...(assignment.unsupportedFeatures ? { unsupportedFeatures: [...assignment.unsupportedFeatures] } : {})
-  };
-}
-
-function clonePlan(plan: ScenePlanMetadata): ScenePlanMetadata {
-  return {
-    ...plan,
-    ...(plan.nodeIds ? { nodeIds: [...plan.nodeIds] } : {}),
-    ...(plan.unsupportedFeatures ? { unsupportedFeatures: [...plan.unsupportedFeatures] } : {}),
-    ...(plan.evidence ? { evidence: [...plan.evidence] } : {})
-  };
-}
-
-function cloneCapability(capability: SceneCapabilityDisclosure): SceneCapabilityDisclosure {
-  return {
-    ...capability,
-    ...(capability.evidence ? { evidence: [...capability.evidence] } : {})
-  };
-}
-
-function cloneRevision(revision: SceneRevisionMetadata): SceneRevisionRecord {
-  return { ...revision, id: revision.id ?? "revision-1" };
-}

package/src/SceneNode.ts

@@ -1,139 +0,0 @@
-import { ValidationError } from "@aura3d/core";
-import { Bounds3 } from "./Bounds.js";
-import { cloneMat4, invertMat4, multiplyMat4 } from "./MathTypes.js";
-import type { Renderable } from "./Renderable.js";
-import { TransformNode } from "./TransformNode.js";
-
-let nextSceneNodeId = 1;
-
-export interface SceneNodeOptions {
-  id?: string;
-  name?: string;
-}
-
-export interface AddChildOptions {
-  preserveWorldTransform?: boolean;
-}
-
-export interface DisposeNodeOptions {
-  recursive?: boolean;
-}
-
-export class SceneNode {
-  readonly id: string;
-  name: string;
-  visible = true;
-  layerMask = 1;
-  renderOrder = 0;
-  disposed = false;
-  userData: Record<string, unknown> = {};
-  renderable?: Renderable;
-  readonly transform = new TransformNode();
-  localBounds: Bounds3 | null = null;
-  worldBounds = new Bounds3();
-  readonly children: SceneNode[] = [];
-  parent: SceneNode | null = null;
-
-  constructor(options: SceneNodeOptions = {}) {
-    this.id = options.id ?? `node-${nextSceneNodeId++}`;
-    this.name = options.name ?? this.id;
-    this.transform.onDirty(() => this.markWorldDirty());
-  }
-
-  addChild(child: SceneNode, options: AddChildOptions = {}): this {
-    this.assertAlive();
-    child.assertAlive();
-    assertCanParent(this, child);
-    if (child.parent === this) return this;
-    const preservedWorld = options.preserveWorldTransform ? cloneMat4(child.transform.worldMatrix) : undefined;
-    if (preservedWorld) this.updateWorldTransform();
-    child.parent?.removeChild(child);
-    this.children.push(child);
-    child.parent = this;
-    if (preservedWorld) child.transform.setFromLocalMatrix(multiplyMat4(invertMat4(this.transform.worldMatrix), preservedWorld));
-    child.markWorldDirty();
-    return this;
-  }
-
-  removeChild(child: SceneNode): boolean {
-    this.assertAlive();
-    const index = this.children.indexOf(child);
-    if (index < 0) return false;
-    this.children.splice(index, 1);
-    child.parent = null;
-    child.markWorldDirty();
-    return true;
-  }
-
-  removeFromParent(): boolean {
-    return this.parent?.removeChild(this) ?? false;
-  }
-
-  isAncestorOf(candidate: SceneNode): boolean {
-    let current = candidate.parent;
-    while (current) {
-      if (current === this) return true;
-      current = current.parent;
-    }
-    return false;
-  }
-
-  traverse(visitor: (node: SceneNode) => void): void {
-    visitor(this);
-    for (const child of [...this.children]) child.traverse(visitor);
-  }
-
-  updateWorldTransform(force = false): void {
-    const changed = this.transform.updateWorld(this.parent?.transform.worldMatrix, force);
-    for (const child of this.children) child.updateWorldTransform(force || changed);
-  }
-
-  updateWorldBounds(): Bounds3 {
-    let bounds = this.localBounds ? this.localBounds.transform(this.transform.worldMatrix) : new Bounds3();
-    for (const child of this.children) bounds = bounds.union(child.updateWorldBounds());
-    this.worldBounds = bounds;
-    return this.worldBounds;
-  }
-
-  setLocalBounds(bounds: Bounds3 | null): this {
-    this.assertAlive();
-    this.localBounds = bounds?.clone() ?? null;
-    this.worldBounds = this.localBounds ? this.localBounds.transform(this.transform.worldMatrix) : new Bounds3();
-    return this;
-  }
-
-  dispose(options: DisposeNodeOptions = {}): void {
-    if (this.disposed) return;
-    const recursive = options.recursive ?? true;
-    const children = [...this.children];
-    if (recursive) {
-      for (const child of children) child.dispose(options);
-    } else {
-      for (const child of children) child.parent = null;
-    }
-    this.children.length = 0;
-    this.parent?.removeChild(this);
-    this.parent = null;
-    this.renderable = undefined;
-    this.localBounds = null;
-    this.userData = {};
-    this.visible = false;
-    this.disposed = true;
-  }
-
-  markWorldDirty(): void {
-    for (const child of this.children) {
-      child.transform.markDirty();
-      child.markWorldDirty();
-    }
-  }
-
-  protected assertAlive(): void {
-    if (this.disposed) throw new ValidationError("DISPOSED_SCENE_NODE", `Scene node ${this.name} is disposed.`);
-  }
-}
-
-export function assertCanParent(parent: SceneNode, child: SceneNode): void {
-  if (parent === child) throw new ValidationError("SCENE_SELF_PARENT", "A scene node cannot be parented to itself.");
-  if (child.isAncestorOf(parent)) throw new ValidationError("SCENE_HIERARCHY_CYCLE", "Scene hierarchy cycle rejected.");
-}

package/src/SceneQuery.ts

@@ -1,39 +0,0 @@
-import { Bounds3 } from "./Bounds.js";
-import { Camera } from "./Camera.js";
-import { Light } from "./Light.js";
-import { Renderable } from "./Renderable.js";
-import { SceneNode } from "./SceneNode.js";
-
-export interface SceneQueryOptions {
-  name?: string | RegExp;
-  visible?: boolean;
-  layerMask?: number;
-  type?: "camera" | "light" | "node";
-  bounds?: Bounds3;
-}
-
-export function queryScene(root: SceneNode, options: SceneQueryOptions): SceneNode[] {
-  const result: SceneNode[] = [];
-  root.traverse((node) => {
-    if (options.visible !== undefined && node.visible !== options.visible) return;
-    if (options.layerMask !== undefined && (node.layerMask & options.layerMask) === 0) return;
-    if (options.name !== undefined) {
-      const matches = typeof options.name === "string" ? node.name === options.name : options.name.test(node.name);
-      if (!matches) return;
-    }
-    if (options.type === "camera" && !(node instanceof Camera)) return;
-    if (options.type === "light" && !(node instanceof Light)) return;
-    if (options.bounds && !node.worldBounds.intersects(options.bounds)) return;
-    result.push(node);
-  });
-  return result;
-}
-
-export function collectRenderables(root: SceneNode): { node: SceneNode; renderable: Renderable }[] {
-  const result: { node: SceneNode; renderable: Renderable }[] = [];
-  root.traverse((node) => {
-    const maybe = node.renderable;
-    if (maybe && node.visible) result.push({ node, renderable: maybe });
-  });
-  return result;
-}