@directivegames/genesys.js 3.1.24

package/dist/test/serialization.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/serialization.test.js

@@ -0,0 +1,425 @@
+import * as ENGINE from 'genesys.js';
+import QUnit from 'qunit';
+import * as THREE from 'three';
+import { internalSceneComponentData, internalSceneComponentOtherData, reloadActor, reloadActorInGame, TestActor, TestSceneComponent, } from './utils.js';
+QUnit.module('Serialization', hooks => {
+    hooks.before(() => {
+    });
+    QUnit.test('basic actor test', assert => {
+        // {
+        //   // unregistered actor should throw an error
+        //   assert.throws(() => {
+        //     const actor = new UnregisteredActor();
+        //     actor.asExportedObject();
+        //   }, 'Unregistered actor should throw an error');
+        // }
+        {
+            // verify loaded actor class
+            const originalActor = new TestActor();
+            originalActor.editorData.displayName = 'Test Actor';
+            const loadedActor = reloadActor(originalActor);
+            assert.ok(loadedActor instanceof TestActor, 'Loaded actor is a TestActor');
+            assert.equal(loadedActor.uuid, originalActor.uuid, 'Loaded actor has the same uuid');
+            assert.equal(loadedActor.editorData.displayName, originalActor.editorData.displayName, 'Loaded actor has the same display name');
+        }
+        {
+            // verify actor with custom data
+            const originalActor = new TestActor();
+            originalActor.customActorData = 'Test Actor Data';
+            const loadedActor = reloadActor(originalActor);
+            assert.equal(loadedActor.customActorData, originalActor.customActorData, 'Loaded actor has the same custom data');
+        }
+    });
+    QUnit.test('actor transform test', assert => {
+        {
+            // verify loaded transform
+            const position = new THREE.Vector3(1, 2, 3);
+            const rotation = new THREE.Euler(0.1, 0.2, 0.3);
+            const scale = new THREE.Vector3(4, 5, 6);
+            const loadedActor = reloadActor(new TestActor({
+                position,
+                rotation,
+                scale,
+            }));
+            assert.ok(loadedActor.getWorldPosition().almostEquals(position), 'Loaded actor has the same position');
+            assert.ok(loadedActor.getWorldRotation().almostEquals(rotation), 'Loaded actor has the same rotation');
+            assert.ok(loadedActor.getWorldScale().almostEquals(scale), 'Loaded actor has the same scale');
+        }
+        {
+            // verify loaded transform via root component
+            const position = new THREE.Vector3(1, 2, 3);
+            const rotation = new THREE.Euler(0.1, 0.2, 0.3);
+            const scale = new THREE.Vector3(4, 5, 6);
+            const loadedActor = reloadActor(new TestActor({
+                rootComponent: new TestSceneComponent({
+                    position,
+                    rotation,
+                    scale,
+                }),
+            }));
+            assert.ok(loadedActor.getWorldPosition().almostEquals(position), 'Loaded actor has the same position');
+            assert.ok(loadedActor.getWorldRotation().almostEquals(rotation), 'Loaded actor has the same rotation');
+            assert.ok(loadedActor.getWorldScale().almostEquals(scale), 'Loaded actor has the same scale');
+            assert.ok(loadedActor.rootComponent instanceof TestSceneComponent, 'Loaded actor has a TestSceneComponent as its root component');
+            assert.ok(loadedActor.getComponents(ENGINE.SceneComponent).length === 1, 'Loaded actor has one scene component');
+        }
+        {
+            // modify transform post spawn
+            const position = new THREE.Vector3(1, 2, 3);
+            const rotation = new THREE.Euler(0.1, 0.2, 0.3);
+            const scale = new THREE.Vector3(4, 5, 6);
+            const originalActor = new TestActor();
+            originalActor.setWorldPosition(position);
+            originalActor.setWorldRotation(rotation);
+            originalActor.setWorldScale(scale);
+            const loadedActor = reloadActor(originalActor);
+            assert.ok(loadedActor.getWorldPosition().almostEquals(position), 'Loaded actor has the same position');
+            assert.ok(loadedActor.getWorldRotation().almostEquals(rotation), 'Loaded actor has the same rotation');
+            assert.ok(loadedActor.getWorldScale().almostEquals(scale), 'Loaded actor has the same scale');
+        }
+    });
+    QUnit.test('constructor scene component', assert => {
+        // child component added via constructor, case 1
+        const component = new TestSceneComponent({
+            data: 123,
+        });
+        component.otherData = 456;
+        const loadedActor = reloadActor(new TestActor({
+            sceneComponents: [component],
+        }));
+        assert.equal(loadedActor.getComponents(TestSceneComponent).length, 1, 'Loaded actor has one scene component');
+        const loadedComponent = loadedActor.getComponents(TestSceneComponent)[0];
+        if (loadedComponent) {
+            assert.equal(loadedComponent.options.data, 123, 'Loaded component has the correct data');
+            assert.equal(loadedComponent.otherData, 456, 'Loaded component has the correct other data');
+        }
+    });
+    QUnit.test('added scene component', assert => {
+        // child component added via addComponents
+        const component = new TestSceneComponent({
+            data: 123,
+        });
+        component.otherData = 456;
+        const originalActor = new TestActor();
+        originalActor.rootComponent.add(component);
+        const loadedActor = reloadActor(originalActor);
+        assert.equal(loadedActor.getComponents(TestSceneComponent).length, 1, 'Loaded actor has one scene component');
+        const loadedComponent = loadedActor.getComponents(TestSceneComponent)[0];
+        if (loadedComponent) {
+            assert.equal(loadedComponent.options.data, 123, 'Loaded component has the correct data');
+            assert.equal(loadedComponent.otherData, 456, 'Loaded component has the correct other data');
+        }
+    });
+    QUnit.test('modify constructor scene component data', assert => {
+        // child component added via constructor, case 1
+        const component = new TestSceneComponent({
+            data: 333,
+        });
+        component.otherData = 444;
+        const originalActor = new TestActor({
+            sceneComponents: [component],
+        });
+        component.otherData = 888;
+        const loadedActor = reloadActor(originalActor);
+        assert.equal(loadedActor.getComponents(TestSceneComponent).length, 1, 'Loaded actor has one scene component');
+        const loadedComponent = loadedActor.getComponents(TestSceneComponent)[0];
+        if (loadedComponent) {
+            assert.equal(loadedComponent.options.data, 333, 'Loaded component has the correct data');
+            assert.equal(loadedComponent.otherData, 888, 'Loaded component has the correct other data');
+        }
+    });
+    QUnit.test('modify added scene component data', assert => {
+        // child component added via addComponents
+        const component = new TestSceneComponent({
+            data: 333,
+        });
+        component.otherData = 444;
+        const originalActor = new TestActor();
+        originalActor.rootComponent.add(component);
+        component.otherData = 888;
+        const loadedActor = reloadActor(originalActor);
+        assert.equal(loadedActor.getComponents(TestSceneComponent).length, 1, 'Loaded actor has one scene component');
+        const loadedComponent = loadedActor.getComponents(TestSceneComponent)[0];
+        if (loadedComponent) {
+            assert.equal(loadedComponent.options.data, 333, 'Loaded component has the correct data');
+            assert.equal(loadedComponent.otherData, 888, 'Loaded component has the correct other data');
+        }
+    });
+    QUnit.test('transient constructor scene component 1', assert => {
+        // transient component added via constructor case 1
+        const component = new TestSceneComponent({
+            data: 123,
+        });
+        component.otherData = 456;
+        component.setTransient(true);
+        const loadedActor = reloadActor(new TestActor({
+            sceneComponents: [component],
+        }));
+        assert.equal(loadedActor.getComponents(TestSceneComponent).length, 0, 'Loaded actor has same amount of scene components');
+    });
+    QUnit.test('transient constructor scene component 2', assert => {
+        // child component added via constructor, case 2
+        const component = new TestSceneComponent({
+            data: 123,
+        });
+        component.otherData = 456;
+        component.setTransient(true);
+        const loadedActor = reloadActor(new TestActor({
+            testSceneComponent: component,
+        }));
+        assert.equal(loadedActor.getComponents(TestSceneComponent).length, 0, 'Loaded actor has same amount of scene components');
+    });
+    QUnit.test('transient added scene component', assert => {
+        // transient component added via addComponents
+        const component = new TestSceneComponent({
+            data: 123,
+        });
+        component.otherData = 456;
+        component.setTransient(true);
+        const originalActor = new TestActor();
+        originalActor.rootComponent.add(component);
+        const loadedActor = reloadActor(originalActor);
+        assert.equal(loadedActor.getComponents(TestSceneComponent).length, 0, 'Loaded actor has same amount of scene components');
+    });
+    QUnit.test('internal scene component', assert => {
+        // internal component
+        const originalActor = new TestActor({
+            createInternalSceneComponent: true,
+        });
+        const loadedActor = reloadActor(originalActor);
+        assert.equal(loadedActor.getComponents(TestSceneComponent).length, 1, 'Loaded actor has one scene component');
+        const loadedComponent = loadedActor.getComponents(TestSceneComponent)[0];
+        if (loadedComponent) {
+            assert.equal(loadedComponent.options.data, internalSceneComponentData, 'Loaded component has the correct data');
+            assert.equal(loadedComponent.otherData, internalSceneComponentOtherData, 'Loaded component has the correct other data');
+        }
+    });
+    QUnit.test('scene component transform', assert => {
+        {
+            // actor with root component and child component
+            const rootPosition = new THREE.Vector3(1, 2, 3);
+            const rootRotation = new THREE.Euler(0.1, 0.2, 0.3);
+            const rootScale = new THREE.Vector3(4, 5, 6);
+            const childPosition = new THREE.Vector3(7, 8, 9);
+            const childRotation = new THREE.Euler(0.4, 0.5, 0.6);
+            const childScale = new THREE.Vector3(10, 11, 12);
+            const loadedActor = reloadActor(new TestActor({
+                position: rootPosition,
+                rotation: rootRotation,
+                scale: rootScale,
+                sceneComponents: [
+                    new TestSceneComponent({
+                        position: childPosition,
+                        rotation: childRotation,
+                        scale: childScale,
+                    })
+                ],
+            }));
+            assert.ok(loadedActor.getWorldPosition().almostEquals(rootPosition), 'Loaded actor has the same position');
+            assert.ok(loadedActor.getWorldRotation().almostEquals(rootRotation), 'Loaded actor has the same rotation');
+            assert.ok(loadedActor.getWorldScale().almostEquals(rootScale), 'Loaded actor has the same scale');
+            assert.ok(loadedActor.rootComponent instanceof ENGINE.SceneComponent, 'Loaded actor has a SceneComponent as its root component');
+            assert.equal(loadedActor.getComponents(ENGINE.SceneComponent).length, 2, 'Loaded actor has two scene components');
+            assert.equal(loadedActor.getComponents(TestSceneComponent).length, 1, 'Loaded actor has one test scene component');
+            const child = loadedActor.getComponents(TestSceneComponent)[0];
+            if (child) {
+                assert.ok(child instanceof TestSceneComponent, 'Loaded actor has a TestSceneComponent as its child');
+                assert.ok(child.position.almostEquals(childPosition), 'Loaded actor has the same child position');
+                assert.ok(child.rotation.almostEquals(childRotation), 'Loaded actor has the same child rotation');
+                assert.ok(child.scale.almostEquals(childScale), 'Loaded actor has the same child scale');
+            }
+        }
+    });
+    QUnit.test('external object reference', assert => {
+        const loadedActor = reloadActor(new TestActor({
+            material: ENGINE.MaterialUtils.DefaultMaterial,
+        }));
+        /*
+        "ctor": {
+          "material": {
+            "@external": "DefaultMaterial"
+          }
+        },
+        */
+        assert.equal(loadedActor.options.material, ENGINE.MaterialUtils.DefaultMaterial, 'Loaded actor has the default material');
+    });
+    QUnit.test('default value', assert => {
+        const component = new ENGINE.PrimitiveComponent();
+        const componentData = component.asExportedObject(false);
+        assert.equal(componentData.ctor, undefined, 'ctor is not serialized');
+        component.overridePhysicsOptions({
+            collisionMeshType: ENGINE.CollisionMeshType.Trimesh,
+        });
+        const componentData2 = component.asExportedObject(false);
+        assert.ok(!!componentData2.$root.$base.$ctorArgs[0].physicsOptions, 'Custom physics options are serialized');
+        assert.equal(componentData2.$root.$base.$ctorArgs[0].physicsOptions.collisionMeshType, ENGINE.CollisionMeshType.Trimesh, 'Custom physics options are serialized');
+    });
+    QUnit.test('duplicate scene component', assert => {
+        const component = new TestSceneComponent({
+            data: 123,
+        });
+        component.otherData = 456;
+        const loadedActor = reloadActor(new TestActor({
+            testSceneComponent: component,
+        }));
+        assert.equal(loadedActor.getComponents(TestSceneComponent).length, 1, 'Loaded actor has one scene component');
+        const loadedComponent = loadedActor.getComponents(TestSceneComponent)[0];
+        if (loadedComponent) {
+            assert.equal(loadedActor.testSceneComponent, loadedComponent, 'Loaded actor has the correct test scene component');
+            assert.equal(loadedComponent.options.data, 123, 'Loaded component has the correct data');
+            assert.equal(loadedComponent.otherData, 456, 'Loaded component has the correct other data');
+        }
+    });
+    QUnit.test('editorOnly actor', assert => {
+        // Test editorOnly actor in editor mode
+        const originalActor = new TestActor();
+        originalActor.setEditorOnly(true);
+        originalActor.customActorData = 'Editor Only Actor';
+        // Should load in editor mode
+        const loadedActorInEditor = reloadActor(originalActor, false, {}, true);
+        assert.ok(loadedActorInEditor, 'EditorOnly actor should load in editor mode');
+        assert.ok(loadedActorInEditor.isEditorOnly(), 'Loaded actor should be marked as editorOnly');
+        assert.equal(loadedActorInEditor.customActorData, 'Editor Only Actor', 'Loaded actor should have custom data');
+        // Should NOT load in game mode
+        const loadedActorInGame = reloadActorInGame(originalActor);
+        assert.equal(loadedActorInGame, null, 'EditorOnly actor should not load in game mode');
+    });
+    QUnit.test('editorOnly scene component', assert => {
+        // Test editorOnly scene component
+        const sceneComponent = new TestSceneComponent({
+            data: 789,
+        });
+        sceneComponent.otherData = 101;
+        sceneComponent.setEditorOnly(true);
+        const originalActor = new TestActor();
+        originalActor.rootComponent.add(sceneComponent);
+        // Should load scene component in editor mode
+        const loadedActorInEditor = reloadActor(originalActor, false, {}, true);
+        assert.equal(loadedActorInEditor.getComponents(TestSceneComponent).length, 1, 'EditorOnly scene component should load in editor mode');
+        const loadedSceneComponentInEditor = loadedActorInEditor.getComponents(TestSceneComponent)[0];
+        if (loadedSceneComponentInEditor) {
+            assert.ok(loadedSceneComponentInEditor.isEditorOnly(), 'Loaded scene component should be marked as editorOnly');
+            assert.equal(loadedSceneComponentInEditor.options.data, 789, 'Loaded scene component has the correct data');
+            assert.equal(loadedSceneComponentInEditor.otherData, 101, 'Loaded scene component has the correct other data');
+        }
+        // Should NOT load scene component in game mode
+        const loadedActorInGame = reloadActorInGame(originalActor);
+        assert.ok(loadedActorInGame, 'Actor should load in game mode');
+        if (loadedActorInGame) {
+            assert.equal(loadedActorInGame.getComponents(TestSceneComponent).length, 0, 'EditorOnly scene component should not load in game mode');
+        }
+    });
+    QUnit.test('editorOnly root component', assert => {
+        const rootComponent = new TestSceneComponent({
+            data: 999,
+        });
+        rootComponent.otherData = 888;
+        rootComponent.setEditorOnly(true);
+        const originalActor = new TestActor({
+            rootComponent: rootComponent,
+        });
+        // Should load in editor mode
+        const loadedActorInEditor = reloadActor(originalActor, false, {}, true);
+        assert.ok(loadedActorInEditor, 'Actor with editorOnly root component should load in editor mode');
+        assert.ok(loadedActorInEditor.rootComponent.isEditorOnly(), 'Root component should be marked as editorOnly');
+        assert.equal(loadedActorInEditor.getComponents(TestSceneComponent).length, 1, 'Should have one TestSceneComponent');
+        // Should be replaced by the default root component
+        const loadedActorInGame = reloadActorInGame(originalActor);
+        assert.ok(loadedActorInGame, 'Actor with editorOnly root component should load in game mode');
+        assert.equal((loadedActorInGame?.rootComponent).otherData, undefined, 'Actor with editorOnly root component should load in game mode');
+    });
+    QUnit.test('mixed editorOnly and regular components', assert => {
+        // Test mix of editorOnly and regular components
+        const regularSceneComponent = new TestSceneComponent({
+            data: 555,
+        });
+        regularSceneComponent.otherData = 666;
+        const editorOnlySceneComponent = new TestSceneComponent({
+            data: 777,
+        });
+        editorOnlySceneComponent.otherData = 888;
+        editorOnlySceneComponent.setEditorOnly(true);
+        const originalActor = new TestActor();
+        originalActor.rootComponent.add(regularSceneComponent);
+        originalActor.rootComponent.add(editorOnlySceneComponent);
+        // In editor mode: should load all components
+        const loadedActorInEditor = reloadActor(originalActor, false, {}, true);
+        assert.equal(loadedActorInEditor.getComponents(TestSceneComponent).length, 2, 'Should load both scene components in editor mode');
+        // In game mode: should only load regular components
+        const loadedActorInGame = reloadActorInGame(originalActor);
+        assert.ok(loadedActorInGame, 'Actor should load in game mode');
+        if (loadedActorInGame) {
+            assert.equal(loadedActorInGame.getComponents(TestSceneComponent).length, 1, 'Should only load regular scene component in game mode');
+            const loadedRegularSceneComponent = loadedActorInGame.getComponents(TestSceneComponent)[0];
+            if (loadedRegularSceneComponent) {
+                assert.equal(loadedRegularSceneComponent.options.data, 555, 'Regular scene component should have correct data');
+                assert.equal(loadedRegularSceneComponent.otherData, 666, 'Regular scene component should have correct other data');
+                assert.ok(!loadedRegularSceneComponent.isEditorOnly(), 'Regular scene component should not be marked as editorOnly');
+            }
+        }
+    });
+    QUnit.test('editorOnly serialization format', assert => {
+        // Test that editorOnly flag is properly serialized
+        const component = new TestSceneComponent({
+            data: 123,
+        });
+        component.setEditorOnly(true);
+        const actor = new TestActor();
+        actor.rootComponent.add(component);
+        actor.setEditorOnly(true);
+        const exportedData = actor.asExportedObject();
+        // Check actor editorOnly flag
+        assert.equal(exportedData.$root.editorOnly, true, 'Actor editorOnly should be serialized as true');
+        // Check component editorOnly flag
+        const reloadedActor = reloadActor(actor, false, {}, true);
+        assert.equal(reloadedActor.getComponent(TestSceneComponent)?.isEditorOnly(), true, 'Component editorOnly should be serialized as true');
+    });
+    QUnit.test('non-editorOnly serialization format', assert => {
+        // Test that non-editorOnly objects don't include the flag (undefined)
+        const component = new TestSceneComponent({
+            data: 123,
+        });
+        // Don't set editorOnly (should be false by default)
+        const actor = new TestActor();
+        actor.rootComponent.add(component);
+        // Don't set editorOnly (should be false by default)
+        const exportedData = actor.asExportedObject();
+        // Check actor editorOnly flag is undefined (not serialized when false)
+        assert.equal(exportedData.properties?.editorOnly, undefined, 'Actor editorOnly should be undefined when false');
+        // Check component editorOnly flag
+        const reloadedActor = reloadActor(actor, false, {}, true);
+        assert.equal(reloadedActor.getComponent(TestSceneComponent)?.isEditorOnly(), false, 'Component editorOnly should be serialized as false');
+    });
+    QUnit.test('transient root component', (assert) => {
+        const actor = new ENGINE.Actor({});
+        actor.rootComponent.setTransient(true);
+        actor.rootComponent.name = 'root0';
+        actor.setWorldPosition(new THREE.Vector3(1, 2, 3));
+        const reloadedActor = reloadActor(actor, false, {}, true);
+        assert.deepEqual(reloadedActor.getWorldPosition(), new THREE.Vector3(0, 0, 0), 'Position set on a transient root component is not saved');
+        assert.equal(reloadedActor.rootComponent.name, '', 'Transient root component state is not saved');
+    });
+    QUnit.test('component name serialization', (assert) => {
+        const actor = new TestActor({});
+        // Test 1: Component doesn't have a default name
+        const componentWithoutName = new TestSceneComponent();
+        actor.rootComponent.add(componentWithoutName);
+        assert.equal(componentWithoutName.name, '', 'Component should not have a default name');
+        // Test 2: If set, the component name is properly persisted
+        const componentWithName = new TestSceneComponent();
+        componentWithName.name = 'MyTestComponent';
+        actor.rootComponent.add(componentWithName);
+        assert.equal(componentWithName.name, 'MyTestComponent', 'Component name should be set correctly');
+        const reloadedActor = reloadActor(actor, false, {}, true);
+        const reloadedComponents = reloadedActor.getComponents(TestSceneComponent);
+        // Find the component with the name
+        const namedComponent = reloadedComponents.find(c => c.name === 'MyTestComponent');
+        assert.notEqual(namedComponent, undefined, 'Named component should be found after reload');
+        assert.equal(namedComponent?.name, 'MyTestComponent', 'Component name should be persisted after reload');
+        // Find the component without a name
+        const unnamedComponent = reloadedComponents.find(c => c.name === '');
+        assert.notEqual(unnamedComponent, undefined, 'Unnamed component should be found after reload');
+        assert.equal(unnamedComponent?.name, '', 'Component without name should remain unnamed after reload');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serialization.test.js","sourceRoot":"","sources":["../../test/serialization.test.ts"],"names":[],"mappings":"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"}

package/dist/test/spawn.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/spawn.test.js

@@ -0,0 +1,137 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+import { NodeStorageProvider } from './nodeStorage.js';
+QUnit.module('SerializationV1', hooks => {
+    hooks.before(() => {
+    });
+    hooks.beforeEach(() => {
+        ENGINE.clearCdoCache();
+        ENGINE.PrefabManager.clearCache();
+    });
+    QUnit.test('test spawn actor by class', assert => {
+        {
+            const actor = ENGINE.spawn(ENGINE.Actor);
+            assert.ok(actor instanceof ENGINE.Actor, 'spawned actor is instance of Actor');
+        }
+        {
+            const actor = ENGINE.spawn(ENGINE.Actor, { ctorArgsOverrides: { position: new THREE.Vector3(10, 20, 30) } });
+            assert.ok(actor instanceof ENGINE.Actor, 'spawned actor is instance of Actor');
+            assert.deepEqual(actor.getWorldPosition(), new THREE.Vector3(10, 20, 30), 'spawned actor has correct position');
+        }
+        {
+            const pawn = ENGINE.spawn(ENGINE.Pawn, { ctorArgsOverrides: { position: new THREE.Vector3(10, 20, 30) } });
+            assert.ok(pawn instanceof ENGINE.Pawn, 'spawned actor is instance of Pawn');
+            assert.deepEqual(pawn.getWorldPosition(), new THREE.Vector3(10, 20, 30), 'spawned pawn has correct position');
+        }
+    });
+    QUnit.test('test spawn actor by class name', assert => {
+        {
+            const actor = ENGINE.spawn('ENGINE.Actor');
+            assert.ok(actor instanceof ENGINE.Actor, 'spawned actor is instance of Actor');
+        }
+        {
+            const actor = ENGINE.spawn('ENGINE.Actor', { ctorArgsOverrides: { position: new THREE.Vector3(10, 20, 30) } });
+            assert.ok(actor instanceof ENGINE.Actor, 'spawned actor is instance of Actor');
+            assert.deepEqual(actor.getWorldPosition(), new THREE.Vector3(10, 20, 30), 'spawned actor has correct position');
+        }
+        {
+            const pawn = ENGINE.spawn('ENGINE.Pawn', { ctorArgsOverrides: { position: new THREE.Vector3(10, 20, 30) } });
+            assert.ok(pawn instanceof ENGINE.Pawn, 'spawned actor is instance of Pawn');
+            assert.deepEqual(pawn.getWorldPosition(), new THREE.Vector3(10, 20, 30), 'spawned pawn has correct position');
+        }
+    });
+    QUnit.test('test spawn actor by prefab', assert => {
+        const prefabTemplate = ENGINE.spawn('ENGINE.Actor');
+        prefabTemplate.addComponent(new ENGINE.MeshComponent());
+        const prefabData = { TestPrefab: prefabTemplate.asExportedPrefabData() };
+        {
+            const actor = ENGINE.spawn('TestPrefab', { prefabData });
+            assert.ok(prefabTemplate instanceof ENGINE.Actor, 'spawned actor is instance of Actor');
+            assert.ok(actor.getComponent(ENGINE.MeshComponent) instanceof ENGINE.MeshComponent, 'spawned actor has MeshComponent');
+        }
+        {
+            const actor = ENGINE.spawn('TestPrefab', { prefabData, ctorArgsOverrides: { position: new THREE.Vector3(10, 20, 30) } });
+            assert.ok(prefabTemplate instanceof ENGINE.Actor, 'spawned actor is instance of Actor');
+            assert.ok(actor.getComponent(ENGINE.MeshComponent) instanceof ENGINE.MeshComponent, 'spawned actor has MeshComponent');
+            assert.deepEqual(actor.getWorldPosition(), new THREE.Vector3(10, 20, 30), 'spawned actor has correct position');
+        }
+    });
+    QUnit.test('test bad spawn', assert => {
+        assert.throws(() => {
+            ENGINE.spawn(123);
+        }, /Cannot spawn from 123/, 'throws error on invalid spawn input');
+        assert.throws(() => {
+            ENGINE.spawn('NonExistentClassOrPrefab');
+        }, /Prefab data is missing for path: NonExistentClassOrPrefab/, 'treated as prefab path and throws error on missing prefab data');
+    });
+    QUnit.test('test async spawn actor by prefab', async (assert) => {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const storageProvider = new NodeStorageProvider();
+            const context = __addDisposableResource(env_1, ENGINE.scopedProjectContext({ project: 'test', storageProvider }), false);
+            const actor = await ENGINE.spawnAsync('@engine/assets/prefabs/actors/demo_health_pickup.prefab.json');
+            assert.ok(actor instanceof ENGINE.Actor, 'spawned actor is instance of Actor');
+            assert.ok(actor.getComponent(ENGINE.GLTFMeshComponent) instanceof ENGINE.GLTFMeshComponent, 'spawned actor has GLTFMeshComponent');
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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