@nice2dev/game-engine 1.3.15 → 1.3.16

package/dist/esm/native-engine/SceneGraph.js

@@ -1,856 +1,822 @@
-/**
- * @file SceneGraph.ts
- * @description Scene Graph system for Nice2Dev Game Engine
- * PRO-1.11.1: Core Engine Systems - Scene Graph
- *
- * Features:
- * - Hierarchical transforms
- * - Frustum culling
- * - Octree/BVH spatial partitioning
- * - Instanced rendering support
- * - LOD system
- */
-class SceneNode {
-    constructor(name, type = 'empty') {
-        this.parent = null;
-        this.children = [];
-        this.visible = true;
-        this.castShadows = true;
-        this.receiveShadows = true;
-        this.layer = 0;
-        this.tags = new Set();
-        this.data = {};
-        this.currentLODLevel = 0;
-        this.id = `node_${SceneNode.nextId++}`;
-        this.name = name;
-        this.type = type;
-        this.transform = {
-            position: { x: 0, y: 0, z: 0 },
-            rotation: { x: 0, y: 0, z: 0, w: 1 },
-            scale: { x: 1, y: 1, z: 1 },
-            localMatrix: new Float32Array(16),
-            worldMatrix: new Float32Array(16),
-            dirty: true,
-        };
-        this.localBounds = {
-            min: { x: -0.5, y: -0.5, z: -0.5 },
-            max: { x: 0.5, y: 0.5, z: 0.5 },
-        };
-        this.worldBounds = { ...this.localBounds };
-        this.boundingSphere = {
-            center: { x: 0, y: 0, z: 0 },
-            radius: 0.866,
-        };
-        mat4Identity(this.transform.localMatrix);
-        mat4Identity(this.transform.worldMatrix);
-    }
-    // ─── Transform Methods ─────────────────────────────────
-    setPosition(x, y, z) {
-        this.transform.position.x = x;
-        this.transform.position.y = y;
-        this.transform.position.z = z;
-        this.markDirty();
-    }
-    setRotation(x, y, z, w) {
-        this.transform.rotation.x = x;
-        this.transform.rotation.y = y;
-        this.transform.rotation.z = z;
-        this.transform.rotation.w = w;
-        this.markDirty();
-    }
-    setRotationEuler(pitch, yaw, roll) {
-        eulerToQuaternion(pitch, yaw, roll, this.transform.rotation);
-        this.markDirty();
-    }
-    setScale(x, y, z) {
-        this.transform.scale.x = x;
-        this.transform.scale.y = y;
-        this.transform.scale.z = z;
-        this.markDirty();
-    }
-    translate(x, y, z) {
-        this.transform.position.x += x;
-        this.transform.position.y += y;
-        this.transform.position.z += z;
-        this.markDirty();
-    }
-    rotate(x, y, z, w) {
-        const q = this.transform.rotation;
-        const result = quaternionMultiply(q, { x, y, z, w });
-        this.transform.rotation.x = result.x;
-        this.transform.rotation.y = result.y;
-        this.transform.rotation.z = result.z;
-        this.transform.rotation.w = result.w;
-        this.markDirty();
-    }
-    lookAt(target, up = { x: 0, y: 1, z: 0 }) {
-        const forward = vec3Normalize(vec3Subtract(target, this.transform.position));
-        const right = vec3Normalize(vec3Cross(up, forward));
-        const newUp = vec3Cross(forward, right);
-        // Convert rotation matrix to quaternion
-        this.transform.rotation = matrixToQuaternion(right, newUp, forward);
-        this.markDirty();
-    }
-    getWorldPosition() {
-        this.updateWorldMatrix();
-        return {
-            x: this.transform.worldMatrix[12],
-            y: this.transform.worldMatrix[13],
-            z: this.transform.worldMatrix[14],
-        };
-    }
-    getForward() {
-        this.updateWorldMatrix();
-        return vec3Normalize({
-            x: -this.transform.worldMatrix[8],
-            y: -this.transform.worldMatrix[9],
-            z: -this.transform.worldMatrix[10],
-        });
-    }
-    getRight() {
-        this.updateWorldMatrix();
-        return vec3Normalize({
-            x: this.transform.worldMatrix[0],
-            y: this.transform.worldMatrix[1],
-            z: this.transform.worldMatrix[2],
-        });
-    }
-    getUp() {
-        this.updateWorldMatrix();
-        return vec3Normalize({
-            x: this.transform.worldMatrix[4],
-            y: this.transform.worldMatrix[5],
-            z: this.transform.worldMatrix[6],
-        });
-    }
-    markDirty() {
-        this.transform.dirty = true;
-        for (const child of this.children) {
-            child.markDirty();
-        }
-    }
-    updateLocalMatrix() {
-        // Compose TRS matrix
-        mat4Compose(this.transform.position, this.transform.rotation, this.transform.scale, this.transform.localMatrix);
-    }
-    updateWorldMatrix() {
-        if (!this.transform.dirty) {
-            return;
-        }
-        this.updateLocalMatrix();
-        if (this.parent) {
-            this.parent.updateWorldMatrix();
-            mat4Multiply(this.parent.transform.worldMatrix, this.transform.localMatrix, this.transform.worldMatrix);
-        }
-        else {
-            mat4Copy(this.transform.localMatrix, this.transform.worldMatrix);
-        }
-        this.updateWorldBounds();
-        this.transform.dirty = false;
-    }
-    updateWorldBounds() {
-        // Transform local AABB by world matrix to get world AABB
-        const corners = getAABBCorners(this.localBounds);
-        const transformedCorners = corners.map((c) => transformPoint(c, this.transform.worldMatrix));
-        this.worldBounds.min = { x: Infinity, y: Infinity, z: Infinity };
-        this.worldBounds.max = { x: -Infinity, y: -Infinity, z: -Infinity };
-        for (const corner of transformedCorners) {
-            this.worldBounds.min.x = Math.min(this.worldBounds.min.x, corner.x);
-            this.worldBounds.min.y = Math.min(this.worldBounds.min.y, corner.y);
-            this.worldBounds.min.z = Math.min(this.worldBounds.min.z, corner.z);
-            this.worldBounds.max.x = Math.max(this.worldBounds.max.x, corner.x);
-            this.worldBounds.max.y = Math.max(this.worldBounds.max.y, corner.y);
-            this.worldBounds.max.z = Math.max(this.worldBounds.max.z, corner.z);
-        }
-        // Update bounding sphere
-        this.boundingSphere.center = {
-            x: (this.worldBounds.min.x + this.worldBounds.max.x) / 2,
-            y: (this.worldBounds.min.y + this.worldBounds.max.y) / 2,
-            z: (this.worldBounds.min.z + this.worldBounds.max.z) / 2,
-        };
-        const dx = this.worldBounds.max.x - this.boundingSphere.center.x;
-        const dy = this.worldBounds.max.y - this.boundingSphere.center.y;
-        const dz = this.worldBounds.max.z - this.boundingSphere.center.z;
-        this.boundingSphere.radius = Math.sqrt(dx * dx + dy * dy + dz * dz);
-    }
-    // ─── Hierarchy Methods ─────────────────────────────────
-    addChild(node) {
-        if (node.parent) {
-            node.parent.removeChild(node);
-        }
-        node.parent = this;
-        this.children.push(node);
-        node.markDirty();
-    }
-    removeChild(node) {
-        const index = this.children.indexOf(node);
-        if (index >= 0) {
-            this.children.splice(index, 1);
-            node.parent = null;
-            node.markDirty();
-        }
-    }
-    removeFromParent() {
-        if (this.parent) {
-            this.parent.removeChild(this);
-        }
-    }
-    getRoot() {
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        let node = this;
-        while (node.parent) {
-            node = node.parent;
-        }
-        return node;
-    }
-    findByName(name) {
-        if (this.name === name) {
-            return this;
-        }
-        for (const child of this.children) {
-            const found = child.findByName(name);
-            if (found) {
-                return found;
-            }
-        }
-        return null;
-    }
-    findById(id) {
-        if (this.id === id) {
-            return this;
-        }
-        for (const child of this.children) {
-            const found = child.findById(id);
-            if (found) {
-                return found;
-            }
-        }
-        return null;
-    }
-    findByTag(tag) {
-        const results = [];
-        this.collectByTag(tag, results);
-        return results;
-    }
-    collectByTag(tag, results) {
-        if (this.tags.has(tag)) {
-            results.push(this);
-        }
-        for (const child of this.children) {
-            child.collectByTag(tag, results);
-        }
-    }
-    traverse(callback) {
-        if (callback(this) === false) {
-            return;
-        }
-        for (const child of this.children) {
-            child.traverse(callback);
-        }
-    }
-    traverseVisible(callback) {
-        if (!this.visible) {
-            return;
-        }
-        if (callback(this) === false) {
-            return;
-        }
-        for (const child of this.children) {
-            child.traverseVisible(callback);
-        }
-    }
-    // ─── LOD Methods ───────────────────────────────────────
-    setLOD(config) {
-        this.lod = config;
-    }
-    updateLOD(cameraPosition) {
-        if (!this.lod) {
-            return;
-        }
-        const worldPos = this.getWorldPosition();
-        const distance = vec3Distance(worldPos, cameraPosition);
-        let newLevel = 0;
-        for (let i = 0; i < this.lod.levels.length; i++) {
-            if (distance > this.lod.levels[i].distance) {
-                newLevel = i;
-            }
-            else {
-                break;
-            }
-        }
-        this.currentLODLevel = newLevel;
-    }
-    // ─── Clone ─────────────────────────────────────────────
-    clone(deep = true) {
-        const clone = new SceneNode(this.name, this.type);
-        clone.visible = this.visible;
-        clone.castShadows = this.castShadows;
-        clone.receiveShadows = this.receiveShadows;
-        clone.layer = this.layer;
-        clone.tags = new Set(this.tags);
-        clone.data = { ...this.data };
-        clone.instanceGroup = this.instanceGroup;
-        clone.transform.position = { ...this.transform.position };
-        clone.transform.rotation = { ...this.transform.rotation };
-        clone.transform.scale = { ...this.transform.scale };
-        clone.localBounds = {
-            min: { ...this.localBounds.min },
-            max: { ...this.localBounds.max },
-        };
-        if (this.lod) {
-            clone.lod = {
-                ...this.lod,
-                levels: this.lod.levels.map((l) => ({ ...l })),
-            };
-        }
-        if (deep) {
-            for (const child of this.children) {
-                clone.addChild(child.clone(true));
-            }
-        }
-        return clone;
-    }
-}
-SceneNode.nextId = 0;
+const _SceneNode = class _SceneNode {
+  constructor(name, type = "empty") {
+    this.parent = null;
+    this.children = [];
+    this.visible = true;
+    this.castShadows = true;
+    this.receiveShadows = true;
+    this.layer = 0;
+    this.tags = /* @__PURE__ */ new Set();
+    this.data = {};
+    this.currentLODLevel = 0;
+    this.id = `node_${_SceneNode.nextId++}`;
+    this.name = name;
+    this.type = type;
+    this.transform = {
+      position: { x: 0, y: 0, z: 0 },
+      rotation: { x: 0, y: 0, z: 0, w: 1 },
+      scale: { x: 1, y: 1, z: 1 },
+      localMatrix: new Float32Array(16),
+      worldMatrix: new Float32Array(16),
+      dirty: true
+    };
+    this.localBounds = {
+      min: { x: -0.5, y: -0.5, z: -0.5 },
+      max: { x: 0.5, y: 0.5, z: 0.5 }
+    };
+    this.worldBounds = { ...this.localBounds };
+    this.boundingSphere = {
+      center: { x: 0, y: 0, z: 0 },
+      radius: 0.866
+    };
+    mat4Identity(this.transform.localMatrix);
+    mat4Identity(this.transform.worldMatrix);
+  }
+  // ─── Transform Methods ─────────────────────────────────
+  setPosition(x, y, z) {
+    this.transform.position.x = x;
+    this.transform.position.y = y;
+    this.transform.position.z = z;
+    this.markDirty();
+  }
+  setRotation(x, y, z, w) {
+    this.transform.rotation.x = x;
+    this.transform.rotation.y = y;
+    this.transform.rotation.z = z;
+    this.transform.rotation.w = w;
+    this.markDirty();
+  }
+  setRotationEuler(pitch, yaw, roll) {
+    eulerToQuaternion(pitch, yaw, roll, this.transform.rotation);
+    this.markDirty();
+  }
+  setScale(x, y, z) {
+    this.transform.scale.x = x;
+    this.transform.scale.y = y;
+    this.transform.scale.z = z;
+    this.markDirty();
+  }
+  translate(x, y, z) {
+    this.transform.position.x += x;
+    this.transform.position.y += y;
+    this.transform.position.z += z;
+    this.markDirty();
+  }
+  rotate(x, y, z, w) {
+    const q = this.transform.rotation;
+    const result = quaternionMultiply(q, { x, y, z, w });
+    this.transform.rotation.x = result.x;
+    this.transform.rotation.y = result.y;
+    this.transform.rotation.z = result.z;
+    this.transform.rotation.w = result.w;
+    this.markDirty();
+  }
+  lookAt(target, up = { x: 0, y: 1, z: 0 }) {
+    const forward = vec3Normalize(vec3Subtract(target, this.transform.position));
+    const right = vec3Normalize(vec3Cross(up, forward));
+    const newUp = vec3Cross(forward, right);
+    this.transform.rotation = matrixToQuaternion(right, newUp, forward);
+    this.markDirty();
+  }
+  getWorldPosition() {
+    this.updateWorldMatrix();
+    return {
+      x: this.transform.worldMatrix[12],
+      y: this.transform.worldMatrix[13],
+      z: this.transform.worldMatrix[14]
+    };
+  }
+  getForward() {
+    this.updateWorldMatrix();
+    return vec3Normalize({
+      x: -this.transform.worldMatrix[8],
+      y: -this.transform.worldMatrix[9],
+      z: -this.transform.worldMatrix[10]
+    });
+  }
+  getRight() {
+    this.updateWorldMatrix();
+    return vec3Normalize({
+      x: this.transform.worldMatrix[0],
+      y: this.transform.worldMatrix[1],
+      z: this.transform.worldMatrix[2]
+    });
+  }
+  getUp() {
+    this.updateWorldMatrix();
+    return vec3Normalize({
+      x: this.transform.worldMatrix[4],
+      y: this.transform.worldMatrix[5],
+      z: this.transform.worldMatrix[6]
+    });
+  }
+  markDirty() {
+    this.transform.dirty = true;
+    for (const child of this.children) {
+      child.markDirty();
+    }
+  }
+  updateLocalMatrix() {
+    mat4Compose(
+      this.transform.position,
+      this.transform.rotation,
+      this.transform.scale,
+      this.transform.localMatrix
+    );
+  }
+  updateWorldMatrix() {
+    if (!this.transform.dirty) {
+      return;
+    }
+    this.updateLocalMatrix();
+    if (this.parent) {
+      this.parent.updateWorldMatrix();
+      mat4Multiply(
+        this.parent.transform.worldMatrix,
+        this.transform.localMatrix,
+        this.transform.worldMatrix
+      );
+    } else {
+      mat4Copy(this.transform.localMatrix, this.transform.worldMatrix);
+    }
+    this.updateWorldBounds();
+    this.transform.dirty = false;
+  }
+  updateWorldBounds() {
+    const corners = getAABBCorners(this.localBounds);
+    const transformedCorners = corners.map((c) => transformPoint(c, this.transform.worldMatrix));
+    this.worldBounds.min = { x: Infinity, y: Infinity, z: Infinity };
+    this.worldBounds.max = { x: -Infinity, y: -Infinity, z: -Infinity };
+    for (const corner of transformedCorners) {
+      this.worldBounds.min.x = Math.min(this.worldBounds.min.x, corner.x);
+      this.worldBounds.min.y = Math.min(this.worldBounds.min.y, corner.y);
+      this.worldBounds.min.z = Math.min(this.worldBounds.min.z, corner.z);
+      this.worldBounds.max.x = Math.max(this.worldBounds.max.x, corner.x);
+      this.worldBounds.max.y = Math.max(this.worldBounds.max.y, corner.y);
+      this.worldBounds.max.z = Math.max(this.worldBounds.max.z, corner.z);
+    }
+    this.boundingSphere.center = {
+      x: (this.worldBounds.min.x + this.worldBounds.max.x) / 2,
+      y: (this.worldBounds.min.y + this.worldBounds.max.y) / 2,
+      z: (this.worldBounds.min.z + this.worldBounds.max.z) / 2
+    };
+    const dx = this.worldBounds.max.x - this.boundingSphere.center.x;
+    const dy = this.worldBounds.max.y - this.boundingSphere.center.y;
+    const dz = this.worldBounds.max.z - this.boundingSphere.center.z;
+    this.boundingSphere.radius = Math.sqrt(dx * dx + dy * dy + dz * dz);
+  }
+  // ─── Hierarchy Methods ─────────────────────────────────
+  addChild(node) {
+    if (node.parent) {
+      node.parent.removeChild(node);
+    }
+    node.parent = this;
+    this.children.push(node);
+    node.markDirty();
+  }
+  removeChild(node) {
+    const index = this.children.indexOf(node);
+    if (index >= 0) {
+      this.children.splice(index, 1);
+      node.parent = null;
+      node.markDirty();
+    }
+  }
+  removeFromParent() {
+    if (this.parent) {
+      this.parent.removeChild(this);
+    }
+  }
+  getRoot() {
+    let node = this;
+    while (node.parent) {
+      node = node.parent;
+    }
+    return node;
+  }
+  findByName(name) {
+    if (this.name === name) {
+      return this;
+    }
+    for (const child of this.children) {
+      const found = child.findByName(name);
+      if (found) {
+        return found;
+      }
+    }
+    return null;
+  }
+  findById(id) {
+    if (this.id === id) {
+      return this;
+    }
+    for (const child of this.children) {
+      const found = child.findById(id);
+      if (found) {
+        return found;
+      }
+    }
+    return null;
+  }
+  findByTag(tag) {
+    const results = [];
+    this.collectByTag(tag, results);
+    return results;
+  }
+  collectByTag(tag, results) {
+    if (this.tags.has(tag)) {
+      results.push(this);
+    }
+    for (const child of this.children) {
+      child.collectByTag(tag, results);
+    }
+  }
+  traverse(callback) {
+    if (callback(this) === false) {
+      return;
+    }
+    for (const child of this.children) {
+      child.traverse(callback);
+    }
+  }
+  traverseVisible(callback) {
+    if (!this.visible) {
+      return;
+    }
+    if (callback(this) === false) {
+      return;
+    }
+    for (const child of this.children) {
+      child.traverseVisible(callback);
+    }
+  }
+  // ─── LOD Methods ───────────────────────────────────────
+  setLOD(config) {
+    this.lod = config;
+  }
+  updateLOD(cameraPosition) {
+    if (!this.lod) {
+      return;
+    }
+    const worldPos = this.getWorldPosition();
+    const distance = vec3Distance(worldPos, cameraPosition);
+    let newLevel = 0;
+    for (let i = 0; i < this.lod.levels.length; i++) {
+      if (distance > this.lod.levels[i].distance) {
+        newLevel = i;
+      } else {
+        break;
+      }
+    }
+    this.currentLODLevel = newLevel;
+  }
+  // ─── Clone ─────────────────────────────────────────────
+  clone(deep = true) {
+    const clone = new _SceneNode(this.name, this.type);
+    clone.visible = this.visible;
+    clone.castShadows = this.castShadows;
+    clone.receiveShadows = this.receiveShadows;
+    clone.layer = this.layer;
+    clone.tags = new Set(this.tags);
+    clone.data = { ...this.data };
+    clone.instanceGroup = this.instanceGroup;
+    clone.transform.position = { ...this.transform.position };
+    clone.transform.rotation = { ...this.transform.rotation };
+    clone.transform.scale = { ...this.transform.scale };
+    clone.localBounds = {
+      min: { ...this.localBounds.min },
+      max: { ...this.localBounds.max }
+    };
+    if (this.lod) {
+      clone.lod = {
+        ...this.lod,
+        levels: this.lod.levels.map((l) => ({ ...l }))
+      };
+    }
+    if (deep) {
+      for (const child of this.children) {
+        clone.addChild(child.clone(true));
+      }
+    }
+    return clone;
+  }
+};
+_SceneNode.nextId = 0;
+let SceneNode = _SceneNode;
 class Octree {
-    constructor(bounds, config) {
-        this.nodePool = [];
-        this.config = {
-            maxDepth: 8,
-            maxObjectsPerNode: 8,
-            looseness: 1.25,
-            minSize: 1,
-            ...config,
-        };
-        this.root = this.createNode(bounds, 0);
-    }
-    createNode(bounds, depth) {
-        const node = this.nodePool.pop() ?? new OctreeNode();
-        node.bounds = bounds;
-        node.depth = depth;
-        node.objects = [];
-        node.children = null;
-        return node;
-    }
-    releaseNode(node) {
-        if (node.children) {
-            for (const child of node.children) {
-                this.releaseNode(child);
-            }
-        }
-        node.objects = [];
-        node.children = null;
-        this.nodePool.push(node);
-    }
-    insert(node) {
-        this.insertIntoNode(this.root, node);
-    }
-    insertIntoNode(octreeNode, sceneNode) {
-        // Check if node fits in any child
-        if (octreeNode.children) {
-            const childIndex = this.getChildIndex(octreeNode, sceneNode.worldBounds);
-            if (childIndex >= 0) {
-                this.insertIntoNode(octreeNode.children[childIndex], sceneNode);
-                return;
-            }
-        }
-        // Add to this node
-        octreeNode.objects.push(sceneNode);
-        // Split if needed
-        if (!octreeNode.children &&
-            octreeNode.objects.length > this.config.maxObjectsPerNode &&
-            octreeNode.depth < this.config.maxDepth) {
-            this.split(octreeNode);
-        }
-    }
-    split(node) {
-        const center = {
-            x: (node.bounds.min.x + node.bounds.max.x) / 2,
-            y: (node.bounds.min.y + node.bounds.max.y) / 2,
-            z: (node.bounds.min.z + node.bounds.max.z) / 2,
-        };
-        node.children = [];
-        for (let i = 0; i < 8; i++) {
-            const childBounds = {
-                min: {
-                    x: i & 1 ? center.x : node.bounds.min.x,
-                    y: i & 2 ? center.y : node.bounds.min.y,
-                    z: i & 4 ? center.z : node.bounds.min.z,
-                },
-                max: {
-                    x: i & 1 ? node.bounds.max.x : center.x,
-                    y: i & 2 ? node.bounds.max.y : center.y,
-                    z: i & 4 ? node.bounds.max.z : center.z,
-                },
-            };
-            node.children.push(this.createNode(childBounds, node.depth + 1));
-        }
-        // Redistribute objects
-        const objects = node.objects;
-        node.objects = [];
-        for (const obj of objects) {
-            this.insertIntoNode(node, obj);
-        }
-    }
-    getChildIndex(octreeNode, bounds) {
-        if (!octreeNode.children) {
-            return -1;
-        }
-        const center = {
-            x: (octreeNode.bounds.min.x + octreeNode.bounds.max.x) / 2,
-            y: (octreeNode.bounds.min.y + octreeNode.bounds.max.y) / 2,
-            z: (octreeNode.bounds.min.z + octreeNode.bounds.max.z) / 2,
-        };
-        // Check if bounds fits entirely in one octant
-        const minX = bounds.min.x >= center.x;
-        const maxX = bounds.max.x <= center.x;
-        const minY = bounds.min.y >= center.y;
-        const maxY = bounds.max.y <= center.y;
-        const minZ = bounds.min.z >= center.z;
-        const maxZ = bounds.max.z <= center.z;
-        if ((minX || maxX) && (minY || maxY) && (minZ || maxZ)) {
-            return (minX ? 1 : 0) | (minY ? 2 : 0) | (minZ ? 4 : 0);
-        }
-        return -1;
-    }
-    remove(node) {
-        this.removeFromNode(this.root, node);
-    }
-    removeFromNode(octreeNode, sceneNode) {
-        const index = octreeNode.objects.indexOf(sceneNode);
-        if (index >= 0) {
-            octreeNode.objects.splice(index, 1);
-            return true;
-        }
-        if (octreeNode.children) {
-            for (const child of octreeNode.children) {
-                if (this.removeFromNode(child, sceneNode)) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-    update(node) {
-        this.remove(node);
-        this.insert(node);
-    }
-    queryFrustum(frustum) {
-        const results = [];
-        this.queryFrustumNode(this.root, frustum, results);
-        return results;
-    }
-    queryFrustumNode(octreeNode, frustum, results) {
-        const result = frustumAABBIntersection(frustum, octreeNode.bounds);
-        if (result === 'outside') {
-            return;
-        }
-        if (result === 'inside') {
-            // All objects in this node and children are visible
-            this.collectAllObjects(octreeNode, results);
-            return;
-        }
-        // Intersecting - test each object
-        for (const obj of octreeNode.objects) {
-            if (frustumSphereIntersection(frustum, obj.boundingSphere) !== 'outside') {
-                results.push(obj);
-            }
-        }
-        if (octreeNode.children) {
-            for (const child of octreeNode.children) {
-                this.queryFrustumNode(child, frustum, results);
-            }
-        }
-    }
-    collectAllObjects(octreeNode, results) {
-        results.push(...octreeNode.objects);
-        if (octreeNode.children) {
-            for (const child of octreeNode.children) {
-                this.collectAllObjects(child, results);
-            }
-        }
-    }
-    queryAABB(bounds) {
-        const results = [];
-        this.queryAABBNode(this.root, bounds, results);
-        return results;
-    }
-    queryAABBNode(octreeNode, bounds, results) {
-        if (!aabbIntersects(octreeNode.bounds, bounds)) {
-            return;
-        }
-        for (const obj of octreeNode.objects) {
-            if (aabbIntersects(obj.worldBounds, bounds)) {
-                results.push(obj);
-            }
-        }
-        if (octreeNode.children) {
-            for (const child of octreeNode.children) {
-                this.queryAABBNode(child, bounds, results);
-            }
-        }
-    }
-    querySphere(center, radius) {
-        const results = [];
-        const sphere = { center, radius };
-        this.querySphereNode(this.root, sphere, results);
-        return results;
-    }
-    querySphereNode(octreeNode, sphere, results) {
-        if (!sphereAABBIntersection(sphere, octreeNode.bounds)) {
-            return;
-        }
-        for (const obj of octreeNode.objects) {
-            if (sphereIntersects(obj.boundingSphere, sphere)) {
-                results.push(obj);
-            }
-        }
-        if (octreeNode.children) {
-            for (const child of octreeNode.children) {
-                this.querySphereNode(child, sphere, results);
-            }
-        }
-    }
-    raycast(origin, direction, maxDistance = Infinity) {
-        const results = [];
-        this.raycastNode(this.root, origin, direction, maxDistance, results);
-        results.sort((a, b) => a.distance - b.distance);
-        return results;
-    }
-    raycastNode(octreeNode, origin, direction, maxDistance, results) {
-        const hit = rayAABBIntersection(origin, direction, octreeNode.bounds);
-        if (!hit || hit.distance > maxDistance) {
-            return;
-        }
-        for (const obj of octreeNode.objects) {
-            const objHit = rayAABBIntersection(origin, direction, obj.worldBounds);
-            if (objHit && objHit.distance <= maxDistance) {
-                results.push({
-                    node: obj,
-                    distance: objHit.distance,
-                    point: objHit.point,
-                    normal: objHit.normal,
-                });
-            }
-        }
-        if (octreeNode.children) {
-            for (const child of octreeNode.children) {
-                this.raycastNode(child, origin, direction, maxDistance, results);
-            }
-        }
-    }
-    clear() {
-        this.releaseNode(this.root);
-        this.root = this.createNode(this.root.bounds, 0);
-    }
+  constructor(bounds, config) {
+    this.nodePool = [];
+    this.config = {
+      maxDepth: 8,
+      maxObjectsPerNode: 8,
+      looseness: 1.25,
+      minSize: 1,
+      ...config
+    };
+    this.root = this.createNode(bounds, 0);
+  }
+  createNode(bounds, depth) {
+    const node = this.nodePool.pop() ?? new OctreeNode();
+    node.bounds = bounds;
+    node.depth = depth;
+    node.objects = [];
+    node.children = null;
+    return node;
+  }
+  releaseNode(node) {
+    if (node.children) {
+      for (const child of node.children) {
+        this.releaseNode(child);
+      }
+    }
+    node.objects = [];
+    node.children = null;
+    this.nodePool.push(node);
+  }
+  insert(node) {
+    this.insertIntoNode(this.root, node);
+  }
+  insertIntoNode(octreeNode, sceneNode) {
+    if (octreeNode.children) {
+      const childIndex = this.getChildIndex(octreeNode, sceneNode.worldBounds);
+      if (childIndex >= 0) {
+        this.insertIntoNode(octreeNode.children[childIndex], sceneNode);
+        return;
+      }
+    }
+    octreeNode.objects.push(sceneNode);
+    if (!octreeNode.children && octreeNode.objects.length > this.config.maxObjectsPerNode && octreeNode.depth < this.config.maxDepth) {
+      this.split(octreeNode);
+    }
+  }
+  split(node) {
+    const center = {
+      x: (node.bounds.min.x + node.bounds.max.x) / 2,
+      y: (node.bounds.min.y + node.bounds.max.y) / 2,
+      z: (node.bounds.min.z + node.bounds.max.z) / 2
+    };
+    node.children = [];
+    for (let i = 0; i < 8; i++) {
+      const childBounds = {
+        min: {
+          x: i & 1 ? center.x : node.bounds.min.x,
+          y: i & 2 ? center.y : node.bounds.min.y,
+          z: i & 4 ? center.z : node.bounds.min.z
+        },
+        max: {
+          x: i & 1 ? node.bounds.max.x : center.x,
+          y: i & 2 ? node.bounds.max.y : center.y,
+          z: i & 4 ? node.bounds.max.z : center.z
+        }
+      };
+      node.children.push(this.createNode(childBounds, node.depth + 1));
+    }
+    const objects = node.objects;
+    node.objects = [];
+    for (const obj of objects) {
+      this.insertIntoNode(node, obj);
+    }
+  }
+  getChildIndex(octreeNode, bounds) {
+    if (!octreeNode.children) {
+      return -1;
+    }
+    const center = {
+      x: (octreeNode.bounds.min.x + octreeNode.bounds.max.x) / 2,
+      y: (octreeNode.bounds.min.y + octreeNode.bounds.max.y) / 2,
+      z: (octreeNode.bounds.min.z + octreeNode.bounds.max.z) / 2
+    };
+    const minX = bounds.min.x >= center.x;
+    const maxX = bounds.max.x <= center.x;
+    const minY = bounds.min.y >= center.y;
+    const maxY = bounds.max.y <= center.y;
+    const minZ = bounds.min.z >= center.z;
+    const maxZ = bounds.max.z <= center.z;
+    if ((minX || maxX) && (minY || maxY) && (minZ || maxZ)) {
+      return (minX ? 1 : 0) | (minY ? 2 : 0) | (minZ ? 4 : 0);
+    }
+    return -1;
+  }
+  remove(node) {
+    this.removeFromNode(this.root, node);
+  }
+  removeFromNode(octreeNode, sceneNode) {
+    const index = octreeNode.objects.indexOf(sceneNode);
+    if (index >= 0) {
+      octreeNode.objects.splice(index, 1);
+      return true;
+    }
+    if (octreeNode.children) {
+      for (const child of octreeNode.children) {
+        if (this.removeFromNode(child, sceneNode)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  update(node) {
+    this.remove(node);
+    this.insert(node);
+  }
+  queryFrustum(frustum) {
+    const results = [];
+    this.queryFrustumNode(this.root, frustum, results);
+    return results;
+  }
+  queryFrustumNode(octreeNode, frustum, results) {
+    const result = frustumAABBIntersection(frustum, octreeNode.bounds);
+    if (result === "outside") {
+      return;
+    }
+    if (result === "inside") {
+      this.collectAllObjects(octreeNode, results);
+      return;
+    }
+    for (const obj of octreeNode.objects) {
+      if (frustumSphereIntersection(frustum, obj.boundingSphere) !== "outside") {
+        results.push(obj);
+      }
+    }
+    if (octreeNode.children) {
+      for (const child of octreeNode.children) {
+        this.queryFrustumNode(child, frustum, results);
+      }
+    }
+  }
+  collectAllObjects(octreeNode, results) {
+    results.push(...octreeNode.objects);
+    if (octreeNode.children) {
+      for (const child of octreeNode.children) {
+        this.collectAllObjects(child, results);
+      }
+    }
+  }
+  queryAABB(bounds) {
+    const results = [];
+    this.queryAABBNode(this.root, bounds, results);
+    return results;
+  }
+  queryAABBNode(octreeNode, bounds, results) {
+    if (!aabbIntersects(octreeNode.bounds, bounds)) {
+      return;
+    }
+    for (const obj of octreeNode.objects) {
+      if (aabbIntersects(obj.worldBounds, bounds)) {
+        results.push(obj);
+      }
+    }
+    if (octreeNode.children) {
+      for (const child of octreeNode.children) {
+        this.queryAABBNode(child, bounds, results);
+      }
+    }
+  }
+  querySphere(center, radius) {
+    const results = [];
+    const sphere = { center, radius };
+    this.querySphereNode(this.root, sphere, results);
+    return results;
+  }
+  querySphereNode(octreeNode, sphere, results) {
+    if (!sphereAABBIntersection(sphere, octreeNode.bounds)) {
+      return;
+    }
+    for (const obj of octreeNode.objects) {
+      if (sphereIntersects(obj.boundingSphere, sphere)) {
+        results.push(obj);
+      }
+    }
+    if (octreeNode.children) {
+      for (const child of octreeNode.children) {
+        this.querySphereNode(child, sphere, results);
+      }
+    }
+  }
+  raycast(origin, direction, maxDistance = Infinity) {
+    const results = [];
+    this.raycastNode(this.root, origin, direction, maxDistance, results);
+    results.sort((a, b) => a.distance - b.distance);
+    return results;
+  }
+  raycastNode(octreeNode, origin, direction, maxDistance, results) {
+    const hit = rayAABBIntersection(origin, direction, octreeNode.bounds);
+    if (!hit || hit.distance > maxDistance) {
+      return;
+    }
+    for (const obj of octreeNode.objects) {
+      const objHit = rayAABBIntersection(origin, direction, obj.worldBounds);
+      if (objHit && objHit.distance <= maxDistance) {
+        results.push({
+          node: obj,
+          distance: objHit.distance,
+          point: objHit.point,
+          normal: objHit.normal
+        });
+      }
+    }
+    if (octreeNode.children) {
+      for (const child of octreeNode.children) {
+        this.raycastNode(child, origin, direction, maxDistance, results);
+      }
+    }
+  }
+  clear() {
+    this.releaseNode(this.root);
+    this.root = this.createNode(this.root.bounds, 0);
+  }
 }
 class OctreeNode {
-    constructor() {
-        this.children = null;
-    }
+  constructor() {
+    this.children = null;
+  }
 }
-// ============================================================
-// Mathematics Helpers
-// ============================================================
 function mat4Identity(out) {
-    out[0] = 1;
-    out[1] = 0;
-    out[2] = 0;
-    out[3] = 0;
-    out[4] = 0;
-    out[5] = 1;
-    out[6] = 0;
-    out[7] = 0;
-    out[8] = 0;
-    out[9] = 0;
-    out[10] = 1;
-    out[11] = 0;
-    out[12] = 0;
-    out[13] = 0;
-    out[14] = 0;
-    out[15] = 1;
+  out[0] = 1;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = 1;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[10] = 1;
+  out[11] = 0;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = 0;
+  out[15] = 1;
 }
 function mat4Compose(position, rotation, scale, out) {
-    const x = rotation.x, y = rotation.y, z = rotation.z, w = rotation.w;
-    const x2 = x + x, y2 = y + y, z2 = z + z;
-    const xx = x * x2, xy = x * y2, xz = x * z2;
-    const yy = y * y2, yz = y * z2, zz = z * z2;
-    const wx = w * x2, wy = w * y2, wz = w * z2;
-    out[0] = (1 - (yy + zz)) * scale.x;
-    out[1] = (xy + wz) * scale.x;
-    out[2] = (xz - wy) * scale.x;
-    out[3] = 0;
-    out[4] = (xy - wz) * scale.y;
-    out[5] = (1 - (xx + zz)) * scale.y;
-    out[6] = (yz + wx) * scale.y;
-    out[7] = 0;
-    out[8] = (xz + wy) * scale.z;
-    out[9] = (yz - wx) * scale.z;
-    out[10] = (1 - (xx + yy)) * scale.z;
-    out[11] = 0;
-    out[12] = position.x;
-    out[13] = position.y;
-    out[14] = position.z;
-    out[15] = 1;
+  const x = rotation.x, y = rotation.y, z = rotation.z, w = rotation.w;
+  const x2 = x + x, y2 = y + y, z2 = z + z;
+  const xx = x * x2, xy = x * y2, xz = x * z2;
+  const yy = y * y2, yz = y * z2, zz = z * z2;
+  const wx = w * x2, wy = w * y2, wz = w * z2;
+  out[0] = (1 - (yy + zz)) * scale.x;
+  out[1] = (xy + wz) * scale.x;
+  out[2] = (xz - wy) * scale.x;
+  out[3] = 0;
+  out[4] = (xy - wz) * scale.y;
+  out[5] = (1 - (xx + zz)) * scale.y;
+  out[6] = (yz + wx) * scale.y;
+  out[7] = 0;
+  out[8] = (xz + wy) * scale.z;
+  out[9] = (yz - wx) * scale.z;
+  out[10] = (1 - (xx + yy)) * scale.z;
+  out[11] = 0;
+  out[12] = position.x;
+  out[13] = position.y;
+  out[14] = position.z;
+  out[15] = 1;
 }
 function mat4Multiply(a, b, out) {
-    const a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
-    const a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
-    const a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11];
-    const a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
-    let b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3];
-    out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
-    out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
-    out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
-    out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
-    b0 = b[4];
-    b1 = b[5];
-    b2 = b[6];
-    b3 = b[7];
-    out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
-    out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
-    out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
-    out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
-    b0 = b[8];
-    b1 = b[9];
-    b2 = b[10];
-    b3 = b[11];
-    out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
-    out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
-    out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
-    out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
-    b0 = b[12];
-    b1 = b[13];
-    b2 = b[14];
-    b3 = b[15];
-    out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
-    out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
-    out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
-    out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  const a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
+  const a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
+  const a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11];
+  const a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
+  let b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3];
+  out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  b0 = b[4];
+  b1 = b[5];
+  b2 = b[6];
+  b3 = b[7];
+  out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  b0 = b[8];
+  b1 = b[9];
+  b2 = b[10];
+  b3 = b[11];
+  out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  b0 = b[12];
+  b1 = b[13];
+  b2 = b[14];
+  b3 = b[15];
+  out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
 }
 function mat4Copy(src, dst) {
-    for (let i = 0; i < 16; i++) {
-        dst[i] = src[i];
-    }
+  for (let i = 0; i < 16; i++) {
+    dst[i] = src[i];
+  }
 }
 function eulerToQuaternion(pitch, yaw, roll, out) {
-    const c1 = Math.cos(pitch / 2);
-    const s1 = Math.sin(pitch / 2);
-    const c2 = Math.cos(yaw / 2);
-    const s2 = Math.sin(yaw / 2);
-    const c3 = Math.cos(roll / 2);
-    const s3 = Math.sin(roll / 2);
-    out.x = s1 * c2 * c3 + c1 * s2 * s3;
-    out.y = c1 * s2 * c3 - s1 * c2 * s3;
-    out.z = c1 * c2 * s3 + s1 * s2 * c3;
-    out.w = c1 * c2 * c3 - s1 * s2 * s3;
+  const c1 = Math.cos(pitch / 2);
+  const s1 = Math.sin(pitch / 2);
+  const c2 = Math.cos(yaw / 2);
+  const s2 = Math.sin(yaw / 2);
+  const c3 = Math.cos(roll / 2);
+  const s3 = Math.sin(roll / 2);
+  out.x = s1 * c2 * c3 + c1 * s2 * s3;
+  out.y = c1 * s2 * c3 - s1 * c2 * s3;
+  out.z = c1 * c2 * s3 + s1 * s2 * c3;
+  out.w = c1 * c2 * c3 - s1 * s2 * s3;
 }
 function quaternionMultiply(a, b) {
-    return {
-        x: a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y,
-        y: a.w * b.y - a.x * b.z + a.y * b.w + a.z * b.x,
-        z: a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w,
-        w: a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z,
-    };
+  return {
+    x: a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y,
+    y: a.w * b.y - a.x * b.z + a.y * b.w + a.z * b.x,
+    z: a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w,
+    w: a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z
+  };
 }
 function matrixToQuaternion(right, up, forward) {
-    const trace = right.x + up.y + forward.z;
-    let x, y, z, w;
-    if (trace > 0) {
-        const s = 0.5 / Math.sqrt(trace + 1);
-        w = 0.25 / s;
-        x = (up.z - forward.y) * s;
-        y = (forward.x - right.z) * s;
-        z = (right.y - up.x) * s;
-    }
-    else if (right.x > up.y && right.x > forward.z) {
-        const s = 2 * Math.sqrt(1 + right.x - up.y - forward.z);
-        w = (up.z - forward.y) / s;
-        x = 0.25 * s;
-        y = (up.x + right.y) / s;
-        z = (forward.x + right.z) / s;
-    }
-    else if (up.y > forward.z) {
-        const s = 2 * Math.sqrt(1 + up.y - right.x - forward.z);
-        w = (forward.x - right.z) / s;
-        x = (up.x + right.y) / s;
-        y = 0.25 * s;
-        z = (forward.y + up.z) / s;
-    }
-    else {
-        const s = 2 * Math.sqrt(1 + forward.z - right.x - up.y);
-        w = (right.y - up.x) / s;
-        x = (forward.x + right.z) / s;
-        y = (forward.y + up.z) / s;
-        z = 0.25 * s;
-    }
-    return { x, y, z, w };
+  const trace = right.x + up.y + forward.z;
+  let x, y, z, w;
+  if (trace > 0) {
+    const s = 0.5 / Math.sqrt(trace + 1);
+    w = 0.25 / s;
+    x = (up.z - forward.y) * s;
+    y = (forward.x - right.z) * s;
+    z = (right.y - up.x) * s;
+  } else if (right.x > up.y && right.x > forward.z) {
+    const s = 2 * Math.sqrt(1 + right.x - up.y - forward.z);
+    w = (up.z - forward.y) / s;
+    x = 0.25 * s;
+    y = (up.x + right.y) / s;
+    z = (forward.x + right.z) / s;
+  } else if (up.y > forward.z) {
+    const s = 2 * Math.sqrt(1 + up.y - right.x - forward.z);
+    w = (forward.x - right.z) / s;
+    x = (up.x + right.y) / s;
+    y = 0.25 * s;
+    z = (forward.y + up.z) / s;
+  } else {
+    const s = 2 * Math.sqrt(1 + forward.z - right.x - up.y);
+    w = (right.y - up.x) / s;
+    x = (forward.x + right.z) / s;
+    y = (forward.y + up.z) / s;
+    z = 0.25 * s;
+  }
+  return { x, y, z, w };
 }
 function vec3Subtract(a, b) {
-    return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
+  return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
 }
 function vec3Cross(a, b) {
-    return {
-        x: a.y * b.z - a.z * b.y,
-        y: a.z * b.x - a.x * b.z,
-        z: a.x * b.y - a.y * b.x,
-    };
+  return {
+    x: a.y * b.z - a.z * b.y,
+    y: a.z * b.x - a.x * b.z,
+    z: a.x * b.y - a.y * b.x
+  };
 }
 function vec3Normalize(v) {
-    const len = Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
-    if (len === 0) {
-        return { x: 0, y: 0, z: 0 };
-    }
-    return { x: v.x / len, y: v.y / len, z: v.z / len };
+  const len = Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
+  if (len === 0) {
+    return { x: 0, y: 0, z: 0 };
+  }
+  return { x: v.x / len, y: v.y / len, z: v.z / len };
 }
 function vec3Distance(a, b) {
-    const dx = a.x - b.x, dy = a.y - b.y, dz = a.z - b.z;
-    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+  const dx = a.x - b.x, dy = a.y - b.y, dz = a.z - b.z;
+  return Math.sqrt(dx * dx + dy * dy + dz * dz);
 }
 function transformPoint(p, m) {
-    const w = m[3] * p.x + m[7] * p.y + m[11] * p.z + m[15];
-    return {
-        x: (m[0] * p.x + m[4] * p.y + m[8] * p.z + m[12]) / w,
-        y: (m[1] * p.x + m[5] * p.y + m[9] * p.z + m[13]) / w,
-        z: (m[2] * p.x + m[6] * p.y + m[10] * p.z + m[14]) / w,
-    };
+  const w = m[3] * p.x + m[7] * p.y + m[11] * p.z + m[15];
+  return {
+    x: (m[0] * p.x + m[4] * p.y + m[8] * p.z + m[12]) / w,
+    y: (m[1] * p.x + m[5] * p.y + m[9] * p.z + m[13]) / w,
+    z: (m[2] * p.x + m[6] * p.y + m[10] * p.z + m[14]) / w
+  };
 }
 function getAABBCorners(aabb) {
-    return [
-        { x: aabb.min.x, y: aabb.min.y, z: aabb.min.z },
-        { x: aabb.max.x, y: aabb.min.y, z: aabb.min.z },
-        { x: aabb.min.x, y: aabb.max.y, z: aabb.min.z },
-        { x: aabb.max.x, y: aabb.max.y, z: aabb.min.z },
-        { x: aabb.min.x, y: aabb.min.y, z: aabb.max.z },
-        { x: aabb.max.x, y: aabb.min.y, z: aabb.max.z },
-        { x: aabb.min.x, y: aabb.max.y, z: aabb.max.z },
-        { x: aabb.max.x, y: aabb.max.y, z: aabb.max.z },
-    ];
+  return [
+    { x: aabb.min.x, y: aabb.min.y, z: aabb.min.z },
+    { x: aabb.max.x, y: aabb.min.y, z: aabb.min.z },
+    { x: aabb.min.x, y: aabb.max.y, z: aabb.min.z },
+    { x: aabb.max.x, y: aabb.max.y, z: aabb.min.z },
+    { x: aabb.min.x, y: aabb.min.y, z: aabb.max.z },
+    { x: aabb.max.x, y: aabb.min.y, z: aabb.max.z },
+    { x: aabb.min.x, y: aabb.max.y, z: aabb.max.z },
+    { x: aabb.max.x, y: aabb.max.y, z: aabb.max.z }
+  ];
 }
 function aabbIntersects(a, b) {
-    return (a.min.x <= b.max.x &&
-        a.max.x >= b.min.x &&
-        a.min.y <= b.max.y &&
-        a.max.y >= b.min.y &&
-        a.min.z <= b.max.z &&
-        a.max.z >= b.min.z);
+  return a.min.x <= b.max.x && a.max.x >= b.min.x && a.min.y <= b.max.y && a.max.y >= b.min.y && a.min.z <= b.max.z && a.max.z >= b.min.z;
 }
 function sphereIntersects(a, b) {
-    const d = vec3Distance(a.center, b.center);
-    return d <= a.radius + b.radius;
+  const d = vec3Distance(a.center, b.center);
+  return d <= a.radius + b.radius;
 }
 function sphereAABBIntersection(sphere, aabb) {
-    const closest = {
-        x: Math.max(aabb.min.x, Math.min(sphere.center.x, aabb.max.x)),
-        y: Math.max(aabb.min.y, Math.min(sphere.center.y, aabb.max.y)),
-        z: Math.max(aabb.min.z, Math.min(sphere.center.z, aabb.max.z)),
-    };
-    return vec3Distance(sphere.center, closest) <= sphere.radius;
+  const closest = {
+    x: Math.max(aabb.min.x, Math.min(sphere.center.x, aabb.max.x)),
+    y: Math.max(aabb.min.y, Math.min(sphere.center.y, aabb.max.y)),
+    z: Math.max(aabb.min.z, Math.min(sphere.center.z, aabb.max.z))
+  };
+  return vec3Distance(sphere.center, closest) <= sphere.radius;
 }
 function frustumAABBIntersection(frustum, aabb) {
-    let inside = true;
-    for (const plane of frustum.planes) {
-        const p = {
-            x: plane.normal.x > 0 ? aabb.max.x : aabb.min.x,
-            y: plane.normal.y > 0 ? aabb.max.y : aabb.min.y,
-            z: plane.normal.z > 0 ? aabb.max.z : aabb.min.z,
-        };
-        const n = {
-            x: plane.normal.x > 0 ? aabb.min.x : aabb.max.x,
-            y: plane.normal.y > 0 ? aabb.min.y : aabb.max.y,
-            z: plane.normal.z > 0 ? aabb.min.z : aabb.max.z,
-        };
-        const dp = plane.normal.x * p.x + plane.normal.y * p.y + plane.normal.z * p.z + plane.distance;
-        const dn = plane.normal.x * n.x + plane.normal.y * n.y + plane.normal.z * n.z + plane.distance;
-        if (dp < 0) {
-            return 'outside';
-        }
-        if (dn < 0) {
-            inside = false;
-        }
+  let inside = true;
+  for (const plane of frustum.planes) {
+    const p = {
+      x: plane.normal.x > 0 ? aabb.max.x : aabb.min.x,
+      y: plane.normal.y > 0 ? aabb.max.y : aabb.min.y,
+      z: plane.normal.z > 0 ? aabb.max.z : aabb.min.z
+    };
+    const n = {
+      x: plane.normal.x > 0 ? aabb.min.x : aabb.max.x,
+      y: plane.normal.y > 0 ? aabb.min.y : aabb.max.y,
+      z: plane.normal.z > 0 ? aabb.min.z : aabb.max.z
+    };
+    const dp = plane.normal.x * p.x + plane.normal.y * p.y + plane.normal.z * p.z + plane.distance;
+    const dn = plane.normal.x * n.x + plane.normal.y * n.y + plane.normal.z * n.z + plane.distance;
+    if (dp < 0) {
+      return "outside";
     }
-    return inside ? 'inside' : 'intersecting';
+    if (dn < 0) {
+      inside = false;
+    }
+  }
+  return inside ? "inside" : "intersecting";
 }
 function frustumSphereIntersection(frustum, sphere) {
-    let inside = true;
-    for (const plane of frustum.planes) {
-        const d = plane.normal.x * sphere.center.x +
-            plane.normal.y * sphere.center.y +
-            plane.normal.z * sphere.center.z +
-            plane.distance;
-        if (d < -sphere.radius) {
-            return 'outside';
-        }
-        if (d < sphere.radius) {
-            inside = false;
-        }
+  let inside = true;
+  for (const plane of frustum.planes) {
+    const d = plane.normal.x * sphere.center.x + plane.normal.y * sphere.center.y + plane.normal.z * sphere.center.z + plane.distance;
+    if (d < -sphere.radius) {
+      return "outside";
+    }
+    if (d < sphere.radius) {
+      inside = false;
     }
-    return inside ? 'inside' : 'intersecting';
+  }
+  return inside ? "inside" : "intersecting";
 }
 function rayAABBIntersection(origin, direction, aabb) {
-    let tmin = -Infinity;
-    let tmax = Infinity;
-    let normalAxis = 0;
-    let normalSign = 1;
-    for (let i = 0; i < 3; i++) {
-        const o = i === 0 ? origin.x : i === 1 ? origin.y : origin.z;
-        const d = i === 0 ? direction.x : i === 1 ? direction.y : direction.z;
-        const min = i === 0 ? aabb.min.x : i === 1 ? aabb.min.y : aabb.min.z;
-        const max = i === 0 ? aabb.max.x : i === 1 ? aabb.max.y : aabb.max.z;
-        if (Math.abs(d) < 1e-8) {
-            if (o < min || o > max) {
-                return null;
-            }
-        }
-        else {
-            let t1 = (min - o) / d;
-            let t2 = (max - o) / d;
-            let sign = -1;
-            if (t1 > t2) {
-                const tmp = t1;
-                t1 = t2;
-                t2 = tmp;
-                sign = 1;
-            }
-            if (t1 > tmin) {
-                tmin = t1;
-                normalAxis = i;
-                normalSign = sign;
-            }
-            tmax = Math.min(tmax, t2);
-            if (tmin > tmax) {
-                return null;
-            }
-        }
-    }
-    if (tmin < 0) {
+  let tmin = -Infinity;
+  let tmax = Infinity;
+  let normalAxis = 0;
+  let normalSign = 1;
+  for (let i = 0; i < 3; i++) {
+    const o = i === 0 ? origin.x : i === 1 ? origin.y : origin.z;
+    const d = i === 0 ? direction.x : i === 1 ? direction.y : direction.z;
+    const min = i === 0 ? aabb.min.x : i === 1 ? aabb.min.y : aabb.min.z;
+    const max = i === 0 ? aabb.max.x : i === 1 ? aabb.max.y : aabb.max.z;
+    if (Math.abs(d) < 1e-8) {
+      if (o < min || o > max) {
         return null;
-    }
-    const point = {
-        x: origin.x + direction.x * tmin,
-        y: origin.y + direction.y * tmin,
-        z: origin.z + direction.z * tmin,
-    };
-    const normal = { x: 0, y: 0, z: 0 };
-    if (normalAxis === 0) {
-        normal.x = normalSign;
-    }
-    else if (normalAxis === 1) {
-        normal.y = normalSign;
-    }
-    else {
-        normal.z = normalSign;
-    }
-    return { distance: tmin, point, normal };
+      }
+    } else {
+      let t1 = (min - o) / d;
+      let t2 = (max - o) / d;
+      let sign = -1;
+      if (t1 > t2) {
+        const tmp = t1;
+        t1 = t2;
+        t2 = tmp;
+        sign = 1;
+      }
+      if (t1 > tmin) {
+        tmin = t1;
+        normalAxis = i;
+        normalSign = sign;
+      }
+      tmax = Math.min(tmax, t2);
+      if (tmin > tmax) {
+        return null;
+      }
+    }
+  }
+  if (tmin < 0) {
+    return null;
+  }
+  const point = {
+    x: origin.x + direction.x * tmin,
+    y: origin.y + direction.y * tmin,
+    z: origin.z + direction.z * tmin
+  };
+  const normal = { x: 0, y: 0, z: 0 };
+  if (normalAxis === 0) {
+    normal.x = normalSign;
+  } else if (normalAxis === 1) {
+    normal.y = normalSign;
+  } else {
+    normal.z = normalSign;
+  }
+  return { distance: tmin, point, normal };
 }
-// ============================================================
-// Factory Functions
-// ============================================================
 function createSceneNode(name, type) {
-    return new SceneNode(name, type);
+  return new SceneNode(name, type);
 }
 function createOctree(bounds, config) {
-    return new Octree(bounds, config);
+  return new Octree(bounds, config);
 }
-
-export { Octree, SceneNode, createOctree, createSceneNode };
+export {
+  Octree,
+  SceneNode,
+  createOctree,
+  createSceneNode
+};