@needle-tools/engine 2.24.0-pre

package/lib/engine-components/Component.js

@@ -0,0 +1,895 @@
+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 { InstantiateIdProvider, syncDestroy, syncInstantiate } from "../engine/engine_networking_instantiate";
+// export interface ISerializationCallbackReceiver {
+//     onBeforeSerialize?(): object | void;
+//     onAfterSerialize?();
+//     onBeforeDeserialize?(data?: any);
+//     onAfterDeserialize?();
+//     onDeserialize?(key: string, value: any): any | void;
+// }
+const debug = utils.getParam("debugcomponents");
+export var HideFlags;
+(function (HideFlags) {
+    HideFlags[HideFlags["None"] = 0] = "None";
+    HideFlags[HideFlags["HideInHierarchy"] = 1] = "HideInHierarchy";
+    HideFlags[HideFlags["HideInInspector"] = 2] = "HideInInspector";
+    HideFlags[HideFlags["DontSaveInEditor"] = 4] = "DontSaveInEditor";
+    HideFlags[HideFlags["NotEditable"] = 8] = "NotEditable";
+    HideFlags[HideFlags["DontSaveInBuild"] = 16] = "DontSaveInBuild";
+    HideFlags[HideFlags["DontUnloadUnusedAsset"] = 32] = "DontUnloadUnusedAsset";
+    HideFlags[HideFlags["DontSave"] = 52] = "DontSave";
+    HideFlags[HideFlags["HideAndDontSave"] = 61] = "HideAndDontSave";
+})(HideFlags || (HideFlags = {}));
+export class InstantiateOptions {
+    idProvider;
+    //** parent guid */
+    parent;
+    /** for duplicatable parenting */
+    keepWorldPosition;
+    position;
+    rotation;
+    scale;
+    visible;
+    context;
+}
+THREE.Object3D.prototype["SetActive"] = function (active) {
+    this.visible = active;
+};
+class GameObject extends THREE.Object3D {
+    guid;
+    static setActive(go, active) {
+        if (!go)
+            return;
+        go.visible = active;
+    }
+    static isActiveSelf(go) {
+        return go.visible || GameObject.isUsingInstancing(go);
+    }
+    static isActiveInHierarchy(go) {
+        return go[activeInHierarchyFieldName] || GameObject.isUsingInstancing(go);
+    }
+    static markAsInstancedRendered(go, instanced) {
+        go["__isUsingInstancing"] = instanced;
+    }
+    static isUsingInstancing(instance) { return instance["__isUsingInstancing"] === true; }
+    static foreachComponent(instance, cb, recursive = true) {
+        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;
+            }
+        }
+    }
+    static instantiateSynced(instance, opts) {
+        if (!instance)
+            return null;
+        return syncInstantiate(instance, opts);
+    }
+    static instantiate(instance, opts = null) {
+        if (instance === null)
+            return null;
+        let options = 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;
+            }
+            else {
+                // if (opts instanceof InstantiateOptions)
+                options = opts;
+                // 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 = [];
+        const goMapping = {}; // used to resolve references on components to components on other gameobjects to their new counterpart
+        const skinnedMeshes = {};
+        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 = {};
+        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;
+    }
+    static internalInstantiate(context, instance, opts, componentsList, newGameObjectsMap, skinnedMeshesMap) {
+        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;
+        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 = clone;
+            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 = 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 = [];
+            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, opts, componentsList, newGameObjectsMap, skinnedMeshesMap);
+            if (newChild)
+                clone.add(newChild);
+        }
+        return clone;
+    }
+    static resolveAndBindSkinnedMeshBones(skinnedMeshes, newObjectsMap) {
+        for (const key in skinnedMeshes) {
+            const val = skinnedMeshes[key];
+            const original = val.original;
+            const originalSkeleton = original.skeleton;
+            const clone = val.clone;
+            // 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 = [];
+            clonedSkeleton.bones = bones;
+            for (let i = 0; i < originalBones.length; i++) {
+                const bone = originalBones[i];
+                const newBoneInfo = newObjectsMap[bone.uuid];
+                const clonedBone = newBoneInfo.clone;
+                // 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;
+            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;
+    // }
+    static resolveReferences(newObjectsMap) {
+        // 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 = [];
+                            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 = 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;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    static postProcessNewInstance(copy, key, value, newObjectsMap) {
+        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;
+                }
+            }
+        }
+    }
+    static destroySynced(instance, context, recursive = true) {
+        if (!instance)
+            return;
+        const go = instance;
+        context = context ?? Context.Current;
+        syncDestroy(go, context.connection, recursive);
+    }
+    static destroy(instance, recursive = true, isRoot = true) {
+        const comp = instance;
+        if (comp.isComponent) {
+            comp.destroy();
+            return;
+        }
+        const obj = instance;
+        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 = 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
+     */
+    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);
+        main.updateActiveInHierarchyWithoutEventCall(instance);
+        if (context) {
+            GameObject.foreachComponent(instance, (comp) => {
+                main.addScriptToArrays(comp, context);
+                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);
+        GameObject.foreachComponent(instance, (comp) => {
+            main.processRemoveFromScene(comp);
+        }, true);
+    }
+    static invokeOnChildren(go, functionName, ...args) {
+        this.invoke(go, functionName, true, args);
+    }
+    static invoke(go, functionName, children = false, ...args) {
+        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);
+    }
+    static addNewComponent(go, type, callAwake = true) {
+        const instance = new type();
+        object.addNewComponentInstance(instance, go, callAwake);
+        return instance;
+    }
+    static addComponent(go, instance) {
+        if (instance.gameObject == null) {
+            throw new Error("Did you mean to create a new component? Use addNewComponent");
+        }
+        object.moveComponentInstance(instance, go);
+    }
+    static removeComponent(instance) {
+        object.removeComponent(instance.gameObject, instance);
+        return instance;
+    }
+    static getOrAddComponent(go, typeName) {
+        const comp = this.getComponent(go, typeName);
+        if (comp)
+            return comp;
+        return this.addNewComponent(go, typeName);
+    }
+    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 object.getComponent(typeName, go);
+    }
+    static getComponents(go, typeName, arr = null) {
+        if (go === null)
+            return arr ?? [];
+        return object.getComponents(typeName, go, arr);
+    }
+    static findByGuid(guid, hierarchy) {
+        return utils.tryFindObject(guid, hierarchy, true, true);
+    }
+    static findObjectOfType(typeName, context, includeInactive = true) {
+        return object.findObjectOfType(typeName, context, includeInactive);
+    }
+    static findObjectsOfType(typeName, context) {
+        const arr = [];
+        object.findObjectsOfType(typeName, arr, context);
+        return arr;
+    }
+    static getComponentInChildren(go, typeName) {
+        return object.getComponentInChildren(typeName, go);
+    }
+    static getComponentsInChildren(go, typeName, arr = null) {
+        return object.getComponentsInChildren(typeName, go, arr);
+    }
+    static getComponentInParent(go, typeName) {
+        return object.getComponentInParent(typeName, go);
+    }
+    static getComponentsInParent(go, typeName, arr = null) {
+        return object.getComponentsInParent(typeName, go, 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];
+            }
+        }
+    }
+}
+THREE.Object3D.prototype["addNewComponent"] = function (type) {
+    return GameObject.addNewComponent(this, type);
+};
+THREE.Object3D.prototype["removeComponent"] = function (inst) {
+    return GameObject.removeComponent(inst);
+};
+THREE.Object3D.prototype["getOrAddComponent"] = function (typeName) {
+    return GameObject.getOrAddComponent(this, typeName);
+};
+THREE.Object3D.prototype["getComponent"] = function (type) {
+    return GameObject.getComponent(this, type);
+};
+THREE.Object3D.prototype["getComponents"] = function (type, arr) {
+    return GameObject.getComponents(this, type, arr);
+};
+THREE.Object3D.prototype["getComponentInChildren"] = function (type) {
+    return GameObject.getComponentInChildren(this, type);
+};
+THREE.Object3D.prototype["getComponentsInChildren"] = function (type, arr) {
+    return GameObject.getComponentsInChildren(this, type, arr);
+};
+THREE.Object3D.prototype["getComponentInParent"] = function (type) {
+    return GameObject.getComponentInParent(this, type);
+};
+THREE.Object3D.prototype["getComponentsInParent"] = function (type, 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 {
+    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() {
+        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)
+            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;
+    }
+    gameObject;
+    guid = "invalid";
+    sourceId;
+    // 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;
+    }
+    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;
+        // console.log("destroy", this);
+        object.destroyComponentInstance(this);
+    }
+    __didAwake = false;
+    __didStart = false;
+    __didEnable = false;
+    __isEnabled = undefined;
+    __destroyed = 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
+    static _worldPositionBuffer = new THREE.Vector3();
+    static _worldQuaternionBuffer = new THREE.Quaternion();
+    static _worldEulerBuffer = new THREE.Euler();
+    _worldPosition = undefined;
+    _worldQuaternion = undefined;
+    static _tempQuaternionBuffer2 = new THREE.Quaternion();
+    _worldEuler = undefined;
+    _worldRotation = undefined;
+    get worldPosition() {
+        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) {
+        threeutils.setWorldPosition(this.gameObject, val);
+    }
+    setWorldPosition(x, y, z) {
+        Component._worldPositionBuffer.set(x, y, z);
+        this.worldPosition = Component._worldPositionBuffer;
+    }
+    get worldQuaternion() {
+        if (!this._worldQuaternion)
+            this._worldQuaternion = new THREE.Quaternion();
+        return threeutils.getWorldQuaternion(this.gameObject, this._worldQuaternion);
+    }
+    set worldQuaternion(val) {
+        threeutils.setWorldQuaternion(this.gameObject, val);
+    }
+    setWorldQuaternion(x, y, z, w) {
+        Component._worldQuaternionBuffer.set(x, y, z, w);
+        this.worldQuaternion = Component._worldQuaternionBuffer;
+    }
+    // world euler (in radians)
+    get worldEuler() {
+        if (!this._worldEuler)
+            this._worldEuler = new THREE.Euler();
+        this._worldEuler.setFromQuaternion(this.worldQuaternion);
+        return this._worldEuler;
+    }
+    // world euler (in radians)
+    set worldEuler(val) {
+        if (!this._worldQuaternion)
+            this._worldQuaternion = new THREE.Quaternion();
+        this._worldQuaternion?.setFromEuler(val);
+        this.worldQuaternion = this._worldQuaternion;
+    }
+    // returns rotation in degrees
+    get worldRotation() {
+        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) {
+        this.setWorldRotation(val.x, val.y, val.z, true);
+    }
+    setWorldRotation(x, y, z, degrees = 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;
+    }
+    static _forward = new THREE.Vector3(0, 0, 1);
+    get forward() {
+        return Component._forward.set(0, 0, 1).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 (!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() {
+        return this.__isEnabled ?? true; // if it has no enabled field it is always enabled
+    }
+    set enabled(val) {
+        // 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 };
+//# sourceMappingURL=Component.js.map