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

package/src/engine/engine_components.ts

@@ -1,4 +1,4 @@
-import { Object3D } from "three";
+import { Object3D, Scene } from "three";
 import { Constructor, ConstructorConcrete, IComponent as Component, IComponent, IGameObject } from "./engine_types";
 import { Context, registerComponent } from "./engine_setup";
 import { getParam } from "./engine_utils";
@@ -28,7 +28,7 @@ export function removeComponent(go: Object3D, componentInstance: IComponent) {
 }
 
 export function getOrAddComponent<T extends IComponent>(go: Object3D, typeName: ConstructorConcrete<T>): T {
-    const comp = getComponent(typeName, go);
+    const comp = getComponent(go, typeName);
     if (comp) return comp;
     const newInstance = new typeName();
     return addNewComponentInstance(go, newInstance) as unknown as T;
@@ -53,7 +53,7 @@ export function addNewComponentInstance<T extends IComponent>(obj: Object3D, com
     return componentInstance;
 }
 
-export function moveComponentInstance(componentInstance: IComponent, obj: Object3D) {
+export function moveComponentInstance(obj: Object3D, componentInstance: IComponent) {
     if (componentInstance.gameObject === obj) return;
     // TODO: update raycast array
     if (componentInstance.gameObject && componentInstance.gameObject.userData.components) {
@@ -85,13 +85,19 @@ export function destroyComponentInstance(componentInstance: IComponent) {
     // console.log("destroyed", index, componentInstance);
 }
 
-export function onGetComponent<T>(componentType: Constructor<T>, obj: Object3D, arr?: IComponent[]) {
+function onGetComponent<T>(obj: Object3D | null | undefined, componentType: Constructor<T>, arr?: T[]) {
+    if (obj === null || obj === undefined) return;
+    if (!obj.isObject3D) {
+        console.error("Object is not object3D");
+        return;
+    }
     if (!(obj?.userData?.components)) return null;
     if (debug)
         console.log("FIND", componentType);
+    if (componentType === undefined || componentType === null) return;
     for (let i = 0; i < obj.userData.components.length; i++) {
         const component = obj.userData.components[i];
-        if (componentType === null || component.constructor.name === componentType.name || component.constructor.name === componentType) {
+        if (componentType === null || component.constructor.name === componentType["name"] || component.constructor.name === componentType) {
             if (debug)
                 console.log("MATCH BY NAME", component)
             if (arr) arr.push(component);
@@ -116,59 +122,63 @@ export function onGetComponent<T>(componentType: Constructor<T>, obj: Object3D,
     return arr;
 }
 
-export function getComponent<T>(componentType: Constructor<T>, obj) {
-    return onGetComponent(componentType, obj);
+export function getComponent<T>(obj: Object3D, componentType: Constructor<T>) {
+    return onGetComponent(obj, componentType);
 }
 
-export function getComponents(componentType, obj, arr) {
+export function getComponents<T>(obj: Object3D, componentType: Constructor<T>, arr?: T[] | null): T[] {
     if (!arr) arr = [];
-    return onGetComponent(componentType, obj, arr);
+    return onGetComponent(obj, componentType, arr);
 }
 
-export function getComponentInChildren(componentType, obj, includeInactive?: boolean) {
-    const res = getComponent(componentType, obj);
+export function getComponentInChildren<T>(obj: Object3D, componentType: Constructor<T>, includeInactive?: boolean) {
+    const res = getComponent(obj, componentType);
     if (includeInactive === false && res.enabled === false) return null;
     if (res) return res;
     for (let i = 0; i < obj?.children?.length; i++) {
-        const res = getComponentInChildren(componentType, obj.children[i]);
+        const res = getComponentInChildren(obj.children[i], componentType);
         if (res) return res;
     }
     return null;
 }
 
-export function getComponentsInChildren<T extends IComponent>(componentType : Constructor<T>, obj : Object3D, arr?: T[]) {
+export function getComponentsInChildren<T>(obj: Object3D, componentType: Constructor<T>, arr?: T[]) {
     if (!arr) arr = [];
-    getComponents(componentType, obj, arr);
+    getComponents(obj, componentType, arr);
     for (let i = 0; i < obj?.children?.length; i++) {
-        getComponentsInChildren(componentType, obj.children[i], arr);
+        getComponentsInChildren(obj.children[i], componentType, arr);
     }
     return arr;
 }
 
-export function getComponentInParent(componentType, obj) {
+export function getComponentInParent<T>(obj: Object3D, componentType: Constructor<T>) {
     if (!obj) return null;
     if (Array.isArray(obj)) {
         for (let i = 0; i < obj.length; i++) {
             const o = tryGetObject(obj[i]);
-            const res = getComponentInParent(componentType, o);
+            const res = getComponentInParent(o, componentType);
             if (res) return res;
         }
         return null;
     }
     // console.log(obj);
-    const res = getComponent(componentType, obj);
+    const res = getComponent(obj, componentType);
     if (res) return res;
-    return getComponentInParent(componentType, obj.parent);
+    if (obj.parent)
+        return getComponentInParent(obj.parent, componentType);
+    return null;
 }
 
-export function getComponentsInParent(componentType, obj, arr) {
+export function getComponentsInParent<T>(obj: Object3D, componentType: Constructor<T>, arr?: T[] | null): T[] {
     if (!arr) arr = [];
     if (!obj) return arr;
-    getComponents(componentType, obj, arr);
-    return getComponentsInParent(componentType, obj.parent, arr);
+    getComponents(obj, componentType, arr);
+    if (obj.parent)
+        return getComponentsInParent(obj.parent, componentType, arr);
+    return arr;
 }
 
-export function findObjectOfType(type, contextOrScene, includeInactive) {
+export function findObjectOfType<T>(type: Constructor<T>, contextOrScene: Object3D | { scene: Scene }, includeInactive) {
     if (!type) return null;
     if (!contextOrScene) {
         contextOrScene = Context.Current;
@@ -177,18 +187,23 @@ export function findObjectOfType(type, contextOrScene, includeInactive) {
             return null;
         }
     }
-    const scene = contextOrScene.isScene === true || contextOrScene.isObject3D === true ? contextOrScene : contextOrScene?.scene;
+
+    let scene = contextOrScene as Scene;
+    if (!scene.isScene) scene = (contextOrScene as { scene: Scene })?.scene;
+    if (!scene) return null;
+
+    // const scene = contextOrScene.isScene === true || contextOrScene.isObject3D === true ? contextOrScene : contextOrScene?.scene;
     for (const i in scene.children) {
         const child = scene.children[i];
         if (includeInactive === false && child[activeInHierarchyFieldName] === false) continue;
         if (child.constructor == type) return child;
-        const res = getComponentInChildren(type, child);
+        const res = getComponentInChildren(child, type);
         if (res) return res;
     }
     return null;
 }
 
-export function findObjectsOfType(type, array, contextOrScene) {
+export function findObjectsOfType<T>(type: Constructor<T>, array: T[], contextOrScene) : T[] {
     if (!type) return array;
     if (!contextOrScene) {
         contextOrScene = Context.Current;
@@ -202,7 +217,7 @@ export function findObjectsOfType(type, array, contextOrScene) {
     for (const i in scene.children) {
         const child = scene.children[i];
         if (child.constructor == type) return child;
-        getComponentsInChildren(type, child, array);
+        getComponentsInChildren(child, type, array);
     }
     return array;
 }

package/src/engine/engine_element.ts

@@ -162,13 +162,14 @@ export class EngineElement extends HTMLElement {
             if (fn) {
                 this.classList.add("loading");
                 console.log("Needle Engine: Begin loading", alias ?? "");
+                const allowOverridingDefaultLoading = false;
                 // default loading can be overriden by calling preventDefault in the onload start event
                 const useDefaultLoading = this.dispatchEvent(new CustomEvent("loadstart", {
                     detail: {
                         context: this._context,
                         alias: alias
                     },
-                    cancelable: true
+                    cancelable: allowOverridingDefaultLoading
                 }));
                 if (!this._loadingView && useDefaultLoading)
                     this._loadingView = new EngineLoadingView(this);

package/src/engine/engine_element_loading.ts

@@ -127,6 +127,8 @@ export class EngineLoadingView implements ILoadingViewHandler {
 
     private createLoadingElement(existing?: HTMLElement): HTMLElement {
         this._loadingElement = existing || document.createElement("div");
+        this._loadingElement.style.width = "100%";
+
         const className = this._loadingElementOptions?.className ?? "loading";
         this._loadingElement.classList.add(className);
         if (this._loadingElementOptions?.additionalClasses) {
@@ -141,7 +143,7 @@ export class EngineLoadingView implements ILoadingViewHandler {
         }
 
         const loadingBarContainer = document.createElement("div");
-        const maxWidth = 20;
+        const maxWidth = 30;
         loadingBarContainer.style.display = "flex";
         loadingBarContainer.style.width = maxWidth + "%";
         loadingBarContainer.style.height = "2px";
@@ -171,6 +173,8 @@ export class EngineLoadingView implements ILoadingViewHandler {
         messageContainer.style.fontSize = ".8em";
         messageContainer.style.paddingTop = ".5em";
         messageContainer.style.color = "rgba(255,255,255,.5)";
+        // messageContainer.style.border = "1px solid rgba(255,255,255,.1)";
+        messageContainer.style.justifyContent = "center";
         this._loadingElement.appendChild(messageContainer);
 
         return this._loadingElement;

package/src/engine/engine_networking.ts

@@ -4,8 +4,7 @@
 let serverUrl = 'wss://needle-tiny-starter.glitch.me/socket';
 
 import { Websocket, WebsocketBuilder } from 'websocket-ts';
-import { Behaviour, GameObject } from '../engine-components/Component';
-import { Networking } from '../engine-components/Networking';
+// import { Networking } from '../engine-components/Networking';
 import { Context } from './engine_setup';
 import * as utils from "./engine_utils";
 import * as flatbuffers from 'flatbuffers';
@@ -16,6 +15,9 @@ import { IModel, INetworkConnection, SendQueue } from './engine_networking_types
 export const debugNet = utils.getParam("debugnet") ? true : false;
 export const debugOwner = debugNet || utils.getParam("debugowner") ? true : false;
 
+export interface INetworkingWebsocketUrlProvider {
+    getWebsocketUrl() : string | null;
+}
 
 export declare interface IConnectionData {
     id: string;
@@ -384,14 +386,20 @@ export class NetworkConnection implements INetworkConnection {
         }
     }
 
+    private netWebSocketUrlProvider? : INetworkingWebsocketUrlProvider;
+
+    public registerProvider(prov : INetworkingWebsocketUrlProvider){
+        this.netWebSocketUrlProvider = prov;
+    }
+
     public connect() {
         if (this.connected) return;
         if (debugNet)
             console.log("connecting");
         // this.channel = geckos({ port: 9208, url: 'http://127.0.0.1' });
         // this.channel.onConnect(this.onConnectGeckosIo.bind(this));
-        const networking = GameObject.findObjectOfType(Networking, this.context, false);
-        const overrideUrl = networking?.getWebsocketUrl();
+        // const networking = GameObject.findObjectOfType(Networking, this.context, false);
+        const overrideUrl = this.netWebSocketUrlProvider?.getWebsocketUrl();
         if (overrideUrl) {
             serverUrl = overrideUrl;
         }

package/src/engine/engine_physics.ts

@@ -4,10 +4,21 @@ import { Context } from './engine_setup';
 import cannonDebugger from 'cannon-es-debugger'
 import * as utils from "./engine_utils"
 import * as threeutils from "./engine_three_utils"
-import { IComponent as Component, IGameObject as GameObject, ICollider as Collider, IRigidbody as Rigidbody, ICollider, $physicsKey, Collision, CannonCollision } from './engine_types';
+import {
+    IComponent as Component,
+    IGameObject as GameObject,
+    ICollider,
+    IRigidbody as Rigidbody, $physicsKey,
+    Collision, CannonCollision,
+    ICollisionContext,
+    IComponent
+}
+    from './engine_types';
 import { Shape } from 'cannon-es';
 import { InstancingUtil } from './engine_instancing';
 import { foreachComponent } from './engine_gameobject';
+import { getComponentInChildren } from './engine_components';
+
 
 const debugPhysics = utils.getParam("debugphysics");
 const debugCollisions = utils.getParam("debugcollisions");
@@ -635,8 +646,10 @@ export class Physics {
         // console.log("START");
     }
 
+    private readonly collisionContext: ICollisionContext = new CollisionContext();
+
     private raiseCollisionEvents(obj: THREE.Object3D, event: CannonCollision) {
-        const collision = new Collision(obj, event);
+        const collision = new Collision(obj, event, this.collisionContext);
         if (debugCollisions)
             console.log("collision between", event.contact.bi, event.contact.bj, obj, event);
         foreachComponent(obj, (c: Component) => {
@@ -645,7 +658,7 @@ export class Physics {
 
         // handle triggers
         if (collision.collider && !collision.collider.attachedRigidbody && collision.collider.isTrigger) {
-            const collision2 = new Collision(collision.gameObject, event, true);
+            const collision2 = new Collision(collision.gameObject, event, this.collisionContext, true);
             foreachComponent(collision.gameObject, (c: Component) => {
                 c.__internalHandleCollision(collision2, true);
             });
@@ -659,7 +672,6 @@ export class Physics {
         const obj2 = args.bodyB[$physicsKey];
         // console.log(obj2);
 
-        
         foreachComponent(obj2, (c: Component) => {
             c.__internalHandleExitCollisionEvent(obj1, false);
         });
@@ -676,3 +688,21 @@ export class Physics {
     }
 
 }
+
+export interface IColliderProvider {
+    getCollider(obj: THREE.Object3D): ICollider;
+}
+
+let colliderProvider: IColliderProvider | null = null;
+export function registerColliderProvider(prov: IColliderProvider) {
+    colliderProvider = prov;
+}
+
+class CollisionContext implements ICollisionContext {
+
+    getCollider(obj: THREE.Object3D<THREE.Event>): ICollider {
+        return colliderProvider!.getCollider(obj);
+    }
+
+}
+

package/src/engine/engine_types.ts

@@ -27,6 +27,7 @@ export declare interface IGameObject extends Object3D {
 export interface IComponent {
     get isComponent(): boolean;
 
+
     gameObject: IGameObject;
     guid: string;
     enabled: boolean;
@@ -73,6 +74,8 @@ export interface IComponent {
 
     __internalHandleCollision(col: Collision, isTriggerCollision: boolean);
     __internalHandleExitCollisionEvent(obj: Object3D, isTriggerCollision: boolean);
+
+    get forward() : Vector3;
 }
 
 
@@ -99,7 +102,7 @@ export declare interface IRenderer extends IComponent {
 
 export declare interface ICollider extends IComponent {
     get isCollider();
-    attachedRigidbody: IRigidbody;
+    attachedRigidbody: IRigidbody | null;
     isTrigger: boolean;
 }
 
@@ -123,6 +126,10 @@ export declare type CannonCollision = {
     type: string;
 }
 
+export declare type ICollisionContext = {
+    getCollider(obj : Object3D) : ICollider;
+}
+
 export class Collision {
 
     get __internalCollision(): CannonCollision {
@@ -136,6 +143,7 @@ export class Collision {
     private readonly invert: boolean;
     private readonly collision: CannonCollision;
     private readonly targetBody: Body;
+    private readonly context : ICollisionContext;
 
     readonly me: Object3D;
 
@@ -151,8 +159,7 @@ export class Collision {
     private _collider?: ICollider;
     get collider(): ICollider {
         if (!this._collider) {
-            //@ts-ignore
-            this._collider = getComponentInChildren(this.gameObject, Collider) as ICollider;
+            this._collider = this.context.getCollider(this.gameObject);
         }
         return this._collider;
     }
@@ -171,10 +178,11 @@ export class Collision {
     //     return this._point;
     // }
 
-    constructor(obj: Object3D, collision: CannonCollision, invert: boolean = false) {
-        this.invert = invert;
+    constructor(obj: Object3D, collision: CannonCollision, context : ICollisionContext, invert: boolean = false) {
         this.me = obj;
         this.collision = collision;
-        this.targetBody = this.invert ? collision.target : collision.body;
+        this.context = context;
+        this.targetBody = invert ? collision.target : collision.body;
+        this.invert = invert;
     }
 }

package/src/engine-components/Collider.ts

@@ -1,10 +1,25 @@
 import { Behaviour } from "./Component";
 import { Rigidbody } from "./RigidBody";
 import { serializeable } from "../engine/engine_serialization_decorator";
-import { Vector3 } from "three"
+import { Event, Object3D, Vector3 } from "three"
 import { Shape } from "cannon-es";
+import { IColliderProvider, registerColliderProvider } from "../engine/engine_physics";
+import { ICollider } from "../engine/engine_types";
+import { getComponentInChildren } from "../engine/engine_components";
+
+class ColliderProvider implements IColliderProvider {
+    getCollider(obj: Object3D): ICollider {
+        return getComponentInChildren<Collider>(obj, Collider);
+    }
+}
+registerColliderProvider(new ColliderProvider());
+
+export class Collider extends Behaviour implements ICollider {
+
+    get isCollider(): any {
+        return true;
+    }
 
-export class Collider extends Behaviour {
     @serializeable(Rigidbody)
     attachedRigidbody: Rigidbody | null = null;
     @serializeable()

package/src/engine-components/Component.ts

@@ -40,13 +40,13 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
     }
 
     public static markAsInstancedRendered(go: THREE.Object3D, instanced: boolean) {
-        markAsInstancedRendered(go, instanced);	
+        markAsInstancedRendered(go, instanced);
     }
 
     public static isUsingInstancing(instance: THREE.Object3D): boolean { return isUsingInstancing(instance); }
 
     public static foreachComponent(instance: THREE.Object3D, cb: (comp: Component) => any, recursive: boolean = true): any {
-        return foreachComponent(instance, cb as (comp : IComponent) => any, recursive);
+        return foreachComponent(instance, cb as (comp: IComponent) => any, recursive);
     }
 
     public static instantiateSynced(instance: GameObject | Object3D | null, opts: InstantiateOptions): GameObject | null {
@@ -124,7 +124,7 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
         }, children);
     }
 
-    public static addNewComponent<T extends Behaviour>(go: GameObject | THREE.Object3D, type: ConstructorConcrete<T>, callAwake: boolean = true): T {
+    public static addNewComponent<T>(go: GameObject | THREE.Object3D, type: ConstructorConcrete<T>, callAwake: boolean = true): T {
         const instance = new type();
         //@ts-ignore
         addNewComponentInstance(go, instance, callAwake);
@@ -135,7 +135,7 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
         if (instance.gameObject == null) {
             throw new Error("Did you mean to create a new component? Use addNewComponent");
         }
-        moveComponentInstance(instance as any, go);
+        moveComponentInstance(go, instance as any);
     }
 
     public static removeComponent(instance: Component): Component {
@@ -143,7 +143,7 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
         return instance;
     }
 
-    public static getOrAddComponent<T extends IComponent>(go: GameObject | THREE.Object3D, typeName: ConstructorConcrete<T>): T {
+    public static getOrAddComponent<T>(go: GameObject | THREE.Object3D, typeName: ConstructorConcrete<T>): T {
         return getOrAddComponent<any>(go, typeName);
     }
 
@@ -153,12 +153,12 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
         // not ideal, but I dont know a good/sane way to do this otherwise
         // const res = TypeStore.get(typeName);
         // if(res) typeName = res;
-        return getComponent(typeName as any, go);
+        return getComponent(go, typeName as any);
     }
 
-    public static getComponents<T>(go: GameObject | THREE.Object3D | null, typeName: Constructor<T> | null, arr: T[] | null = null): T[] {
+    public static getComponents<T>(go: GameObject | THREE.Object3D | null, typeName: Constructor<T>, arr: T[] | null = null): T[] {
         if (go === null) return arr ?? [];
-        return getComponents(typeName, go, arr);
+        return getComponents(go, typeName, arr);
     }
 
     public static findByGuid(guid: string, hierarchy: THREE.Object3D): GameObject | Component | null | undefined {
@@ -166,8 +166,8 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
         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 findObjectOfType(typeName, context, includeInactive);
+    public static findObjectOfType<T>(typeName: Constructor<T>, context?: Context | THREE.Object3D, includeInactive: boolean = true): T | null {
+        return findObjectOfType(typeName, context ?? Context.Current, includeInactive);
     }
 
     public static findObjectsOfType<T>(typeName: Constructor<T>, context?: Context | THREE.Object3D): Array<T> {
@@ -176,20 +176,20 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
         return arr;
     }
 
-    public static getComponentInChildren<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T> | null): T | null {
-        return getComponentInChildren(typeName, go);
+    public static getComponentInChildren<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T>): T | null {
+        return getComponentInChildren(go, typeName);
     }
 
-    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 getComponentsInChildren<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T>, arr: T[] | null = null): Array<T> {
+        return getComponentsInChildren<T>(go, typeName, arr ?? undefined) as T[]
     }
 
-    public static getComponentInParent<T>(go: GameObject | THREE.Object3D | Array<Object3D>, typeName: Constructor<T>): T | null {
-        return getComponentInParent(typeName, go);
+    public static getComponentInParent<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T>): T | null {
+        return getComponentInParent(go, typeName);
     }
 
     public static getComponentsInParent<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T>, arr: Array<T> | null = null): Array<T> {
-        return getComponentsInParent(typeName, go, arr);
+        return getComponentsInParent(go, typeName, arr);
     }
 
     public static getAllComponents(go: GameObject | THREE.Object3D): Behaviour[] {
@@ -291,8 +291,7 @@ class Component implements IComponent, EventTarget {
         return res;
     }
 
-    private set __isActiveInHierarchy(val: boolean)
-    {
+    private set __isActiveInHierarchy(val: boolean) {
         if (!this.gameObject) return;
         this.gameObject[activeInHierarchyFieldName] = val;
     }
@@ -339,7 +338,7 @@ class Component implements IComponent, EventTarget {
         this.context.unregisterCoroutineUpdate(routine, evt);
     }
 
-    public get destroyed() : boolean {
+    public get destroyed(): boolean {
         return this.__destroyed;
     }
 
@@ -378,7 +377,7 @@ class Component implements IComponent, EventTarget {
         if (this.start) this.start();
     }
 
-    __internalEnable() : boolean {
+    __internalEnable(): boolean {
         if (this.__didEnable) return false;
         // console.trace("INTERNAL ENABLE");
         this.__didEnable = true;
@@ -401,7 +400,7 @@ class Component implements IComponent, EventTarget {
         // console.log("destroy", this);
         destroyComponentInstance(this as any);
     }
-    
+
     // isActiveAndEnabled: boolean = false;
 
     get enabled(): boolean {

package/src/engine-components/Networking.ts

@@ -1,8 +1,9 @@
+import { INetworkingWebsocketUrlProvider } from "../engine/engine_networking";
 import { isLocalNetwork } from "../engine/engine_networking_utils";
 import { getParam } from "../engine/engine_utils";
 import { Behaviour } from "./Component";
 
-export class Networking extends Behaviour {
+export class Networking extends Behaviour implements INetworkingWebsocketUrlProvider {
 
     url: string | null = null;
     urlParameterName: string | null = null;
@@ -10,6 +11,10 @@ export class Networking extends Behaviour {
     // used when local host is detected
     localhost: string | null = null;
 
+    awake(){
+        this.context.connection.registerProvider(this);
+    }
+
     getWebsocketUrl(): string | null {
 
         let socketurl = this.url ? Networking.GetUrl(this.url, this.localhost) : null;

package/src/engine-components/js-extensions/Object3D.ts

@@ -12,15 +12,17 @@ export function apply(object: Object3D) {
 
 
 // this is a fix to allow gameObject active animation be applied to a three object
-Object.defineProperty(Object3D.prototype, "activeSelf", {
-    get: function () {
-        return this.visible;
-    },
-    set: function (val: boolean | number) {
-        const state = typeof val === "number" ? val > 0.5 : val;
-        this.visible = state;
-    }
-});
+if (!Object.getOwnPropertyDescriptor(Object3D.prototype, "activeSelf")) {
+    Object.defineProperty(Object3D.prototype, "activeSelf", {
+        get: function () {
+            return this.visible;
+        },
+        set: function (val: boolean | number) {
+            const state = typeof val === "number" ? val > 0.5 : val;
+            this.visible = state;
+        }
+    });
+}
 
 
 // do we still need this?
@@ -40,23 +42,23 @@ Object3D.prototype["getOrAddComponent"] = function <T extends IComponent>(typeNa
     return getOrAddComponent<T>(this, typeName);
 }
 
-Object3D.prototype["getComponent"] = function <T>(type: Constructor<T>) {
-    return getComponent(type, this);
+Object3D.prototype["getComponent"] = function <T extends IComponent>(type: Constructor<T>) {
+    return getComponent(this, type);
 }
 
-Object3D.prototype["getComponents"] = function <T>(type: Constructor<T>, arr?: []) {
+Object3D.prototype["getComponents"] = function <T extends IComponent>(type: Constructor<T>, arr?: []) {
     return getComponents(this, type, arr);
 }
 
-Object3D.prototype["getComponentInChildren"] = function <T>(type: Constructor<T>) {
+Object3D.prototype["getComponentInChildren"] = function <T extends IComponent>(type: Constructor<T>) {
     return getComponentInChildren(this, type);
 }
 
 Object3D.prototype["getComponentsInChildren"] = function <T extends IComponent>(type: Constructor<T>, arr?: []) {
-    return getComponentsInChildren(type, this, arr);
+    return getComponentsInChildren(this, type, arr);
 }
 
-Object3D.prototype["getComponentInParent"] = function <T>(type: Constructor<T>) {
+Object3D.prototype["getComponentInParent"] = function <T extends IComponent>(type: Constructor<T>) {
     return getComponentInParent(this, type);
 }
 

package/src/engine-components/ui/EventSystem.ts

@@ -344,8 +344,8 @@ export class EventSystem extends Behaviour {
             }
         }
 
-        if (clicked)
-            console.log(this.context.time.frame, object);
+        // if (clicked)
+        //     console.log(this.context.time.frame, object);
         this.objectsHoveredThisFrame.push(object);
 
         if (canvasGroup === null || canvasGroup.interactable) {