@directivegames/genesys.js 3.1.24

package/dist/test/absolute-transform.test.js

@@ -0,0 +1,796 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+import '../src/utils/ThreeJsExtensions.js';
+// Test helpers for serialization
+let AbsoluteTransformTestSceneComponent = class AbsoluteTransformTestSceneComponent extends ENGINE.SceneComponent {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "testData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+    }
+};
+AbsoluteTransformTestSceneComponent = __decorate([
+    ENGINE.GameClass()
+], AbsoluteTransformTestSceneComponent);
+let AbsoluteTransformTestActor = class AbsoluteTransformTestActor extends ENGINE.Actor {
+    constructor(options = {}) {
+        super(options);
+    }
+};
+AbsoluteTransformTestActor = __decorate([
+    ENGINE.GameClass(),
+    __metadata("design:paramtypes", [Object])
+], AbsoluteTransformTestActor);
+function reloadActor(actor) {
+    const data = JSON.parse(JSON.stringify(actor.asExportedObject()));
+    const loadedActor = ENGINE.WorldSerializer.loadActorSync(data, {}, true);
+    if (!loadedActor) {
+        throw new Error('Failed to reload actor');
+    }
+    return loadedActor;
+}
+QUnit.module('Absolute Transform Tests', () => {
+    QUnit.test('useAbsolutePosition maintains world position when parent moves', (assert) => {
+        const scene = new THREE.Scene();
+        const parent = new THREE.Object3D();
+        scene.add(parent);
+        const child = new THREE.Object3D();
+        child.useAbsolutePosition = true;
+        child.position.set(5, 3, 2);
+        parent.add(child);
+        // Initial update
+        scene.updateMatrixWorld(true);
+        const initialWorldPos = child.getWorldPosition(new THREE.Vector3());
+        assert.ok(initialWorldPos.almostEquals(new THREE.Vector3(5, 3, 2)), 'Initial world position is correct');
+        // Move parent
+        parent.position.set(10, 10, 10);
+        scene.updateMatrixWorld(true);
+        const newWorldPos = child.getWorldPosition(new THREE.Vector3());
+        assert.ok(newWorldPos.almostEquals(new THREE.Vector3(5, 3, 2)), 'World position remains unchanged after parent moves');
+    });
+    QUnit.test('useAbsoluteRotation maintains world rotation when parent rotates', (assert) => {
+        const scene = new THREE.Scene();
+        const parent = new THREE.Object3D();
+        scene.add(parent);
+        const child = new THREE.Object3D();
+        child.useAbsoluteRotation = true;
+        child.rotation.set(0, Math.PI / 4, 0); // 45 degrees on Y axis
+        parent.add(child);
+        // Initial update
+        scene.updateMatrixWorld(true);
+        const initialWorldRot = child.getWorldRotation(new THREE.Euler());
+        assert.ok(Math.abs(initialWorldRot.y - Math.PI / 4) < 0.001, 'Initial world rotation is correct');
+        // Rotate parent
+        parent.rotation.set(0, Math.PI / 2, 0); // 90 degrees on Y axis
+        scene.updateMatrixWorld(true);
+        const newWorldRot = child.getWorldRotation(new THREE.Euler());
+        assert.ok(Math.abs(newWorldRot.y - Math.PI / 4) < 0.001, 'World rotation remains unchanged after parent rotates');
+    });
+    QUnit.test('useAbsoluteScale maintains world scale when parent scales', (assert) => {
+        const scene = new THREE.Scene();
+        const parent = new THREE.Object3D();
+        scene.add(parent);
+        const child = new THREE.Object3D();
+        child.useAbsoluteScale = true;
+        child.scale.set(2, 3, 4);
+        parent.add(child);
+        // Initial update
+        scene.updateMatrixWorld(true);
+        const initialWorldScale = child.getWorldScale(new THREE.Vector3());
+        assert.ok(initialWorldScale.almostEquals(new THREE.Vector3(2, 3, 4)), 'Initial world scale is correct');
+        // Scale parent
+        parent.scale.set(0.5, 0.5, 0.5);
+        scene.updateMatrixWorld(true);
+        const newWorldScale = child.getWorldScale(new THREE.Vector3());
+        assert.ok(newWorldScale.almostEquals(new THREE.Vector3(2, 3, 4)), 'World scale remains unchanged after parent scales');
+    });
+    QUnit.test('Multiple absolute flags work together', (assert) => {
+        const scene = new THREE.Scene();
+        const parent = new THREE.Object3D();
+        scene.add(parent);
+        const child = new THREE.Object3D();
+        child.useAbsolutePosition = true;
+        child.useAbsoluteRotation = true;
+        child.position.set(10, 5, 0);
+        child.rotation.set(0, Math.PI / 6, 0); // 30 degrees
+        child.scale.set(1, 1, 1); // This should still be affected by parent
+        parent.add(child);
+        // Transform parent
+        parent.position.set(20, 20, 20);
+        parent.rotation.set(0, Math.PI, 0); // 180 degrees
+        parent.scale.set(2, 2, 2);
+        scene.updateMatrixWorld(true);
+        const worldPos = child.getWorldPosition(new THREE.Vector3());
+        const worldRot = child.getWorldRotation(new THREE.Euler());
+        const worldScale = child.getWorldScale(new THREE.Vector3());
+        assert.ok(worldPos.almostEquals(new THREE.Vector3(10, 5, 0)), 'Absolute position is maintained');
+        assert.ok(Math.abs(worldRot.y - Math.PI / 6) < 0.001, 'Absolute rotation is maintained');
+        assert.ok(worldScale.almostEquals(new THREE.Vector3(2, 2, 2)), 'Relative scale is affected by parent');
+    });
+    QUnit.test('Normal children are still affected by parent transform', (assert) => {
+        const scene = new THREE.Scene();
+        const parent = new THREE.Object3D();
+        scene.add(parent);
+        const absoluteChild = new THREE.Object3D();
+        absoluteChild.useAbsolutePosition = true;
+        absoluteChild.position.set(5, 5, 5);
+        parent.add(absoluteChild);
+        const normalChild = new THREE.Object3D();
+        normalChild.position.set(5, 5, 5);
+        parent.add(normalChild);
+        // Move parent
+        parent.position.set(10, 0, 0);
+        scene.updateMatrixWorld(true);
+        const absoluteWorldPos = absoluteChild.getWorldPosition(new THREE.Vector3());
+        const normalWorldPos = normalChild.getWorldPosition(new THREE.Vector3());
+        assert.ok(absoluteWorldPos.almostEquals(new THREE.Vector3(5, 5, 5)), 'Absolute child maintains position');
+        assert.ok(normalWorldPos.almostEquals(new THREE.Vector3(15, 5, 5)), 'Normal child moves with parent');
+    });
+    QUnit.test('Nested hierarchy with absolute transforms', (assert) => {
+        const scene = new THREE.Scene();
+        const grandParent = new THREE.Object3D();
+        scene.add(grandParent);
+        const parent = new THREE.Object3D();
+        parent.position.set(5, 0, 0);
+        grandParent.add(parent);
+        const child = new THREE.Object3D();
+        child.useAbsolutePosition = true;
+        child.position.set(10, 10, 10);
+        parent.add(child);
+        // Move both grandparent and parent
+        grandParent.position.set(20, 20, 20);
+        parent.position.set(30, 30, 30);
+        scene.updateMatrixWorld(true);
+        const worldPos = child.getWorldPosition(new THREE.Vector3());
+        assert.ok(worldPos.almostEquals(new THREE.Vector3(10, 10, 10)), 'Absolute position maintained in nested hierarchy');
+    });
+    QUnit.test('Absolute properties can be toggled dynamically', (assert) => {
+        const scene = new THREE.Scene();
+        const parent = new THREE.Object3D();
+        parent.position.set(10, 10, 10);
+        scene.add(parent);
+        const child = new THREE.Object3D();
+        child.position.set(5, 5, 5);
+        parent.add(child);
+        // Initially without absolute position
+        scene.updateMatrixWorld(true);
+        let worldPos = child.getWorldPosition(new THREE.Vector3());
+        assert.ok(worldPos.almostEquals(new THREE.Vector3(15, 15, 15)), 'Initially follows parent transform');
+        // Enable absolute position
+        child.useAbsolutePosition = true;
+        child.position.set(5, 5, 5); // Set to world position
+        scene.updateMatrixWorld(true);
+        worldPos = child.getWorldPosition(new THREE.Vector3());
+        assert.ok(worldPos.almostEquals(new THREE.Vector3(5, 5, 5)), 'Absolute position takes effect');
+        // Disable absolute position
+        child.useAbsolutePosition = false;
+        scene.updateMatrixWorld(true);
+        worldPos = child.getWorldPosition(new THREE.Vector3());
+        assert.ok(worldPos.almostEquals(new THREE.Vector3(15, 15, 15)), 'Returns to following parent transform');
+    });
+    QUnit.test('Absolute transform with non-uniform parent scale', (assert) => {
+        const scene = new THREE.Scene();
+        const parent = new THREE.Object3D();
+        scene.add(parent);
+        const child = new THREE.Object3D();
+        child.useAbsoluteScale = true;
+        child.scale.set(1, 1, 1);
+        parent.add(child);
+        // Non-uniform parent scale
+        parent.scale.set(2, 0.5, 3);
+        scene.updateMatrixWorld(true);
+        const worldScale = child.getWorldScale(new THREE.Vector3());
+        assert.ok(worldScale.almostEquals(new THREE.Vector3(1, 1, 1)), 'Absolute scale maintained with non-uniform parent scale');
+    });
+    QUnit.test('Properties are stored in userData', (assert) => {
+        const obj = new THREE.Object3D();
+        assert.strictEqual(obj.useAbsolutePosition, false, 'Default useAbsolutePosition is false');
+        assert.strictEqual(obj.useAbsoluteRotation, false, 'Default useAbsoluteRotation is false');
+        assert.strictEqual(obj.useAbsoluteScale, false, 'Default useAbsoluteScale is false');
+        obj.useAbsolutePosition = true;
+        obj.useAbsoluteRotation = true;
+        obj.useAbsoluteScale = true;
+        assert.strictEqual(obj.userData.useAbsolutePosition, true, 'useAbsolutePosition stored in userData');
+        assert.strictEqual(obj.userData.useAbsoluteRotation, true, 'useAbsoluteRotation stored in userData');
+        assert.strictEqual(obj.userData.useAbsoluteScale, true, 'useAbsoluteScale stored in userData');
+    });
+    QUnit.test('Absolute transform works with setWorldPosition/Rotation/Scale methods', (assert) => {
+        const scene = new THREE.Scene();
+        const parent = new THREE.Object3D();
+        parent.position.set(10, 10, 10);
+        parent.rotation.set(0, Math.PI / 2, 0);
+        parent.scale.set(2, 2, 2);
+        scene.add(parent);
+        const child = new THREE.Object3D();
+        child.useAbsolutePosition = true;
+        child.useAbsoluteRotation = true;
+        child.useAbsoluteScale = true;
+        parent.add(child);
+        // Set world transforms using the setWorld methods
+        child.setWorldPosition(new THREE.Vector3(5, 3, 1));
+        child.setWorldRotation(new THREE.Euler(0, Math.PI / 4, 0));
+        child.setWorldScale(new THREE.Vector3(3, 3, 3));
+        scene.updateMatrixWorld(true);
+        const worldPos = child.getWorldPosition(new THREE.Vector3());
+        const worldRot = child.getWorldRotation(new THREE.Euler());
+        const worldScale = child.getWorldScale(new THREE.Vector3());
+        assert.ok(worldPos.almostEquals(new THREE.Vector3(5, 3, 1)), 'setWorldPosition works with absolute position');
+        assert.ok(Math.abs(worldRot.y - Math.PI / 4) < 0.001, 'setWorldRotation works with absolute rotation');
+        assert.ok(worldScale.almostEquals(new THREE.Vector3(3, 3, 3)), 'setWorldScale works with absolute scale');
+    });
+    QUnit.test('getWorldPosition with deep nested hierarchy', (assert) => {
+        const scene = new THREE.Scene();
+        // Create a deep hierarchy with various transforms
+        const level1 = new THREE.Object3D();
+        level1.position.set(10, 0, 0);
+        scene.add(level1);
+        const level2 = new THREE.Object3D();
+        level2.position.set(0, 10, 0);
+        level1.add(level2);
+        const level3 = new THREE.Object3D();
+        level3.position.set(0, 0, 10);
+        level2.add(level3);
+        const level4 = new THREE.Object3D();
+        level4.position.set(5, 5, 5);
+        level3.add(level4);
+        scene.updateMatrixWorld(true);
+        // Test getWorldPosition at each level
+        const pos1 = level1.getWorldPosition(new THREE.Vector3());
+        const pos2 = level2.getWorldPosition(new THREE.Vector3());
+        const pos3 = level3.getWorldPosition(new THREE.Vector3());
+        const pos4 = level4.getWorldPosition(new THREE.Vector3());
+        assert.ok(pos1.almostEquals(new THREE.Vector3(10, 0, 0)), 'Level 1 world position correct');
+        assert.ok(pos2.almostEquals(new THREE.Vector3(10, 10, 0)), 'Level 2 world position correct');
+        assert.ok(pos3.almostEquals(new THREE.Vector3(10, 10, 10)), 'Level 3 world position correct');
+        assert.ok(pos4.almostEquals(new THREE.Vector3(15, 15, 15)), 'Level 4 world position correct');
+        // Test with absolute position in the middle of hierarchy
+        level3.useAbsolutePosition = true;
+        level3.position.set(20, 20, 20); // This is now the world position
+        scene.updateMatrixWorld(true);
+        const absPos3 = level3.getWorldPosition(new THREE.Vector3());
+        const absPos4 = level4.getWorldPosition(new THREE.Vector3());
+        assert.ok(absPos3.almostEquals(new THREE.Vector3(20, 20, 20)), 'Absolute position in middle of hierarchy');
+        // Level4's world position should be level3's world position (20,20,20) plus level4's local offset (5,5,5)
+        assert.ok(absPos4.almostEquals(new THREE.Vector3(25, 25, 25)), 'Child of absolute positioned object adds its local offset');
+    });
+    QUnit.test('getWorldRotation with compound rotations', (assert) => {
+        const scene = new THREE.Scene();
+        const parent = new THREE.Object3D();
+        parent.rotation.set(Math.PI / 4, 0, 0); // 45 deg X
+        scene.add(parent);
+        const child = new THREE.Object3D();
+        child.rotation.set(0, Math.PI / 4, 0); // 45 deg Y
+        parent.add(child);
+        const grandchild = new THREE.Object3D();
+        grandchild.rotation.set(0, 0, Math.PI / 4); // 45 deg Z
+        child.add(grandchild);
+        scene.updateMatrixWorld(true);
+        // Get world rotations
+        const parentRot = parent.getWorldRotation(new THREE.Euler());
+        const childRot = child.getWorldRotation(new THREE.Euler());
+        const grandchildRot = grandchild.getWorldRotation(new THREE.Euler());
+        assert.ok(Math.abs(parentRot.x - Math.PI / 4) < 0.001, 'Parent world rotation X correct');
+        // Test with absolute rotation
+        child.useAbsoluteRotation = true;
+        child.rotation.set(0, Math.PI / 4, 0); // This is now the world rotation
+        scene.updateMatrixWorld(true);
+        const absChildRot = child.getWorldRotation(new THREE.Euler());
+        const absGrandchildRot = grandchild.getWorldRotation(new THREE.Euler());
+        assert.ok(Math.abs(absChildRot.y - Math.PI / 4) < 0.001, 'Absolute rotation ignores parent rotation');
+        assert.ok(Math.abs(absChildRot.x) < 0.001, 'Absolute rotation X is zero');
+        // Grandchild should compound with child's world rotation (0, 45deg, 0) and its own local (0, 0, 45deg)
+        // The grandchild rotates relative to its parent's world transform
+        const childWorldQuat = new THREE.Quaternion();
+        childWorldQuat.setFromEuler(new THREE.Euler(0, Math.PI / 4, 0));
+        const grandchildLocalQuat = new THREE.Quaternion();
+        grandchildLocalQuat.setFromEuler(new THREE.Euler(0, 0, Math.PI / 4));
+        const expectedGrandchildQuat = childWorldQuat.clone().multiply(grandchildLocalQuat);
+        const actualGrandchildQuat = new THREE.Quaternion();
+        actualGrandchildQuat.setFromEuler(absGrandchildRot);
+        assert.ok(expectedGrandchildQuat.dot(actualGrandchildQuat) > 0.999, 'Grandchild compounds with absolute parent');
+    });
+    QUnit.test('getWorldScale with nested non-uniform scaling', (assert) => {
+        const scene = new THREE.Scene();
+        const parent = new THREE.Object3D();
+        parent.scale.set(2, 1, 0.5);
+        scene.add(parent);
+        const child = new THREE.Object3D();
+        child.scale.set(1, 2, 4);
+        parent.add(child);
+        const grandchild = new THREE.Object3D();
+        grandchild.scale.set(0.5, 0.5, 0.5);
+        child.add(grandchild);
+        scene.updateMatrixWorld(true);
+        // Test compound scaling
+        const parentScale = parent.getWorldScale(new THREE.Vector3());
+        const childScale = child.getWorldScale(new THREE.Vector3());
+        const grandchildScale = grandchild.getWorldScale(new THREE.Vector3());
+        assert.ok(parentScale.almostEquals(new THREE.Vector3(2, 1, 0.5)), 'Parent world scale correct');
+        assert.ok(childScale.almostEquals(new THREE.Vector3(2, 2, 2)), 'Child world scale correct');
+        assert.ok(grandchildScale.almostEquals(new THREE.Vector3(1, 1, 1)), 'Grandchild world scale correct');
+        // Test with absolute scale
+        child.useAbsoluteScale = true;
+        child.scale.set(3, 3, 3); // This is now the world scale
+        scene.updateMatrixWorld(true);
+        const absChildScale = child.getWorldScale(new THREE.Vector3());
+        const absGrandchildScale = grandchild.getWorldScale(new THREE.Vector3());
+        assert.ok(absChildScale.almostEquals(new THREE.Vector3(3, 3, 3)), 'Absolute scale ignores parent');
+        // Grandchild's world scale should be child's world scale (3,3,3) multiplied by grandchild's local scale (0.5,0.5,0.5)
+        assert.ok(absGrandchildScale.almostEquals(new THREE.Vector3(1.5, 1.5, 1.5)), 'Grandchild scales with absolute parent');
+    });
+    QUnit.test('getWorldPosition/Rotation/Scale with matrix decomposition', (assert) => {
+        const scene = new THREE.Scene();
+        const obj = new THREE.Object3D();
+        obj.position.set(10, 20, 30);
+        obj.rotation.set(Math.PI / 6, Math.PI / 4, Math.PI / 3);
+        obj.scale.set(2, 3, 4);
+        scene.add(obj);
+        scene.updateMatrixWorld(true);
+        // Get world transforms
+        const worldPos = obj.getWorldPosition(new THREE.Vector3());
+        const worldRot = obj.getWorldRotation(new THREE.Euler());
+        const worldScale = obj.getWorldScale(new THREE.Vector3());
+        // Manually decompose matrix to verify
+        const matrix = obj.matrixWorld;
+        const manualPos = new THREE.Vector3();
+        const manualQuat = new THREE.Quaternion();
+        const manualScale = new THREE.Vector3();
+        matrix.decompose(manualPos, manualQuat, manualScale);
+        assert.ok(worldPos.almostEquals(manualPos), 'getWorldPosition matches matrix decomposition');
+        assert.ok(worldScale.almostEquals(manualScale), 'getWorldScale matches matrix decomposition');
+        const manualEuler = new THREE.Euler().setFromQuaternion(manualQuat);
+        assert.ok(Math.abs(worldRot.x - manualEuler.x) < 0.001 &&
+            Math.abs(worldRot.y - manualEuler.y) < 0.001 &&
+            Math.abs(worldRot.z - manualEuler.z) < 0.001, 'getWorldRotation matches matrix decomposition');
+    });
+    QUnit.test('getWorldPosition/Rotation/Scale performance with reused objects', (assert) => {
+        const scene = new THREE.Scene();
+        const parent = new THREE.Object3D();
+        parent.position.set(5, 5, 5);
+        parent.rotation.set(0, Math.PI / 2, 0);
+        parent.scale.set(2, 2, 2);
+        scene.add(parent);
+        const child = new THREE.Object3D();
+        child.position.set(10, 10, 10);
+        child.rotation.set(Math.PI / 4, 0, 0);
+        child.scale.set(0.5, 0.5, 0.5);
+        parent.add(child);
+        scene.updateMatrixWorld(true);
+        // Test reusing the same target objects
+        const targetPos = new THREE.Vector3();
+        const targetRot = new THREE.Euler();
+        const targetScale = new THREE.Vector3();
+        // First call
+        child.getWorldPosition(targetPos);
+        child.getWorldRotation(targetRot);
+        child.getWorldScale(targetScale);
+        const firstPos = targetPos.clone();
+        const firstRot = targetRot.clone();
+        const firstScale = targetScale.clone();
+        // Second call with same targets
+        child.getWorldPosition(targetPos);
+        child.getWorldRotation(targetRot);
+        child.getWorldScale(targetScale);
+        assert.ok(targetPos.equals(firstPos), 'getWorldPosition consistent with reused vector');
+        assert.ok(targetRot.equals(firstRot), 'getWorldRotation consistent with reused euler');
+        assert.ok(targetScale.equals(firstScale), 'getWorldScale consistent with reused vector');
+    });
+    QUnit.test('getWorldPosition/Rotation/Scale with moving hierarchy', (assert) => {
+        const scene = new THREE.Scene();
+        const root = new THREE.Object3D();
+        scene.add(root);
+        const parent = new THREE.Object3D();
+        parent.position.set(10, 0, 0);
+        root.add(parent);
+        const child = new THREE.Object3D();
+        child.position.set(5, 0, 0);
+        child.useAbsolutePosition = true;
+        parent.add(child);
+        // Initial state
+        scene.updateMatrixWorld(true);
+        const initialPos = child.getWorldPosition(new THREE.Vector3());
+        assert.ok(initialPos.almostEquals(new THREE.Vector3(5, 0, 0)), 'Initial absolute position');
+        // Animate parent position
+        for (let i = 0; i < 10; i++) {
+            parent.position.x = 10 + i;
+            scene.updateMatrixWorld(true);
+            const currentPos = child.getWorldPosition(new THREE.Vector3());
+            assert.ok(currentPos.almostEquals(new THREE.Vector3(5, 0, 0)), `Absolute position stable at frame ${i}`);
+        }
+        // Switch to relative and animate
+        child.useAbsolutePosition = false;
+        for (let i = 0; i < 10; i++) {
+            parent.position.x = 20 + i;
+            scene.updateMatrixWorld(true);
+            const currentPos = child.getWorldPosition(new THREE.Vector3());
+            assert.ok(currentPos.almostEquals(new THREE.Vector3(25 + i, 0, 0)), `Relative position follows parent at frame ${i}`);
+        }
+    });
+    QUnit.test('getWorldRotation with quaternion vs euler consistency', (assert) => {
+        const scene = new THREE.Scene();
+        const obj = new THREE.Object3D();
+        obj.rotation.set(Math.PI / 3, Math.PI / 4, Math.PI / 6);
+        scene.add(obj);
+        scene.updateMatrixWorld(true);
+        // Get world rotation as euler
+        const worldEuler = obj.getWorldRotation(new THREE.Euler());
+        // Get world quaternion and convert to euler
+        const worldQuat = obj.getWorldQuaternion(new THREE.Quaternion());
+        const eulerFromQuat = new THREE.Euler().setFromQuaternion(worldQuat);
+        assert.ok(Math.abs(worldEuler.x - eulerFromQuat.x) < 0.001, 'Euler X matches quaternion conversion');
+        assert.ok(Math.abs(worldEuler.y - eulerFromQuat.y) < 0.001, 'Euler Y matches quaternion conversion');
+        assert.ok(Math.abs(worldEuler.z - eulerFromQuat.z) < 0.001, 'Euler Z matches quaternion conversion');
+    });
+    QUnit.test('getWorldScale with negative scales', (assert) => {
+        const scene = new THREE.Scene();
+        const parent = new THREE.Object3D();
+        parent.scale.set(-1, 1, 1); // Negative X scale (mirror)
+        scene.add(parent);
+        const child = new THREE.Object3D();
+        child.scale.set(2, 2, 2);
+        parent.add(child);
+        scene.updateMatrixWorld(true);
+        const childScale = child.getWorldScale(new THREE.Vector3());
+        assert.ok(childScale.almostEquals(new THREE.Vector3(-2, 2, 2)), 'Negative scale propagates correctly');
+        // Test absolute scale with negative parent
+        child.useAbsoluteScale = true;
+        child.scale.set(3, 3, 3);
+        scene.updateMatrixWorld(true);
+        const absChildScale = child.getWorldScale(new THREE.Vector3());
+        assert.ok(absChildScale.almostEquals(new THREE.Vector3(3, 3, 3)), 'Absolute scale ignores negative parent scale');
+    });
+    QUnit.test('getWorldPosition with parent having pivot offset', (assert) => {
+        const scene = new THREE.Scene();
+        const parent = new THREE.Object3D();
+        parent.position.set(10, 10, 10);
+        scene.add(parent);
+        // Create pivot point
+        const pivot = new THREE.Object3D();
+        pivot.position.set(-5, -5, -5); // Offset pivot
+        parent.add(pivot);
+        const child = new THREE.Object3D();
+        child.position.set(5, 5, 5); // Position relative to pivot
+        pivot.add(child);
+        scene.updateMatrixWorld(true);
+        const childWorldPos = child.getWorldPosition(new THREE.Vector3());
+        assert.ok(childWorldPos.almostEquals(new THREE.Vector3(10, 10, 10)), 'Child position with pivot offset');
+        // Rotate parent and check child position
+        parent.rotation.y = Math.PI / 2; // 90 degrees
+        scene.updateMatrixWorld(true);
+        const rotatedPos = child.getWorldPosition(new THREE.Vector3());
+        // After rotation, the child should be at a different world position
+        assert.ok(Math.abs(rotatedPos.x - 10) < 0.001, 'X position after rotation');
+        assert.ok(Math.abs(rotatedPos.y - 10) < 0.001, 'Y position unchanged');
+        assert.ok(Math.abs(rotatedPos.z - 10) < 0.001, 'Z position after rotation');
+    });
+    QUnit.test('addWorldPosition with absolute position', (assert) => {
+        const scene = new THREE.Scene();
+        const parent = new THREE.Object3D();
+        parent.position.set(10, 10, 10);
+        scene.add(parent);
+        const child = new THREE.Object3D();
+        child.useAbsolutePosition = true;
+        child.position.set(20, 20, 20);
+        parent.add(child);
+        scene.updateMatrixWorld(true);
+        // Add world position delta
+        const delta = new THREE.Vector3(5, -3, 2);
+        child.addWorldPosition(delta);
+        scene.updateMatrixWorld(true);
+        const worldPos = child.getWorldPosition(new THREE.Vector3());
+        assert.ok(worldPos.almostEquals(new THREE.Vector3(25, 17, 22)), 'Absolute position after addWorldPosition');
+        // Verify parent position hasn't changed
+        const parentPos = parent.getWorldPosition(new THREE.Vector3());
+        assert.ok(parentPos.almostEquals(new THREE.Vector3(10, 10, 10)), 'Parent position unchanged');
+    });
+    QUnit.test('addWorldPosition without absolute position', (assert) => {
+        const scene = new THREE.Scene();
+        const parent = new THREE.Object3D();
+        parent.position.set(10, 10, 10);
+        parent.rotation.set(0, Math.PI / 2, 0); // 90 degrees Y rotation
+        scene.add(parent);
+        const child = new THREE.Object3D();
+        child.position.set(5, 0, 0);
+        parent.add(child);
+        scene.updateMatrixWorld(true);
+        // Initial world position - parent rotated 90deg Y transforms child's local (5,0,0) to world (0,0,-5) offset
+        const initialPos = child.getWorldPosition(new THREE.Vector3());
+        assert.ok(initialPos.almostEquals(new THREE.Vector3(10, 10, 5)), 'Initial world position with rotated parent');
+        // Add world position delta
+        const delta = new THREE.Vector3(3, 2, 1);
+        child.addWorldPosition(delta);
+        scene.updateMatrixWorld(true);
+        const newPos = child.getWorldPosition(new THREE.Vector3());
+        assert.ok(newPos.almostEquals(new THREE.Vector3(13, 12, 6)), 'World position after addWorldPosition');
+    });
+    QUnit.test('addWorldRotation with absolute rotation', (assert) => {
+        const scene = new THREE.Scene();
+        const parent = new THREE.Object3D();
+        parent.rotation.set(Math.PI / 4, 0, 0); // 45 degrees X rotation
+        scene.add(parent);
+        const child = new THREE.Object3D();
+        child.useAbsoluteRotation = true;
+        child.rotation.set(0, Math.PI / 4, 0); // 45 degrees Y rotation
+        parent.add(child);
+        scene.updateMatrixWorld(true);
+        // Get initial quaternion
+        const initialQuat = child.getWorldQuaternion(new THREE.Quaternion());
+        // Add world rotation delta
+        const delta = new THREE.Euler(0, 0, Math.PI / 4); // 45 degrees Z rotation
+        child.addWorldRotation(delta);
+        scene.updateMatrixWorld(true);
+        // Check that the rotation was applied correctly using quaternions
+        const newQuat = child.getWorldQuaternion(new THREE.Quaternion());
+        const deltaQuat = new THREE.Quaternion().setFromEuler(delta);
+        const expectedQuat = deltaQuat.multiply(initialQuat);
+        // Parent's rotation should not affect this since we have absolute rotation
+        assert.ok(Math.abs(newQuat.dot(expectedQuat)) > 0.999, 'World rotation correctly updated with absolute rotation');
+    });
+    QUnit.test('addWorldRotation without absolute rotation', (assert) => {
+        const scene = new THREE.Scene();
+        const parent = new THREE.Object3D();
+        parent.rotation.set(Math.PI / 4, 0, 0); // 45 degrees X rotation
+        scene.add(parent);
+        const child = new THREE.Object3D();
+        child.rotation.set(0, Math.PI / 4, 0); // 45 degrees Y rotation
+        parent.add(child);
+        scene.updateMatrixWorld(true);
+        // Get initial world rotation
+        const initialQuat = child.getWorldQuaternion(new THREE.Quaternion());
+        // Add world rotation delta
+        const delta = new THREE.Euler(0, 0, Math.PI / 6); // 30 degrees Z rotation
+        child.addWorldRotation(delta);
+        scene.updateMatrixWorld(true);
+        // The new world rotation should be the initial rotation plus the delta
+        const newQuat = child.getWorldQuaternion(new THREE.Quaternion());
+        const deltaQuat = new THREE.Quaternion().setFromEuler(delta);
+        const expectedQuat = deltaQuat.multiply(initialQuat);
+        assert.ok(Math.abs(newQuat.dot(expectedQuat)) > 0.999, 'World rotation correctly updated with delta');
+    });
+    QUnit.test('addWorldPosition and addWorldRotation with mixed absolute flags', (assert) => {
+        const scene = new THREE.Scene();
+        const parent = new THREE.Object3D();
+        parent.position.set(10, 0, 0);
+        parent.rotation.set(0, Math.PI / 2, 0);
+        scene.add(parent);
+        const child = new THREE.Object3D();
+        child.useAbsolutePosition = true;
+        child.useAbsoluteRotation = false;
+        child.position.set(5, 5, 5);
+        child.rotation.set(Math.PI / 4, 0, 0);
+        parent.add(child);
+        scene.updateMatrixWorld(true);
+        // Add world position (absolute)
+        child.addWorldPosition(new THREE.Vector3(2, 3, 1));
+        scene.updateMatrixWorld(true);
+        const worldPos = child.getWorldPosition(new THREE.Vector3());
+        assert.ok(worldPos.almostEquals(new THREE.Vector3(7, 8, 6)), 'Absolute position updated correctly');
+        // Add world rotation (relative)
+        const initialWorldRot = child.getWorldQuaternion(new THREE.Quaternion());
+        child.addWorldRotation(new THREE.Euler(0, Math.PI / 6, 0));
+        scene.updateMatrixWorld(true);
+        const newWorldRot = child.getWorldQuaternion(new THREE.Quaternion());
+        const deltaQuat = new THREE.Quaternion().setFromEuler(new THREE.Euler(0, Math.PI / 6, 0));
+        const expectedQuat = deltaQuat.multiply(initialWorldRot);
+        assert.ok(Math.abs(newWorldRot.dot(expectedQuat)) > 0.999, 'Relative rotation updated correctly');
+    });
+    QUnit.test('addWorldPosition with nested absolute transforms', (assert) => {
+        const scene = new THREE.Scene();
+        const grandparent = new THREE.Object3D();
+        grandparent.position.set(10, 10, 10);
+        scene.add(grandparent);
+        const parent = new THREE.Object3D();
+        parent.useAbsolutePosition = true;
+        parent.position.set(20, 20, 20);
+        grandparent.add(parent);
+        const child = new THREE.Object3D();
+        child.position.set(5, 5, 5);
+        parent.add(child);
+        scene.updateMatrixWorld(true);
+        // Child's world position should be parent's absolute (20,20,20) + child's local (5,5,5) = (25,25,25)
+        const initialPos = child.getWorldPosition(new THREE.Vector3());
+        assert.ok(initialPos.almostEquals(new THREE.Vector3(25, 25, 25)), 'Initial child position with absolute parent');
+        // Add world position to child
+        child.addWorldPosition(new THREE.Vector3(-5, 0, 5));
+        scene.updateMatrixWorld(true);
+        const newPos = child.getWorldPosition(new THREE.Vector3());
+        assert.ok(newPos.almostEquals(new THREE.Vector3(20, 25, 30)), 'Child position after addWorldPosition');
+        // Parent's absolute position should remain unchanged
+        const parentPos = parent.getWorldPosition(new THREE.Vector3());
+        assert.ok(parentPos.almostEquals(new THREE.Vector3(20, 20, 20)), 'Parent absolute position unchanged');
+    });
+    QUnit.test('Absolute transform flags serialization with SceneComponent', (assert) => {
+        // Create an actor with a scene component that has absolute transforms
+        const actor = new AbsoluteTransformTestActor({
+            position: new THREE.Vector3(10, 10, 10),
+            rotation: new THREE.Euler(0, Math.PI / 2, 0),
+        });
+        // Add a scene component with absolute transforms
+        const sceneComp = new AbsoluteTransformTestSceneComponent({
+            position: new THREE.Vector3(20, 20, 20),
+            rotation: new THREE.Euler(Math.PI / 4, 0, 0),
+            scale: new THREE.Vector3(2, 3, 4),
+        });
+        sceneComp.useAbsolutePosition = true;
+        sceneComp.useAbsoluteRotation = false;
+        sceneComp.useAbsoluteScale = true;
+        actor.rootComponent.add(sceneComp);
+        // Serialize and reload
+        const reloadedActor = reloadActor(actor);
+        // Find the reloaded scene component
+        const reloadedComp = reloadedActor.rootComponent.children.find(child => child instanceof AbsoluteTransformTestSceneComponent);
+        assert.ok(reloadedComp, 'Scene component reloaded');
+        assert.strictEqual(reloadedComp.useAbsolutePosition, true, 'useAbsolutePosition preserved');
+        assert.strictEqual(reloadedComp.useAbsoluteRotation, false, 'useAbsoluteRotation preserved');
+        assert.strictEqual(reloadedComp.useAbsoluteScale, true, 'useAbsoluteScale preserved');
+        // Check transform values are preserved
+        assert.ok(reloadedComp.position.almostEquals(sceneComp.position), 'Position preserved');
+        // Check rotation with tolerance due to serialization precision (6 decimal places)
+        const rotationTolerance = 0.000001;
+        assert.ok(Math.abs(reloadedComp.rotation.x - sceneComp.rotation.x) < rotationTolerance, 'Rotation X preserved');
+        assert.ok(Math.abs(reloadedComp.rotation.y - sceneComp.rotation.y) < rotationTolerance, 'Rotation Y preserved');
+        assert.ok(Math.abs(reloadedComp.rotation.z - sceneComp.rotation.z) < rotationTolerance, 'Rotation Z preserved');
+        assert.strictEqual(reloadedComp.rotation.order, sceneComp.rotation.order, 'Rotation order preserved');
+        assert.ok(reloadedComp.scale.almostEquals(sceneComp.scale), 'Scale preserved');
+    });
+    QUnit.test('Absolute transforms in actor hierarchy serialization', (assert) => {
+        // Create actor with hierarchy
+        const actor = new AbsoluteTransformTestActor({
+            position: new THREE.Vector3(10, 10, 10),
+            rotation: new THREE.Euler(0, Math.PI / 2, 0),
+        });
+        // Add child component with absolute transforms
+        const childComp = new AbsoluteTransformTestSceneComponent({
+            position: new THREE.Vector3(20, 20, 20),
+            rotation: new THREE.Euler(Math.PI / 4, 0, 0),
+        });
+        childComp.useAbsolutePosition = true;
+        childComp.useAbsoluteRotation = true;
+        childComp.name = 'AbsoluteChild';
+        actor.rootComponent.add(childComp);
+        // Add grandchild without absolute transforms
+        const grandchildComp = new AbsoluteTransformTestSceneComponent({
+            position: new THREE.Vector3(5, 5, 5),
+        });
+        grandchildComp.name = 'NormalGrandchild';
+        childComp.add(grandchildComp);
+        // Serialize and reload
+        const reloadedActor = reloadActor(actor);
+        // Find reloaded components
+        const reloadedChild = reloadedActor.rootComponent.getObjectByName('AbsoluteChild');
+        const reloadedGrandchild = reloadedChild?.getObjectByName('NormalGrandchild');
+        assert.ok(reloadedChild, 'Child component reloaded');
+        assert.ok(reloadedGrandchild, 'Grandchild component reloaded');
+        // Check absolute flags
+        assert.strictEqual(reloadedChild.useAbsolutePosition, true, 'Child useAbsolutePosition restored');
+        assert.strictEqual(reloadedChild.useAbsoluteRotation, true, 'Child useAbsoluteRotation restored');
+        assert.strictEqual(reloadedChild.useAbsoluteScale, false, 'Child useAbsoluteScale default false');
+        // Check transforms
+        assert.ok(reloadedChild.position.equals(childComp.position), 'Child position preserved');
+        // Check rotation with tolerance due to serialization precision (6 decimal places)
+        const rotationTolerance = 0.000001;
+        assert.ok(Math.abs(reloadedChild.rotation.x - childComp.rotation.x) < rotationTolerance, 'Child rotation X preserved');
+        assert.ok(Math.abs(reloadedChild.rotation.y - childComp.rotation.y) < rotationTolerance, 'Child rotation Y preserved');
+        assert.ok(Math.abs(reloadedChild.rotation.z - childComp.rotation.z) < rotationTolerance, 'Child rotation Z preserved');
+        assert.strictEqual(reloadedChild.rotation.order, childComp.rotation.order, 'Child rotation order preserved');
+        // Create a scene and verify world positions work correctly
+        const scene = new THREE.Scene();
+        scene.add(reloadedActor.rootComponent);
+        scene.updateMatrixWorld(true);
+        const childWorldPos = reloadedChild.getWorldPosition(new THREE.Vector3());
+        assert.ok(childWorldPos.almostEquals(new THREE.Vector3(20, 20, 20)), 'Child absolute world position correct after loading');
+    });
+    QUnit.test('Default absolute transform values in SceneComponent', (assert) => {
+        const comp = new AbsoluteTransformTestSceneComponent();
+        // By default, all should be false
+        assert.strictEqual(comp.useAbsolutePosition, false, 'Default useAbsolutePosition is false');
+        assert.strictEqual(comp.useAbsoluteRotation, false, 'Default useAbsoluteRotation is false');
+        assert.strictEqual(comp.useAbsoluteScale, false, 'Default useAbsoluteScale is false');
+        // Create actor and serialize
+        const actor = new AbsoluteTransformTestActor();
+        actor.rootComponent.add(comp);
+        const reloadedActor = reloadActor(actor);
+        const reloadedComp = reloadedActor.rootComponent.children[0];
+        assert.strictEqual(reloadedComp.useAbsolutePosition, false, 'Loaded default useAbsolutePosition is false');
+        assert.strictEqual(reloadedComp.useAbsoluteRotation, false, 'Loaded default useAbsoluteRotation is false');
+        assert.strictEqual(reloadedComp.useAbsoluteScale, false, 'Loaded default useAbsoluteScale is false');
+    });
+    QUnit.test('Absolute transform with mixed true/false values serialization', (assert) => {
+        // Test all combinations
+        const testCases = [
+            { pos: true, rot: false, scale: false },
+            { pos: false, rot: true, scale: false },
+            { pos: false, rot: false, scale: true },
+            { pos: true, rot: true, scale: false },
+            { pos: true, rot: false, scale: true },
+            { pos: false, rot: true, scale: true },
+            { pos: true, rot: true, scale: true }
+        ];
+        testCases.forEach((testCase, index) => {
+            const actor = new AbsoluteTransformTestActor();
+            const comp = new AbsoluteTransformTestSceneComponent();
+            comp.name = `Test${index}`;
+            comp.useAbsolutePosition = testCase.pos;
+            comp.useAbsoluteRotation = testCase.rot;
+            comp.useAbsoluteScale = testCase.scale;
+            actor.rootComponent.add(comp);
+            const reloadedActor = reloadActor(actor);
+            const reloadedComp = reloadedActor.rootComponent.getObjectByName(`Test${index}`);
+            assert.strictEqual(reloadedComp.useAbsolutePosition, testCase.pos, `Case ${index}: useAbsolutePosition ${testCase.pos} preserved`);
+            assert.strictEqual(reloadedComp.useAbsoluteRotation, testCase.rot, `Case ${index}: useAbsoluteRotation ${testCase.rot} preserved`);
+            assert.strictEqual(reloadedComp.useAbsoluteScale, testCase.scale, `Case ${index}: useAbsoluteScale ${testCase.scale} preserved`);
+        });
+    });
+    QUnit.test('Absolute transforms preserved through clone', (assert) => {
+        const obj = new THREE.Object3D();
+        obj.useAbsolutePosition = true;
+        obj.useAbsoluteRotation = false;
+        obj.useAbsoluteScale = true;
+        obj.position.set(10, 20, 30);
+        const cloned = obj.clone();
+        assert.strictEqual(cloned.useAbsolutePosition, true, 'useAbsolutePosition cloned');
+        assert.strictEqual(cloned.useAbsoluteRotation, false, 'useAbsoluteRotation cloned');
+        assert.strictEqual(cloned.useAbsoluteScale, true, 'useAbsoluteScale cloned');
+        assert.ok(cloned.position.equals(obj.position), 'Position cloned');
+    });
+    QUnit.test('Absolute transforms work correctly after serialization round-trip', (assert) => {
+        // Create actor with complex hierarchy
+        const actor = new AbsoluteTransformTestActor({
+            position: new THREE.Vector3(10, 0, 0),
+            rotation: new THREE.Euler(0, Math.PI / 4, 0),
+        });
+        const absChild = new AbsoluteTransformTestSceneComponent({
+            position: new THREE.Vector3(50, 50, 50), // World position
+            rotation: new THREE.Euler(Math.PI / 2, 0, 0), // World rotation
+        });
+        absChild.name = 'AbsoluteChild';
+        absChild.useAbsolutePosition = true;
+        absChild.useAbsoluteRotation = true;
+        actor.rootComponent.add(absChild);
+        const normalGrandchild = new AbsoluteTransformTestSceneComponent({
+            position: new THREE.Vector3(5, 5, 5), // Local to absChild
+        });
+        normalGrandchild.name = 'NormalGrandchild';
+        absChild.add(normalGrandchild);
+        // Create scene and update world positions
+        const scene = new THREE.Scene();
+        scene.add(actor.rootComponent);
+        scene.updateMatrixWorld(true);
+        const initialAbsWorldPos = absChild.getWorldPosition(new THREE.Vector3());
+        const initialGrandchildWorldPos = normalGrandchild.getWorldPosition(new THREE.Vector3());
+        // Serialize and reload
+        const reloadedActor = reloadActor(actor);
+        const reloadedAbsChild = reloadedActor.rootComponent.getObjectByName('AbsoluteChild');
+        const reloadedGrandchild = reloadedAbsChild?.getObjectByName('NormalGrandchild');
+        // Verify absolute flags
+        assert.strictEqual(reloadedAbsChild.useAbsolutePosition, true, 'Absolute position flag preserved');
+        assert.strictEqual(reloadedAbsChild.useAbsoluteRotation, true, 'Absolute rotation flag preserved');
+        // Add to scene and update world matrices
+        const loadedScene = new THREE.Scene();
+        loadedScene.add(reloadedActor.rootComponent);
+        loadedScene.updateMatrixWorld(true);
+        const loadedAbsWorldPos = reloadedAbsChild.getWorldPosition(new THREE.Vector3());
+        const loadedGrandchildWorldPos = reloadedGrandchild.getWorldPosition(new THREE.Vector3());
+        assert.ok(loadedAbsWorldPos.almostEquals(initialAbsWorldPos), 'Absolute child world position preserved');
+        assert.ok(loadedGrandchildWorldPos.almostEquals(initialGrandchildWorldPos), 'Grandchild world position preserved');
+        // Move the root and verify absolute child doesn't move
+        reloadedActor.rootComponent.position.set(30, 30, 30);
+        loadedScene.updateMatrixWorld(true);
+        const movedAbsWorldPos = reloadedAbsChild.getWorldPosition(new THREE.Vector3());
+        assert.ok(movedAbsWorldPos.almostEquals(new THREE.Vector3(50, 50, 50)), 'Absolute child maintains world position after parent moves');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"absolute-transform.test.js","sourceRoot":"","sources":["../../test/absolute-transform.test.ts"],"names":[],"mappings":"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"}