@needle-tools/engine 2.34.0-pre → 2.35.1-pre

package/src/engine/engine_networking.ts

@@ -4,21 +4,19 @@
 let serverUrl = 'wss://needle-tiny-starter.glitch.me/socket';
 
 import { Websocket, WebsocketBuilder } from 'websocket-ts';
-import { Behaviour, GameObject } from '../engine-components/Component';
-import { Networking } from '../engine-components/Networking';
-import { Context, ContextArgs } from './engine_setup';
+// import { Networking } from '../engine-components/Networking';
+import { Context } from './engine_setup';
 import * as utils from "./engine_utils";
 import * as flatbuffers from 'flatbuffers';
 import * as schemes from "../engine-schemes/schemes";
 import { PeerNetworking } from './engine_networking_peer';
+import { IModel, INetworkConnection, SendQueue } from './engine_networking_types';
 
 export const debugNet = utils.getParam("debugnet") ? true : false;
 export const debugOwner = debugNet || utils.getParam("debugowner") ? true : false;
 
-
-export declare interface IModel {
-    guid: string;
-    dontSave?: boolean; // if set to true the model will not be saved in the server room state
+export interface INetworkingWebsocketUrlProvider {
+    getWebsocketUrl() : string | null;
 }
 
 export declare interface IConnectionData {
@@ -225,18 +223,11 @@ export class OwnershipModel {
 }
 
 
-export enum SendQueue {
-    OnConnection,
-    OnRoomJoin,
-    Queued,
-    Immediate,
-}
-
 export declare type BinaryCallback = {
     (data: any | flatbuffers.ByteBuffer): void;
 }
 
-export class NetworkConnection {
+export class NetworkConnection implements INetworkConnection {
 
     private context: Context;
     private _peer: PeerNetworking | null = null;
@@ -395,14 +386,20 @@ export class NetworkConnection {
         }
     }
 
+    private netWebSocketUrlProvider? : INetworkingWebsocketUrlProvider;
+
+    public registerProvider(prov : INetworkingWebsocketUrlProvider){
+        this.netWebSocketUrlProvider = prov;
+    }
+
     public connect() {
         if (this.connected) return;
         if (debugNet)
             console.log("connecting");
         // this.channel = geckos({ port: 9208, url: 'http://127.0.0.1' });
         // this.channel.onConnect(this.onConnectGeckosIo.bind(this));
-        const networking = GameObject.findObjectOfType(Networking, this.context, false);
-        const overrideUrl = networking?.getWebsocketUrl();
+        // const networking = GameObject.findObjectOfType(Networking, this.context, false);
+        const overrideUrl = this.netWebSocketUrlProvider?.getWebsocketUrl();
         if (overrideUrl) {
             serverUrl = overrideUrl;
         }

package/src/engine/engine_networking_files.ts

@@ -1,12 +1,15 @@
-import { GameObject } from "../engine-components/Component";
 import { Context } from "../engine/engine_setup";
-import { loadSync, parseSync } from "../engine/engine_scenetools";
+// import { loadSync, parseSync } from "../engine/engine_scenetools";
 import * as THREE from "three";
 import * as web from "../engine/engine_web_api";
-import { IModel, NetworkConnection } from "../engine/engine_networking";
+import { NetworkConnection } from "../engine/engine_networking";
 import { generateSeed, InstantiateIdProvider } from "../engine/engine_networking_instantiate";
 import * as def from "./engine_networking_files_default_components"
 import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader.js'
+import { getLoader } from "../engine/engine_gltf";
+import { IModel } from "./engine_networking_types";
+import { IGameObject } from "./engine_types";
+import { findByGuid } from "./engine_gameobject";
 
 export enum File_Event {
     File_Spawned = "file-spawned",
@@ -50,9 +53,9 @@ export async function addFile(file: File, context: Context, backendUrl?: string)
                 // first load it locally
                 const seed = generateSeed();
                 const prov = new InstantiateIdProvider(seed);
-                const gltf: GLTF = await loadSync(context, content, prov, true) as GLTF;
+                const gltf: GLTF = await getLoader().loadSync(context, content, prov, true) as GLTF;
                 if (gltf && gltf.scene) {
-                    const obj = gltf.scene as unknown as GameObject;
+                    const obj = gltf.scene as unknown as IGameObject;
                     // if we dont have a guid yet (because components guids are actually created in a callback a bit later)
                     // we just use the same seed and generate a guid for the root only
                     // this should be the exact same guid the instantiate call will produce
@@ -81,9 +84,9 @@ export async function addFileFromUrl(url: URL, context: Context): Promise<GLTF |
     return new Promise(async (resolve, _reject) => {
         const seed = generateSeed();
         const prov = new InstantiateIdProvider(seed);
-        const gltf: GLTF = await loadSync(context, url.toString(), prov, true) as GLTF;
+        const gltf: GLTF = await getLoader().loadSync(context, url.toString(), prov, true) as GLTF;
         if (gltf && gltf.scene) {
-            const obj = gltf.scene as unknown as GameObject;
+            const obj = gltf.scene as unknown as IGameObject;
             // handleUpload(context.connection, file, seed, obj); // TODO needs to upload the URL only and store that
             def.onDynamicObjectAdded(obj, prov, gltf);
             resolve(gltf);
@@ -108,7 +111,7 @@ export function beginListenFileSpawn(context: Context) {
             }
             if (bin) {
                 const prov = new InstantiateIdProvider(evt.seed);
-                const gltf = await parseSync(context, bin, null!, prov);
+                const gltf = await getLoader().parseSync(context, bin, null!, prov);
                 if (gltf && gltf.scene) {
                     const obj = gltf.scene;
                     def.onDynamicObjectAdded(obj, prov, gltf);
@@ -118,7 +121,7 @@ export function beginListenFileSpawn(context: Context) {
 
                     // add object to proper parent
                     if (evt.parentGuid) {
-                        const parent = GameObject.findByGuid(evt.parentGuid, context.scene) as THREE.Object3D;
+                        const parent = findByGuid(evt.parentGuid, context.scene) as THREE.Object3D;
                         if ("add" in parent) parent.add(obj);
                     }
                     if (!obj.parent)
@@ -136,7 +139,7 @@ export function beginListenFileSpawn(context: Context) {
 
 
 
-async function handleUpload(connection: NetworkConnection, file: File, seed: number, obj: GameObject, backendUrl: string) {
+async function handleUpload(connection: NetworkConnection, file: File, seed: number, obj: IGameObject, backendUrl: string) {
     if (!connection.connectionId) {
         console.error("Can not upload file - no connection id");
         return;
@@ -180,7 +183,7 @@ function addPreview(evt: FileSpawnModel, context: Context) {
     previews[evt.guid] = box;
     context.scene.add(box);
     if (evt.parentGuid) {
-        const parent = GameObject.findByGuid(evt.parentGuid, context.scene) as THREE.Object3D;
+        const parent = findByGuid(evt.parentGuid, context.scene) as THREE.Object3D;
         if (parent)
             parent.add(box);
     }

package/src/engine/engine_networking_files_default_components.ts

@@ -1,54 +1,55 @@
-import { Behaviour, GameObject, UIDProvider } from "../engine-components/Component";
-import { SyncedTransform } from "../engine-components/SyncedTransform";
-import { DragControls } from "../engine-components/DragControls"
-import { ObjectRaycaster } from "../engine-components/ui/Raycaster";
+// import { SyncedTransform } from "../engine-components/SyncedTransform";
+// import { DragControls } from "../engine-components/DragControls"
+// import { ObjectRaycaster } from "../engine-components/ui/Raycaster";
+import { UIDProvider } from "./engine_types";
 import { GLTF } from "three/examples/jsm/loaders/GLTFLoader";
-import { Animation } from "../engine-components/Animation";
-import { Mesh } from "three";
-
-
-export function onDynamicObjectAdded(obj: THREE.Object3D, idProv: UIDProvider, gltf?: GLTF) {
-
-    // this ensures we have a drag component
-    let drag = GameObject.getComponentInChildren(obj as GameObject, DragControls);
-    if (!drag) {
-        drag = GameObject.addNewComponent(obj as GameObject, DragControls, false);
-        drag.guid = idProv.generateUUID();
-    }
-
-    // if a drag component is found we add a syncedTransform if none exists
-    if (drag && !GameObject.getComponent(drag.gameObject, SyncedTransform)) {
-        const st = GameObject.addNewComponent(drag.gameObject, SyncedTransform, false);
-        st.guid = idProv.generateUUID();
-        // st.autoOwnership = true;
-
-        //drag.transformGroup = true;
-        //drag.targets = [obj];
-    }
-
-    // if a drag component is found we add a syncedTransform if none exists
-    if (drag && !GameObject.getComponentInParent(drag.gameObject, ObjectRaycaster)) {
-        const st = GameObject.addNewComponent(drag.gameObject, ObjectRaycaster, false);
-        st.guid = idProv.generateUUID();
-    }
-
-    if (gltf) {
-        if (gltf.animations?.length > 0) {
-            const firstAnimation = gltf.animations[0];
-            const anim = GameObject.addNewComponent(obj, Animation, false);
-            anim.animations = [firstAnimation];
-        }
-    }
-
-    let didDisablFrustumCulling = false;
-    obj.traverse(o => {
-        if (!o) return;
-
-        if (o["isSkinnedMesh"] === true) {
-            if (!didDisablFrustumCulling) console.log("Disabling frustum culling for skinned meshes", gltf);
-            didDisablFrustumCulling = true;
-            o.frustumCulled = false;
-        }
-
-    });
+// import { Animation } from "../engine-components/Animation";
+
+
+export function onDynamicObjectAdded(_obj: THREE.Object3D, _idProv: UIDProvider, _gltf?: GLTF) {
+
+    console.warn("Adding components on object has been temporarily disabled");
+    
+    // // this ensures we have a drag component
+    // let drag = getComponentInChildren(obj as GameObject, DragControls);
+    // if (!drag) {
+    //     drag = GameObject.addNewComponent(obj as GameObject, DragControls, false);
+    //     drag.guid = idProv.generateUUID();
+    // }
+
+    // // if a drag component is found we add a syncedTransform if none exists
+    // if (drag && !GameObject.getComponent(drag.gameObject, SyncedTransform)) {
+    //     const st = GameObject.addNewComponent(drag.gameObject, SyncedTransform, false);
+    //     st.guid = idProv.generateUUID();
+    //     // st.autoOwnership = true;
+
+    //     //drag.transformGroup = true;
+    //     //drag.targets = [obj];
+    // }
+
+    // // if a drag component is found we add a syncedTransform if none exists
+    // if (drag && !GameObject.getComponentInParent(drag.gameObject, ObjectRaycaster)) {
+    //     const st = GameObject.addNewComponent(drag.gameObject, ObjectRaycaster, false);
+    //     st.guid = idProv.generateUUID();
+    // }
+
+    // if (gltf) {
+    //     if (gltf.animations?.length > 0) {
+    //         const firstAnimation = gltf.animations[0];
+    //         const anim = GameObject.addNewComponent(obj, Animation, false);
+    //         anim.animations = [firstAnimation];
+    //     }
+    // }
+
+    // let didDisablFrustumCulling = false;
+    // obj.traverse(o => {
+    //     if (!o) return;
+
+    //     if (o["isSkinnedMesh"] === true) {
+    //         if (!didDisablFrustumCulling) console.log("Disabling frustum culling for skinned meshes", gltf);
+    //         didDisablFrustumCulling = true;
+    //         o.frustumCulled = false;
+    //     }
+
+    // });
 }

package/src/engine/engine_networking_instantiate.ts

@@ -1,17 +1,27 @@
-import { IModel, NetworkConnection } from "./engine_networking"
+// import { IModel, NetworkConnection } from "./engine_networking"
 import * as THREE from "three";
 import { Context } from "./engine_setup"
-import { Behaviour, Component, GameObject, InstantiateOptions, UIDProvider } from "../engine-components/Component";
 import * as utils from "./engine_utils"
-const debug = utils.getParam("debugcomponents");
+import { INetworkConnection } from "./engine_networking_types";
+import { IGameObject as GameObject, IComponent as Component } from "./engine_types"
 
 // https://github.com/uuidjs/uuid
 // v5 takes string and namespace
 import { v5, v1 } from 'uuid';
+import { UIDProvider } from "./engine_types";
+import { IModel } from "./engine_networking_types";
+import { SendQueue } from "./engine_networking_types";
+import { destroy, findByGuid, instantiate } from "./engine_gameobject";
 import { Object3D } from "three";
-const ID_NAMESPACE = 'eff8ba80-635d-11ec-90d6-0242ac120003';
+import { InstantiateOptions } from "./engine_gameobject";
+
+
+const debug = utils.getParam("debugcomponents");
+
 
 
+const ID_NAMESPACE = 'eff8ba80-635d-11ec-90d6-0242ac120003';
+
 export class InstantiateIdProvider implements UIDProvider {
 
     get seed() {
@@ -63,10 +73,10 @@ export interface IBeforeNetworkedDestroy {
     onBeforeNetworkedDestroy(networkIds: string[]): void;
 }
 
-export function syncDestroy(obj: GameObject | Component, con: NetworkConnection, recursive: boolean = true) {
+export function syncDestroy(obj: GameObject | Component, con: INetworkConnection, recursive: boolean = true) {
     if (!obj) return;
     const go = obj as GameObject;
-    GameObject.destroy(obj, recursive);
+    destroy(obj, recursive);
 
     if (!con) {
         console.warn("Can not send destroy: No networking connection provided", obj.guid);
@@ -88,12 +98,12 @@ export function syncDestroy(obj: GameObject | Component, con: NetworkConnection,
     }
 
     const model = new DestroyInstanceModel(guid);
-    con.send(InstantiateEvent.InstanceDestroyed, model);
+    con.send(InstantiateEvent.InstanceDestroyed, model, SendQueue.Queued);
 }
 
-export function sendDestroyed(guid: string, con: NetworkConnection) {
+export function sendDestroyed(guid: string, con: INetworkConnection) {
     const model = new DestroyInstanceModel(guid);
-    con.send(InstantiateEvent.InstanceDestroyed, model);
+    con.send(InstantiateEvent.InstanceDestroyed, model, SendQueue.Queued);
 }
 
 export function beginListenDestroy(context: Context) {
@@ -101,8 +111,8 @@ export function beginListenDestroy(context: Context) {
         if (debug)
             console.log("[Remote] Destroyed", context.scene, data);
         // TODO: create global lookup table for guids
-        const obj = GameObject.findByGuid(data.guid, context.scene);
-        if (obj) GameObject.destroy(obj);
+        const obj = findByGuid(data.guid, context.scene);
+        if (obj) destroy(obj);
     });
 }
 
@@ -140,7 +150,7 @@ class NewInstanceModel implements IModel {
     }
 }
 
-export function syncInstantiate(object: GameObject | THREE.Object3D, opts: InstantiateOptions, hostData?: HostData, save?: boolean): GameObject | null {
+export function syncInstantiate(object: GameObject | Object3D, opts: InstantiateOptions, hostData?: HostData, save?: boolean): GameObject | null {
 
     const obj: GameObject = object as GameObject;
 
@@ -226,7 +236,7 @@ export function beginListenInstantiate(context: Context) {
         options.context = context;
         if (debug && context.alias)
             console.log("[Remote] instantiate in: " + context.alias);
-        const inst = GameObject.instantiate(obj as GameObject, options);
+        const inst = instantiate(obj as GameObject, options);
 
         if (inst) {
             if (model.parent === "scene")
@@ -247,7 +257,7 @@ function instantiateSeeded(obj: GameObject, opts: InstantiateOptions | null): {
     const seed = generateSeed();
     const options = opts ?? new InstantiateOptions();
     options.idProvider = new InstantiateIdProvider(seed);
-    const instance = GameObject.instantiate(obj, options);
+    const instance = instantiate(obj, options);
     return { seed: seed, instance: instance };
 }
 

package/src/engine/engine_networking_types.ts

@@ -0,0 +1,19 @@
+export declare interface IModel {
+    guid: string;
+    dontSave?: boolean; // if set to true the model will not be saved in the server room state
+}
+
+
+export enum SendQueue {
+    OnConnection,
+    OnRoomJoin,
+    Queued,
+    Immediate,
+}
+
+export declare interface INetworkConnection {
+    get isConnected(): boolean;
+
+    send(key: string, data: IModel | object | boolean | null | string | number, queue: SendQueue): unknown;
+
+}

package/src/engine/engine_physics.ts

@@ -2,14 +2,23 @@ import * as CANNON from 'cannon-es'
 import * as THREE from 'three'
 import { Context } from './engine_setup';
 import cannonDebugger from 'cannon-es-debugger'
-import { Rigidbody } from '../engine-components/Rigidbody';
 import * as utils from "./engine_utils"
 import * as threeutils from "./engine_three_utils"
-import { Behaviour, Component, GameObject } from '../engine-components/Component';
-import { Body, RigidVehicle, Shape, Vec3 } from 'cannon-es';
-import { Matrix4, Object3D, RGBA_BPTC_Format, Vector3, Wrapping } from 'three';
-import { Collider } from '../engine-components/Collider';
+import {
+    IComponent as Component,
+    IGameObject as GameObject,
+    ICollider,
+    IRigidbody as Rigidbody, $physicsKey,
+    Collision, CannonCollision,
+    ICollisionContext,
+    IComponent
+}
+    from './engine_types';
+import { Shape } from 'cannon-es';
 import { InstancingUtil } from './engine_instancing';
+import { foreachComponent } from './engine_gameobject';
+import { getComponentInChildren } from './engine_components';
+
 
 const debugPhysics = utils.getParam("debugphysics");
 const debugCollisions = utils.getParam("debugcollisions");
@@ -23,7 +32,6 @@ export class BodyOptions {
     sleepThreshold: number = .01;
 }
 
-const bodyObjectKey = Symbol("object");
 
 // TODO: refactor to return some kind of handle for adding/removing
 class PhysicsObject {
@@ -41,17 +49,10 @@ class PhysicsObject {
         this.parent = obj.parent;
         this.body = body;
         if (this.body)
-            this.body[bodyObjectKey] = obj;
+            this.body[$physicsKey] = obj;
     }
 }
 
-declare type CannonCollision = {
-    body: CANNON.Body;
-    contact: CANNON.ContactEquation;
-    target: CANNON.Body;
-    type: string;
-}
-
 export class RaycastOptions {
     ray: THREE.Ray | undefined = undefined;
     cam: THREE.Camera | undefined | null = undefined;
@@ -645,18 +646,20 @@ export class Physics {
         // console.log("START");
     }
 
+    private readonly collisionContext: ICollisionContext = new CollisionContext();
+
     private raiseCollisionEvents(obj: THREE.Object3D, event: CannonCollision) {
-        const collision = new Collision(obj, event);
+        const collision = new Collision(obj, event, this.collisionContext);
         if (debugCollisions)
             console.log("collision between", event.contact.bi, event.contact.bj, obj, event);
-        GameObject.foreachComponent(obj, (c: Component) => {
+        foreachComponent(obj, (c: Component) => {
             c.__internalHandleCollision(collision, false);
         });
 
         // handle triggers
         if (collision.collider && !collision.collider.attachedRigidbody && collision.collider.isTrigger) {
-            const collision2 = new Collision(collision.gameObject, event, true);
-            GameObject.foreachComponent(collision.gameObject, (c: Component) => {
+            const collision2 = new Collision(collision.gameObject, event, this.collisionContext, true);
+            foreachComponent(collision.gameObject, (c: Component) => {
                 c.__internalHandleCollision(collision2, true);
             });
         }
@@ -665,76 +668,41 @@ export class Physics {
     private onEndContact(args: { bodyA: CANNON.Body, bodyB: CANNON.Body }) {
         // if(args.bodyB.sleepState !== CANNON.Body.AWAKE) return;
         // console.log("END", CANNON.BODY_SLEEP_STATES, args.bodyB.sleepState);
-        const obj1 = args.bodyA[bodyObjectKey];
-        const obj2 = args.bodyB[bodyObjectKey];
+        const obj1 = args.bodyA[$physicsKey];
+        const obj2 = args.bodyB[$physicsKey];
         // console.log(obj2);
-        GameObject.foreachComponent(obj2, (c: Component) => {
+
+        foreachComponent(obj2, (c: Component) => {
             c.__internalHandleExitCollisionEvent(obj1, false);
         });
 
-        const collider = GameObject.getComponent(obj1, Collider);
-        if (collider && !collider.attachedRigidbody && collider.isTrigger) {
-            
-            GameObject.foreachComponent(collider.gameObject, (c: Component) => {
-                c.__internalHandleExitCollisionEvent(obj2, true);
-            });
-        }
+        // TODO: stop iterating when we found the collider
+        foreachComponent(obj1, c => {
+            const collider = c as ICollider;
+            if (collider.isCollider && !collider.attachedRigidbody && collider.isTrigger) {
+                foreachComponent(collider.gameObject, (c: Component) => {
+                    c.__internalHandleExitCollisionEvent(obj2, true);
+                });
+            }
+        });
     }
 
 }
 
+export interface IColliderProvider {
+    getCollider(obj: THREE.Object3D): ICollider;
+}
 
-export class Collision {
-
-    get __internalCollision(): CannonCollision {
-        return this.collision;
-    }
-
-    get __internalInvertedSourceReceiver(): boolean {
-        return this.invert;
-    }
-
-    private readonly invert: boolean;
-    private readonly collision: CannonCollision;
-    private readonly targetBody: CANNON.Body;
+let colliderProvider: IColliderProvider | null = null;
+export function registerColliderProvider(prov: IColliderProvider) {
+    colliderProvider = prov;
+}
 
-    readonly me: Object3D;
+class CollisionContext implements ICollisionContext {
 
-    private _normal?: Vector3;
-    get normal(): Vector3 {
-        if (!this._normal) {
-            const vec = this.collision.contact.ni;
-            this._normal = new Vector3(vec.x, vec.y, vec.z);
-        }
-        return this._normal;
-    }
-
-    private _collider?: Collider;
-    get collider(): Collider {
-        if (this._collider === undefined) {
-            this._collider = GameObject.getComponentInChildren(this.gameObject, Collider)!;
-        }
-        return this._collider;
+    getCollider(obj: THREE.Object3D<THREE.Event>): ICollider {
+        return colliderProvider!.getCollider(obj);
     }
 
-    get gameObject(): Object3D {
-        return this.targetBody[bodyObjectKey];
-    }
-
-    // private _point?: Vector3;
-    // get point(): Vector3 {
-    //     if (!this._point) {
-    //         const c = this.collision.contact;
-    //         const point = c.bi.position.clone().vadd(c.ri);
-    //         this._point = new Vector3(point.x, point.y, point.z);
-    //     }
-    //     return this._point;
-    // }
+}
 
-    constructor(obj: Object3D, collision: CannonCollision, invert: boolean = false) {
-        this.invert = invert;
-        this.me = obj;
-        this.collision = collision;
-        this.targetBody = this.invert ? collision.target : collision.body;
-    }
-}

package/src/engine/engine_rendererdata.ts

@@ -1,10 +1,10 @@
-import { SourceIdentifier } from "./engine_gltf";
 import { Vector4, EquirectangularReflectionMapping, sRGBEncoding, WebGLCubeRenderTarget, Texture, LightProbe, Color } from "three";
 import { LightProbeGenerator } from "three/examples/jsm/lights/LightProbeGenerator.js"
 import { Context } from "./engine_setup";
 import { SceneLightSettings } from "./extensions/NEEDLE_lighting_settings";
 import { createFlatTexture, createTrilightTexture } from "./engine_shaders";
 import { getParam } from "./engine_utils";
+import { SourceIdentifier } from "./engine_types";
 
 const debug = getParam("debugenvlight");
 

package/src/engine/engine_scenetools.ts

@@ -2,12 +2,36 @@ import { Context } from "./engine_setup"
 import { Animator } from '../engine-components/Animator';
 import { Animation } from '../engine-components/Animation';
 import { GLTF, GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js'
-import * as object from "./engine_gltf_builtin_components";
+// import * as object from "./engine_gltf_builtin_components";
 import * as loaders from "./engine_loaders"
-import { GameObject, UIDProvider } from "../engine-components/Component";
 import * as utils from "./engine_utils";
 import { registerComponentExtension, registerExtensions } from "./extensions/extensions";
-import { SourceIdentifier } from "./engine_gltf";
+import { getLoader, INeedleGltfLoader, registerLoader } from "./engine_gltf";
+import { SourceIdentifier, UIDProvider } from "./engine_types";
+import { createBuiltinComponents, writeBuiltinComponentData } from "./engine_gltf_builtin_components";
+import { SerializationContext } from "./engine_serialization_core";
+import { NEEDLE_components } from "./extensions/NEEDLE_components";
+import { addNewComponentInstance, getComponentInChildren } from "./engine_components";
+
+
+class NeedleGltfLoader implements INeedleGltfLoader {
+    createBuiltinComponents(context: Context, gltfId: string, gltf: any, seed: number | UIDProvider | null, extension?: NEEDLE_components | undefined) {
+        return createBuiltinComponents(context, gltfId, gltf, seed, extension);
+    }
+
+    writeBuiltinComponentData(comp: any, context: SerializationContext) {
+        return writeBuiltinComponentData(comp, context);
+    }
+
+    parseSync(context: Context, data, path: string, seed: number | UIDProvider | null): Promise<GLTF | undefined> {
+        return parseSync(context, data, path, seed);
+    }
+    loadSync(context: Context, url: string, seed: number | UIDProvider | null, _allowAddingAnimator: boolean, prog?: ((ProgressEvent: any) => void) | undefined): Promise<GLTF | undefined> {
+        return loadSync(context, url, seed, _allowAddingAnimator, prog);
+    }
+}
+
+registerLoader(new NeedleGltfLoader());
 
 
 const printGltf = utils.getParam("printGltf");
@@ -64,7 +88,7 @@ async function handleLoadedGltf(context: Context, gltfId: string, gltf, seed: nu
     if (printGltf)
         console.log(gltf);
     await context.assets.registerGltf(gltf);
-    await object.createBuiltinComponents(context, gltfId, gltf, seed, componentsExtension);
+    await getLoader().createBuiltinComponents(context, gltfId, gltf, seed, componentsExtension);
 
     // load and assign animation
     // we still need this for Animation component
@@ -151,7 +175,7 @@ export function findAnimations(gltf: GLTF, allowAddingAnimator: boolean = false)
     if (!allowAddingAnimator) {
         // we only need to search if any animation component is in the scene
         // otherwise if we dont add anything there is no reason to search and log anything
-        if (!GameObject.getComponentInChildren(gltf.scene, Animation)) return;
+        if (!getComponentInChildren(gltf.scene, Animation)) return;
     }
 
     for (let i = 0; i < gltf.animations.length; i++) {
@@ -168,7 +192,7 @@ export function findAnimations(gltf: GLTF, allowAddingAnimator: boolean = false)
             let animationComponent = findAnimationGameObjectInParent(obj);
             if (!animationComponent) {
                 if (allowAddingAnimator)
-                    animationComponent = GameObject.addNewComponent(gltf.scene, Animation);
+                    animationComponent = addNewComponentInstance(gltf.scene, new Animation());
                 else {
                     console.warn("Failed finding animator for", track.name, objectName);
                     continue;

package/src/engine/engine_serialization_core.ts

@@ -3,7 +3,7 @@ import { getParam } from "./engine_utils";
 import { Object3D } from "three";
 import { Context } from "./engine_setup";
 import { isPersistentAsset } from "./extensions/NEEDLE_persistent_assets";
-import { SourceIdentifier } from "./engine_gltf";
+import { SourceIdentifier } from "./engine_types";
 import { debugExtension } from "../engine/engine_default_parameters";
 
 const debug = getParam("debugserializer");

package/src/engine/engine_serialization_decorator.ts

@@ -1,4 +1,4 @@
-import { Constructor } from "../engine-components/Component"
+import { Constructor } from "./engine_types";
 
 export declare type TypeResolver<T> = (data) => Constructor<T> | null;