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

package/src/engine-components/Duplicatable.ts

@@ -1,10 +1,11 @@
-import { Behaviour, GameObject, InstantiateOptions } from "./Component";
+import { Behaviour, GameObject } from "./Component";
 import { WebXRController, ControllerEvents } from "./WebXRController";
 import { DragControls, DragEvents } from "./DragControls";
 import { Interactable } from "./Interactable";
 import { Animation } from "./Animation";
 import { Vector3, Quaternion, Object3D } from "three";
 import { serializeable } from "../engine/engine_serialization_decorator";
+import { InstantiateOptions } from "../engine/engine_gameobject";
 
 export class Duplicatable extends Interactable {
 
@@ -35,7 +36,7 @@ export class Duplicatable extends Interactable {
         // }
         // console.log(this, this.object);
         if (this.object) {
-            if (this.object === this.gameObject) {
+            if (this.object as any === this.gameObject) {
                 console.error("Can not duplicate self");
                 return;
             }
@@ -90,7 +91,7 @@ export class Duplicatable extends Interactable {
         if (!this.object) return null;
         if (selected === this.gameObject || this.handleMultiObject(selected)) {
 
-            if (this.object === this.gameObject) return null;
+            if (this.object as any === this.gameObject) return null;
             this.object.visible = true;
 
             if (this._startPosition)

package/src/engine-components/LODGroup.ts

@@ -31,7 +31,7 @@ class LOD {
         this.model = model;
         this.renderers = [];
         for (const guid of model.renderers) {
-            const rend = this.findRenderer(guid, group.gameObject);// GameObject.findByGuid(guid, group.gameObject) as Renderer;
+            const rend = this.findRenderer(guid, group.gameObject as GameObject);// GameObject.findByGuid(guid, group.gameObject) as Renderer;
             if (rend && rend.gameObject) {
                 this.renderers.push(rend);
             }

package/src/engine-components/Light.ts

@@ -7,6 +7,7 @@ import { serializeable } from "../engine/engine_serialization_decorator";
 import { Color, DirectionalLight, OrthographicCamera } from "three";
 import { WebXR, WebXREvent } from "./WebXR";
 import { WebARSessionRoot } from "./WebARSessionRoot";
+import { ILight } from "../engine/engine_types";
 
 // https://threejs.org/examples/webgl_shadowmap_csm.html
 
@@ -82,7 +83,7 @@ enum LightShadows {
     Soft = 2,
 }
 
-export class Light extends Behaviour {
+export class Light extends Behaviour implements ILight {
 
     @serializeable()
     private type: LightType = 0;
@@ -263,7 +264,7 @@ export class Light extends Behaviour {
     private _webARRoot?: WebARSessionRoot;
 
     private onWebXRStarted() {
-        this._webARRoot = this.gameObject.getComponentInParent(WebARSessionRoot) ?? undefined;
+        this._webARRoot = GameObject.getComponentInParent(this.gameObject, WebARSessionRoot) ?? undefined;
         this.startCoroutine(this._updateLightIntensityInARRoutine());
     }
 

package/src/engine-components/NestedGltf.ts

@@ -1,8 +1,9 @@
 import { getParam } from "../engine/engine_utils";
-import { Behaviour, InstantiateOptions } from "../engine-components/Component";
+import { Behaviour } from "../engine-components/Component";
 import { AssetReference, ProgressCallback } from "../engine/engine_addressables";
 import { serializeable } from "../engine/engine_serialization_decorator";
 import { InstantiateIdProvider } from "../engine/engine_networking_instantiate";
+import { InstantiateOptions } from "../engine/engine_gameobject";
 
 const debug = getParam("debugnestedgltf");
 

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/OrbitControls.ts

@@ -1,12 +1,12 @@
 import { Behaviour, GameObject } from "./Component";
-import { Camera } from "./Camera";
+// import { Camera } from "./Camera";
 import { OrbitControls as ThreeOrbitControls } from "three/examples/jsm/controls/OrbitControls";
 import { LookAtConstraint } from "./LookAtConstraint";
 import * as THREE from "three";
 import { getWorldPosition } from "../engine/engine_three_utils";
-import { Physics, RaycastOptions } from "../engine/engine_physics";
+import { RaycastOptions } from "../engine/engine_physics";
 import { serializeable } from "../engine/engine_serialization_decorator";
-import { Vector3 } from "three";
+import { Camera } from "./Camera";
 
 export class OrbitControls extends Behaviour {
     public get controls() {
@@ -30,7 +30,7 @@ export class OrbitControls extends Behaviour {
     minZoom: number = 0;
     maxZoom: number = Infinity;
     enablePan: boolean = true;
-    @serializeable()
+    @serializeable(LookAtConstraint)
     lookAtConstraint: LookAtConstraint | null = null;
     lookAtConstraint01: number = 1;
     middleClickToFocus: boolean = true;
@@ -61,10 +61,10 @@ export class OrbitControls extends Behaviour {
     }
 
     onEnable() {
+    
         this._enableTime = this.context.time.time;
         const camGo = GameObject.getComponent(this.gameObject, Camera);
         const cam = camGo?.cam;
-
         if (!this._controls) {
             console.assert(cam !== null && cam !== undefined, "Missing camera", this);
             if (cam)

package/src/engine-components/Renderer.ts

@@ -9,6 +9,10 @@ import { Material, Texture, Vector4 } from "three";
 import { NEEDLE_render_objects } from "../engine/extensions/NEEDLE_render_objects";
 import { NEEDLE_deferred_texture } from "../engine/extensions/NEEDLE_deferred_texture";
 import { NEED_UPDATE_INSTANCE_KEY } from "../engine/engine_instancing";
+import { IRenderer } from "../engine/engine_types";
+
+// for staying compatible with old code
+export { InstancingUtil } from "../engine/engine_instancing";
 
 const suppressInstancing = getParam("noInstancing");
 const debugLightmap = getParam("debuglightmaps") ? true : false;
@@ -99,7 +103,7 @@ class SharedMaterialArray {
 
 }
 
-export class Renderer extends Behaviour {
+export class Renderer extends Behaviour implements IRenderer {
 
     @serializeable()
     receiveShadows: boolean = false;

package/src/engine-components/RigidBody.ts

@@ -6,8 +6,9 @@ import { getWorldPosition } from "../engine/engine_three_utils";
 import { serializeable } from "../engine/engine_serialization_decorator";
 import { Watch } from "../engine/engine_utils";
 import { Vector3 } from "three";
+import { IRigidbody } from "../engine/engine_types";
 
-export class Rigidbody extends Behaviour {
+export class Rigidbody extends Behaviour implements IRigidbody {
 
     @serializeable()
     mass: number = 1;

package/src/engine-components/ScreenCapture.ts

@@ -5,11 +5,11 @@ import { Context } from "../engine/engine_setup";
 import { RoomEvents } from "../engine/engine_networking";
 import { UserJoinedOrLeftRoomModel } from "../engine/engine_networking";
 import { serializeable } from "../engine/engine_serialization";
-import { IModel } from "../engine/engine_networking";
 import { IPointerClickHandler } from "./ui/PointerEvents";
 import { EventDispatcher } from "three";
 import { AudioSource } from "./AudioSource";
 import { getParam } from "../engine/engine_utils";
+import { IModel } from "../engine/engine_networking_types";
 
 const debug = getParam("debugscreenshare");
 

package/src/engine-components/SpectatorCamera.ts

@@ -12,7 +12,9 @@ import { Context } from "../engine/engine_setup";
 import { getParam } from "../engine/engine_utils";
 import { PlayerView, ViewDevice } from "../engine/engine_playerview";
 import { RaycastOptions } from "../engine/engine_physics";
-import { IModel, RoomEvents } from "../engine/engine_networking";
+import { RoomEvents } from "../engine/engine_networking";
+import { ICamera } from "../engine/engine_types";
+import { IModel } from "../engine/engine_networking_types";
 
 
 export enum SpectatorMode {
@@ -177,7 +179,7 @@ export class SpectatorCamera extends Behaviour {
     }
 
     private onXRSessionEnded(_evt) {
-        this.context.removeCamera(this.cam);
+        this.context.removeCamera(this.cam as ICamera);
         GameObject.setActive(this.gameObject, false);
         if (this.orbit) this.orbit.enabled = true;
         this._handler?.set(undefined);
@@ -355,16 +357,16 @@ class SpectatorHandler implements ISpectatorHandler {
         // this.context.setCurrentCamera(this.cam);
         if (debug) console.log("FOLLOW", followObject);
         if (!this.context.isInXR) {
-            this.context.setCurrentCamera(this.cam);
+            this.context.setCurrentCamera(this.cam as ICamera);
         }
-        else this.context.removeCamera(this.cam);
+        else this.context.removeCamera(this.cam as ICamera);
     }
 
     disable() {
         if (debug) console.log("STOP FOLLOW", this.currentObject);
         this.view = undefined;
         this.currentObject = undefined;
-        this.context.removeCamera(this.cam);
+        this.context.removeCamera(this.cam as ICamera);
         if (this.follow)
             this.follow.enabled = false;
     }

package/src/engine-components/SyncedCamera.ts

@@ -1,5 +1,5 @@
 import { NetworkConnection } from "../engine/engine_networking";
-import { Behaviour, GameObject, InstantiateOptions } from "./Component";
+import { Behaviour, GameObject } from "./Component";
 import { Camera } from "./Camera";
 import * as utils from "../engine/engine_three_utils"
 import { WebXR } from "./WebXR";
@@ -13,6 +13,7 @@ import { Object3D } from "three";
 import { AvatarMarker } from "./WebXRAvatar";
 import { AssetReference } from "../engine/engine_addressables";
 import { ViewDevice } from "../engine/engine_playerview";
+import { InstantiateOptions } from "../engine/engine_gameobject";
 
 const SyncedCameraModelIdentifier = "SCAM";
 registerType(SyncedCameraModelIdentifier, SyncedCameraModel.getRootAsSyncedCameraModel);

package/src/engine-components/SyncedTransform.ts

@@ -1,5 +1,5 @@
 import * as THREE from 'three'
-import { IModel, OwnershipModel, RoomEvents } from "../engine/engine_networking"
+import { OwnershipModel, RoomEvents } from "../engine/engine_networking"
 import { Behaviour, GameObject } from "./Component";
 import { Rigidbody } from "./RigidBody";
 import * as utils from "../engine/engine_utils"

package/src/engine-components/TestRunner.ts

@@ -3,10 +3,9 @@ import * as tests from "../engine/tests/test_utils";
 import { createTransformModel, SyncedTransform, SyncedTransformIdentifier } from "./SyncedTransform";
 import * as flatbuffers from 'flatbuffers';
 import { SyncedTransformModel } from "../engine-schemes/synced-transform-model";
-import * as schemes from "../engine-schemes/schemes";
-import { IModel, NetworkConnection } from "../engine/engine_networking";
 import { Rigidbody } from "./Rigidbody";
 import { Vector3 } from "three";
+import { IModel } from "../engine/engine_networking_types";
 
 export class TestRunner extends Behaviour {
     awake(): void {

package/src/engine-components/Voip.ts

@@ -1,11 +1,12 @@
 
 import { Behaviour } from "./Component";
 import * as THREE from "three";
-import { RoomEvents, SendQueue } from "../engine/engine_networking"
+import { RoomEvents } from "../engine/engine_networking"
 import Peer, { MediaConnection } from "peerjs"
 import { AudioSource } from "./AudioSource";
 import * as utils from "../engine/engine_utils"
 import { AudioAnalyser } from "three";
+import { SendQueue } from "../engine/engine_networking_types";
 
 export const noVoip = "noVoip";
 const debug = utils.getParam("debugvoip");

package/src/engine-components/WebXR.ts

@@ -285,7 +285,7 @@ export class WebXR extends Behaviour {
             // build controllers before session begins - this seems to fix issue with controller models not appearing/not getting connection event
             this.ensureRig();
             for (let i = 0; i < 2; i++) {
-                WebXRController.Create(this, i, this.gameObject, ControllerType.PhysicalDevice);
+                WebXRController.Create(this, i, this.gameObject as GameObject, ControllerType.PhysicalDevice);
             }
 
             WebXR.events.dispatchEvent({ type: WebXREvent.RequestVRSession });
@@ -499,7 +499,7 @@ export class WebAR {
 
         const deviceType = navigator.userAgent?.includes("OculusBrowser") ? ControllerType.PhysicalDevice : ControllerType.Touch;
         for (let i = 0; i < 4; i++) {
-            WebXRController.Create(this.webxr, i, this.webxr.gameObject, deviceType)
+            WebXRController.Create(this.webxr, i, this.webxr.gameObject as GameObject, deviceType)
         }
 
         if (!this.sessionRoot || this.sessionRoot.destroyed || !this.sessionRoot.activeAndEnabled)

package/src/engine-components/WebXRController.ts

@@ -13,7 +13,9 @@ import * as utils from "../engine/engine_three_utils"
 import { Interactable, UsageMarker } from "./Interactable";
 import { InstancingUtil } from "../engine/engine_instancing";
 import { Rigidbody } from "./RigidBody";
-import { getParam } from "../engine/engine_utils";
+import { delay, getParam } from "../engine/engine_utils";
+import { UIRaycastUtils } from "./ui/RaycastUtils";
+import { RaycastResult } from "cannon-es";
 
 const debug = getParam("debugwebxrcontroller");
 
@@ -128,7 +130,7 @@ export class WebXRController extends Behaviour {
 
     // TODO: replace with component events
     public static removeEventListener(evt: ControllerEvents, callback: (controller: WebXRController, args: any) => void) {
-        if(!callback) return;
+        if (!callback) return;
         const list = this.eventSubs[evt] ?? [];
         const idx = list.indexOf(callback);
         if (idx >= 0) list.splice(idx, 1);
@@ -568,6 +570,7 @@ export class WebXRController extends Behaviour {
         if (this.webXR.Rig) {
             factor /= this.webXR.Rig.scale.x;
         }
+        // if (!hit) factor = 0;
 
         if (this.raycastLine) {
             this.raycastLine.scale.z = factor * (this.lastHit?.distance ?? 9999);
@@ -625,11 +628,11 @@ export class WebXRController extends Behaviour {
         if (intersections && intersections.length > 0) {
             for (const intersection of intersections) {
                 const object = intersection.object;
-                if (!this.testIsVisible(object)) {
-                    if (debug)
-                        console.log("not visible");
-                    continue;
-                }
+                // if (!this.testIsVisible(object)) {
+                //     if (debug)
+                //         console.log("not visible");
+                //     continue;
+                // }
                 this.lastSelectStartObject = object;
                 const args = { selected: object, grab: object };
                 const subs = WebXRController.eventSubs[ControllerEvents.SelectStart];
@@ -687,8 +690,12 @@ export class WebXRController extends Behaviour {
     }
 
     private testIsVisible(obj: THREE.Object3D | null): boolean {
-        if (!obj) return true;
-        return GameObject.isActiveInHierarchy(obj);
+        if (!obj) return false;
+        if (GameObject.isActiveInHierarchy(obj) === false) return false;
+        if (UIRaycastUtils.isInteractable(obj) === false) {
+            return false;
+        }
+        return true;
         // if (!obj.visible) return false;
         // return this.testIsVisible(obj.parent);
     }
@@ -729,7 +736,20 @@ export class WebXRController extends Behaviour {
         opts.layerMask = new THREE.Layers();
         opts.layerMask.set(0);
         opts.ray = this.getRay();
-        return this.context.physics.raycast(opts);
+        const hits = this.context.physics.raycast(opts);
+        for (let i = 0; i < hits.length; i++) {
+            const hit = hits[i];
+            const obj = hit.object;
+            if (!this.testIsVisible(obj)) {
+                hits.splice(i, 1);
+                i--;
+                continue;
+            }
+            hit.object = UIRaycastUtils.getObject(obj);
+            break;
+        }
+        // console.log(...hits);
+        return hits;
     }
 }
 

package/src/engine-components/WebXRGrabRendering.ts

@@ -1,10 +1,10 @@
-import { IModel, SendQueue } from "../engine/engine_networking";
 import { getWorldPosition, setWorldPosition, setWorldPositionXYZ } from "../engine/engine_three_utils";
 import { Behaviour, GameObject } from "./Component";
 import { AttachedObject, AttachedObjectEvents } from "./WebXRController";
 import * as THREE from "three";
 import { PlayerColor } from "./PlayerColor";
 import { Context } from "../engine/engine_setup";
+import { IModel, SendQueue } from "../engine/engine_networking_types";
 
 enum XRGrabEvent {
     StartOrUpdate = "xr-grab-visual-start-or-update",

package/src/engine-components/WebXRSync.ts

@@ -182,7 +182,7 @@ export class WebXRSync extends Behaviour {
 
     async awake() {
 
-        if(!this.webXR) this.webXR = this.gameObject.getComponent(WebXR);
+        if(!this.webXR) this.webXR = GameObject.getComponent(this.gameObject, WebXR);
         if(!this.webXR) this.webXR = GameObject.findObjectOfType(WebXR, this.context);
 
         if(!this.webXR) 

package/src/engine-components/avatar/Avatar_Brain_LookAt.ts

@@ -3,9 +3,10 @@ import { TypeStore } from "../../engine/engine_typestore";
 import { Behaviour, GameObject } from "../Component";
 import { AvatarMarker } from "../WebXRAvatar";
 import * as utils from "../../engine/engine_three_utils";
-import { IModel, OwnershipModel } from "../../engine/engine_networking";
+import { OwnershipModel } from "../../engine/engine_networking";
 import { Int8BufferAttribute } from "three";
 import { Context } from "../../engine/engine_setup";
+import { IModel } from "../../engine/engine_networking_types";
 
 export class Avatar_POI {
 

package/src/engine-components/codegen/components.ts

@@ -16,7 +16,6 @@ export { Camera } from "../Camera";
 export { Collider } from "../Collider";
 export { SphereCollider } from "../Collider";
 export { BoxCollider } from "../Collider";
-export { InstantiateOptions } from "../Component";
 export { DeleteBox } from "../DeleteBox";
 export { Deletable } from "../DeleteBox";
 export { DeviceFlag } from "../DeviceFlag";
@@ -132,6 +131,7 @@ export { PointerEventData } from "../ui/PointerEvents";
 export { Raycaster } from "../ui/Raycaster";
 export { ObjectRaycaster } from "../ui/Raycaster";
 export { GraphicRaycaster } from "../ui/Raycaster";
+export { UIRaycastUtils } from "../ui/RaycastUtils";
 export { Size } from "../ui/RectTransform";
 export { Rect } from "../ui/RectTransform";
 export { RectTransform } from "../ui/RectTransform";

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

@@ -0,0 +1,66 @@
+
+const handlers : Map<any, ApplyPrototypeExtension> = new Map();
+
+export function applyPrototypeExtensions(obj : any){
+    if(!obj) return;
+    const prototype = obj.prototype;
+    if(!prototype) return;
+    let handler = handlers.get(prototype);
+    if(!handler){
+        handler = createPrototypeExtensionHandler(prototype);
+        handlers.set(prototype, handler);
+    }
+    handler.apply(obj);
+}
+
+function createPrototypeExtensionHandler(prototype: any) { 
+    return new ApplyPrototypeExtension(prototype);
+}
+
+export interface IApplyPrototypeExtension {
+    apply(object: object): void;
+}
+
+class ApplyPrototypeExtension implements IApplyPrototypeExtension {
+
+    private readonly $symbol: symbol;
+    private readonly extensions: string[];
+    private readonly descriptors: Array<PropertyDescriptor | undefined>;
+
+    constructor(prototype: object) {
+        this.$symbol = Symbol("prototype-extension");
+        // used to decorate cloned object3D objects with the same added components defined above
+        this.extensions = Object.keys(prototype);
+        this.descriptors = new Array<PropertyDescriptor | undefined>();
+        for (let i = 0; i < this.extensions.length; i++) {
+            const key = this.extensions[i];
+            const descriptor = Object.getOwnPropertyDescriptor(prototype, key);
+            if (descriptor) {
+                this.descriptors.push(descriptor);
+            }
+        }
+    }
+
+    apply(object: object): void {
+
+        if (object[this.$symbol]) return;
+        object[this.$symbol] = true;
+
+        // const prototype = object.constructor.prototype;
+
+        for (let i = 0; i < this.extensions.length; i++) {
+            const key = this.extensions[i];
+            const desc = this.descriptors[i];
+            if (desc) {
+                // if (prototype) {
+                //     const exists = Object.getOwnPropertyDescriptor(prototype, key);
+                //     if (exists) {
+                //         continue;
+                //     }
+                // }
+                // console.trace("DEFINE", object.name, key);
+                Object.defineProperty(object, key, desc);
+            }
+        }
+    }
+}

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

@@ -1,18 +1,28 @@
+import { applyPrototypeExtensions } from "./ExtensionUtils";
 import { Object3D } from "three";
-import { Behaviour, Component, Constructor, ConstructorConcrete, GameObject } from "../Component";
+import { Constructor, ConstructorConcrete, IComponent } from "../../engine/engine_types"
+import { IComponent as Component } from "../../engine/engine_types";
+import { addNewComponentInstance, getComponent, getComponentInChildren, getComponentInParent, getComponents, getComponentsInChildren, getComponentsInParent, getOrAddComponent, removeComponent } from "../../engine/engine_components";
+
+// used to decorate cloned object3D objects with the same added components defined above
+export function apply(object: Object3D) {
+    if (object && object.isObject3D === true)
+        applyPrototypeExtensions(object);
+}
 
-const decorated = Symbol("GameObject.decorated");
 
 // 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?
@@ -20,72 +30,38 @@ Object3D.prototype["SetActive"] = function (active: boolean) {
     this.visible = active;
 }
 
-Object3D.prototype["addNewComponent"] = function <T extends Behaviour>(type: ConstructorConcrete<T>) {
-    return GameObject.addNewComponent(this, type);
+Object3D.prototype["addNewComponent"] = function <T extends Component>(type: ConstructorConcrete<T>) {
+    return addNewComponentInstance(this, new type());
 }
 
 Object3D.prototype["removeComponent"] = function (inst: Component) {
-    return GameObject.removeComponent(inst);
+    return removeComponent(this, inst);
 }
 
-Object3D.prototype["getOrAddComponent"] = function <T>(typeName: Constructor<T> | null): T {
-    return GameObject.getOrAddComponent(this, typeName);
+Object3D.prototype["getOrAddComponent"] = function <T extends IComponent>(typeName: ConstructorConcrete<T>): T {
+    return getOrAddComponent<T>(this, typeName);
 }
 
-Object3D.prototype["getComponent"] = function <T>(type: Constructor<T>) {
-    return GameObject.getComponent(this, type);
+Object3D.prototype["getComponent"] = function <T extends IComponent>(type: Constructor<T>) {
+    return getComponent(this, type);
 }
 
-Object3D.prototype["getComponents"] = function <T>(type: Constructor<T>, arr?: []) {
-    return GameObject.getComponents(this, type, 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>) {
-    return GameObject.getComponentInChildren(this, type);
+Object3D.prototype["getComponentInChildren"] = function <T extends IComponent>(type: Constructor<T>) {
+    return getComponentInChildren(this, type);
 }
 
-Object3D.prototype["getComponentsInChildren"] = function <T>(type: Constructor<T>, arr?: []) {
-    return GameObject.getComponentsInChildren(this, type, arr);
+Object3D.prototype["getComponentsInChildren"] = function <T extends IComponent>(type: Constructor<T>, arr?: []) {
+    return getComponentsInChildren(this, type, arr);
 }
 
-Object3D.prototype["getComponentInParent"] = function <T>(type: Constructor<T>) {
-    return GameObject.getComponentInParent(this, type);
+Object3D.prototype["getComponentInParent"] = function <T extends IComponent>(type: Constructor<T>) {
+    return getComponentInParent(this, type);
 }
 
 Object3D.prototype["getComponentsInParent"] = function <T>(type: Constructor<T>, arr?: []) {
-    return GameObject.getComponentsInParent(this, type, arr);
+    return getComponentsInParent(this, type, arr);
 }
-
-
-// used to decorate cloned object3D objects with the same added components defined above
-const extensions = Object.keys(Object3D.prototype);
-const descriptors = new Array<PropertyDescriptor | undefined>();
-for (let i = 0; i < extensions.length; i++) {
-    const key = extensions[i];
-    const descriptor = Object.getOwnPropertyDescriptor(Object3D.prototype, key);
-    if (descriptor) {
-        descriptors.push(descriptor);
-    }
-}
-
-export function apply(object: Object3D) {
-    if (object[decorated]) return;
-    object[decorated] = true;
-
-    // const prototype = object.constructor.prototype;
-
-    for (let i = 0; i < extensions.length; i++) {
-        const key = extensions[i];
-        const desc = descriptors[i];
-        if (desc) {
-            // if (prototype) {
-            //     const exists = Object.getOwnPropertyDescriptor(prototype, key);
-            //     if (exists) {
-            //         continue;
-            //     }
-            // }
-            // console.trace("DEFINE", object.name, key);
-            Object.defineProperty(object, key, desc);
-        }
-    }
-}

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

@@ -0,0 +1,17 @@
+import { applyPrototypeExtensions } from "./ExtensionUtils";
+import { Mathf } from "../../engine/engine_math";
+import { Vector3 } from "three";
+
+export function apply(object: Vector3) {
+    if (object && object.isVector3 === true) {
+        console.log(object);
+        applyPrototypeExtensions(object);
+    }
+}
+
+Vector3.prototype["slerp"] = function (end: Vector3, t: number) {
+    const len1 = this.length();
+    const len2 = end.length();
+    const targetLen = Mathf.lerp(len1, len2, t);
+    return this.lerp(end, t).normalize().multiplyScalar(targetLen);
+}