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

package/lib/engine-components/Component.js

@@ -1,542 +1,542 @@
-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 { addNewComponent, destroyComponentInstance, findObjectOfType, findObjectsOfType, getComponent, getComponentInChildren, getComponentInParent, getComponents, getComponentsInChildren, getComponentsInParent, getOrAddComponent, moveComponentInstance, removeComponent } from "../engine/engine_components.js";
-import { findByGuid, destroy, instantiate, foreachComponent, markAsInstancedRendered, isActiveInHierarchy, isActiveSelf, isUsingInstancing, setActive, isDestroyed } from "../engine/engine_gameobject.js";
-import { Object3D, Vector3 } from "three";
-import { 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 class GameObject extends Object3D {
-    guid;
-    static isDestroyed(go) {
-        return isDestroyed(go);
-    }
-    static setActive(go, active, processStart = 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) */
-    static isActiveSelf(go) {
-        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
-    */
-    static isActiveInHierarchy(go) {
-        return isActiveInHierarchy(go);
-    }
-    static markAsInstancedRendered(go, instanced) {
-        markAsInstancedRendered(go, instanced);
-    }
-    static isUsingInstancing(instance) { 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
-     */
-    static foreachComponent(instance, cb, recursive = true) {
-        return foreachComponent(instance, cb, 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
-     */
-    static instantiateSynced(instance, opts) {
-        if (!instance)
-            return null;
-        return syncInstantiate(instance, opts);
-    }
-    /** 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.)
-    */
-    static instantiate(instance, opts = null) {
-        return instantiate(instance, opts);
-    }
-    /** Destroys a object on all connected clients (if you are in a networked session)
-     * @param instance object to destroy
-    */
-    static destroySynced(instance, context, recursive = true) {
-        if (!instance)
-            return;
-        const go = instance;
-        context = context ?? Context.Current;
-        syncDestroy(go, 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
-     */
-    static destroy(instance, recursive = true, isRoot = true) {
-        return destroy(instance, recursive, isRoot);
-    }
-    /**
-     * Add an object to parent and also ensure all components are being registered
-     */
-    static add(instance, parent, 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) => {
-                main.addScriptToArrays(comp, context);
-                if (comp.__internalDidAwakeAndStart)
-                    return;
-                if (context.new_script_start.includes(comp) === false) {
-                    context.new_script_start.push(comp);
-                }
-            }, true);
-        }
-        else {
-            console.warn("Missing context");
-        }
-    }
-    /**
-     * Removes the object from its parent and deactivates all of its components
-     */
-    static remove(instance) {
-        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) */
-    static invokeOnChildren(go, functionName, ...args) {
-        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
-     */
-    static invoke(go, functionName, children = false, ...args) {
-        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
-     */
-    static addNewComponent(go, type, callAwake = true) {
-        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
-     */
-    static addComponent(go, instance) {
-        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
-     */
-    static moveComponent(go, instance) {
-        return moveComponentInstance(go, instance);
-    }
-    /** Removes a component from its object
-     * @param instance component to remove
-     */
-    static removeComponent(instance) {
-        removeComponent(instance.gameObject, instance);
-        return instance;
-    }
-    static getOrAddComponent(go, typeName) {
-        return getOrAddComponent(go, typeName);
-    }
-    /** Gets a component on the provided object */
-    static getComponent(go, typeName) {
-        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);
-    }
-    static getComponents(go, typeName, arr = null) {
-        if (go === null)
-            return arr ?? [];
-        return getComponents(go, typeName, arr);
-    }
-    static findByGuid(guid, hierarchy) {
-        const res = findByGuid(guid, hierarchy);
-        return res;
-    }
-    static findObjectOfType(typeName, context, includeInactive = true) {
-        return findObjectOfType(typeName, context ?? Context.Current, includeInactive);
-    }
-    static findObjectsOfType(typeName, context) {
-        const arr = [];
-        findObjectsOfType(typeName, arr, context);
-        return arr;
-    }
-    static getComponentInChildren(go, typeName) {
-        return getComponentInChildren(go, typeName);
-    }
-    static getComponentsInChildren(go, typeName, arr = null) {
-        return getComponentsInChildren(go, typeName, arr ?? undefined);
-    }
-    static getComponentInParent(go, typeName) {
-        return getComponentInParent(go, typeName);
-    }
-    static getComponentsInParent(go, typeName, arr = null) {
-        return getComponentsInParent(go, typeName, arr);
-    }
-    static getAllComponents(go) {
-        const componentsList = go.userData?.components;
-        const newList = [...componentsList];
-        return newList;
-    }
-    static *iterateComponents(go) {
-        const list = go?.userData?.components;
-        if (list && Array.isArray(list)) {
-            for (let i = 0; i < list.length; i++) {
-                yield list[i];
-            }
-        }
-    }
-}
-export class Component {
-    get isComponent() { return true; }
-    __context;
-    get context() {
-        return this.__context ?? Context.Current;
-    }
-    set context(context) {
-        this.__context = context;
-    }
-    get scene() { return this.context.scene; }
-    get layer() {
-        return this.gameObject?.userData?.layer;
-    }
-    get name() {
-        if (this.gameObject?.name) {
-            return this.gameObject.name;
-        }
-        return this.gameObject?.userData.name;
-    }
-    __name;
-    set name(str) {
-        if (this.gameObject) {
-            if (!this.gameObject.userData)
-                this.gameObject.userData = {};
-            this.gameObject.userData.name = str;
-            this.__name = str;
-        }
-        else {
-            this.__name = str;
-        }
-    }
-    get tag() {
-        return this.gameObject?.userData.tag;
-    }
-    set tag(str) {
-        if (this.gameObject) {
-            if (!this.gameObject.userData)
-                this.gameObject.userData = {};
-            this.gameObject.userData.tag = str;
-        }
-    }
-    get static() {
-        return this.gameObject?.userData.static;
-    }
-    get hideFlags() {
-        return this.gameObject?.userData.hideFlags;
-    }
-    get activeAndEnabled() {
-        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;
-    }
-    get __isActive() {
-        return this.gameObject.visible;
-    }
-    get __isActiveInHierarchy() {
-        if (!this.gameObject)
-            return false;
-        const res = this.gameObject[activeInHierarchyFieldName];
-        if (res === undefined)
-            return true;
-        return res;
-    }
-    set __isActiveInHierarchy(val) {
-        if (!this.gameObject)
-            return;
-        this.gameObject[activeInHierarchyFieldName] = val;
-    }
-    gameObject;
-    guid = "invalid";
-    sourceId;
-    /** 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;
-    }
-    startCoroutine(routine, evt = FrameEvent.Update) {
-        return this.context.registerCoroutineUpdate(this, routine, evt);
-    }
-    stopCoroutine(routine, evt = FrameEvent.Update) {
-        this.context.unregisterCoroutineUpdate(routine, evt);
-    }
-    get destroyed() {
-        return this.__destroyed;
-    }
-    destroy() {
-        if (this.__destroyed)
-            return;
-        this.__internalDestroy();
-    }
-    /** @internal */
-    __didAwake = false;
-    /** @internal */
-    __didStart = false;
-    /** @internal */
-    __didEnable = false;
-    /** @internal */
-    __isEnabled = undefined;
-    /** @internal */
-    __destroyed = 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) {
-        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) {
-        // 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);
-    }
-    get enabled() {
-        return typeof this.__isEnabled === "boolean" ? this.__isEnabled : true; // if it has no enabled field it is always enabled
-    }
-    set enabled(val) {
-        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() {
-        return threeutils.getWorldPosition(this.gameObject);
-    }
-    set worldPosition(val) {
-        threeutils.setWorldPosition(this.gameObject, val);
-    }
-    setWorldPosition(x, y, z) {
-        threeutils.setWorldPositionXYZ(this.gameObject, x, y, z);
-    }
-    get worldQuaternion() {
-        return threeutils.getWorldQuaternion(this.gameObject);
-    }
-    set worldQuaternion(val) {
-        threeutils.setWorldQuaternion(this.gameObject, val);
-    }
-    setWorldQuaternion(x, y, z, w) {
-        threeutils.setWorldQuaternionXYZW(this.gameObject, x, y, z, w);
-    }
-    // world euler (in radians)
-    get worldEuler() {
-        return threeutils.getWorldEuler(this.gameObject);
-    }
-    // world euler (in radians)
-    set worldEuler(val) {
-        threeutils.setWorldEuler(this.gameObject, val);
-    }
-    // returns rotation in degrees
-    get worldRotation() {
-        return this.gameObject.worldRotation;
-        ;
-    }
-    set worldRotation(val) {
-        this.setWorldRotation(val.x, val.y, val.z, true);
-    }
-    setWorldRotation(x, y, z, degrees = true) {
-        threeutils.setWorldRotationXYZ(this.gameObject, x, y, z, degrees);
-    }
-    static _forward = new Vector3();
-    /** Forward (0,0,-1) vector in world space */
-    get forward() {
-        return Component._forward.set(0, 0, -1).applyQuaternion(this.worldQuaternion);
-    }
-    static _right = new Vector3();
-    /** Right (1,0,0) vector in world space */
-    get right() {
-        return Component._right.set(1, 0, 0).applyQuaternion(this.worldQuaternion);
-    }
-    static _up = new Vector3();
-    /** Up (0,1,0) vector in world space */
-    get up() {
-        return Component._up.set(0, 1, 0).applyQuaternion(this.worldQuaternion);
-    }
-    // EventTarget implementation:
-    _eventListeners = new Map();
-    addEventListener(type, listener) {
-        this._eventListeners[type] = this._eventListeners[type] || [];
-        this._eventListeners[type].push(listener);
-    }
-    removeEventListener(type, listener) {
-        if (!this._eventListeners[type])
-            return;
-        const index = this._eventListeners[type].indexOf(listener);
-        if (index >= 0)
-            this._eventListeners[type].splice(index, 1);
-    }
-    dispatchEvent(evt) {
-        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 * 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 { addNewComponent, destroyComponentInstance, findObjectOfType, findObjectsOfType, getComponent, getComponentInChildren, getComponentInParent, getComponents, getComponentsInChildren, getComponentsInParent, getOrAddComponent, moveComponentInstance, removeComponent } from "../engine/engine_components.js";
+import { findByGuid, destroy, instantiate, foreachComponent, markAsInstancedRendered, isActiveInHierarchy, isActiveSelf, isUsingInstancing, setActive, isDestroyed } from "../engine/engine_gameobject.js";
+import { Object3D, Vector3 } from "three";
+import { 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 class GameObject extends Object3D {
+    guid;
+    static isDestroyed(go) {
+        return isDestroyed(go);
+    }
+    static setActive(go, active, processStart = 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) */
+    static isActiveSelf(go) {
+        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
+    */
+    static isActiveInHierarchy(go) {
+        return isActiveInHierarchy(go);
+    }
+    static markAsInstancedRendered(go, instanced) {
+        markAsInstancedRendered(go, instanced);
+    }
+    static isUsingInstancing(instance) { 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
+     */
+    static foreachComponent(instance, cb, recursive = true) {
+        return foreachComponent(instance, cb, 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
+     */
+    static instantiateSynced(instance, opts) {
+        if (!instance)
+            return null;
+        return syncInstantiate(instance, opts);
+    }
+    /** 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.)
+    */
+    static instantiate(instance, opts = null) {
+        return instantiate(instance, opts);
+    }
+    /** Destroys a object on all connected clients (if you are in a networked session)
+     * @param instance object to destroy
+    */
+    static destroySynced(instance, context, recursive = true) {
+        if (!instance)
+            return;
+        const go = instance;
+        context = context ?? Context.Current;
+        syncDestroy(go, 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
+     */
+    static destroy(instance, recursive = true, isRoot = true) {
+        return destroy(instance, recursive, isRoot);
+    }
+    /**
+     * Add an object to parent and also ensure all components are being registered
+     */
+    static add(instance, parent, 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) => {
+                main.addScriptToArrays(comp, context);
+                if (comp.__internalDidAwakeAndStart)
+                    return;
+                if (context.new_script_start.includes(comp) === false) {
+                    context.new_script_start.push(comp);
+                }
+            }, true);
+        }
+        else {
+            console.warn("Missing context");
+        }
+    }
+    /**
+     * Removes the object from its parent and deactivates all of its components
+     */
+    static remove(instance) {
+        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) */
+    static invokeOnChildren(go, functionName, ...args) {
+        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
+     */
+    static invoke(go, functionName, children = false, ...args) {
+        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
+     */
+    static addNewComponent(go, type, callAwake = true) {
+        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
+     */
+    static addComponent(go, instance) {
+        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
+     */
+    static moveComponent(go, instance) {
+        return moveComponentInstance(go, instance);
+    }
+    /** Removes a component from its object
+     * @param instance component to remove
+     */
+    static removeComponent(instance) {
+        removeComponent(instance.gameObject, instance);
+        return instance;
+    }
+    static getOrAddComponent(go, typeName) {
+        return getOrAddComponent(go, typeName);
+    }
+    /** Gets a component on the provided object */
+    static getComponent(go, typeName) {
+        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);
+    }
+    static getComponents(go, typeName, arr = null) {
+        if (go === null)
+            return arr ?? [];
+        return getComponents(go, typeName, arr);
+    }
+    static findByGuid(guid, hierarchy) {
+        const res = findByGuid(guid, hierarchy);
+        return res;
+    }
+    static findObjectOfType(typeName, context, includeInactive = true) {
+        return findObjectOfType(typeName, context ?? Context.Current, includeInactive);
+    }
+    static findObjectsOfType(typeName, context) {
+        const arr = [];
+        findObjectsOfType(typeName, arr, context);
+        return arr;
+    }
+    static getComponentInChildren(go, typeName) {
+        return getComponentInChildren(go, typeName);
+    }
+    static getComponentsInChildren(go, typeName, arr = null) {
+        return getComponentsInChildren(go, typeName, arr ?? undefined);
+    }
+    static getComponentInParent(go, typeName) {
+        return getComponentInParent(go, typeName);
+    }
+    static getComponentsInParent(go, typeName, arr = null) {
+        return getComponentsInParent(go, typeName, arr);
+    }
+    static getAllComponents(go) {
+        const componentsList = go.userData?.components;
+        const newList = [...componentsList];
+        return newList;
+    }
+    static *iterateComponents(go) {
+        const list = go?.userData?.components;
+        if (list && Array.isArray(list)) {
+            for (let i = 0; i < list.length; i++) {
+                yield list[i];
+            }
+        }
+    }
+}
+export class Component {
+    get isComponent() { return true; }
+    __context;
+    get context() {
+        return this.__context ?? Context.Current;
+    }
+    set context(context) {
+        this.__context = context;
+    }
+    get scene() { return this.context.scene; }
+    get layer() {
+        return this.gameObject?.userData?.layer;
+    }
+    get name() {
+        if (this.gameObject?.name) {
+            return this.gameObject.name;
+        }
+        return this.gameObject?.userData.name;
+    }
+    __name;
+    set name(str) {
+        if (this.gameObject) {
+            if (!this.gameObject.userData)
+                this.gameObject.userData = {};
+            this.gameObject.userData.name = str;
+            this.__name = str;
+        }
+        else {
+            this.__name = str;
+        }
+    }
+    get tag() {
+        return this.gameObject?.userData.tag;
+    }
+    set tag(str) {
+        if (this.gameObject) {
+            if (!this.gameObject.userData)
+                this.gameObject.userData = {};
+            this.gameObject.userData.tag = str;
+        }
+    }
+    get static() {
+        return this.gameObject?.userData.static;
+    }
+    get hideFlags() {
+        return this.gameObject?.userData.hideFlags;
+    }
+    get activeAndEnabled() {
+        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;
+    }
+    get __isActive() {
+        return this.gameObject.visible;
+    }
+    get __isActiveInHierarchy() {
+        if (!this.gameObject)
+            return false;
+        const res = this.gameObject[activeInHierarchyFieldName];
+        if (res === undefined)
+            return true;
+        return res;
+    }
+    set __isActiveInHierarchy(val) {
+        if (!this.gameObject)
+            return;
+        this.gameObject[activeInHierarchyFieldName] = val;
+    }
+    gameObject;
+    guid = "invalid";
+    sourceId;
+    /** 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;
+    }
+    startCoroutine(routine, evt = FrameEvent.Update) {
+        return this.context.registerCoroutineUpdate(this, routine, evt);
+    }
+    stopCoroutine(routine, evt = FrameEvent.Update) {
+        this.context.unregisterCoroutineUpdate(routine, evt);
+    }
+    get destroyed() {
+        return this.__destroyed;
+    }
+    destroy() {
+        if (this.__destroyed)
+            return;
+        this.__internalDestroy();
+    }
+    /** @internal */
+    __didAwake = false;
+    /** @internal */
+    __didStart = false;
+    /** @internal */
+    __didEnable = false;
+    /** @internal */
+    __isEnabled = undefined;
+    /** @internal */
+    __destroyed = 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) {
+        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) {
+        // 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);
+    }
+    get enabled() {
+        return typeof this.__isEnabled === "boolean" ? this.__isEnabled : true; // if it has no enabled field it is always enabled
+    }
+    set enabled(val) {
+        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() {
+        return threeutils.getWorldPosition(this.gameObject);
+    }
+    set worldPosition(val) {
+        threeutils.setWorldPosition(this.gameObject, val);
+    }
+    setWorldPosition(x, y, z) {
+        threeutils.setWorldPositionXYZ(this.gameObject, x, y, z);
+    }
+    get worldQuaternion() {
+        return threeutils.getWorldQuaternion(this.gameObject);
+    }
+    set worldQuaternion(val) {
+        threeutils.setWorldQuaternion(this.gameObject, val);
+    }
+    setWorldQuaternion(x, y, z, w) {
+        threeutils.setWorldQuaternionXYZW(this.gameObject, x, y, z, w);
+    }
+    // world euler (in radians)
+    get worldEuler() {
+        return threeutils.getWorldEuler(this.gameObject);
+    }
+    // world euler (in radians)
+    set worldEuler(val) {
+        threeutils.setWorldEuler(this.gameObject, val);
+    }
+    // returns rotation in degrees
+    get worldRotation() {
+        return this.gameObject.worldRotation;
+        ;
+    }
+    set worldRotation(val) {
+        this.setWorldRotation(val.x, val.y, val.z, true);
+    }
+    setWorldRotation(x, y, z, degrees = true) {
+        threeutils.setWorldRotationXYZ(this.gameObject, x, y, z, degrees);
+    }
+    static _forward = new Vector3();
+    /** Forward (0,0,-1) vector in world space */
+    get forward() {
+        return Component._forward.set(0, 0, -1).applyQuaternion(this.worldQuaternion);
+    }
+    static _right = new Vector3();
+    /** Right (1,0,0) vector in world space */
+    get right() {
+        return Component._right.set(1, 0, 0).applyQuaternion(this.worldQuaternion);
+    }
+    static _up = new Vector3();
+    /** Up (0,1,0) vector in world space */
+    get up() {
+        return Component._up.set(0, 1, 0).applyQuaternion(this.worldQuaternion);
+    }
+    // EventTarget implementation:
+    _eventListeners = new Map();
+    addEventListener(type, listener) {
+        this._eventListeners[type] = this._eventListeners[type] || [];
+        this._eventListeners[type].push(listener);
+    }
+    removeEventListener(type, listener) {
+        if (!this._eventListeners[type])
+            return;
+        const index = this._eventListeners[type].indexOf(listener);
+        if (index >= 0)
+            this._eventListeners[type].splice(index, 1);
+    }
+    dispatchEvent(evt) {
+        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 {
+}
 //# sourceMappingURL=Component.js.map