@needle-tools/engine 2.24.0-pre

package/src/engine-components/SyncedCamera.ts

@@ -0,0 +1,206 @@
+import { NetworkConnection } from "../engine/engine_networking";
+import { Behaviour, GameObject, InstantiateOptions } from "./Component";
+import { Camera } from "./Camera";
+import * as utils from "../engine/engine_three_utils"
+import { WebXR } from "./WebXR";
+import { Builder } from "flatbuffers";
+import { SyncedCameraModel } from "../engine-schemes/synced-camera-model";
+import { Vec3 } from "../engine-schemes/vec3";
+import { registerType } from "../engine-schemes/schemes";
+import { InstancingUtil } from "./Renderer";
+import { serializeable } from "../engine/engine_serialization_decorator";
+import { Object3D } from "three";
+import { AvatarMarker } from "./WebXRAvatar";
+import { AssetReference } from "../engine/engine_addressables";
+
+const SyncedCameraModelIdentifier = "SCAM";
+registerType(SyncedCameraModelIdentifier, SyncedCameraModel.getRootAsSyncedCameraModel);
+const builder = new Builder();
+
+// enum CameraSyncEvent {
+//     Update = "sync-update-camera",
+// }
+
+class CameraModel {
+    userId: string;
+    guid: string;
+    // dontSave: boolean = true;
+    // pos: { x: number, y: number, z: number } = { x: 0, y: 0, z: 0 };
+    // rot: { x: number, y: number, z: number } = { x: 0, y: 0, z: 0 };
+
+    constructor(connectionId: string, guid: string) {
+        this.guid = guid;
+        this.userId = connectionId;
+    }
+
+    send(sync: SyncedCamera, con: NetworkConnection) {
+        const cam = sync.cam?.cam;
+        if (cam) {
+            builder.clear();
+            const guid = builder.createString(this.guid);
+            const userId = builder.createString(this.userId);
+            SyncedCameraModel.startSyncedCameraModel(builder);
+            SyncedCameraModel.addGuid(builder, guid);
+            SyncedCameraModel.addUserId(builder, userId);
+            const p = utils.getWorldPosition(cam);
+            const r = utils.getWorldRotation(cam);
+            SyncedCameraModel.addPos(builder, Vec3.createVec3(builder, p.x, p.y, p.z));
+            SyncedCameraModel.addRot(builder, Vec3.createVec3(builder, r.x, r.y, r.z));
+            const offset = SyncedCameraModel.endSyncedCameraModel(builder);
+            builder.finish(offset, SyncedCameraModelIdentifier);
+            con.sendBinary(builder.asUint8Array());
+        }
+    }
+}
+
+declare type UserCamInfo =
+    {
+        obj: THREE.Object3D,
+        lastUpdate: number;
+        userId: string;
+    };
+
+export class SyncedCamera extends Behaviour {
+
+    getUserCamera(userId: string): THREE.Object3D | null {
+        const guid = this.userToCamMap[userId];
+        if (!guid) return null;
+        return this.remoteCams[guid].obj;
+    }
+
+    @serializeable(Camera)
+    public cam: Camera | null = null;
+    @serializeable([Object3D, AssetReference])
+    public cameraPrefab: THREE.Object3D | null | AssetReference = null;
+
+    private _lastWorldPosition!: THREE.Vector3;
+    private _lastWorldQuaternion!: THREE.Quaternion;
+    private _model: CameraModel | null = null;
+    private _needsUpdate: boolean = true;
+    private _lastUpdateTime: number = 0;
+
+    private remoteCams: { [id: string]: UserCamInfo } = {};
+    private userToCamMap: { [id: string]: string } = {};
+    private _camTimeoutInSeconds = 10;
+    private _receiveCallback: Function | null = null;
+
+    async awake() {
+        this._lastWorldPosition = this.worldPosition.clone();
+        this._lastWorldQuaternion = this.worldQuaternion.clone();
+
+        if (this.cameraPrefab) {
+
+            if ("uri" in this.cameraPrefab) {
+                this.cameraPrefab = await this.cameraPrefab.instantiate(this.gameObject);
+            }
+
+            if (this.cameraPrefab && "isObject3D" in this.cameraPrefab) {
+                this.cameraPrefab.visible = false;
+            }
+
+        }
+    }
+
+    start() {
+        if (!this.cam) {
+            console.warn("Missing camera, fallback to main camera", this);
+            this.cam = this.context.mainCameraComponent as Camera ?? null;
+        }
+    }
+
+    onEnable(): void {
+        this._receiveCallback = this.context.connection.beginListenBinrary(SyncedCameraModelIdentifier, this.onReceivedRemoteCameraInfoBin.bind(this));
+    }
+
+    onDisable(): void {
+        this.context.connection.stopListenBinary(SyncedCameraModelIdentifier, this._receiveCallback);
+    }
+
+    update(): void {
+
+        for (const guid in this.remoteCams) {
+            const cam = this.remoteCams[guid];
+            const timeDiff = this.context.time.realtimeSinceStartup - cam.lastUpdate;
+            if (!cam || (timeDiff) > this._camTimeoutInSeconds) {
+                console.log("Remote cam timeout", cam, timeDiff);
+                if (cam?.obj) {
+                    GameObject.destroy(cam.obj);
+                }
+                delete this.remoteCams[guid];
+                if (cam)
+                    delete this.userToCamMap[cam.userId];
+                continue;
+            }
+        }
+
+        if (WebXR.IsInWebXR) return;
+
+        if (this.cam === null) {
+            this.enabled = false;
+            return;
+        }
+
+        if (!this.context.connection.isConnected || this.context.connection.connectionId === null) return;
+
+        if (this._model === null) {
+            this._model = new CameraModel(this.context.connection.connectionId, this.context.connection.connectionId + "_camera");
+        }
+
+        const wp = utils.getWorldPosition(this.cam.cam);
+        const wq = utils.getWorldQuaternion(this.cam.cam);
+        if (wp.distanceTo(this._lastWorldPosition) > 0.001 || wq.angleTo(this._lastWorldQuaternion) > 0.01) {
+            this._needsUpdate = true;
+        }
+        this._lastWorldPosition.copy(wp);
+        this._lastWorldQuaternion.copy(wq);
+
+        if (!this._needsUpdate || this.context.time.frameCount % 2 !== 0) {
+            if (this.context.time.realtimeSinceStartup - this._lastUpdateTime > this._camTimeoutInSeconds * .5) {
+                // send update anyways to avoid timeout
+            }
+            else return;
+        }
+
+        this._lastUpdateTime = this.context.time.realtimeSinceStartup;
+        this._needsUpdate = false;
+        this._model.send(this, this.context.connection);
+    }
+
+    private onReceivedRemoteCameraInfoBin(model: SyncedCameraModel) {
+        const guid = model.guid();
+        if (!guid) return;
+        const userId = model.userId();
+        if (!userId) return;
+        if (!this.context.connection.userIsInRoom(userId)) return;
+        if (!this.cameraPrefab) return;
+        let rc = this.remoteCams[guid];
+        if (!rc) {
+            if ("isObject3D" in this.cameraPrefab) {
+                const opt = new InstantiateOptions();
+                opt.context = this.context;
+                const instance = GameObject.instantiate(this.cameraPrefab, opt) as GameObject;
+                rc = this.remoteCams[guid] = { obj: instance, lastUpdate: this.context.time.realtimeSinceStartup, userId: userId };
+                rc.obj.visible = true;
+                this.gameObject.add(instance);
+                this.userToCamMap[userId] = guid;
+
+                const marker = GameObject.getOrAddComponent(instance, AvatarMarker);
+                marker.connectionId = userId;
+                marker.avatar = instance;
+            }
+            else {
+                return;
+            }
+            // console.log(this.remoteCams);
+        }
+        const obj = rc.obj;
+        rc.lastUpdate = this.context.time.realtimeSinceStartup;
+        InstancingUtil.markDirty(obj);
+        const pos = model.pos();
+        if (pos)
+            utils.setWorldPositionXYZ(obj, pos.x(), pos.y(), pos.z());
+        const rot = model.rot();
+        if (rot)
+            utils.setWorldRotationXYZ(obj, rot.x(), rot.y(), rot.z());
+    }
+}

package/src/engine-components/SyncedRoom.ts

@@ -0,0 +1,157 @@
+import { Behaviour } from "./Component";
+import * as utils from "../engine/engine_utils"
+import { serializeable } from "../engine/engine_serialization_decorator";
+
+const viewParamName = "view";
+const debug = utils.getParam("debugsyncedroom");
+
+export class SyncedRoom extends Behaviour {
+
+    @serializeable()
+    public roomName!: string;
+    @serializeable()
+    public urlParameterName!: string;
+    @serializeable()
+    public joinRandomRoom: boolean = true;
+    @serializeable()
+    public requireRoomParameter: boolean = false;
+    @serializeable()
+    public autoRejoin: boolean = true;
+
+    private _roomPrefix?: string;
+
+    awake() {
+        if (this._roomPrefix === undefined) {
+            this._roomPrefix = this.roomName;
+            this.roomName = "";
+        }
+    }
+
+    onEnable() {
+        // if the url contains a view parameter override room and join in view mode
+        const viewId = utils.getParam(viewParamName);
+        if (viewId && typeof viewId === "string" && viewId.length > 0) {
+            console.log("Join as viewer");
+            this.context.connection.joinRoom(viewId, true);
+            return;
+        }
+        this.tryJoinRoom();
+    }
+
+    onDisable(): void {
+        if (this.roomName && this.roomName.length > 0)
+            this.context.connection.leaveRoom(this.roomName);
+    }
+
+    tryJoinRoom(call: number = 0): boolean {
+        let hasRoomParameter = false;
+        if (this.urlParameterName) {
+            const val = utils.getParam(this.urlParameterName);
+            if (val && typeof val === "string") {
+                hasRoomParameter = true;
+                const roomNameParam = utils.sanitizeString(val);
+                this.roomName = roomNameParam;
+            }
+            else if (this.joinRandomRoom) {
+                console.log("No room name found in url, generating random one");
+                this.setRandomRoomUrlParameter();
+                if (call < 1)
+                    return this.tryJoinRoom(call + 1);
+            }
+        }
+        else {
+            if (this.joinRandomRoom && (this.roomName === null || this.roomName === undefined || this.roomName.length <= 0)) {
+                console.log("generate room name");
+                this.roomName = this.generateRoomName();
+            }
+        }
+
+        if (this.requireRoomParameter && !hasRoomParameter) {
+            if (debug)
+                console.log("No required room parameter \"" + this.urlParameterName + "\" in url - will not connect to networking backend.");
+            return false;
+        }
+
+        if (!this.roomName || this.roomName.length <= 0) {
+            if (debug)
+                console.error("Missing room name on \"" + this.name + "\". Make sure this is correctly configured in Unity", this.context.connection.isDebugEnabled ? this : "");
+            return false;
+        }
+
+        if (!this.context.connection.isConnected) {
+            this.context.connection.connect();
+        }
+
+        if (this._roomPrefix)
+            this.roomName = this._roomPrefix + this.roomName;
+
+        this.context.connection.joinRoom(this.roomName);
+        return true;
+    }
+
+    private _lastPingTime: number = 0;
+    private _lastRoomTime: number = -1;
+
+    update(): void {
+        if (this.context.connection.isConnected) {
+            if (this.context.time.time - this._lastPingTime > 3) {
+                this._lastPingTime = this.context.time.time;
+                // console.log("PING");
+                this.context.connection.send("ping", { time: this.context.time.time });
+            }
+
+            if (this.context.connection.isInRoom) {
+                this._lastRoomTime = this.context.time.time;
+            }
+        }
+
+        if (this._lastRoomTime > 0 && this.context.time.time - this._lastRoomTime > .3) {
+            this._lastRoomTime = -1;
+
+            if (this.autoRejoin) {
+                console.log("Disconnected from networking backend - attempt reconnecting now")
+                this.tryJoinRoom();
+            }
+            else
+                console.warn("You are not connected to a room anymore (possibly because the tab was inactive for too long and the server kicked you)");
+        }
+    }
+
+    get currentRoomName(): string | null {
+        const view = utils.getParam(viewParamName);
+        if (view) return view as string;
+        return utils.getParam(this.urlParameterName) as string;
+    }
+
+    setRandomRoomUrlParameter() {
+        const params = utils.getUrlParams();
+        const room = this.generateRoomName();
+        // if we already have this parameter
+        if (utils.getParam(this.urlParameterName)) {
+            params.set(this.urlParameterName, room);
+        }
+        else
+            params.append(this.urlParameterName, room);
+        utils.setState(room, params);
+    }
+
+    generateRoomName(): string {
+        const words = utils.makeIdFromRandomWords();
+        const roomName = words + "_" + utils.randomNumber(100, 999);
+        return roomName;
+    }
+
+    getViewOnlyUrl(): string | null {
+        if (this.context.connection.isConnected && this.context.connection.currentRoomViewId) {
+            const url = window.location.search;
+            const urlParams = new URLSearchParams(url);
+            if (urlParams.has(this.urlParameterName))
+                urlParams.delete(this.urlParameterName);
+            urlParams.set(viewParamName, this.context.connection.currentRoomViewId);
+            return window.location.origin + window.location.pathname + "?" + urlParams.toString();
+        }
+
+
+        return null;
+    }
+}

package/src/engine-components/SyncedTransform.ts

@@ -0,0 +1,339 @@
+import * as THREE from 'three'
+import { IModel, OwnershipModel, RoomEvents } from "../engine/engine_networking"
+import { Behaviour, GameObject } from "./Component";
+import { Rigidbody } from "./RigidBody";
+import * as utils from "../engine/engine_utils"
+import { sendDestroyed } from '../engine/engine_networking_instantiate';
+import { InstancingUtil } from './Renderer';
+import { SyncedTransformModel } from '../engine-schemes/synced-transform-model';
+import * as flatbuffers from "flatbuffers";
+import { Transform } from '../engine-schemes/transform';
+import { registerType } from '../engine-schemes/schemes';
+import { setWorldEuler } from '../engine/engine_three_utils';
+
+const debug = utils.getParam("debugsync");
+export const SyncedTransformIdentifier = "STRS";
+registerType(SyncedTransformIdentifier, SyncedTransformModel.getRootAsSyncedTransformModel);
+
+const builder = new flatbuffers.Builder();
+
+export function createTransformModel(guid: string, b: Behaviour, fast: boolean = true): Uint8Array {
+    builder.clear();
+    const guidObj = builder.createString(guid);
+    SyncedTransformModel.startSyncedTransformModel(builder);
+    SyncedTransformModel.addGuid(builder, guidObj);
+    SyncedTransformModel.addFast(builder, fast);
+    const p = b.worldPosition;
+    const r = b.worldEuler;
+    const s = b.gameObject.scale; // todo: world scale
+    // console.log(p, r, s);
+    SyncedTransformModel.addTransform(builder, Transform.createTransform(builder, p.x, p.y, p.z, r.x, r.y, r.z, s.x, s.y, s.z));
+    const res = SyncedTransformModel.endSyncedTransformModel(builder);
+    // SyncedTransformModel.finishSyncedTransformModelBuffer(builder, res);
+    builder.finish(res, SyncedTransformIdentifier);
+    return builder.asUint8Array();
+}
+
+
+export class SyncedTransform extends Behaviour {
+
+    // public autoOwnership: boolean = true;
+    public overridePhysics: boolean = true
+    public interpolatePosition: boolean = true;
+    public interpolateRotation: boolean = true;
+    public fastMode: boolean = false;
+    public syncDestroy: boolean = false;
+
+    // private _state!: SyncedTransformModel;
+    private _model: OwnershipModel | null = null;
+    private _needsUpdate: boolean = true;
+    private rb: Rigidbody | null = null;
+    private _wasKinematic: boolean | undefined = false;
+    private _receivedDataBefore: boolean = false;
+
+    private _targetPosition!: THREE.Vector3;
+    private _targetRotation!: THREE.Quaternion;
+
+    private _receivedFastUpdate: boolean = false;
+    private _shouldRequestOwnership: boolean = false;
+
+    public requestOwnership() {
+        if (debug)
+            console.log("Request ownership");
+        if (!this._model) {
+            this._shouldRequestOwnership = true;
+            this._needsUpdate = true;
+        }
+        else
+            this._model.requestOwnership();
+    }
+
+    public hasOwnership(): boolean | undefined {
+        return this._model?.hasOwnership ?? undefined;
+    }
+
+    public isOwned(): boolean | undefined {
+        return this._model?.isOwned;
+    }
+
+    private joinedRoomCallback: any = null;
+    private receivedDataCallback: any = null;
+
+    awake() {
+        if (debug)
+            console.log("new instance", this.guid, this);
+        this._receivedDataBefore = false;
+        this._targetPosition = new THREE.Vector3();
+        this._targetRotation = new THREE.Quaternion();
+
+        // sync instantiate issue was because they shared the same last pos vector!
+        this.lastWorldPos = new THREE.Vector3();
+        this.lastWorldRotation = new THREE.Quaternion();
+
+        this.rb = GameObject.getComponentInChildren(this.gameObject, Rigidbody);
+        if (this.rb) {
+            this._wasKinematic = this.rb.isKinematic;
+        }
+
+        this.receivedUpdate = true;
+        // this._state = new TransformModel(this.guid, this);
+        this._model = new OwnershipModel(this.context.connection, this.guid);
+        if (this.context.connection.isConnected) {
+            this.tryGetLastState();
+        }
+
+        this.joinedRoomCallback = this.tryGetLastState.bind(this);
+        this.context.connection.beginListen(RoomEvents.JoinedRoom, this.joinedRoomCallback);
+        this.receivedDataCallback = this.onReceivedData.bind(this);
+        this.context.connection.beginListenBinrary(SyncedTransformIdentifier, this.receivedDataCallback);
+    }
+
+    onDestroy(): void {
+        // TODO: can we add a new component for this?! do we really need this?!
+        if (this.syncDestroy)
+            sendDestroyed(this.guid, this.context.connection);
+        this._model = null;
+        this.context.connection.stopListening(RoomEvents.JoinedRoom, this.joinedRoomCallback);
+        this.context.connection.stopListenBinary(SyncedTransformIdentifier, this.receivedDataCallback);
+    }
+
+    private tryGetLastState() {
+        const model = this.context.connection.tryGetState(this.guid) as unknown as SyncedTransformModel;
+        if (model) this.onReceivedData(model);
+    }
+
+    private tempEuler: THREE.Euler = new THREE.Euler();
+
+    private onReceivedData(data: SyncedTransformModel) {
+        if (this.destroyed) return;
+        if (typeof data.guid === "function" && data.guid() === this.guid) {
+            if (debug)
+                console.log("new data", this.context.connection.connectionId, this.context.time.frameCount, this.guid, data);
+            this.receivedUpdate = true;
+            this._receivedFastUpdate = data.fast();
+            const transform = data.transform();
+            if (transform) {
+                InstancingUtil.markDirty(this.gameObject, true);
+                const position = transform.position();
+                if (position) {
+                    if (this.interpolatePosition)
+                        this._targetPosition?.set(position.x(), position.y(), position.z());
+                    if (!this.interpolatePosition || !this._receivedDataBefore)
+                        this.setWorldPosition(position.x(), position.y(), position.z());
+                }
+
+                const rotation = transform.rotation();
+                if (rotation) {
+                    this.tempEuler.set(rotation.x(), rotation.y(), rotation.z());
+                    if (this.interpolateRotation) {
+                        this._targetRotation.setFromEuler(this.tempEuler);
+                    }
+                    if (!this.interpolateRotation || !this._receivedDataBefore)
+                        setWorldEuler(this.gameObject, this.tempEuler);
+                }
+            }
+            this._receivedDataBefore = true;
+
+            // if (this.rb && !this._model?.hasOwnership) {
+            //     this.rb.setBodyFromGameObject(data.velocity)
+            // }
+        }
+    }
+
+    onEnable(): void {
+        this.lastWorldPos.copy(this.worldPosition);
+        this.lastWorldRotation.copy(this.worldQuaternion);
+        this._needsUpdate = true;
+        // console.log("ENABLE", this.guid, this.gameObject.guid, this.lastWorldPos);
+        if (this._model) {
+            this._model.updateIsOwned();
+        }
+    }
+
+    onDisable(): void {
+        if (this._model)
+            this._model.freeOwnership();
+    }
+
+
+    private receivedUpdate = false;
+    private lastWorldPos!: THREE.Vector3;
+    private lastWorldRotation!: THREE.Quaternion;
+
+    onBeforeRender() {
+        if (!this.activeAndEnabled || !this.context.connection.isConnected) return;
+        // console.log("BEFORE RENDER", this.destroyed, this.guid, this._model?.isOwned, this.name, this.gameObject);
+
+        if (!this.context.connection.isInRoom || !this._model) {
+            if (debug)
+                console.log("no model or room", this.name, this.guid, this.context.connection.isInRoom);
+            return;
+        }
+
+        if (this._shouldRequestOwnership) {
+            this._shouldRequestOwnership = false;
+            this._model.requestOwnership();
+        }
+
+        let wp = this.worldPosition;
+        let wr = this.worldQuaternion;
+        if (this._model.isOwned && !this.receivedUpdate) {
+            const worlddiff = wp.distanceTo(this.lastWorldPos);
+            const worldRot = wr.angleTo(this.lastWorldRotation);
+            const threshold = this._model.hasOwnership || this.fastMode ? .0001 : .001;
+            if (worlddiff > threshold || worldRot > threshold) {
+                // console.log(worlddiff, worldRot);
+                if (!this._model.hasOwnership) {
+
+                    if (debug)
+                        console.log(this.guid, "reset because not owned but", this.gameObject.name, this.lastWorldPos);
+
+                    this.worldPosition = this.lastWorldPos;
+                    wp.copy(this.lastWorldPos);
+
+                    this.worldQuaternion = this.lastWorldRotation;
+                    wr.copy(this.lastWorldRotation);
+
+                    InstancingUtil.markDirty(this.gameObject, true);
+                    this._needsUpdate = false;
+                }
+                else {
+                    this._needsUpdate = true;
+                }
+            }
+        }
+        // else if (this._model.isOwned === false) {
+        //     if (!this._didRequestOwnershipOnce && this.autoOwnership) {
+        //         this._didRequestOwnershipOnce = true;
+        //         this._model.requestOwnershipIfNotOwned();
+        //     }
+        // }
+
+
+        if (this._model && !this._model.hasOwnership && this._model.isOwned) {
+            if (this._receivedDataBefore) {
+                const factor = this._receivedFastUpdate || this.fastMode ? .5 : .3;
+                const t = factor;//Mathf.clamp01(this.context.time.deltaTime * factor);
+                let requireMarkDirty = false;
+                if (this.interpolatePosition && this._targetPosition) {
+                    const pos = this.worldPosition;
+                    pos.lerp(this._targetPosition, t);
+                    this.worldPosition = pos;
+                    requireMarkDirty = true;
+                }
+                if (this.interpolateRotation && this._targetRotation) {
+                    const rot = this.worldQuaternion;
+                    rot.slerp(this._targetRotation, t);
+                    this.worldQuaternion = rot;
+                    requireMarkDirty = true;
+                }
+                if (requireMarkDirty)
+                    InstancingUtil.markDirty(this.gameObject, true);
+            }
+        }
+
+
+        this.receivedUpdate = false;
+        this.lastWorldPos.copy(wp);
+        this.lastWorldRotation.copy(wr);
+
+
+        // if (this._model.isOwned === false && this.autoOwnership) {
+        //     this.requestOwnership();
+        // }
+
+        if (!this._model) return;
+        // only run if we are the owner
+        if (!this._model || this._model.hasOwnership === undefined || !this._model.hasOwnership) {
+            if (this.rb) {
+                this.rb.isKinematic = this._model.isOwned ?? false;
+                this.rb.setVelocity(0, 0, 0);
+                this.rb.setBodyFromGameObject();
+            }
+            return;
+        }
+
+        // local user is owner:
+
+        if (this.rb) {
+            if (this._wasKinematic !== undefined) {
+                if (debug)
+                    console.log("reset kinematic", this.rb.name, this._wasKinematic);
+                this.rb.isKinematic = this._wasKinematic;
+            }
+
+            // hacky reset if too far off
+            if (this.gameObject.position.distanceTo(new THREE.Vector3(0, 0, 0)) > 1000) {
+                if (debug)
+                    console.log("RESET", this.name)
+                this.gameObject.position.set(0, 1, 0);
+                this.rb.setVelocity(0, 0, 0);
+                this.rb.setBodyFromGameObject();
+            }
+        }
+
+        const updateInterval = 10;
+        const fastUpdate = this.rb || this.fastMode;
+        if (this._needsUpdate && (updateInterval <= 0 || updateInterval > 0 && this.context.time.frameCount % updateInterval === 0 || fastUpdate)) {
+
+            if (debug)
+                console.log("send update", this.context.connection.connectionId, this.guid, this.gameObject.name, this.gameObject.guid);
+
+            if (this.overridePhysics && this.rb) {
+                this.rb.setBodyFromGameObject();
+            }
+
+            this._needsUpdate = false;
+            const st = createTransformModel(this.guid, this, fastUpdate ? true : false);
+            // this._state.update(this, this.rb);
+            // this._state.fast = fastUpdate ? true : false;
+            this.context.connection.sendBinary(st);
+        }
+    }
+
+
+    // private lastPosition: THREE.Vector3 = new THREE.Vector3();
+
+    // private async setPosition(pt: THREE.Vector3) {
+
+    //     if (this._model.isConnected && !this._model?.hasOwnership) {
+    //         await this._model?.requestOwnershipAsync();
+    //     }
+
+    //     if (pt.distanceTo(this.lastPosition) < .001) {
+    //         return;
+    //     }
+    //     this.lastPosition.copy(pt);
+
+    //     if(this.gameObject.parent) this.gameObject.parent.worldToLocal(pt);
+    //     // this.gameObject.position.copy(pt);
+    //     this.gameObject.position.set(pt.x, pt.y, pt.z);
+    //     this._target.set(pt.x, pt.y, pt.z);
+    //     this._needsUpdate = true;
+    //     if (this.rb) {
+    //         this.gameObject.position.set(pt.x, pt.y + .5, pt.z);
+    //         this.rb.setVelocity(0, 0, 0);
+    //         this.rb.setBodyFromGameObject();
+    //     }
+    // }
+}