@nice2dev/game-engine 1.0.5 → 1.0.10

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

@@ -0,0 +1,862 @@
+'use strict';
+
+/**
+ * @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;
+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);
+    }
+}
+class OctreeNode {
+    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;
+}
+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;
+}
+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;
+}
+function mat4Copy(src, dst) {
+    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;
+}
+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,
+    };
+}
+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 };
+}
+function vec3Subtract(a, b) {
+    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,
+    };
+}
+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 };
+}
+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);
+}
+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,
+    };
+}
+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 },
+    ];
+}
+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);
+}
+function sphereIntersects(a, b) {
+    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;
+}
+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;
+        }
+    }
+    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;
+        }
+    }
+    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) {
+        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);
+}
+function createOctree(bounds, config) {
+    return new Octree(bounds, config);
+}
+
+exports.Octree = Octree;
+exports.SceneNode = SceneNode;
+exports.createOctree = createOctree;
+exports.createSceneNode = createSceneNode;
+//# sourceMappingURL=SceneGraph.js.map