@needle-tools/engine 3.28.6-beta → 3.28.7-beta.1

package/lib/engine-components/webxr/WebXRGrabRendering.d.ts

@@ -1,42 +1,42 @@
-import { Behaviour } from "../Component.js";
-import { Object3D, Vector3 } from "three";
-import { Context } from "../../engine/engine_setup.js";
-import { type IModel } from "../../engine/engine_networking_types.js";
-export declare class XRGrabModel implements IModel {
-    guid: any;
-    dontSave: boolean;
-    userId: string | null | undefined;
-    point: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    source: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    target: string | undefined;
-    update(context: Context, point: Vector3, source: Vector3, target?: string | undefined): void;
-}
-export declare class XRGrabRendering extends Behaviour {
-    prefab: Object3D | null;
-    private _grabModels;
-    private _grabModelsUpdateTime;
-    private _addOrUpdateSub;
-    private _endSub;
-    private _freeSub;
-    private _instances;
-    awake(): void;
-    onEnable(): void;
-    onDisable(): void;
-    addOrUpdateGrab(model: XRGrabModel): void;
-    endGrab(model: XRGrabModel): void;
-    private onRemoteGrabStartOrUpdate;
-    private onRemoteGrabEnd;
-    private onAttachedObjectFree;
-    onBeforeRender(): void;
-    private updateModel;
-    private temp;
-    private updateRendering;
-}
+import { Behaviour } from "../Component.js";
+import { Object3D, Vector3 } from "three";
+import { Context } from "../../engine/engine_setup.js";
+import { type IModel } from "../../engine/engine_networking_types.js";
+export declare class XRGrabModel implements IModel {
+    guid: any;
+    dontSave: boolean;
+    userId: string | null | undefined;
+    point: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    source: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    target: string | undefined;
+    update(context: Context, point: Vector3, source: Vector3, target?: string | undefined): void;
+}
+export declare class XRGrabRendering extends Behaviour {
+    prefab: Object3D | null;
+    private _grabModels;
+    private _grabModelsUpdateTime;
+    private _addOrUpdateSub;
+    private _endSub;
+    private _freeSub;
+    private _instances;
+    awake(): void;
+    onEnable(): void;
+    onDisable(): void;
+    addOrUpdateGrab(model: XRGrabModel): void;
+    endGrab(model: XRGrabModel): void;
+    private onRemoteGrabStartOrUpdate;
+    private onRemoteGrabEnd;
+    private onAttachedObjectFree;
+    onBeforeRender(): void;
+    private updateModel;
+    private temp;
+    private updateRendering;
+}

package/lib/engine-components/webxr/WebXRGrabRendering.js

@@ -1,138 +1,138 @@
-import { getWorldPosition, setWorldPosition } from "../../engine/engine_three_utils.js";
-import { Behaviour, GameObject } from "../Component.js";
-import { AttachedObject, AttachedObjectEvents } from "./WebXRController.js";
-import { Vector3 } from "three";
-import { PlayerColor } from "../PlayerColor.js";
-import { SendQueue } from "../../engine/engine_networking_types.js";
-var XRGrabEvent;
-(function (XRGrabEvent) {
-    XRGrabEvent["StartOrUpdate"] = "xr-grab-visual-start-or-update";
-    XRGrabEvent["End"] = "xr-grab-visual-end";
-})(XRGrabEvent || (XRGrabEvent = {}));
-export class XRGrabModel {
-    guid;
-    dontSave = true;
-    userId;
-    point = { x: 0, y: 0, z: 0 };
-    source = { x: 0, y: 0, z: 0 };
-    target;
-    update(context, point, source, target = undefined) {
-        this.userId = context.connection.connectionId;
-        this.point.x = point.x;
-        this.point.y = point.y;
-        this.point.z = point.z;
-        this.source.x = source.x;
-        this.source.y = source.y;
-        this.source.z = source.z;
-        this.target = target;
-    }
-}
-// sends grab info to other users and creates rendering instances
-export class XRGrabRendering extends Behaviour {
-    prefab = null;
-    _grabModels = [];
-    _grabModelsUpdateTime = [];
-    _addOrUpdateSub = null;
-    _endSub = null;
-    _freeSub = null;
-    _instances = {};
-    awake() {
-        if (this.prefab)
-            this.prefab.visible = false;
-    }
-    onEnable() {
-        this._addOrUpdateSub = this.context.connection.beginListen(XRGrabEvent.StartOrUpdate, this.onRemoteGrabStartOrUpdate.bind(this));
-        this._endSub = this.context.connection.beginListen(XRGrabEvent.End, this.onRemoteGrabEnd.bind(this));
-        this._freeSub = AttachedObject.AddEventListener(AttachedObjectEvents.WillFree, this.onAttachedObjectFree.bind(this));
-    }
-    onDisable() {
-        this.context.connection.stopListen(XRGrabEvent.StartOrUpdate, this._addOrUpdateSub);
-        this.context.connection.stopListen(XRGrabEvent.End, this._endSub);
-        AttachedObject.RemoveEventListener(AttachedObjectEvents.WillFree, this._freeSub);
-    }
-    addOrUpdateGrab(model) {
-        this.context.connection.send(XRGrabEvent.StartOrUpdate, model, SendQueue.Queued);
-    }
-    endGrab(model) {
-        this.context.connection.send(XRGrabEvent.End, model, SendQueue.Queued);
-    }
-    onRemoteGrabStartOrUpdate(data) {
-        if (!this.prefab)
-            return;
-        const inst = this._instances[data.guid];
-        if (!inst) {
-            const instance = GameObject.instantiate(this.prefab);
-            instance.visible = true;
-            this._instances[data.guid] = { instance, model: data };
-            if (data.userId) {
-                const playerColor = GameObject.getComponentsInChildren(instance, PlayerColor);
-                if (playerColor?.length > 0) {
-                    for (const pl of playerColor) {
-                        pl.assignUserColor(data.userId);
-                    }
-                }
-            }
-            return;
-        }
-        inst.model = data;
-    }
-    onRemoteGrabEnd(data) {
-        if (!data)
-            return;
-        const id = data.guid;
-        if (this._instances[id]) {
-            GameObject.destroy(this._instances[id].instance);
-            delete this._instances[id];
-        }
-    }
-    onAttachedObjectFree(att) {
-        if (this._grabModels.length <= 0)
-            return;
-        const mod = this._grabModels[0];
-        this.updateModel(mod, att);
-        this.endGrab(mod);
-    }
-    onBeforeRender() {
-        this.updateRendering();
-        if (!this.prefab)
-            return;
-        this.prefab.visible = false;
-        if (this.context.time.frameCount % 10 !== 0)
-            return;
-        for (let i = 0; i < AttachedObject.Current.length; i++) {
-            const att = AttachedObject.Current[i];
-            if (!att.controller || !att.selected)
-                continue;
-            if (this._grabModels.length <= i) {
-                this._grabModels.push(new XRGrabModel());
-                this._grabModelsUpdateTime.push(0);
-            }
-            this._grabModelsUpdateTime[i] = this.context.time.time;
-            const model = this._grabModels[i];
-            this.updateModel(model, att);
-            this.addOrUpdateGrab(model);
-        }
-    }
-    updateModel(model, att) {
-        if (!att.controller || !att.selected)
-            return;
-        model.guid = att.grabUUID;
-        const targetObject = att.selected["guid"];
-        model.update(this.context, att.grabPoint, att.controller.worldPosition, targetObject);
-    }
-    temp = new Vector3();
-    updateRendering() {
-        const step = this.context.time.deltaTime / .5;
-        for (const key in this._instances) {
-            const { instance, model } = this._instances[key];
-            if (!instance || !model)
-                continue;
-            const { point } = model;
-            const wp = getWorldPosition(instance);
-            this.temp.set(point.x, point.y, point.z);
-            wp.lerp(this.temp, step);
-            setWorldPosition(instance, wp);
-        }
-    }
-}
+import { getWorldPosition, setWorldPosition } from "../../engine/engine_three_utils.js";
+import { Behaviour, GameObject } from "../Component.js";
+import { AttachedObject, AttachedObjectEvents } from "./WebXRController.js";
+import { Vector3 } from "three";
+import { PlayerColor } from "../PlayerColor.js";
+import { SendQueue } from "../../engine/engine_networking_types.js";
+var XRGrabEvent;
+(function (XRGrabEvent) {
+    XRGrabEvent["StartOrUpdate"] = "xr-grab-visual-start-or-update";
+    XRGrabEvent["End"] = "xr-grab-visual-end";
+})(XRGrabEvent || (XRGrabEvent = {}));
+export class XRGrabModel {
+    guid;
+    dontSave = true;
+    userId;
+    point = { x: 0, y: 0, z: 0 };
+    source = { x: 0, y: 0, z: 0 };
+    target;
+    update(context, point, source, target = undefined) {
+        this.userId = context.connection.connectionId;
+        this.point.x = point.x;
+        this.point.y = point.y;
+        this.point.z = point.z;
+        this.source.x = source.x;
+        this.source.y = source.y;
+        this.source.z = source.z;
+        this.target = target;
+    }
+}
+// sends grab info to other users and creates rendering instances
+export class XRGrabRendering extends Behaviour {
+    prefab = null;
+    _grabModels = [];
+    _grabModelsUpdateTime = [];
+    _addOrUpdateSub = null;
+    _endSub = null;
+    _freeSub = null;
+    _instances = {};
+    awake() {
+        if (this.prefab)
+            this.prefab.visible = false;
+    }
+    onEnable() {
+        this._addOrUpdateSub = this.context.connection.beginListen(XRGrabEvent.StartOrUpdate, this.onRemoteGrabStartOrUpdate.bind(this));
+        this._endSub = this.context.connection.beginListen(XRGrabEvent.End, this.onRemoteGrabEnd.bind(this));
+        this._freeSub = AttachedObject.AddEventListener(AttachedObjectEvents.WillFree, this.onAttachedObjectFree.bind(this));
+    }
+    onDisable() {
+        this.context.connection.stopListen(XRGrabEvent.StartOrUpdate, this._addOrUpdateSub);
+        this.context.connection.stopListen(XRGrabEvent.End, this._endSub);
+        AttachedObject.RemoveEventListener(AttachedObjectEvents.WillFree, this._freeSub);
+    }
+    addOrUpdateGrab(model) {
+        this.context.connection.send(XRGrabEvent.StartOrUpdate, model, SendQueue.Queued);
+    }
+    endGrab(model) {
+        this.context.connection.send(XRGrabEvent.End, model, SendQueue.Queued);
+    }
+    onRemoteGrabStartOrUpdate(data) {
+        if (!this.prefab)
+            return;
+        const inst = this._instances[data.guid];
+        if (!inst) {
+            const instance = GameObject.instantiate(this.prefab);
+            instance.visible = true;
+            this._instances[data.guid] = { instance, model: data };
+            if (data.userId) {
+                const playerColor = GameObject.getComponentsInChildren(instance, PlayerColor);
+                if (playerColor?.length > 0) {
+                    for (const pl of playerColor) {
+                        pl.assignUserColor(data.userId);
+                    }
+                }
+            }
+            return;
+        }
+        inst.model = data;
+    }
+    onRemoteGrabEnd(data) {
+        if (!data)
+            return;
+        const id = data.guid;
+        if (this._instances[id]) {
+            GameObject.destroy(this._instances[id].instance);
+            delete this._instances[id];
+        }
+    }
+    onAttachedObjectFree(att) {
+        if (this._grabModels.length <= 0)
+            return;
+        const mod = this._grabModels[0];
+        this.updateModel(mod, att);
+        this.endGrab(mod);
+    }
+    onBeforeRender() {
+        this.updateRendering();
+        if (!this.prefab)
+            return;
+        this.prefab.visible = false;
+        if (this.context.time.frameCount % 10 !== 0)
+            return;
+        for (let i = 0; i < AttachedObject.Current.length; i++) {
+            const att = AttachedObject.Current[i];
+            if (!att.controller || !att.selected)
+                continue;
+            if (this._grabModels.length <= i) {
+                this._grabModels.push(new XRGrabModel());
+                this._grabModelsUpdateTime.push(0);
+            }
+            this._grabModelsUpdateTime[i] = this.context.time.time;
+            const model = this._grabModels[i];
+            this.updateModel(model, att);
+            this.addOrUpdateGrab(model);
+        }
+    }
+    updateModel(model, att) {
+        if (!att.controller || !att.selected)
+            return;
+        model.guid = att.grabUUID;
+        const targetObject = att.selected["guid"];
+        model.update(this.context, att.grabPoint, att.controller.worldPosition, targetObject);
+    }
+    temp = new Vector3();
+    updateRendering() {
+        const step = this.context.time.deltaTime / .5;
+        for (const key in this._instances) {
+            const { instance, model } = this._instances[key];
+            if (!instance || !model)
+                continue;
+            const { point } = model;
+            const wp = getWorldPosition(instance);
+            this.temp.set(point.x, point.y, point.z);
+            wp.lerp(this.temp, step);
+            setWorldPosition(instance, wp);
+        }
+    }
+}
 //# sourceMappingURL=WebXRGrabRendering.js.map

package/lib/engine-components/webxr/WebXRImageTracking.d.ts

@@ -1,49 +1,49 @@
-import { Behaviour } from "../Component.js";
-import { Object3D, Quaternion, Vector3 } from "three";
-import { AssetReference } from "../../engine/engine_addressables.js";
-export declare class WebXRTrackedImage {
-    get url(): string;
-    get widthInMeters(): number;
-    get bitmap(): ImageBitmap;
-    get model(): WebXRImageTrackingModel;
-    readonly measuredSize: number;
-    readonly state: "tracked" | "emulated";
-    /** Copy the image position to a vector */
-    getPosition(vec: Vector3): Vector3;
-    /** Copy the image rotation to a quaternion */
-    getQuaternion(quat: Quaternion): Quaternion;
-    private static y180;
-    applyToObject(object: Object3D, t01?: number | undefined): void;
-    private static _positionBuffer;
-    private static _rotationBuffer;
-    private _position;
-    private _rotation;
-    private ensureTransformData;
-    private readonly _trackingComponent;
-    private readonly _trackedImage;
-    private readonly _bitmap;
-    private readonly _pose;
-    constructor(context: WebXRImageTracking, trackedImage: WebXRImageTrackingModel, bitmap: ImageBitmap, measuredSize: number, state: "tracked" | "emulated", pose: any);
-}
-export declare class WebXRImageTrackingModel {
-    image?: string;
-    widthInMeters: number;
-    object?: AssetReference;
-    createObjectInstance: boolean;
-    imageDoesNotMove: boolean;
-}
-export declare class WebXRImageTracking extends Behaviour {
-    trackedImages?: WebXRImageTrackingModel[];
-    private readonly trackedImageIndexMap;
-    private static _imageElements;
-    private webxr;
-    awake(): void;
-    onEnable(): void;
-    onDisable(): void;
-    private onModifyAROptions;
-    private onXRStarted;
-    private readonly imageToObjectMap;
-    private readonly currentImages;
-    private onXRUpdate;
-    private onImageTrackingUpdate;
-}
+import { Behaviour } from "../Component.js";
+import { Object3D, Quaternion, Vector3 } from "three";
+import { AssetReference } from "../../engine/engine_addressables.js";
+export declare class WebXRTrackedImage {
+    get url(): string;
+    get widthInMeters(): number;
+    get bitmap(): ImageBitmap;
+    get model(): WebXRImageTrackingModel;
+    readonly measuredSize: number;
+    readonly state: "tracked" | "emulated";
+    /** Copy the image position to a vector */
+    getPosition(vec: Vector3): Vector3;
+    /** Copy the image rotation to a quaternion */
+    getQuaternion(quat: Quaternion): Quaternion;
+    private static y180;
+    applyToObject(object: Object3D, t01?: number | undefined): void;
+    private static _positionBuffer;
+    private static _rotationBuffer;
+    private _position;
+    private _rotation;
+    private ensureTransformData;
+    private readonly _trackingComponent;
+    private readonly _trackedImage;
+    private readonly _bitmap;
+    private readonly _pose;
+    constructor(context: WebXRImageTracking, trackedImage: WebXRImageTrackingModel, bitmap: ImageBitmap, measuredSize: number, state: "tracked" | "emulated", pose: any);
+}
+export declare class WebXRImageTrackingModel {
+    image?: string;
+    widthInMeters: number;
+    object?: AssetReference;
+    createObjectInstance: boolean;
+    imageDoesNotMove: boolean;
+}
+export declare class WebXRImageTracking extends Behaviour {
+    trackedImages?: WebXRImageTrackingModel[];
+    private readonly trackedImageIndexMap;
+    private static _imageElements;
+    private webxr;
+    awake(): void;
+    onEnable(): void;
+    onDisable(): void;
+    private onModifyAROptions;
+    private onXRStarted;
+    private readonly imageToObjectMap;
+    private readonly currentImages;
+    private onXRUpdate;
+    private onImageTrackingUpdate;
+}