@needle-tools/engine 2.24.0-pre

package/src/engine-components/Component.ts

@@ -0,0 +1,1042 @@
+import * as THREE from "three";
+import * as object from "../engine/engine_components"
+import { Mathf } from "../engine/engine_math";
+import * as threeutils from "../engine/engine_three_utils";
+import * as utils from "../engine/engine_utils";
+import { activeInHierarchyFieldName } from "../engine/engine_constants";
+import { Context, FrameEvent } from "../engine/engine_setup";
+import * as main from "../engine/engine_mainloop_utils";
+import { Object3D } from "three";
+import { InstantiateIdProvider, syncDestroy, syncInstantiate } from "../engine/engine_networking_instantiate";
+import { SourceIdentifier } from "../engine/engine_gltf";
+
+export interface UIDProvider {
+    seed: number;
+    generateUUID(): string;
+}
+
+// export interface ISerializationCallbackReceiver {
+//     onBeforeSerialize?(): object | void;
+//     onAfterSerialize?();
+//     onBeforeDeserialize?(data?: any);
+//     onAfterDeserialize?();
+//     onDeserialize?(key: string, value: any): any | void;
+// }
+
+const debug = utils.getParam("debugcomponents");
+
+export enum HideFlags {
+    None = 0,
+    HideInHierarchy = 1,
+    HideInInspector = 2,
+    DontSaveInEditor = 4,
+    NotEditable = 8,
+    DontSaveInBuild = 16, // 0x00000010
+    DontUnloadUnusedAsset = 32, // 0x00000020
+    DontSave = DontUnloadUnusedAsset | DontSaveInBuild | DontSaveInEditor, // 0x00000034
+    HideAndDontSave = DontSave | NotEditable | HideInHierarchy, // 0x0000003D
+}
+
+// TODO: figure out what is best here!
+// https://stackoverflow.com/a/67229348
+// https://stackoverflow.com/questions/36886082/abstract-constructor-type-in-typescript
+// type Constructor<T> = Function & { prototype: T } // << this includes abstract constructor types
+export type Constructor<T> = abstract new (...args: any[]) => T; // abstract to support @serializable and also getComponent with abstract types
+export type ConstructorConcrete<T> = new (...args: any[]) => T;
+
+export type GuidsMap = { [key: string]: string };
+
+type FunctionName = string;
+
+export class InstantiateOptions {
+    idProvider?: UIDProvider | undefined;
+
+    //** parent guid */
+    parent?: string | undefined | Object3D;
+    /** for duplicatable parenting */
+    keepWorldPosition?: boolean
+    position?: THREE.Vector3 | undefined;
+    rotation?: THREE.Quaternion | undefined;
+    scale?: THREE.Vector3 | undefined;
+
+    visible?: boolean | undefined;
+
+    context?: Context | undefined;
+}
+
+declare class NewGameObjectReferenceInfo {
+    original: THREE.Object3D;
+    clone: THREE.Object3D;
+}
+
+THREE.Object3D.prototype["SetActive"] = function (active: boolean) {
+    this.visible = active;
+}
+
+
+abstract class GameObject extends THREE.Object3D implements THREE.Object3D {
+
+    guid: string | undefined;
+
+    public static setActive(go: THREE.Object3D, active: boolean) {
+        if (!go) return;
+        go.visible = active;
+    }
+
+    public static isActiveSelf(go: THREE.Object3D): boolean {
+        return go.visible || GameObject.isUsingInstancing(go);
+    }
+
+    public static isActiveInHierarchy(go: THREE.Object3D): boolean {
+        return go[activeInHierarchyFieldName] || GameObject.isUsingInstancing(go);
+    }
+
+    public static markAsInstancedRendered(go: THREE.Object3D, instanced: boolean) {
+        go["__isUsingInstancing"] = instanced;
+    }
+
+    public static isUsingInstancing(instance: THREE.Object3D): boolean { return instance["__isUsingInstancing"] === true; }
+
+    public static foreachComponent(instance: THREE.Object3D, cb: (comp: Component) => any, recursive: boolean = true): any {
+        if (!instance) return;
+        if (instance.userData.components) {
+            for (let i = 0; i < instance.userData.components.length; i++) {
+                const comp = instance.userData.components[i];
+                if (comp instanceof Behaviour) {
+                    const res = cb(comp);
+                    if (res !== undefined) return res;
+                }
+            }
+        }
+
+        if (recursive && instance.children) {
+            for (let i = 0; i < instance.children.length; i++) {
+                const child = instance.children[i];
+                if (!child) continue;
+                const res = GameObject.foreachComponent(child, cb, recursive);
+                if (res !== undefined) return res;
+            }
+        }
+    }
+
+    public static instantiateSynced(instance: GameObject | THREE.Object3D | null, opts: InstantiateOptions): GameObject | null {
+        if (!instance) return null;
+        return syncInstantiate(instance, opts);
+    }
+
+    public static instantiate(instance: GameObject | THREE.Object3D | null, opts: InstantiateOptions | null = null): GameObject | null {
+        if (instance === null) return null;
+
+        let options: InstantiateOptions | null = null;
+        if (opts !== null) {
+            // if x is defined assume this is a vec3 - this is just to not break everything at once and stay a little bit backwards compatible
+            if (opts["x"] !== undefined) {
+                options = new InstantiateOptions();
+                options.position = opts as unknown as THREE.Vector3;
+            }
+            else {
+                // if (opts instanceof InstantiateOptions)
+                options = opts as InstantiateOptions;
+                // else {
+                //     options = new InstantiateOptions();
+                //     Object.assign(options, opts);
+                // }
+            }
+        }
+
+        let context = Context.Current;
+        if (options?.context) context = options.context;
+        if (debug && context.alias)
+            console.log("context", context.alias);
+
+        // we need to create the id provider before calling internal instantiate because cloned gameobjects also create new guids
+        if (options && !options.idProvider) {
+            options.idProvider = new InstantiateIdProvider(Date.now());
+        }
+
+        const components: Array<Behaviour> = [];
+        const goMapping: { [key: string]: NewGameObjectReferenceInfo } = {}; // used to resolve references on components to components on other gameobjects to their new counterpart
+        const skinnedMeshes: { [key: string]: NewGameObjectReferenceInfo } = {};
+        const clone = this.internalInstantiate(context, instance, options, components, goMapping, skinnedMeshes);
+
+        if (clone) {
+            this.resolveReferences(goMapping);
+            this.resolveAndBindSkinnedMeshBones(skinnedMeshes, goMapping);
+        }
+
+        if (debug) {
+            threeutils.logHierarchy(instance, true);
+            threeutils.logHierarchy(clone, true);
+        }
+
+        const guidsMap: GuidsMap = {};
+        for (const i in components) {
+            const copy = components[i];
+            const oldGuid = copy.guid;
+            if (options && options.idProvider) {
+                copy.guid = options.idProvider.generateUUID();
+                guidsMap[oldGuid] = copy.guid;
+                if (debug)
+                    console.log(copy.name, copy.guid)
+            }
+            object.registerComponent(copy, context);
+            if (copy.__internalNewInstanceCreated)
+                copy.__internalNewInstanceCreated();
+        }
+        for (const i in components) {
+            const copy = components[i];
+            if (copy.resolveGuids)
+                copy.resolveGuids(guidsMap);
+            if (copy.enabled === false) continue;
+            else copy.enabled = true;
+        }
+
+        main.processNewScripts(context);
+
+        return clone as GameObject;
+    }
+
+    private static internalInstantiate(
+        context: Context, instance: GameObject | THREE.Object3D, opts: InstantiateOptions | null,
+        componentsList: Array<Behaviour>,
+        newGameObjectsMap: { [key: string]: NewGameObjectReferenceInfo },
+        skinnedMeshesMap: { [key: string]: NewGameObjectReferenceInfo }
+    )
+        : GameObject | THREE.Object3D | null {
+        if (!instance) return null;
+        // prepare, remove things that dont work out of the box
+        // e.g. user data we want to manually clone
+        // also children throw errors (e.g. recursive toJson with nested meshes)
+        const userData = instance.userData;
+        instance.userData = {};
+        const children = instance.children;
+        instance.children = [];
+        let clone: THREE.Object3D | GameObject;
+        clone = instance.clone(false);
+        instance.userData = userData;
+        instance.children = children;
+
+        // make reference from old id to new object
+        newGameObjectsMap[instance.uuid] = { original: instance, clone: clone };
+
+        if (instance.type === "SkinnedMesh") {
+            skinnedMeshesMap[instance.uuid] = { original: instance, clone: clone };
+        }
+
+        // DO NOT EVER RENAME BECAUSE IT BREAKS / MIGHT BREAK ANIMATIONS
+        // clone.name += " (Clone)";
+
+        if (opts?.visible !== undefined)
+            clone.visible = opts.visible;
+
+        if (opts?.idProvider) {
+            clone.uuid = opts.idProvider.generateUUID();
+            const cloneGo: GameObject = clone as GameObject;
+            if (cloneGo) cloneGo.guid = clone.uuid;
+        }
+
+        if (instance.animations && instance.animations.length > 0) {
+            clone.animations = [...instance.animations];
+        }
+
+        const parent = instance.parent;
+        if (parent) {
+            parent.add(clone);
+        }
+
+        // apply transform
+        if (opts?.position) {
+            threeutils.setWorldPosition(clone, opts.position);
+        }
+        else clone.position.copy(instance.position);
+        if (opts?.rotation) {
+            threeutils.setWorldQuaternion(clone, opts.rotation);
+            // clone.quaternion.copy(opts.rotation);
+        }
+        else clone.quaternion.copy(instance.quaternion);
+        if (opts?.scale) {
+            // TODO: make set world scale work
+            clone.scale.copy(opts.scale);
+        }
+        else clone.scale.copy(instance.scale);
+
+        if (opts?.parent && opts.parent !== "scene") {
+            let requestedParent: Object3D | null = null;
+            if (typeof opts.parent === "string") {
+                requestedParent = utils.tryFindObject(opts.parent, context.scene, true);
+            }
+            else {
+                requestedParent = opts.parent;
+            }
+            if (requestedParent) {
+                const func = opts.keepWorldPosition === true ? requestedParent.attach : requestedParent.add;
+                if (!func) console.error("Invalid parent object", requestedParent, "received when instantiating:", instance);
+                else func.call(requestedParent, clone);
+            }
+            else console.warn("could not find parent:", opts.parent);
+        }
+
+        for (const [key, value] of Object.entries(instance.userData)) {
+            if (key === "components") continue;
+            clone.userData[key] = value;
+        }
+
+        if (instance.userData?.components) {
+            const components = instance.userData.components;
+            const newComponents: Behaviour[] = [];
+            clone.userData.components = newComponents;
+            for (let i = 0; i < components.length; i++) {
+                const comp = components[i];
+                const copy = Object.create(comp);
+                Object.assign(copy, comp);
+                newComponents.push(copy);
+                copy.gameObject = clone;
+                // copy.transform = clone;
+                componentsList.push(copy);
+
+            }
+        }
+
+        // children should just clone the original transform
+        if (opts) {
+            opts.position = undefined;
+            opts.rotation = undefined;
+            opts.scale = undefined;
+            opts.parent = undefined;
+        }
+
+        for (const ch in instance.children) {
+            const child = instance.children[ch];
+            const newChild = GameObject.internalInstantiate(context, child as GameObject, opts, componentsList, newGameObjectsMap, skinnedMeshesMap);
+            if (newChild)
+                clone.add(newChild);
+        }
+
+        return clone;
+
+    }
+
+    private static resolveAndBindSkinnedMeshBones(
+        skinnedMeshes: { [key: string]: NewGameObjectReferenceInfo },
+        newObjectsMap: { [key: string]: NewGameObjectReferenceInfo }
+    ) {
+        for (const key in skinnedMeshes) {
+            const val = skinnedMeshes[key];
+            const original = val.original as THREE.SkinnedMesh;
+            const originalSkeleton = original.skeleton;
+            const clone = val.clone as THREE.SkinnedMesh;
+            // clone.updateWorldMatrix(true, true);
+            if (!originalSkeleton) {
+                console.warn("Skinned mesh has no skeleton?", val);
+                continue;
+            }
+            const originalBones = originalSkeleton.bones;
+            const clonedSkeleton = clone.skeleton.clone();
+
+            clone.skeleton = clonedSkeleton;
+            clone.bindMatrix.clone().copy(original.bindMatrix);
+            // console.log(clone.bindMatrix)
+            clone.bindMatrixInverse.copy(original.bindMatrixInverse);
+            // clone.bindMatrix.multiplyScalar(.025);
+            // console.assert(originalSkeleton.uuid !== clonedSkeleton.uuid);
+            // console.assert(originalBones.length === clonedSkeleton.bones.length);
+            const bones: Array<THREE.Bone> = [];
+            clonedSkeleton.bones = bones;
+            for (let i = 0; i < originalBones.length; i++) {
+                const bone = originalBones[i];
+                const newBoneInfo = newObjectsMap[bone.uuid];
+                const clonedBone = newBoneInfo.clone as THREE.Bone;
+                // console.log("NEW BONE: ", clonedBone, "BEFORE", newBoneInfo.original);
+                bones.push(clonedBone);
+            }
+            // clone.skeleton = new THREE.Skeleton(bones);
+            // clone.skeleton.update();
+            // clone.pose();
+            // clone.scale.set(1,1,1);
+            // clone.position.y += .1;
+            // console.log("ORIG", original, "CLONE", clone);
+        }
+        for (const key in skinnedMeshes) {
+            const clone = skinnedMeshes[key].clone as THREE.SkinnedMesh;
+            clone.skeleton.update();
+            // clone.skeleton.calculateInverses();
+            clone.bind(clone.skeleton, clone.bindMatrix);
+            clone.updateMatrixWorld(true);
+            // clone.pose();
+        }
+    }
+
+    // private static bindNewSkinnedMeshBones(source, clone) {
+    //     const sourceLookup = new Map();
+    //     const cloneLookup = new Map();
+    //     // const clone = source.clone(false);
+
+    //     function parallelTraverse(a, b, callback) {
+    //         callback(a, b);
+    //         for (let i = 0; i < a.children.length; i++) {
+    //             parallelTraverse(a.children[i], b.children[i], callback);
+    //         }
+    //     }
+    //     parallelTraverse(source, clone, function (sourceNode, clonedNode) {
+    //         sourceLookup.set(clonedNode, sourceNode);
+    //         cloneLookup.set(sourceNode, clonedNode);
+    //     });
+
+    //     clone.traverse(function (node) {
+    //         if (!node.isSkinnedMesh) return;
+    //         const clonedMesh = node;
+    //         const sourceMesh = sourceLookup.get(node);
+    //         const sourceBones = sourceMesh.skeleton.bones;
+
+    //         clonedMesh.skeleton = sourceMesh.skeleton.clone();
+    //         clonedMesh.bindMatrix.copy(sourceMesh.bindMatrix);
+
+    //         clonedMesh.skeleton.bones = sourceBones.map(function (bone) {
+    //             return cloneLookup.get(bone);
+    //         });
+    //         clonedMesh.bind(clonedMesh.skeleton, clonedMesh.bindMatrix);
+    //     });
+    //     return clone;
+
+    // }
+
+    private static resolveReferences(newObjectsMap: { [key: string]: NewGameObjectReferenceInfo }) {
+        // for every object that is newly created we want to update references to their newly created counterparts
+        // e.g. a collider instance referencing a rigidbody instance should be updated so that 
+        // the cloned collider does not reference the cloned rigidbody (instead of the original rigidbody)
+        for (const key in newObjectsMap) {
+            const val = newObjectsMap[key];
+            const clone = val.clone;
+            // resolve references
+            if (clone.userData?.components) {
+                for (let i = 0; i < clone.userData.components.length; i++) {
+                    const copy = clone.userData.components[i];
+                    // find referenced within a cloned gameobject
+                    const entries = Object.entries(copy);
+                    // console.log(copy, entries);
+                    for (const [key, value] of entries) {
+                        if (Array.isArray(value)) {
+                            const clonedArray: Array<any> = [];
+                            copy[key] = clonedArray;
+                            // console.log(copy, key, value, copy[key]);
+                            for (let i = 0; i < value.length; i++) {
+                                const entry = value[i];
+                                // push value types into new array
+                                if (typeof entry !== "object") {
+                                    clonedArray.push(entry);
+                                    continue;
+                                }
+                                const res: any = this.postProcessNewInstance(copy, key, entry, newObjectsMap);
+                                if (res !== undefined)
+                                    clonedArray.push(res);
+                                else clonedArray.push(entry);
+                            }
+                            // console.log(copy[key])
+                        }
+                        else if (typeof value === "object") {
+                            const res = this.postProcessNewInstance(copy, key, value, newObjectsMap);
+                            if (res !== undefined) {
+                                copy[key] = res;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+    }
+
+    private static postProcessNewInstance(copy: THREE.Object3D, key: string, value, newObjectsMap: { [key: string]: NewGameObjectReferenceInfo }) {
+        if (value instanceof Component || value instanceof Behaviour) {
+            const originalGameObjectReference = value["gameObject"];
+            // console.log(key, value, originalGameObjectReference);
+            if (originalGameObjectReference) {
+                const id = originalGameObjectReference.uuid;
+                const newGameObject = newObjectsMap[id]?.clone;
+                if (!newGameObject) {
+                    // reference has not changed!
+                    if (debug)
+                        console.log("reference did not change", key, copy, value);
+                    return;
+                }
+                const index = originalGameObjectReference.userData.components.indexOf(value);
+                if (index >= 0) {
+                    if (debug)
+                        console.log(key, id);
+                    const found = newGameObject.userData.components[index];
+                    return found;
+                }
+                else {
+                    console.warn("could not find component", key, value);
+                }
+            }
+        } else if (value instanceof THREE.Object3D) {
+            // console.log(value);
+            if (key === "gameObject") return;
+            const originalGameObjectReference = value;
+            if (originalGameObjectReference) {
+                const id = originalGameObjectReference.uuid;
+                const newGameObject = newObjectsMap[id]?.clone;
+                if (newGameObject) {
+                    if (debug)
+                        console.log(key, "old", value, "new", newGameObject);
+                    return newGameObject;
+                }
+            }
+        }
+    }
+
+    public static destroySynced(instance: THREE.Object3D | Component, context?: Context, recursive: boolean = true) {
+        if (!instance) return;
+        const go = instance as GameObject;
+        context = context ?? Context.Current;
+        syncDestroy(go, context.connection, recursive);
+    }
+
+    public static destroy(instance: THREE.Object3D | Component, recursive: boolean = true, isRoot: boolean = true) {
+        const comp = instance as Component;
+        if (comp.isComponent) {
+            comp.destroy();
+            return;
+        }
+
+        const obj = instance as GameObject;
+        if (debug) console.log(obj);
+
+        if (recursive && obj.children) {
+            for (const ch of obj.children) {
+                GameObject.destroy(ch, recursive, false);
+            }
+        }
+
+        const components = obj.userData.components;
+        if (components) {
+            let lastLength = components.length;
+            for (let i = 0; i < components.length; i++) {
+                const comp: Behaviour = components[i];
+                if (comp.destroy) {
+                    if (debug) console.log("destroying", comp);
+                    comp.destroy();
+                }
+                // components will  be removed from componentlist in destroy
+                if (components.length < lastLength) {
+                    lastLength = components.length;
+                    i--;
+                }
+            }
+        }
+        if (isRoot)
+            obj.removeFromParent();
+    }
+
+    /**
+     * Add an object to parent and also ensure all components are being registered
+     */
+    public static add(instance: THREE.Object3D | null | undefined, parent: THREE.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);
+        main.updateActiveInHierarchyWithoutEventCall(instance);
+        if (context) {
+            GameObject.foreachComponent(instance, (comp: Component) => {
+                main.addScriptToArrays(comp, context!);
+                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: THREE.Object3D | null | undefined) {
+        if (!instance) return;
+        instance.parent?.remove(instance);
+        GameObject.foreachComponent(instance, (comp) => {
+            main.processRemoveFromScene(comp);
+        }, true);
+    }
+
+    public static invokeOnChildren(go: THREE.Object3D | null | undefined, functionName: string | FunctionName, ...args: any) {
+        this.invoke(go, functionName, true, args);
+    }
+
+    public static invoke(go: THREE.Object3D | null | undefined, functionName: string | FunctionName, children: boolean = false, ...args: any) {
+        if (!go) return;
+        // console.log(go);
+        this.foreachComponent(go, c => {
+            const fn = c[functionName];
+            if (fn && typeof fn === "function") {
+                const bound = fn.bind(c);
+                // console.log(c, bound)
+                bound(...args)
+            }
+        }, children);
+    }
+
+    public static addNewComponent<T extends Behaviour>(go: GameObject | THREE.Object3D, type: ConstructorConcrete<T>, callAwake: boolean = true): T {
+        const instance = new type();
+        object.addNewComponentInstance(instance, go, callAwake);
+        return instance;
+    }
+
+    public static addComponent(go: GameObject, instance: Component): void {
+        if (instance.gameObject == null) {
+            throw new Error("Did you mean to create a new component? Use addNewComponent");
+        }
+        object.moveComponentInstance(instance, go);
+    }
+
+    public static removeComponent(instance: Component): Component {
+        object.removeComponent(instance.gameObject, instance);
+        return instance;
+    }
+
+    public static getOrAddComponent<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T> | null): T {
+        const comp = this.getComponent(go, typeName);
+        if (comp) return comp;
+        return this.addNewComponent(go, typeName as unknown as ConstructorConcrete<Behaviour>) as unknown as T;
+    }
+
+    public static getComponent<T>(go: GameObject | THREE.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 object.getComponent(typeName, go);
+    }
+
+    public static getComponents<T>(go: GameObject | THREE.Object3D | null, typeName: Constructor<T> | null, arr: T[] | null = null): T[] {
+        if (go === null) return arr ?? [];
+        return object.getComponents(typeName, go, arr);
+    }
+
+    public static findByGuid(guid: string, hierarchy: THREE.Object3D): GameObject | Behaviour | null | undefined {
+        return utils.tryFindObject(guid, hierarchy, true, true);
+    }
+
+    public static findObjectOfType<T>(typeName: Constructor<T> | string, context?: Context | THREE.Object3D, includeInactive: boolean = true): T | null {
+        return object.findObjectOfType(typeName, context, includeInactive);
+    }
+
+    public static findObjectsOfType<T>(typeName: Constructor<T>, context?: Context | THREE.Object3D): Array<T> {
+        const arr = [];
+        object.findObjectsOfType(typeName, arr, context);
+        return arr;
+    }
+
+    public static getComponentInChildren<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T> | null): T | null {
+        return object.getComponentInChildren(typeName, go);
+    }
+
+    public static getComponentsInChildren<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T> | null, arr: T[] | null = null): Array<T> {
+        return object.getComponentsInChildren(typeName, go, arr);
+    }
+
+    public static getComponentInParent<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T>): T | null {
+        return object.getComponentInParent(typeName, go);
+    }
+
+    public static getComponentsInParent<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T>, arr: Array<T> | null = null): Array<T> {
+        return object.getComponentsInParent(typeName, go, arr);
+    }
+
+    public static getAllComponents(go: GameObject | THREE.Object3D): Behaviour[] {
+        const componentsList = go.userData?.components;
+        const newList = [...componentsList];
+        return newList;
+    }
+
+    public static *iterateComponents(go: GameObject | THREE.Object3D) {
+        const list = go?.userData?.components;
+        if (list && Array.isArray(list)) {
+            for (let i = 0; i < list.length; i++) {
+                yield list[i];
+            }
+        }
+    }
+
+
+    abstract addNewComponent<T>(type: Constructor<T>): T | null;
+    abstract removeComponent(comp: Component): Component;
+    abstract getOrAddComponent<T>(go: GameObject | THREE.Object3D, typeName: Constructor<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>;
+}
+
+
+
+THREE.Object3D.prototype["addNewComponent"] = function <T extends Behaviour>(type: ConstructorConcrete<T>) {
+    return GameObject.addNewComponent(this, type);
+}
+
+THREE.Object3D.prototype["removeComponent"] = function (inst: Component) {
+    return GameObject.removeComponent(inst);
+}
+
+THREE.Object3D.prototype["getOrAddComponent"] = function <T>(typeName: Constructor<T> | null): T {
+    return GameObject.getOrAddComponent(this, typeName);
+}
+
+THREE.Object3D.prototype["getComponent"] = function <T>(type: Constructor<T>) {
+    return GameObject.getComponent(this, type);
+}
+
+THREE.Object3D.prototype["getComponents"] = function <T>(type: Constructor<T>, arr?: []) {
+    return GameObject.getComponents(this, type, arr);
+}
+
+THREE.Object3D.prototype["getComponentInChildren"] = function <T>(type: Constructor<T>) {
+    return GameObject.getComponentInChildren(this, type);
+}
+
+THREE.Object3D.prototype["getComponentsInChildren"] = function <T>(type: Constructor<T>, arr?: []) {
+    return GameObject.getComponentsInChildren(this, type, arr);
+}
+
+THREE.Object3D.prototype["getComponentInParent"] = function <T>(type: Constructor<T>) {
+    return GameObject.getComponentInParent(this, type);
+}
+
+THREE.Object3D.prototype["getComponentsInParent"] = function <T>(type: Constructor<T>, arr?: []) {
+    return GameObject.getComponentsInParent(this, type, arr);
+}
+
+// function patch_THREEObject3D() {
+//     const props = Object.getOwnPropertyNames(GameObject.prototype);
+//     for (const propName in props) {
+//         const prop = props[propName];
+//         if (prop === "constructor") continue;
+//         const fn = GameObject.prototype[prop];
+//         THREE.Object3D.prototype[prop] = fn;
+//     }
+// }
+// patch_THREEObject3D();
+
+
+class Component implements 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(): THREE.Scene { return this.context.scene; }
+
+    get layer(): number {
+        return this.gameObject?.userData?.layer;
+    }
+
+    get name(): string {
+        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)
+            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;
+    }
+
+    gameObject!: GameObject;
+    guid: string = "invalid";
+    sourceId?: SourceIdentifier;
+    // transform: THREE.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;
+
+    // TODO: can we not have these and then check in update loop if they are implemented (magick methods) ?
+    awake() { }
+    // update() { }
+    onEnable() { }
+    onDisable() { }
+    onDestroy() {
+        this.__destroyed = true;
+    }
+    start?(): void;
+    // available update loop events:
+    // earlyUpdate, update, lateUpdate, onBeforeRender, onAfterRender
+    earlyUpdate?(): void;
+    update?(): void;
+    lateUpdate?(): void;
+    onBeforeRender?(frame: THREE.XRFrame | null): void;
+    onAfterRender?(): void;
+
+    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() {
+        return this.__destroyed;
+    }
+
+    public destroy() {
+        if (this.destroyed) return;
+        // console.log("destroy", this);
+        object.destroyComponentInstance(this);
+    }
+
+    protected __didAwake: boolean = false;
+    private __didStart: boolean = false;
+    protected __didEnable: boolean = false;
+    protected __isEnabled: boolean | undefined = undefined;
+    private __destroyed: boolean = false;
+
+    __internalNewInstanceCreated() {
+        this.__didAwake = false;
+        this.__didStart = false;
+        this.__didEnable = false;
+        this.__isEnabled = undefined;
+        this.__destroyed = false;
+    }
+
+    __internalAwake() {
+        if (this.__didAwake) return;
+        // console.log("__internalAwake");
+        this.__didAwake = true;
+        // this.gameObject.test();
+
+        this.awake();
+    }
+
+    __internalStart() {
+        if (this.__didStart) return;
+        this.__didStart = true;
+        if (this.start) this.start();
+    }
+
+    __internalEnable() {
+        if (this.__didEnable) return;
+        // console.trace("INTERNAL ENABLE");
+        this.__didEnable = true;
+        this.onEnable();
+    }
+
+    __internalDisable() {
+        if (!this.__didEnable) return;
+        this.__didEnable = false;
+        this.onDisable();
+    }
+
+    constructor() {
+        this.__internalNewInstanceCreated();
+    }
+
+
+
+    // TODO move this to threeutils
+
+    // we need a copy for modifying the values to local space
+    private static _worldPositionBuffer: THREE.Vector3 = new THREE.Vector3();
+    private static _worldQuaternionBuffer: THREE.Quaternion = new THREE.Quaternion();
+    private static _worldEulerBuffer: THREE.Euler = new THREE.Euler();
+
+    private _worldPosition: THREE.Vector3 | undefined = undefined;
+    private _worldQuaternion: THREE.Quaternion | undefined = undefined;
+    private static _tempQuaternionBuffer2: THREE.Quaternion = new THREE.Quaternion();
+    private _worldEuler: THREE.Euler | undefined = undefined;
+    private _worldRotation: THREE.Vector3 | undefined = undefined;
+
+    get worldPosition(): THREE.Vector3 {
+        if (!this._worldPosition) this._worldPosition = new THREE.Vector3();
+        threeutils.getWorldPosition(this.gameObject, this._worldPosition);
+        // this.gameObject.getWorldPosition(this._worldPosition);
+        return this._worldPosition;
+    }
+
+    set worldPosition(val: THREE.Vector3) {
+        threeutils.setWorldPosition(this.gameObject, val);
+    }
+
+    setWorldPosition(x: number, y: number, z: number) {
+        Component._worldPositionBuffer.set(x, y, z);
+        this.worldPosition = Component._worldPositionBuffer;
+    }
+
+
+    get worldQuaternion(): THREE.Quaternion {
+        if (!this._worldQuaternion) this._worldQuaternion = new THREE.Quaternion();
+        return threeutils.getWorldQuaternion(this.gameObject, this._worldQuaternion);
+    }
+    set worldQuaternion(val: THREE.Quaternion) {
+        threeutils.setWorldQuaternion(this.gameObject, val);
+    }
+    setWorldQuaternion(x: number, y: number, z: number, w: number) {
+        Component._worldQuaternionBuffer.set(x, y, z, w);
+        this.worldQuaternion = Component._worldQuaternionBuffer;
+    }
+
+
+    // world euler (in radians)
+    get worldEuler(): THREE.Euler {
+        if (!this._worldEuler) this._worldEuler = new THREE.Euler();
+        this._worldEuler.setFromQuaternion(this.worldQuaternion);
+        return this._worldEuler;
+    }
+
+    // world euler (in radians)
+    set worldEuler(val: THREE.Euler) {
+        if (!this._worldQuaternion) this._worldQuaternion = new THREE.Quaternion();
+        this._worldQuaternion?.setFromEuler(val);
+        this.worldQuaternion = this._worldQuaternion;
+    }
+
+    // returns rotation in degrees
+    get worldRotation(): THREE.Vector3 {
+        const rot = this.worldEuler;
+        if (!this._worldRotation) this._worldRotation = new THREE.Vector3();
+        const wr = this._worldRotation;
+        wr.set(rot.x, rot.y, rot.z);
+        wr.x = Mathf.toDegrees(wr.x);
+        wr.y = Mathf.toDegrees(wr.y);
+        wr.z = Mathf.toDegrees(wr.z);
+        return wr;
+    }
+
+    set worldRotation(val: THREE.Vector3) {
+        this.setWorldRotation(val.x, val.y, val.z, true);
+    }
+
+    setWorldRotation(x: number, y: number, z: number, degrees: boolean = true) {
+        if (degrees) {
+            x = Mathf.toRadians(x);
+            y = Mathf.toRadians(y);
+            z = Mathf.toRadians(z);
+        }
+        Component._worldEulerBuffer.set(x, y, z);
+        Component._worldQuaternionBuffer.setFromEuler(Component._worldEulerBuffer);
+        this.worldQuaternion = Component._worldQuaternionBuffer;
+    }
+
+    private static _forward: THREE.Vector3 = new THREE.Vector3(0, 0, 1);
+    public get forward(): THREE.Vector3 {
+
+        return Component._forward.set(0, 0, 1).applyQuaternion(this.worldQuaternion);
+    }
+
+
+    
+    // EventTarget implementation:
+
+    private _eventListeners = new Map<string, EventListener[]>();
+
+    addEventListener(type: string, listener: EventListener) {
+        this._eventListeners[type] = this._eventListeners[type] || [];
+        this._eventListeners[type].push(listener);
+    }
+
+    removeEventListener(type: string, listener: EventListener) {
+        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 (!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;
+    }
+
+}
+
+class Behaviour extends Component {
+    // isActiveAndEnabled: boolean = false;
+
+    get enabled(): boolean {
+        return this.__isEnabled ?? true; // if it has no enabled field it is always enabled
+    }
+    set enabled(val: boolean) {
+
+        // 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;
+        }
+
+        if (val === this.__isEnabled) return;
+        
+        this.__isEnabled = val;
+        // console.log(val);
+        // need to check here because codegen is calling this before everything is setup
+        if (!this.__didAwake) return;
+        if (val) {
+            this.__internalEnable();
+        } else {
+            this.__internalDisable();
+        }
+    }
+}
+
+export { Behaviour, Component, GameObject };