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

package/src/engine-components/Component.ts

@@ -1,22 +1,15 @@
 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";
-import { Collision } from "../engine/engine_physics";
-import * as Object3DExtensions from "./js-extensions/Object3D";
-import { InstancingUtil } from "../engine/engine_instancing";
-
-export interface UIDProvider {
-    seed: number;
-    generateUUID(): string;
-}
+import { syncDestroy, syncInstantiate } from "../engine/engine_networking_instantiate";
+import { ConstructorConcrete, SourceIdentifier, IComponent, IGameObject, Constructor, GuidsMap, UIDProvider, Collision } from "../engine/engine_types";
+import { addNewComponentInstance, destroyComponentInstance, findObjectOfType, findObjectsOfType, getComponent, getComponentInChildren, getComponentInParent, getComponents, getComponentsInChildren, getComponentsInParent, getOrAddComponent, moveComponentInstance, removeComponent } from "../engine/engine_components";
+import { findByGuid, destroy, InstantiateOptions, instantiate, HideFlags, foreachComponent, markAsInstancedRendered, isActiveInHierarchy, isActiveSelf, isUsingInstancing } from "../engine/engine_gameobject";
+
 
 // export interface ISerializationCallbackReceiver {
 //     onBeforeSerialize?(): object | void;
@@ -26,54 +19,7 @@ export interface UIDProvider {
 //     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;
-}
-
-
-abstract class GameObject extends THREE.Object3D implements THREE.Object3D {
+abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGameObject {
 
     guid: string | undefined;
 
@@ -86,450 +32,41 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D {
     }
 
     public static isActiveSelf(go: THREE.Object3D): boolean {
-        return go.visible || GameObject.isUsingInstancing(go);
+        return isActiveSelf(go);
     }
 
     public static isActiveInHierarchy(go: THREE.Object3D): boolean {
-        return go[activeInHierarchyFieldName] || GameObject.isUsingInstancing(go);
+        return isActiveInHierarchy(go);
     }
 
     public static markAsInstancedRendered(go: THREE.Object3D, instanced: boolean) {
-        go["__isUsingInstancing"] = instanced;
+        markAsInstancedRendered(go, instanced);	
     }
 
-    public static isUsingInstancing(instance: THREE.Object3D): boolean { return InstancingUtil.isUsingInstancing(instance); }
+    public static isUsingInstancing(instance: THREE.Object3D): boolean { return isUsingInstancing(instance); }
 
     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;
+        return foreachComponent(instance, cb as (comp : IComponent) => any, recursive);
     }
 
-    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 {
+    public static instantiateSynced(instance: GameObject | Object3D | null, opts: InstantiateOptions): GameObject | 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);
-        Object3DExtensions.apply(clone);
-        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;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
+        return syncInstantiate(instance as any, opts) as GameObject | null;
     }
 
-    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 instantiate(instance: GameObject | Object3D | null, opts: InstantiateOptions | null = null): GameObject | null {
+        return instantiate(instance, opts) as GameObject | null;
     }
 
     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);
+        syncDestroy(go as any, 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();
+        return destroy(instance, recursive, isRoot);
     }
 
     /**
@@ -570,11 +107,11 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D {
         }, true);
     }
 
-    public static invokeOnChildren(go: THREE.Object3D | null | undefined, functionName: string | FunctionName, ...args: any) {
+    public static invokeOnChildren(go: THREE.Object3D | null | undefined, functionName: string, ...args: any) {
         this.invoke(go, functionName, true, args);
     }
 
-    public static invoke(go: THREE.Object3D | null | undefined, functionName: string | FunctionName, children: boolean = false, ...args: any) {
+    public static invoke(go: THREE.Object3D | null | undefined, functionName: string, children: boolean = false, ...args: any) {
         if (!go) return;
         // console.log(go);
         this.foreachComponent(go, c => {
@@ -589,26 +126,25 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D {
 
     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;
+        //@ts-ignore
+        addNewComponentInstance(go, instance, 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);
+        moveComponentInstance(instance as any, go);
     }
 
     public static removeComponent(instance: Component): Component {
-        object.removeComponent(instance.gameObject, instance);
+        removeComponent(instance.gameObject, instance as any);
         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 getOrAddComponent<T extends IComponent>(go: GameObject | THREE.Object3D, typeName: ConstructorConcrete<T>): T {
+        return getOrAddComponent<any>(go, typeName);
     }
 
     public static getComponent<T>(go: GameObject | THREE.Object3D | null, typeName: Constructor<T> | null): T | null {
@@ -617,42 +153,43 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D {
         // 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);
+        return getComponent(typeName as any, 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);
+        return 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 findByGuid(guid: string, hierarchy: THREE.Object3D): GameObject | Component | null | undefined {
+        const res = findByGuid(guid, hierarchy);
+        return res as GameObject | Component | null | undefined;
     }
 
     public static findObjectOfType<T>(typeName: Constructor<T> | string, context?: Context | THREE.Object3D, includeInactive: boolean = true): T | null {
-        return object.findObjectOfType(typeName, context, includeInactive);
+        return findObjectOfType(typeName, context, includeInactive);
     }
 
     public static findObjectsOfType<T>(typeName: Constructor<T>, context?: Context | THREE.Object3D): Array<T> {
         const arr = [];
-        object.findObjectsOfType(typeName, arr, context);
+        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);
+        return 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 getComponentsInChildren<T extends IComponent>(go: GameObject | THREE.Object3D, typeName: Constructor<T>, arr: T[] | null = null): Array<T> {
+        return getComponentsInChildren<T>(typeName, go, arr ?? undefined) as T[]
     }
 
     public static getComponentInParent<T>(go: GameObject | THREE.Object3D | Array<Object3D>, typeName: Constructor<T>): T | null {
-        return object.getComponentInParent(typeName, go);
+        return 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);
+        return getComponentsInParent(typeName, go, arr);
     }
 
     public static getAllComponents(go: GameObject | THREE.Object3D): Behaviour[] {
@@ -684,7 +221,7 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D {
 
 
 
-class Component implements EventTarget {
+class Component implements IComponent, EventTarget {
 
     get isComponent(): boolean { return true; }
 
@@ -754,6 +291,12 @@ class Component implements EventTarget {
         return res;
     }
 
+    private set __isActiveInHierarchy(val: boolean)
+    {
+        if (!this.gameObject) return;
+        this.gameObject[activeInHierarchyFieldName] = val;
+    }
+
     gameObject!: GameObject;
     guid: string = "invalid";
     sourceId?: SourceIdentifier;
@@ -796,14 +339,13 @@ class Component implements EventTarget {
         this.context.unregisterCoroutineUpdate(routine, evt);
     }
 
-    public get destroyed() {
+    public get destroyed() : boolean {
         return this.__destroyed;
     }
 
     public destroy() {
-        if (this.destroyed) return;
-        // console.log("destroy", this);
-        object.destroyComponentInstance(this);
+        if (this.__destroyed) return;
+        this.__internalDestroy();
     }
 
     protected __didAwake: boolean = false;
@@ -836,11 +378,12 @@ class Component implements EventTarget {
         if (this.start) this.start();
     }
 
-    __internalEnable() {
-        if (this.__didEnable) return;
+    __internalEnable() : boolean {
+        if (this.__didEnable) return false;
         // console.trace("INTERNAL ENABLE");
         this.__didEnable = true;
         this.onEnable();
+        return true;
     }
 
     __internalDisable() {
@@ -851,7 +394,38 @@ class Component implements EventTarget {
         this._collisions?.clear();
     }
 
+    __internalDestroy() {
+        if (this.__destroyed) return;
+        this.__destroyed = true;
+        this.destroy?.call(this);
+        // console.log("destroy", this);
+        destroyComponentInstance(this as any);
+    }
+    
+    // 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;
+        }
+
+        // need to check here because codegen is calling this before everything is setup
+        if (!this.__didAwake) return;
+        if (val) {
+            this.__internalEnable();
+        } else {
+            this.__internalDisable();
+        }
+    }
+
     constructor() {
+        // super();
         this.__internalNewInstanceCreated();
     }
 
@@ -1052,9 +626,8 @@ class Component implements EventTarget {
         this.worldQuaternion = Component._worldQuaternionBuffer;
     }
 
-    private static _forward: THREE.Vector3 = new THREE.Vector3(0, 0, 1);
+    private static _forward: THREE.Vector3 = new THREE.Vector3();
     public get forward(): THREE.Vector3 {
-
         return Component._forward.set(0, 0, -1).applyQuaternion(this.worldQuaternion);
     }
 
@@ -1089,32 +662,6 @@ class Component implements EventTarget {
 }
 
 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 };