@needle-tools/engine 3.28.6-beta → 3.28.7-beta.1

package/src/engine-components/Component.ts

@@ -1,670 +1,670 @@
-import { Mathf } from "../engine/engine_math.js";
-import * as threeutils from "../engine/engine_three_utils.js";
-import { activeInHierarchyFieldName } from "../engine/engine_constants.js";
-import { Context, FrameEvent } from "../engine/engine_setup.js";
-import * as main from "../engine/engine_mainloop_utils.js";
-import { syncDestroy, syncInstantiate } from "../engine/engine_networking_instantiate.js";
-import type { ConstructorConcrete, SourceIdentifier, IComponent, IGameObject, Constructor, GuidsMap, Collision, ICollider } from "../engine/engine_types.js";
-import { addNewComponent, destroyComponentInstance, findObjectOfType, findObjectsOfType, getComponent, getComponentInChildren, getComponentInParent, getComponents, getComponentsInChildren, getComponentsInParent, getOrAddComponent, moveComponentInstance, removeComponent } from "../engine/engine_components.js";
-import { findByGuid, destroy, InstantiateOptions, instantiate, HideFlags, foreachComponent, markAsInstancedRendered, isActiveInHierarchy, isActiveSelf, isUsingInstancing, setActive, isDestroyed } from "../engine/engine_gameobject.js";
-
-import { Euler, Object3D, Quaternion, Scene, Vector3 } from "three";
-import { showBalloonWarning, isDevEnvironment } from "../engine/debug/index.js";
-
-// export interface ISerializationCallbackReceiver {
-//     onBeforeSerialize?(): object | void;
-//     onAfterSerialize?();
-//     onBeforeDeserialize?(data?: any);
-//     onAfterDeserialize?();
-//     onDeserialize?(key: string, value: any): any | void;
-// }
-
-export abstract class GameObject extends Object3D implements Object3D, IGameObject {
-
-    guid: string | undefined;
-
-    // Added to the threejs Object3D prototype
-    abstract destroy();
-
-    public static isDestroyed(go: Object3D): boolean {
-        return isDestroyed(go);
-    }
-
-    public static setActive(go: Object3D, active: boolean, processStart: boolean = true) {
-        if (!go) return;
-        setActive(go, active);
-
-        // TODO: do we still need this?:
-        main.updateIsActive(go);
-        if (active && processStart)
-            main.processStart(Context.Current, go);
-    }
-
-    /** If the object is active (same as go.visible) */
-    public static isActiveSelf(go: Object3D): boolean {
-        return isActiveSelf(go);
-    }
-
-    /** If the object is active in the hierarchy (e.g. if any parent is invisible or not in the scene it will be false) 
-     * @param go object to check
-    */
-    public static isActiveInHierarchy(go: Object3D): boolean {
-        return isActiveInHierarchy(go);
-    }
-
-    public static markAsInstancedRendered(go: Object3D, instanced: boolean) {
-        markAsInstancedRendered(go, instanced);
-    }
-
-    public static isUsingInstancing(instance: Object3D): boolean { return isUsingInstancing(instance); }
-
-    /** Run a callback for all components of the provided type on the provided object and its children (if recursive is true)
-     * @param instance object to run the method on
-     * @param cb callback to run on each component, "return undefined;" to continue and "return <anything>;" to break the loop
-     * @param recursive if true, the method will be run on all children as well
-     * @returns the last return value of the callback
-     */
-    public static foreachComponent(instance: Object3D, cb: (comp: Component) => any, recursive: boolean = true): any {
-        return foreachComponent(instance, cb as (comp: IComponent) => any, recursive);
-    }
-
-    /** Creates a new instance of the provided object. The new instance will be created on all connected clients 
-     * @param instance object to instantiate
-     * @param opts options for the instantiation
-     */
-    public static instantiateSynced(instance: GameObject | Object3D | null, opts: InstantiateOptions): GameObject | null {
-        if (!instance) return null;
-        return syncInstantiate(instance as any, opts) as GameObject | null;
-    }
-
-    /** Creates a new instance of the provided object (like cloning it including all components and children) 
-     * @param instance object to instantiate
-     * @param opts options for the instantiation (e.g. with what parent, position, etc.)
-    */
-    public static instantiate(instance: GameObject | Object3D | null, opts: InstantiateOptions | null = null): GameObject | null {
-        return instantiate(instance, opts) as GameObject | null;
-    }
-
-    /** Destroys a object on all connected clients (if you are in a networked session) 
-     * @param instance object to destroy
-    */
-    public static destroySynced(instance: Object3D | Component, context?: Context, recursive: boolean = true) {
-        if (!instance) return;
-        const go = instance as GameObject;
-        context = context ?? Context.Current;
-        syncDestroy(go as any, context.connection, recursive);
-    }
-
-    /** Destroys a object
-     * @param instance object to destroy
-     * @param recursive if true, all children will be destroyed as well. true by default
-     */
-    public static destroy(instance: Object3D | Component, recursive: boolean = true, isRoot: boolean = true) {
-        return destroy(instance, recursive, isRoot);
-    }
-
-    /**
-     * Add an object to parent and also ensure all components are being registered
-     */
-    public static add(instance: Object3D | null | undefined, parent: Object3D, context?: Context) {
-        if (!instance || !parent) return;
-        if (instance === parent) {
-            console.warn("Can not add object to self", instance);
-            return;
-        }
-        if (!context) {
-            context = Context.Current;
-        }
-        parent.add(instance);
-        setActive(instance, true);
-        main.updateIsActive(instance);
-        if (context) {
-            GameObject.foreachComponent(instance, (comp: Component) => {
-                main.addScriptToArrays(comp, context!);
-                if (comp.__internalDidAwakeAndStart) return;
-                if (context!.new_script_start.includes(comp) === false) {
-                    context!.new_script_start.push(comp as Behaviour);
-                }
-            }, true);
-        }
-        else {
-            console.warn("Missing context");
-        }
-    }
-
-    /**
-     * Removes the object from its parent and deactivates all of its components
-     */
-    public static remove(instance: Object3D | null | undefined) {
-        if (!instance) return;
-        instance.parent?.remove(instance);
-        setActive(instance, false);
-        main.updateIsActive(instance);
-        GameObject.foreachComponent(instance, (comp) => {
-            main.processRemoveFromScene(comp);
-        }, true);
-    }
-
-    /** Invokes a method on all components including children (if a method with that name exists) */
-    public static invokeOnChildren(go: Object3D | null | undefined, functionName: string, ...args: any) {
-        this.invoke(go, functionName, true, args);
-    }
-
-    /** Invokes a method on all components that have a method matching the provided name
-     * @param go object to invoke the method on all components
-     * @param functionName name of the method to invoke
-     */
-    public static invoke(go: Object3D | null | undefined, functionName: string, children: boolean = false, ...args: any) {
-        if (!go) return;
-        this.foreachComponent(go, c => {
-            const fn = c[functionName];
-            if (fn && typeof fn === "function") {
-                fn?.call(c, ...args)
-            }
-        }, children);
-    }
-
-    /**
-     * Adds a new component to the provided object
-     * @param go object to add the component to
-     * @param type type of the component to add
-     * @param callAwake if true, the component will be added and awake will be called immediately
-     */
-    public static addNewComponent<T>(go: IGameObject | Object3D, type: ConstructorConcrete<T>, callAwake: boolean = true): T {
-        const instance = new type();
-        //@ts-ignore
-        addNewComponent(go, instance, callAwake);
-        return instance
-    }
-
-    /**
-     * Moves a component to a new object  
-     * BEWARE: this does MOVE a component. If you want to add a new component use `addNewComponent`  
-     * @param go component to move the component to
-     * @param instance component to move to the GO
-     */
-    public static addComponent<T extends IComponent>(go: IGameObject | Object3D, instance: T | ConstructorConcrete<T>) {
-        return this.moveComponent(go, instance);
-    }
-
-    /**
-     * Moves a component to a new object  
-     * @param go component to move the component to
-     * @param instance component to move to the GO
-     */
-    public static moveComponent<T extends IComponent>(go: IGameObject | Object3D, instance: T | ConstructorConcrete<T>) {
-        return moveComponentInstance(go, instance);
-    }
-
-    /** Removes a component from its object
-     * @param instance component to remove
-     */
-    public static removeComponent<T extends IComponent>(instance: T): T {
-        removeComponent(instance.gameObject, instance as any);
-        return instance;
-    }
-
-    public static getOrAddComponent<T extends IComponent>(go: IGameObject | Object3D, typeName: ConstructorConcrete<T>): T {
-        return getOrAddComponent<any>(go, typeName);
-    }
-
-    /** Gets a component on the provided object */
-    public static getComponent<T extends IComponent>(go: IGameObject | Object3D | null, typeName: Constructor<T> | null): T | null {
-        if (go === null) return null;
-        // if names are minified we could also use the type store and work with strings everywhere
-        // not ideal, but I dont know a good/sane way to do this otherwise
-        // const res = TypeStore.get(typeName);
-        // if(res) typeName = res;
-        return getComponent(go, typeName as any);
-    }
-
-    public static getComponents<T extends IComponent>(go: IGameObject | Object3D | null, typeName: Constructor<T>, arr: T[] | null = null): T[] {
-        if (go === null) return arr ?? [];
-        return getComponents(go, typeName, arr);
-    }
-
-    public static findByGuid(guid: string, hierarchy: Object3D): GameObject | Component | null | undefined {
-        const res = findByGuid(guid, hierarchy);
-        return res as GameObject | Component | null | undefined;
-    }
-
-    public static findObjectOfType<T extends IComponent>(typeName: Constructor<T>, context?: Context | Object3D, includeInactive: boolean = true): T | null {
-        return findObjectOfType(typeName, context ?? Context.Current, includeInactive);
-    }
-
-    public static findObjectsOfType<T extends IComponent>(typeName: Constructor<T>, context?: Context | Object3D): Array<T> {
-        const arr = [];
-        findObjectsOfType(typeName, arr, context);
-        return arr;
-    }
-
-    public static getComponentInChildren<T extends IComponent>(go: IGameObject | Object3D, typeName: Constructor<T>): T | null {
-        return getComponentInChildren(go, typeName);
-    }
-
-    public static getComponentsInChildren<T extends IComponent>(go: IGameObject | Object3D, typeName: Constructor<T>, arr: T[] | null = null): Array<T> {
-        return getComponentsInChildren<T>(go, typeName, arr ?? undefined) as T[]
-    }
-
-    public static getComponentInParent<T extends IComponent>(go: IGameObject | Object3D, typeName: Constructor<T>): T | null {
-        return getComponentInParent(go, typeName);
-    }
-
-    public static getComponentsInParent<T extends IComponent>(go: IGameObject | Object3D, typeName: Constructor<T>, arr: Array<T> | null = null): Array<T> {
-        return getComponentsInParent(go, typeName, arr);
-    }
-
-    public static getAllComponents(go: IGameObject | Object3D): Behaviour[] {
-        const componentsList = go.userData?.components;
-        const newList = [...componentsList];
-        return newList;
-    }
-
-    public static *iterateComponents(go: IGameObject | Object3D) {
-        const list = go?.userData?.components;
-        if (list && Array.isArray(list)) {
-            for (let i = 0; i < list.length; i++) {
-                yield list[i];
-            }
-        }
-    }
-
-    // these are implemented via threejs object extensions
-    abstract activeSelf: boolean;
-
-    // The actual implementation / prototype of threejs is modified in js-extensions/Object3D
-    abstract get transform(): GameObject;
-
-    /** creates a new component on this gameObject */
-    abstract addNewComponent<T>(type: ConstructorConcrete<T>): T | null;
-    /** adds an existing component to this gameObject */
-    abstract addComponent<T extends IComponent>(comp: T | ConstructorConcrete<T>): void;
-    abstract removeComponent(comp: Component): Component;
-    abstract getOrAddComponent<T>(typeName: ConstructorConcrete<T> | null): T;
-    abstract getComponent<T>(type: Constructor<T>): T | null;
-    abstract getComponents<T>(type: Constructor<T>, arr?: T[]): Array<T>;
-    abstract getComponentInChildren<T>(type: Constructor<T>): T | null;
-    abstract getComponentsInChildren<T>(type: Constructor<T>, arr?: T[]): Array<T>;
-    abstract getComponentInParent<T>(type: Constructor<T>): T | null;
-    abstract getComponentsInParent<T>(type: Constructor<T>, arr?: T[]): Array<T>;
-
-
-    abstract get worldPosition(): Vector3
-    abstract set worldPosition(val: Vector3);
-    abstract set worldQuaternion(val: Quaternion);
-    abstract get worldQuaternion(): Quaternion;
-    abstract set worldRotation(val: Vector3);
-    abstract get worldRotation(): Vector3;  
-    abstract set worldScale(val: Vector3);
-    abstract get worldScale(): Vector3;
-
-    abstract get worldForward(): Vector3;
-    abstract get worldRight(): Vector3;
-    abstract get worldUp(): Vector3;
-}
-
-
-
-export class Component implements IComponent, EventTarget {
-
-    get isComponent(): boolean { return true; }
-
-    private __context: Context | undefined;
-    get context(): Context {
-        return this.__context ?? Context.Current;
-    }
-    set context(context: Context) {
-        this.__context = context;
-    }
-    get scene(): Scene { return this.context.scene; }
-
-    get layer(): number {
-        return this.gameObject?.userData?.layer;
-    }
-
-    get name(): string {
-        if (this.gameObject?.name) {
-            return this.gameObject.name;
-        }
-        return this.gameObject?.userData.name;
-    }
-    private __name?: string;
-    set name(str: string) {
-        if (this.gameObject) {
-            if (!this.gameObject.userData) this.gameObject.userData = {}
-            this.gameObject.userData.name = str;
-            this.__name = str;
-        }
-        else {
-            this.__name = str;
-        }
-    }
-    get tag(): string {
-        return this.gameObject?.userData.tag;
-    }
-    set tag(str: string) {
-        if (this.gameObject) {
-            if (!this.gameObject.userData) this.gameObject.userData = {}
-            this.gameObject.userData.tag = str;
-        }
-    }
-    get static() {
-        return this.gameObject?.userData.static;
-    }
-    get hideFlags(): HideFlags {
-        return this.gameObject?.userData.hideFlags;
-    }
-
-
-    get activeAndEnabled(): boolean {
-        if (this.destroyed) return false;
-        if (this.__isEnabled === false) return false;
-        if (!this.__isActiveInHierarchy) return false;
-        // let go = this.gameObject;
-        // do {
-        //     // console.log(go.name, go.visible)
-        //     if (!go.visible) return false;
-        //     go = go.parent as GameObject;
-        // }
-        // while (go);
-        return true;
-    }
-
-    private get __isActive(): boolean {
-        return this.gameObject.visible;
-    }
-    private get __isActiveInHierarchy(): boolean {
-        if (!this.gameObject) return false;
-        const res = this.gameObject[activeInHierarchyFieldName];
-        if (res === undefined) return true;
-        return res;
-    }
-
-    private set __isActiveInHierarchy(val: boolean) {
-        if (!this.gameObject) return;
-        this.gameObject[activeInHierarchyFieldName] = val;
-    }
-
-    gameObject!: GameObject;
-    guid: string = "invalid";
-    sourceId?: SourceIdentifier;
-    // transform: Object3D = nullObject;
-
-    /** called on a component with a map of old to new guids (e.g. when instantiate generated new guids and e.g. timeline track bindings needs to remape them) */
-    resolveGuids?(guidsMap: GuidsMap): void;
-
-    /** called once when the component becomes active for the first time */
-    awake() { }
-    /** called every time when the component gets enabled (this is invoked after awake and before start) */
-    onEnable() { }
-    onDisable() { }
-    onDestroy() {
-        this.__destroyed = true;
-    }
-    /** called when you decorate fields with the @validate() decorator
-     * @param field the name of the field that was changed
-     */
-    onValidate?(prop?: string): void;
-
-    /** Called for all scripts when the context gets paused or unpaused */
-    onPausedChanged?(isPaused: boolean, wasPaused: boolean): void;
-
-    start?(): void;
-    earlyUpdate?(): void;
-    update?(): void;
-    lateUpdate?(): void;
-    onBeforeRender?(frame: XRFrame | null): void;
-    onAfterRender?(): void;
-
-    onCollisionEnter?(col: Collision);
-    onCollisionExit?(col: Collision);
-    onCollisionStay?(col: Collision);
-
-    onTriggerEnter?(col: ICollider);
-    onTriggerStay?(col: ICollider);
-    onTriggerExit?(col: ICollider);
-
-    startCoroutine(routine: Generator, evt: FrameEvent = FrameEvent.Update): Generator {
-        return this.context.registerCoroutineUpdate(this, routine, evt);
-    }
-
-    stopCoroutine(routine: Generator, evt: FrameEvent = FrameEvent.Update): void {
-        this.context.unregisterCoroutineUpdate(routine, evt);
-    }
-
-    public get destroyed(): boolean {
-        return this.__destroyed;
-    }
-
-    public destroy() {
-        if (this.__destroyed) return;
-        this.__internalDestroy();
-    }
-
-
-
-    /** @internal */
-    protected __didAwake: boolean = false;
-
-    /** @internal */
-    private __didStart: boolean = false;
-
-    /** @internal */
-    protected __didEnable: boolean = false;
-
-    /** @internal */
-    protected __isEnabled: boolean | undefined = undefined;
-
-    /** @internal */
-    private __destroyed: boolean = false;
-
-    /** @internal */
-    get __internalDidAwakeAndStart() { return this.__didAwake && this.__didStart; }
-
-
-    /** @internal */
-    constructor() {
-        this.__internalNewInstanceCreated();
-    }
-
-
-    /** @internal */
-    __internalNewInstanceCreated() {
-        this.__didAwake = false;
-        this.__didStart = false;
-        this.__didEnable = false;
-        this.__isEnabled = undefined;
-        this.__destroyed = false;
-    }
-
-
-    /** @internal */
-    __internalAwake() {
-        if (this.__didAwake) return;
-        this.__didAwake = true;
-        this.awake();
-    }
-
-
-    /** @internal */
-    __internalStart() {
-        if (this.__didStart) return;
-        this.__didStart = true;
-        if (this.start) this.start();
-    }
-
-
-    /** @internal */
-    __internalEnable(isAddingToScene?: boolean): boolean {
-        if (this.__destroyed) {
-            if (isDevEnvironment()) {
-                console.warn("[Needle Engine Dev] Trying to enable destroyed component");
-            }
-            return false;
-        }
-        // Don't change enable before awake
-        // But a user can change enable during awake
-        if (!this.__didAwake) return false;
-        if (this.__didEnable) {
-            // We dont want to change the enable state if we are adding to scene
-            // But we want to change the state when e.g. a user changes the enable state during awake
-            if (isAddingToScene !== true)
-                this.__isEnabled = true;
-            return false;
-        }
-        // console.trace("INTERNAL ENABLE");
-        this.__didEnable = true;
-        this.__isEnabled = true;
-        this.onEnable();
-        return true;
-    }
-
-    /** @internal */
-    __internalDisable(isRemovingFromScene?: boolean) {
-        // Don't change enable before awake
-        // But a user can change enable during awake
-        if (!this.__didAwake) return;
-        if (!this.__didEnable) {
-            // We dont want to change the enable state if we are removing from a scene
-            if (isRemovingFromScene !== true)
-                this.__isEnabled = false;
-            return;
-        }
-        this.__didEnable = false;
-        this.__isEnabled = false;
-        this.onDisable();
-    }
-
-    /** @internal */
-    __internalDestroy() {
-        if (this.__destroyed) return;
-        this.__destroyed = true;
-        if (this.__didAwake) {
-            this.onDestroy?.call(this);
-            this.dispatchEvent(new CustomEvent("destroyed", { detail: this }));
-        }
-        destroyComponentInstance(this as any);
-    }
-
-
-    get enabled(): boolean {
-        return typeof this.__isEnabled === "boolean" ? this.__isEnabled : true; // if it has no enabled field it is always enabled
-    }
-    set enabled(val: boolean) {
-        if (this.__destroyed) {
-            if (isDevEnvironment()) {
-                console.warn(`[Needle Engine Dev] Trying to ${val ? "enable" : "disable"} destroyed component`);
-            }
-            return;
-        }
-        // when called from animationclip we receive numbers
-        // due to interpolation they can be anything between 0 and 1
-        if (typeof val === "number") {
-            if (val >= 0.5) val = true;
-            else val = false;
-        }
-
-        // need to check here because codegen is calling this before everything is setup
-        if (!this.__didAwake) {
-            this.__isEnabled = val;
-            return;
-        }
-        if (val) {
-            this.__internalEnable();
-        } else {
-            this.__internalDisable();
-        }
-    }
-
-    get worldPosition(): Vector3 {
-        return threeutils.getWorldPosition(this.gameObject);
-    }
-
-    set worldPosition(val: Vector3) {
-        threeutils.setWorldPosition(this.gameObject, val);
-    }
-
-    setWorldPosition(x: number, y: number, z: number) {
-        threeutils.setWorldPositionXYZ(this.gameObject, x, y, z);
-    }
-
-
-    get worldQuaternion(): Quaternion {
-        return threeutils.getWorldQuaternion(this.gameObject);
-    }
-    set worldQuaternion(val: Quaternion) {
-        threeutils.setWorldQuaternion(this.gameObject, val);
-    }
-    setWorldQuaternion(x: number, y: number, z: number, w: number) {
-        threeutils.setWorldQuaternionXYZW(this.gameObject, x, y, z, w);
-    }
-
-    // world euler (in radians)
-    get worldEuler(): Euler {
-        return threeutils.getWorldEuler(this.gameObject);
-    }
-
-    // world euler (in radians)
-    set worldEuler(val: Euler) {
-        threeutils.setWorldEuler(this.gameObject, val);
-    }
-
-    // returns rotation in degrees
-    get worldRotation(): Vector3 {
-        return this.gameObject.worldRotation;;
-    }
-
-    set worldRotation(val: Vector3) {
-        this.setWorldRotation(val.x, val.y, val.z, true);
-    }
-
-    setWorldRotation(x: number, y: number, z: number, degrees: boolean = true) {
-        threeutils.setWorldRotationXYZ(this.gameObject, x, y, z, degrees);
-    }
-
-    private static _forward: Vector3 = new Vector3();
-    /** Forward (0,0,-1) vector in world space */
-    public get forward(): Vector3 {
-        return Component._forward.set(0, 0, -1).applyQuaternion(this.worldQuaternion);
-    }
-    private static _right: Vector3 = new Vector3();
-    /** Right (1,0,0) vector in world space */
-    public get right(): Vector3 {
-        return Component._right.set(1, 0, 0).applyQuaternion(this.worldQuaternion);
-    }
-    private static _up: Vector3 = new Vector3();
-    /** Up (0,1,0) vector in world space */
-    public get up(): Vector3 {
-        return Component._up.set(0, 1, 0).applyQuaternion(this.worldQuaternion);
-    }
-
-
-
-    // EventTarget implementation:
-
-    private _eventListeners = new Map<string, EventListener[]>();
-
-    addEventListener<T extends Event>(type: string, listener: (evt: T) => any) {
-        this._eventListeners[type] = this._eventListeners[type] || [];
-        this._eventListeners[type].push(listener);
-    }
-
-    removeEventListener<T extends Event>(type: string, listener: (arg: T) => any) {
-        if (!this._eventListeners[type]) return;
-        const index = this._eventListeners[type].indexOf(listener);
-        if (index >= 0) this._eventListeners[type].splice(index, 1);
-    }
-
-    dispatchEvent(evt: Event): boolean {
-        if (!evt || !this._eventListeners[evt.type]) return false;
-        const listeners = this._eventListeners[evt.type];
-        for (let i = 0; i < listeners.length; i++) {
-            listeners[i](evt);
-        }
-
-        return false;
-    }
-}
-
-export class Behaviour extends Component {
-}
+import { Mathf } from "../engine/engine_math.js";
+import * as threeutils from "../engine/engine_three_utils.js";
+import { activeInHierarchyFieldName } from "../engine/engine_constants.js";
+import { Context, FrameEvent } from "../engine/engine_setup.js";
+import * as main from "../engine/engine_mainloop_utils.js";
+import { syncDestroy, syncInstantiate } from "../engine/engine_networking_instantiate.js";
+import type { ConstructorConcrete, SourceIdentifier, IComponent, IGameObject, Constructor, GuidsMap, Collision, ICollider } from "../engine/engine_types.js";
+import { addNewComponent, destroyComponentInstance, findObjectOfType, findObjectsOfType, getComponent, getComponentInChildren, getComponentInParent, getComponents, getComponentsInChildren, getComponentsInParent, getOrAddComponent, moveComponentInstance, removeComponent } from "../engine/engine_components.js";
+import { findByGuid, destroy, InstantiateOptions, instantiate, HideFlags, foreachComponent, markAsInstancedRendered, isActiveInHierarchy, isActiveSelf, isUsingInstancing, setActive, isDestroyed } from "../engine/engine_gameobject.js";
+
+import { Euler, Object3D, Quaternion, Scene, Vector3 } from "three";
+import { showBalloonWarning, isDevEnvironment } from "../engine/debug/index.js";
+
+// export interface ISerializationCallbackReceiver {
+//     onBeforeSerialize?(): object | void;
+//     onAfterSerialize?();
+//     onBeforeDeserialize?(data?: any);
+//     onAfterDeserialize?();
+//     onDeserialize?(key: string, value: any): any | void;
+// }
+
+export abstract class GameObject extends Object3D implements Object3D, IGameObject {
+
+    guid: string | undefined;
+
+    // Added to the threejs Object3D prototype
+    abstract destroy();
+
+    public static isDestroyed(go: Object3D): boolean {
+        return isDestroyed(go);
+    }
+
+    public static setActive(go: Object3D, active: boolean, processStart: boolean = true) {
+        if (!go) return;
+        setActive(go, active);
+
+        // TODO: do we still need this?:
+        main.updateIsActive(go);
+        if (active && processStart)
+            main.processStart(Context.Current, go);
+    }
+
+    /** If the object is active (same as go.visible) */
+    public static isActiveSelf(go: Object3D): boolean {
+        return isActiveSelf(go);
+    }
+
+    /** If the object is active in the hierarchy (e.g. if any parent is invisible or not in the scene it will be false) 
+     * @param go object to check
+    */
+    public static isActiveInHierarchy(go: Object3D): boolean {
+        return isActiveInHierarchy(go);
+    }
+
+    public static markAsInstancedRendered(go: Object3D, instanced: boolean) {
+        markAsInstancedRendered(go, instanced);
+    }
+
+    public static isUsingInstancing(instance: Object3D): boolean { return isUsingInstancing(instance); }
+
+    /** Run a callback for all components of the provided type on the provided object and its children (if recursive is true)
+     * @param instance object to run the method on
+     * @param cb callback to run on each component, "return undefined;" to continue and "return <anything>;" to break the loop
+     * @param recursive if true, the method will be run on all children as well
+     * @returns the last return value of the callback
+     */
+    public static foreachComponent(instance: Object3D, cb: (comp: Component) => any, recursive: boolean = true): any {
+        return foreachComponent(instance, cb as (comp: IComponent) => any, recursive);
+    }
+
+    /** Creates a new instance of the provided object. The new instance will be created on all connected clients 
+     * @param instance object to instantiate
+     * @param opts options for the instantiation
+     */
+    public static instantiateSynced(instance: GameObject | Object3D | null, opts: InstantiateOptions): GameObject | null {
+        if (!instance) return null;
+        return syncInstantiate(instance as any, opts) as GameObject | null;
+    }
+
+    /** Creates a new instance of the provided object (like cloning it including all components and children) 
+     * @param instance object to instantiate
+     * @param opts options for the instantiation (e.g. with what parent, position, etc.)
+    */
+    public static instantiate(instance: GameObject | Object3D | null, opts: InstantiateOptions | null = null): GameObject | null {
+        return instantiate(instance, opts) as GameObject | null;
+    }
+
+    /** Destroys a object on all connected clients (if you are in a networked session) 
+     * @param instance object to destroy
+    */
+    public static destroySynced(instance: Object3D | Component, context?: Context, recursive: boolean = true) {
+        if (!instance) return;
+        const go = instance as GameObject;
+        context = context ?? Context.Current;
+        syncDestroy(go as any, context.connection, recursive);
+    }
+
+    /** Destroys a object
+     * @param instance object to destroy
+     * @param recursive if true, all children will be destroyed as well. true by default
+     */
+    public static destroy(instance: Object3D | Component, recursive: boolean = true, isRoot: boolean = true) {
+        return destroy(instance, recursive, isRoot);
+    }
+
+    /**
+     * Add an object to parent and also ensure all components are being registered
+     */
+    public static add(instance: Object3D | null | undefined, parent: Object3D, context?: Context) {
+        if (!instance || !parent) return;
+        if (instance === parent) {
+            console.warn("Can not add object to self", instance);
+            return;
+        }
+        if (!context) {
+            context = Context.Current;
+        }
+        parent.add(instance);
+        setActive(instance, true);
+        main.updateIsActive(instance);
+        if (context) {
+            GameObject.foreachComponent(instance, (comp: Component) => {
+                main.addScriptToArrays(comp, context!);
+                if (comp.__internalDidAwakeAndStart) return;
+                if (context!.new_script_start.includes(comp) === false) {
+                    context!.new_script_start.push(comp as Behaviour);
+                }
+            }, true);
+        }
+        else {
+            console.warn("Missing context");
+        }
+    }
+
+    /**
+     * Removes the object from its parent and deactivates all of its components
+     */
+    public static remove(instance: Object3D | null | undefined) {
+        if (!instance) return;
+        instance.parent?.remove(instance);
+        setActive(instance, false);
+        main.updateIsActive(instance);
+        GameObject.foreachComponent(instance, (comp) => {
+            main.processRemoveFromScene(comp);
+        }, true);
+    }
+
+    /** Invokes a method on all components including children (if a method with that name exists) */
+    public static invokeOnChildren(go: Object3D | null | undefined, functionName: string, ...args: any) {
+        this.invoke(go, functionName, true, args);
+    }
+
+    /** Invokes a method on all components that have a method matching the provided name
+     * @param go object to invoke the method on all components
+     * @param functionName name of the method to invoke
+     */
+    public static invoke(go: Object3D | null | undefined, functionName: string, children: boolean = false, ...args: any) {
+        if (!go) return;
+        this.foreachComponent(go, c => {
+            const fn = c[functionName];
+            if (fn && typeof fn === "function") {
+                fn?.call(c, ...args)
+            }
+        }, children);
+    }
+
+    /**
+     * Adds a new component to the provided object
+     * @param go object to add the component to
+     * @param type type of the component to add
+     * @param callAwake if true, the component will be added and awake will be called immediately
+     */
+    public static addNewComponent<T>(go: IGameObject | Object3D, type: ConstructorConcrete<T>, callAwake: boolean = true): T {
+        const instance = new type();
+        //@ts-ignore
+        addNewComponent(go, instance, callAwake);
+        return instance
+    }
+
+    /**
+     * Moves a component to a new object  
+     * BEWARE: this does MOVE a component. If you want to add a new component use `addNewComponent`  
+     * @param go component to move the component to
+     * @param instance component to move to the GO
+     */
+    public static addComponent<T extends IComponent>(go: IGameObject | Object3D, instance: T | ConstructorConcrete<T>) {
+        return this.moveComponent(go, instance);
+    }
+
+    /**
+     * Moves a component to a new object  
+     * @param go component to move the component to
+     * @param instance component to move to the GO
+     */
+    public static moveComponent<T extends IComponent>(go: IGameObject | Object3D, instance: T | ConstructorConcrete<T>) {
+        return moveComponentInstance(go, instance);
+    }
+
+    /** Removes a component from its object
+     * @param instance component to remove
+     */
+    public static removeComponent<T extends IComponent>(instance: T): T {
+        removeComponent(instance.gameObject, instance as any);
+        return instance;
+    }
+
+    public static getOrAddComponent<T extends IComponent>(go: IGameObject | Object3D, typeName: ConstructorConcrete<T>): T {
+        return getOrAddComponent<any>(go, typeName);
+    }
+
+    /** Gets a component on the provided object */
+    public static getComponent<T extends IComponent>(go: IGameObject | Object3D | null, typeName: Constructor<T> | null): T | null {
+        if (go === null) return null;
+        // if names are minified we could also use the type store and work with strings everywhere
+        // not ideal, but I dont know a good/sane way to do this otherwise
+        // const res = TypeStore.get(typeName);
+        // if(res) typeName = res;
+        return getComponent(go, typeName as any);
+    }
+
+    public static getComponents<T extends IComponent>(go: IGameObject | Object3D | null, typeName: Constructor<T>, arr: T[] | null = null): T[] {
+        if (go === null) return arr ?? [];
+        return getComponents(go, typeName, arr);
+    }
+
+    public static findByGuid(guid: string, hierarchy: Object3D): GameObject | Component | null | undefined {
+        const res = findByGuid(guid, hierarchy);
+        return res as GameObject | Component | null | undefined;
+    }
+
+    public static findObjectOfType<T extends IComponent>(typeName: Constructor<T>, context?: Context | Object3D, includeInactive: boolean = true): T | null {
+        return findObjectOfType(typeName, context ?? Context.Current, includeInactive);
+    }
+
+    public static findObjectsOfType<T extends IComponent>(typeName: Constructor<T>, context?: Context | Object3D): Array<T> {
+        const arr = [];
+        findObjectsOfType(typeName, arr, context);
+        return arr;
+    }
+
+    public static getComponentInChildren<T extends IComponent>(go: IGameObject | Object3D, typeName: Constructor<T>): T | null {
+        return getComponentInChildren(go, typeName);
+    }
+
+    public static getComponentsInChildren<T extends IComponent>(go: IGameObject | Object3D, typeName: Constructor<T>, arr: T[] | null = null): Array<T> {
+        return getComponentsInChildren<T>(go, typeName, arr ?? undefined) as T[]
+    }
+
+    public static getComponentInParent<T extends IComponent>(go: IGameObject | Object3D, typeName: Constructor<T>): T | null {
+        return getComponentInParent(go, typeName);
+    }
+
+    public static getComponentsInParent<T extends IComponent>(go: IGameObject | Object3D, typeName: Constructor<T>, arr: Array<T> | null = null): Array<T> {
+        return getComponentsInParent(go, typeName, arr);
+    }
+
+    public static getAllComponents(go: IGameObject | Object3D): Behaviour[] {
+        const componentsList = go.userData?.components;
+        const newList = [...componentsList];
+        return newList;
+    }
+
+    public static *iterateComponents(go: IGameObject | Object3D) {
+        const list = go?.userData?.components;
+        if (list && Array.isArray(list)) {
+            for (let i = 0; i < list.length; i++) {
+                yield list[i];
+            }
+        }
+    }
+
+    // these are implemented via threejs object extensions
+    abstract activeSelf: boolean;
+
+    // The actual implementation / prototype of threejs is modified in js-extensions/Object3D
+    abstract get transform(): GameObject;
+
+    /** creates a new component on this gameObject */
+    abstract addNewComponent<T>(type: ConstructorConcrete<T>): T | null;
+    /** adds an existing component to this gameObject */
+    abstract addComponent<T extends IComponent>(comp: T | ConstructorConcrete<T>): void;
+    abstract removeComponent(comp: Component): Component;
+    abstract getOrAddComponent<T>(typeName: ConstructorConcrete<T> | null): T;
+    abstract getComponent<T>(type: Constructor<T>): T | null;
+    abstract getComponents<T>(type: Constructor<T>, arr?: T[]): Array<T>;
+    abstract getComponentInChildren<T>(type: Constructor<T>): T | null;
+    abstract getComponentsInChildren<T>(type: Constructor<T>, arr?: T[]): Array<T>;
+    abstract getComponentInParent<T>(type: Constructor<T>): T | null;
+    abstract getComponentsInParent<T>(type: Constructor<T>, arr?: T[]): Array<T>;
+
+
+    abstract get worldPosition(): Vector3
+    abstract set worldPosition(val: Vector3);
+    abstract set worldQuaternion(val: Quaternion);
+    abstract get worldQuaternion(): Quaternion;
+    abstract set worldRotation(val: Vector3);
+    abstract get worldRotation(): Vector3;  
+    abstract set worldScale(val: Vector3);
+    abstract get worldScale(): Vector3;
+
+    abstract get worldForward(): Vector3;
+    abstract get worldRight(): Vector3;
+    abstract get worldUp(): Vector3;
+}
+
+
+
+export class Component implements IComponent, EventTarget {
+
+    get isComponent(): boolean { return true; }
+
+    private __context: Context | undefined;
+    get context(): Context {
+        return this.__context ?? Context.Current;
+    }
+    set context(context: Context) {
+        this.__context = context;
+    }
+    get scene(): Scene { return this.context.scene; }
+
+    get layer(): number {
+        return this.gameObject?.userData?.layer;
+    }
+
+    get name(): string {
+        if (this.gameObject?.name) {
+            return this.gameObject.name;
+        }
+        return this.gameObject?.userData.name;
+    }
+    private __name?: string;
+    set name(str: string) {
+        if (this.gameObject) {
+            if (!this.gameObject.userData) this.gameObject.userData = {}
+            this.gameObject.userData.name = str;
+            this.__name = str;
+        }
+        else {
+            this.__name = str;
+        }
+    }
+    get tag(): string {
+        return this.gameObject?.userData.tag;
+    }
+    set tag(str: string) {
+        if (this.gameObject) {
+            if (!this.gameObject.userData) this.gameObject.userData = {}
+            this.gameObject.userData.tag = str;
+        }
+    }
+    get static() {
+        return this.gameObject?.userData.static;
+    }
+    get hideFlags(): HideFlags {
+        return this.gameObject?.userData.hideFlags;
+    }
+
+
+    get activeAndEnabled(): boolean {
+        if (this.destroyed) return false;
+        if (this.__isEnabled === false) return false;
+        if (!this.__isActiveInHierarchy) return false;
+        // let go = this.gameObject;
+        // do {
+        //     // console.log(go.name, go.visible)
+        //     if (!go.visible) return false;
+        //     go = go.parent as GameObject;
+        // }
+        // while (go);
+        return true;
+    }
+
+    private get __isActive(): boolean {
+        return this.gameObject.visible;
+    }
+    private get __isActiveInHierarchy(): boolean {
+        if (!this.gameObject) return false;
+        const res = this.gameObject[activeInHierarchyFieldName];
+        if (res === undefined) return true;
+        return res;
+    }
+
+    private set __isActiveInHierarchy(val: boolean) {
+        if (!this.gameObject) return;
+        this.gameObject[activeInHierarchyFieldName] = val;
+    }
+
+    gameObject!: GameObject;
+    guid: string = "invalid";
+    sourceId?: SourceIdentifier;
+    // transform: Object3D = nullObject;
+
+    /** called on a component with a map of old to new guids (e.g. when instantiate generated new guids and e.g. timeline track bindings needs to remape them) */
+    resolveGuids?(guidsMap: GuidsMap): void;
+
+    /** called once when the component becomes active for the first time */
+    awake() { }
+    /** called every time when the component gets enabled (this is invoked after awake and before start) */
+    onEnable() { }
+    onDisable() { }
+    onDestroy() {
+        this.__destroyed = true;
+    }
+    /** called when you decorate fields with the @validate() decorator
+     * @param field the name of the field that was changed
+     */
+    onValidate?(prop?: string): void;
+
+    /** Called for all scripts when the context gets paused or unpaused */
+    onPausedChanged?(isPaused: boolean, wasPaused: boolean): void;
+
+    start?(): void;
+    earlyUpdate?(): void;
+    update?(): void;
+    lateUpdate?(): void;
+    onBeforeRender?(frame: XRFrame | null): void;
+    onAfterRender?(): void;
+
+    onCollisionEnter?(col: Collision);
+    onCollisionExit?(col: Collision);
+    onCollisionStay?(col: Collision);
+
+    onTriggerEnter?(col: ICollider);
+    onTriggerStay?(col: ICollider);
+    onTriggerExit?(col: ICollider);
+
+    startCoroutine(routine: Generator, evt: FrameEvent = FrameEvent.Update): Generator {
+        return this.context.registerCoroutineUpdate(this, routine, evt);
+    }
+
+    stopCoroutine(routine: Generator, evt: FrameEvent = FrameEvent.Update): void {
+        this.context.unregisterCoroutineUpdate(routine, evt);
+    }
+
+    public get destroyed(): boolean {
+        return this.__destroyed;
+    }
+
+    public destroy() {
+        if (this.__destroyed) return;
+        this.__internalDestroy();
+    }
+
+
+
+    /** @internal */
+    protected __didAwake: boolean = false;
+
+    /** @internal */
+    private __didStart: boolean = false;
+
+    /** @internal */
+    protected __didEnable: boolean = false;
+
+    /** @internal */
+    protected __isEnabled: boolean | undefined = undefined;
+
+    /** @internal */
+    private __destroyed: boolean = false;
+
+    /** @internal */
+    get __internalDidAwakeAndStart() { return this.__didAwake && this.__didStart; }
+
+
+    /** @internal */
+    constructor() {
+        this.__internalNewInstanceCreated();
+    }
+
+
+    /** @internal */
+    __internalNewInstanceCreated() {
+        this.__didAwake = false;
+        this.__didStart = false;
+        this.__didEnable = false;
+        this.__isEnabled = undefined;
+        this.__destroyed = false;
+    }
+
+
+    /** @internal */
+    __internalAwake() {
+        if (this.__didAwake) return;
+        this.__didAwake = true;
+        this.awake();
+    }
+
+
+    /** @internal */
+    __internalStart() {
+        if (this.__didStart) return;
+        this.__didStart = true;
+        if (this.start) this.start();
+    }
+
+
+    /** @internal */
+    __internalEnable(isAddingToScene?: boolean): boolean {
+        if (this.__destroyed) {
+            if (isDevEnvironment()) {
+                console.warn("[Needle Engine Dev] Trying to enable destroyed component");
+            }
+            return false;
+        }
+        // Don't change enable before awake
+        // But a user can change enable during awake
+        if (!this.__didAwake) return false;
+        if (this.__didEnable) {
+            // We dont want to change the enable state if we are adding to scene
+            // But we want to change the state when e.g. a user changes the enable state during awake
+            if (isAddingToScene !== true)
+                this.__isEnabled = true;
+            return false;
+        }
+        // console.trace("INTERNAL ENABLE");
+        this.__didEnable = true;
+        this.__isEnabled = true;
+        this.onEnable();
+        return true;
+    }
+
+    /** @internal */
+    __internalDisable(isRemovingFromScene?: boolean) {
+        // Don't change enable before awake
+        // But a user can change enable during awake
+        if (!this.__didAwake) return;
+        if (!this.__didEnable) {
+            // We dont want to change the enable state if we are removing from a scene
+            if (isRemovingFromScene !== true)
+                this.__isEnabled = false;
+            return;
+        }
+        this.__didEnable = false;
+        this.__isEnabled = false;
+        this.onDisable();
+    }
+
+    /** @internal */
+    __internalDestroy() {
+        if (this.__destroyed) return;
+        this.__destroyed = true;
+        if (this.__didAwake) {
+            this.onDestroy?.call(this);
+            this.dispatchEvent(new CustomEvent("destroyed", { detail: this }));
+        }
+        destroyComponentInstance(this as any);
+    }
+
+
+    get enabled(): boolean {
+        return typeof this.__isEnabled === "boolean" ? this.__isEnabled : true; // if it has no enabled field it is always enabled
+    }
+    set enabled(val: boolean) {
+        if (this.__destroyed) {
+            if (isDevEnvironment()) {
+                console.warn(`[Needle Engine Dev] Trying to ${val ? "enable" : "disable"} destroyed component`);
+            }
+            return;
+        }
+        // when called from animationclip we receive numbers
+        // due to interpolation they can be anything between 0 and 1
+        if (typeof val === "number") {
+            if (val >= 0.5) val = true;
+            else val = false;
+        }
+
+        // need to check here because codegen is calling this before everything is setup
+        if (!this.__didAwake) {
+            this.__isEnabled = val;
+            return;
+        }
+        if (val) {
+            this.__internalEnable();
+        } else {
+            this.__internalDisable();
+        }
+    }
+
+    get worldPosition(): Vector3 {
+        return threeutils.getWorldPosition(this.gameObject);
+    }
+
+    set worldPosition(val: Vector3) {
+        threeutils.setWorldPosition(this.gameObject, val);
+    }
+
+    setWorldPosition(x: number, y: number, z: number) {
+        threeutils.setWorldPositionXYZ(this.gameObject, x, y, z);
+    }
+
+
+    get worldQuaternion(): Quaternion {
+        return threeutils.getWorldQuaternion(this.gameObject);
+    }
+    set worldQuaternion(val: Quaternion) {
+        threeutils.setWorldQuaternion(this.gameObject, val);
+    }
+    setWorldQuaternion(x: number, y: number, z: number, w: number) {
+        threeutils.setWorldQuaternionXYZW(this.gameObject, x, y, z, w);
+    }
+
+    // world euler (in radians)
+    get worldEuler(): Euler {
+        return threeutils.getWorldEuler(this.gameObject);
+    }
+
+    // world euler (in radians)
+    set worldEuler(val: Euler) {
+        threeutils.setWorldEuler(this.gameObject, val);
+    }
+
+    // returns rotation in degrees
+    get worldRotation(): Vector3 {
+        return this.gameObject.worldRotation;;
+    }
+
+    set worldRotation(val: Vector3) {
+        this.setWorldRotation(val.x, val.y, val.z, true);
+    }
+
+    setWorldRotation(x: number, y: number, z: number, degrees: boolean = true) {
+        threeutils.setWorldRotationXYZ(this.gameObject, x, y, z, degrees);
+    }
+
+    private static _forward: Vector3 = new Vector3();
+    /** Forward (0,0,-1) vector in world space */
+    public get forward(): Vector3 {
+        return Component._forward.set(0, 0, -1).applyQuaternion(this.worldQuaternion);
+    }
+    private static _right: Vector3 = new Vector3();
+    /** Right (1,0,0) vector in world space */
+    public get right(): Vector3 {
+        return Component._right.set(1, 0, 0).applyQuaternion(this.worldQuaternion);
+    }
+    private static _up: Vector3 = new Vector3();
+    /** Up (0,1,0) vector in world space */
+    public get up(): Vector3 {
+        return Component._up.set(0, 1, 0).applyQuaternion(this.worldQuaternion);
+    }
+
+
+
+    // EventTarget implementation:
+
+    private _eventListeners = new Map<string, EventListener[]>();
+
+    addEventListener<T extends Event>(type: string, listener: (evt: T) => any) {
+        this._eventListeners[type] = this._eventListeners[type] || [];
+        this._eventListeners[type].push(listener);
+    }
+
+    removeEventListener<T extends Event>(type: string, listener: (arg: T) => any) {
+        if (!this._eventListeners[type]) return;
+        const index = this._eventListeners[type].indexOf(listener);
+        if (index >= 0) this._eventListeners[type].splice(index, 1);
+    }
+
+    dispatchEvent(evt: Event): boolean {
+        if (!evt || !this._eventListeners[evt.type]) return false;
+        const listeners = this._eventListeners[evt.type];
+        for (let i = 0; i < listeners.length; i++) {
+            listeners[i](evt);
+        }
+
+        return false;
+    }
+}
+
+export class Behaviour extends Component {
+}