@needle-tools/engine 2.24.0-pre

package/src/engine-components/ComponentExtensions.ts

@@ -0,0 +1,7 @@
+import * as THREE from 'three';
+import {GameObject, Behaviour} from "./Component"
+
+
+export class UnityObject {
+
+}

package/src/engine-components/DeleteBox.ts

@@ -0,0 +1,34 @@
+
+import * as THREE from "three";
+import { syncDestroy } from "../engine/engine_networking_instantiate";
+import { BoxHelperComponent } from "./BoxHelperComponent";
+import { Behaviour, GameObject } from "./Component";
+import { UsageMarker } from "./Interactable";
+
+
+export class DeleteBox extends BoxHelperComponent {}
+
+
+export class Deletable extends Behaviour {
+
+    private deleteBoxes: DeleteBox[] = [];
+
+    awake() {
+        this.deleteBoxes = GameObject.findObjectsOfType(DeleteBox, this.context);
+    }
+
+    update(): void {
+        for (const box of this.deleteBoxes) {
+            const obj = this.gameObject as unknown as THREE.Mesh;
+            const res = box.isInBox(obj);
+            // console.log(res);
+            if (res === true) {
+                const marker = GameObject.getComponentInParent(this.gameObject, UsageMarker);
+                if (!marker) {
+                    // console.log("DESTROY");
+                    syncDestroy(this.gameObject, this.context.connection);
+                }
+            }
+        }
+    }
+}

package/src/engine-components/DeviceFlag.ts

@@ -0,0 +1,46 @@
+import { serializeable } from "../engine/engine_serialization_decorator";
+import { Behaviour, GameObject } from "./Component";
+
+
+export enum DeviceType {
+    Never = 0,
+    Desktop = 1 << 0,
+    Mobile = 2 << 0,
+}
+
+export class DeviceFlag extends Behaviour {
+
+    @serializeable()
+    visibleOn!: DeviceType;
+
+
+    onEnable() {
+        this.apply();
+    }
+
+    apply() {    
+        if (!this.test()) {
+            GameObject.setActive(this.gameObject, false);
+        }
+    }
+
+    private test() : boolean {
+        if(this.visibleOn < 0) return true;
+        if(isMobile()){
+            return (this.visibleOn & (DeviceType.Mobile)) !== 0;
+        }
+        const allowDesktop = (this.visibleOn & (DeviceType.Desktop)) !== 0;
+        return allowDesktop;
+    }
+
+}
+
+// shamelessly taken from https://stackoverflow.com/a/11381730
+let _isMobile: boolean | undefined = undefined;
+function isMobile() {
+    if (_isMobile === true || _isMobile === false) return _isMobile;
+    let check = false;
+    (function (a) { if (/(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i.test(a) || /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i.test(a.substr(0, 4))) check = true; })(navigator.userAgent || navigator.vendor || window["opera"]);
+    _isMobile = check;
+    return check;
+};

package/src/engine-components/DragControls.ts

@@ -0,0 +1,534 @@
+import { Behaviour, GameObject } from "./Component";
+// import { DragControls as Control } from "../include/three/DragControls";
+import { SyncedTransform } from "./SyncedTransform";
+import * as THREE from "three";
+import { IPointerClickHandler, IPointerDownHandler, IPointerEnterHandler, IPointerExitHandler, IPointerUpHandler, PointerEventData } from "./ui/PointerEvents";
+import { Context } from "../engine/engine_setup";
+import { Interactable, UsageMarker } from "./Interactable";
+import { Rigidbody } from "./RigidBody";
+import { WebXR } from "./WebXR";
+import { InstancingUtil } from "./Renderer";
+import { Avatar_POI } from "./avatar/Avatar_Brain_LookAt";
+import { RaycastOptions } from "../engine/engine_physics";
+import { getWorldPosition, getWorldQuaternion, setWorldPosition } from "../engine/engine_three_utils";
+import { KeyCode } from "../engine/engine_input";
+import { nameofFactory } from "../engine/engine_utils";
+
+const debug = false;
+
+export enum DragEvents {
+    SelectStart = "selectstart",
+    SelectEnd = "selectend",
+}
+
+interface SelectArgs {
+    selected: THREE.Object3D;
+    attached: THREE.Object3D | GameObject | null;
+}
+
+
+export interface IDragEventListener {
+    onDragStart?();
+    onDragEnd?();
+}
+
+export class DragControls extends Interactable implements IPointerDownHandler, IPointerUpHandler, IPointerEnterHandler, IPointerExitHandler {
+
+    private static _active: DragControls | null = null;
+    public static get HasAnySelected(): boolean { return this._active !== null; }
+
+
+    public transformSelf: boolean = true;
+    // public transformGroup: boolean = true;
+    // public targets: THREE.Object3D[] | null = null;
+
+    // private controls: Control | null = null;
+    // private orbit: OrbitControls | null = null;
+
+    private selectStartEventListener: ((controls: DragControls, args: SelectArgs) => void)[] = [];
+    private selectEndEventListener: Array<Function> = [];
+
+    constructor() {
+        super();
+        this.selectStartEventListener = [];
+        this.selectEndEventListener = [];
+        this._dragDelta = new THREE.Vector2();
+    }
+
+    addDragEventListener(type: DragEvents, cb: (ctrls: DragControls, args: SelectArgs) => void | Function) {
+        switch (type) {
+            case DragEvents.SelectStart:
+                this.selectStartEventListener.push(cb);
+                break;
+            case DragEvents.SelectEnd:
+                this.selectEndEventListener.push(cb);
+                break;
+        }
+    }
+
+    private _dragHelper: DragHelper | null = null;
+
+
+    start() {
+        // this.orbit = GameObject.findObjectOfType(OrbitControls, this.context);
+    }
+
+    private static lastHovered: THREE.Object3D;
+    private _draggingRigidbodies: Rigidbody[] = [];
+
+    private allowEdit(_obj: THREE.Object3D | null = null) {
+        return this.context.connection.allowEditing;
+    }
+
+    onPointerEnter(evt: PointerEventData) {
+        if (!this.allowEdit(this.gameObject)) return;
+        if (WebXR.IsInWebXR) return;
+        // const interactable = GameObject.getComponentInParent(evt.object, Interactable);
+        // if (!interactable) return;
+        const dc = GameObject.getComponentInParent(evt.object, DragControls);
+        if (!dc || dc !== this) return;
+        DragControls.lastHovered = evt.object;
+        this.context.domElement.style.cursor = 'pointer';
+    }
+
+    onPointerExit(evt: PointerEventData) {
+        if (!this.allowEdit(this.gameObject)) return;
+        if (WebXR.IsInWebXR) return;
+        if (DragControls.lastHovered !== evt.object) return;
+        // const interactable = GameObject.getComponentInParent(evt.object, Interactable);
+        // if (!interactable) return;
+        this.context.domElement.style.cursor = 'auto';
+    }
+
+    private _waitingForDragStart: PointerEventData | null = null;
+
+    onPointerDown(args: PointerEventData) {
+        if (!this.allowEdit(this.gameObject)) return;
+        if (WebXR.IsInWebXR) return;
+        this._dragDelta.set(0, 0);
+        this._didDrag = false;
+        this._waitingForDragStart = args;
+        args.StopPropagation();
+        // if (this.orbit) this.orbit.enabled = false;
+    }
+
+    onPointerUp(args: PointerEventData) {
+        this._waitingForDragStart = null;
+        if (!this.allowEdit(this.gameObject)) return;
+        if (WebXR.IsInWebXR) return;
+        this.onDragEnd(args);
+        args.StopPropagation();
+        // if (this.orbit) this.orbit.enabled = true;
+    }
+
+
+    update(): void {
+        if (WebXR.IsInWebXR) return;
+
+        // drag start only after having dragged for some pixels
+        if (this._waitingForDragStart) {
+
+            if (!this._didDrag) {
+                // this is so we can e.g. process clicks without having a drag change the position
+                // e.g. a click to rotate the object
+                const delta = this.context.input.getPointerPositionDelta(0);
+                if (delta)
+                    this._dragDelta.add(delta);
+                if (this._dragDelta.length() > 2)
+                    this._didDrag = true;
+                else return;
+            }
+
+            const args = this._waitingForDragStart;
+            this._waitingForDragStart = null;
+            this.onDragStart(args);
+        }
+
+        if (this._dragHelper && this._dragHelper.hasSelected) {
+            this.onUpdateDrag();
+        }
+
+        if (this._isDragging && !this._dragHelper?.hasSelected) {
+            this.onDragEnd(null);
+        }
+    }
+
+    private _isDragging: boolean = false;
+    private _marker: UsageMarker | null = null;
+    private _dragDelta!: THREE.Vector2;
+    private _didDrag: boolean = false;
+
+    private onDragStart(evt: PointerEventData) {
+        if (!this._dragHelper) {
+            if (this.context.mainCamera)
+                this._dragHelper = new DragHelper(this.context.mainCamera);
+            else
+                return;
+        }
+        if (!evt || !evt.object) return;
+
+        const dc = GameObject.getComponentInParent(evt.object, DragControls);
+        if (!dc || dc !== this) return;
+
+
+        let object: THREE.Object3D = evt.object;
+
+        if (this.transformSelf) {
+            object = this.gameObject;
+        }
+
+        // raise event
+        const args: { selected: THREE.Object3D, attached: THREE.Object3D | null } = { selected: object, attached: object };
+        for (const listener of this.selectStartEventListener) {
+            listener(this, args);
+        }
+
+        if (!args.attached) return;
+        if (args.attached !== object) {
+            // if duplicatable changes the object being dragged
+            // should it also change the active drag controls (e.g. if it has a own one)
+            // const drag = GameObject.getComponentInParent(args.attached, DragControls);
+            // if(drag !== this){
+            //     console.log(args.attached, object);
+            //     drag?.onDragStart(evt);
+            //     return;
+            // }
+        }
+        object = args.attached;
+        this._isDragging = true;
+        this._dragHelper.setSelected(object, this.context);
+        // if (this.orbit) this.orbit.enabled = false;
+
+        const sync = GameObject.getComponentInChildren(object, SyncedTransform);
+        if (debug)
+            console.log("DRAG START", sync, object);
+        if (sync) {
+            sync.fastMode = true;
+            sync?.requestOwnership();
+        }
+
+        this._marker = GameObject.addNewComponent(object, UsageMarker);
+
+        // console.log(object, this._marker);
+
+        this._draggingRigidbodies.length = 0;
+        const rbs = GameObject.getComponentsInChildren(object, Rigidbody);
+        if (rbs)
+            this._draggingRigidbodies.push(...rbs);
+
+        const l = nameofFactory<IDragEventListener>();
+        GameObject.invokeOnChildren(this._dragHelper.selected, l("onDragStart"));
+    }
+
+    private onUpdateDrag() {
+        if (!this._dragHelper) return;
+
+        this._dragHelper.onUpdate(this.context);
+        for (const rb of this._draggingRigidbodies) {
+            rb.wakeUp();
+            rb.setBodyFromGameObject();
+        }
+    }
+
+    private onDragEnd(evt: PointerEventData | null) {
+        if (!this || !this._isDragging) return;
+        this._isDragging = false;
+        if (!this._dragHelper) return;
+        this._draggingRigidbodies.length = 0;
+        const selected = this._dragHelper.selected;
+        if (debug)
+            console.log("DRAG END", selected, selected?.visible)
+        this._dragHelper.setSelected(null, this.context);
+        // if (this.orbit) this.orbit.enabled = true;
+        if (evt?.object) {
+            const sync = GameObject.getComponentInChildren(evt.object, SyncedTransform);
+            if (sync) {
+                sync.fastMode = false;
+                // sync?.requestOwnership();
+            }
+            if (this._marker) {
+                this._marker.destroy();
+            }
+        }
+        // raise event
+        for (const listener of this.selectEndEventListener) {
+            listener(this);
+        }
+
+        const l = nameofFactory<IDragEventListener>();
+        GameObject.invokeOnChildren(selected, l("onDragEnd"));
+    }
+}
+
+
+
+class DragHelper {
+
+    public get hasSelected(): boolean {
+        return this._selected !== null && this._selected !== undefined;
+    }
+
+    public get selected(): THREE.Object3D | null {
+        return this._selected;
+    }
+
+    private _selected: THREE.Object3D | null = null;
+    private _context: Context | null = null;
+    private _camera: THREE.Camera;;
+    private _cameraPlane: THREE.Plane = new THREE.Plane();
+
+    private _hasGroundPlane: boolean = false;
+    private _groundPlane: THREE.Plane = new THREE.Plane();
+    private _groundOffset: THREE.Vector3 = new THREE.Vector3();
+    private _groundOffsetFactor: number = 0;
+    private _groundDistance: number = 0;
+    private _groundPlanePoint: THREE.Vector3 = new THREE.Vector3();
+
+    private _raycaster = new THREE.Raycaster();
+    private _cameraPlaneOffset = new THREE.Vector3();
+    private _intersection = new THREE.Vector3();
+    private _worldPosition = new THREE.Vector3();
+    private _inverseMatrix = new THREE.Matrix4();
+    private _rbs: Rigidbody[] = [];
+
+    private _groundLine: THREE.Line;
+    private _groundMarker: THREE.Object3D;
+    private static geometry = new THREE.BufferGeometry().setFromPoints([new THREE.Vector3(0, 0, 0), new THREE.Vector3(0, -1, 0)]);
+
+    constructor(camera: THREE.Camera) {
+        this._camera = camera;
+
+        const line = new THREE.Line(DragHelper.geometry);
+        const mat = line.material as THREE.LineBasicMaterial;
+        mat.color = new THREE.Color(.4, .4, .4);
+        line.layers.set(2);
+        line.name = 'line';
+        line.scale.y = 1;
+        // line.matrixAutoUpdate = false;
+        this._groundLine = line;
+
+        const geometry = new THREE.SphereGeometry(.5, 22, 22);
+        const material = new THREE.MeshBasicMaterial({ color: mat.color });
+        const sphere = new THREE.Mesh(geometry, material);
+        sphere.visible = false;
+        sphere.layers.set(2);
+        this._groundMarker = sphere;
+    }
+
+    setSelected(newSelected: THREE.Object3D | null, context: Context) {
+
+        if (this._selected && context) {
+            for (const rb of this._rbs) {
+                rb.wakeUp();
+                if (!rb.smoothedVelocity) continue;
+                rb.setVelocity(rb.smoothedVelocity.x, rb.smoothedVelocity.y, rb.smoothedVelocity.z);
+            }
+        }
+
+        if (this._selected) {
+
+            Avatar_POI.Remove(context, this._selected);
+        }
+
+        this._selected = newSelected;
+        this._context = context;
+        this._rbs.length = 0;
+
+        if (newSelected) {
+            context.scene.add(this._groundLine);
+            context.scene.add(this._groundMarker);
+        }
+        else {
+            this._groundLine.removeFromParent();
+            this._groundMarker.removeFromParent();
+        }
+
+
+        if (this._selected) {
+            if (!context) {
+                console.error("DragHelper: no context");
+                return;
+            }
+            Avatar_POI.Add(context, this._selected, null);
+
+            this._groundOffsetFactor = 0;
+            this._hasGroundPlane = true;
+            this._groundOffset.set(0, 0, 0);
+            this._requireUpdateGroundPlane = true;
+
+            this._rbs = GameObject.getComponentsInChildren(this._selected, Rigidbody);
+            this.onUpdateScreenSpacePlane();
+        }
+    }
+
+    private _groundOffsetVector = new THREE.Vector3(0, 1, 0);
+    private _requireUpdateGroundPlane = true;
+    private _didDragOnGroundPlaneLastFrame: boolean = false;
+
+    onUpdate(_context: Context) {
+        if (!this._context) return;
+
+
+        const mainKey = KeyCode.SPACE;
+        const secondaryKey = KeyCode.KEY_D;
+        const scaleKey = KeyCode.KEY_S;
+
+        const isRotateKeyPressed = this._context?.input.isKeyPressed(mainKey) || this._context?.input.isKeyPressed(secondaryKey);
+        const isRotating = this._context.input.getTouchesPressedCount() >= 2 || isRotateKeyPressed;
+        if (isRotating) {
+            const dt = this._context.input.getPointerPositionDelta(0);
+            if (dt) {
+                this._groundOffsetVector.set(0, 1, 0);
+                this._selected?.rotateOnWorldAxis(this._groundOffsetVector, dt.x * this._context.time.deltaTime);
+            }
+        }
+
+        // todo: allow this once synced transform sends world scale
+        // const isScaling = this._context?.input.isKeyPressed(scaleKey);
+        // if(isScaling){
+        //     const dt = this._context.input.getPointerPositionDelta(0);
+        //     if(dt){
+        //         this._selected?.scale.multiplyScalar(1 + (dt.x * this._context.time.deltaTime));
+        //         return;
+        //     }
+        // }
+
+        const rc = this._context.input.getPointerPositionRC(0);
+        if (!rc) return;
+        this._raycaster.setFromCamera(rc, this._camera);
+
+        if (this._selected) {
+            if (debug) console.log("UPDATE DRAG", this._selected);
+            this._groundOffsetVector.set(0, 1, 0);
+            const lookDirection = getWorldPosition(this._camera).clone().sub(getWorldPosition(this._selected)).normalize();
+            const lookDot = Math.abs(lookDirection.dot(this._groundOffsetVector));
+
+            const switchModeKeyPressed = this._context?.input.isKeyPressed(mainKey) || this._context?.input.isKeyPressed(secondaryKey);
+            const dragOnGroundPlane = !isRotating && lookDot > .2 && !switchModeKeyPressed && this._context!.input.getPointerPressedCount() <= 1;
+            const changed = this._didDragOnGroundPlaneLastFrame !== dragOnGroundPlane;
+            this._didDragOnGroundPlaneLastFrame = dragOnGroundPlane;
+
+            if (!this._hasGroundPlane) this._requireUpdateGroundPlane = true;
+            if (this._requireUpdateGroundPlane || !dragOnGroundPlane || changed)
+                this.onUpdateGroundPlane();
+
+            this._requireUpdateGroundPlane = false;
+            if (this._hasGroundPlane) {
+                // const wp = getWorldPosition(this._selected);
+                // const ray = new THREE.Ray(wp, new THREE.Vector3(0, -1, 0));
+
+                if (this._raycaster.ray.intersectPlane(this._groundPlane, this._intersection)) {
+                    const y = this._intersection.y;
+                    this._groundPlanePoint.copy(this._intersection).sub(this._groundOffset);
+                    this._groundPlanePoint.y = y;
+
+                    if (dragOnGroundPlane) {
+                        this._groundOffsetVector.set(0, 1, 0);
+                        // console.log(this._groundOffset);
+                        const wp = this._intersection.sub(this._groundOffset).add(this._groundOffsetVector.multiplyScalar(this._groundOffsetFactor));
+                        this.onUpdateWorldPosition(wp, this._groundPlanePoint, false);
+                        this.onDidUpdate();
+                        return;
+                    }
+                }
+                // TODO: fix this
+                else this._groundPlanePoint.set(0, 99999, 0);
+                // else  if (ray.intersectPlane(this._groundPlane, this._intersection)) {
+                //     const y = this._intersection.y;
+                //     this._groundPlanePoint.copy(this._intersection).sub(this._groundOffset);
+                //     this._groundPlanePoint.y = y;
+                // }
+            }
+
+            if (changed) {
+                this.onUpdateScreenSpacePlane();
+            }
+
+            this._requireUpdateGroundPlane = true;
+            if (this._raycaster.ray.intersectPlane(this._cameraPlane, this._intersection)) {
+                this.onUpdateWorldPosition(this._intersection.sub(this._cameraPlaneOffset), this._groundPlanePoint, true);
+                this.onDidUpdate();
+            }
+        }
+    }
+
+    private onUpdateWorldPosition(wp: THREE.Vector3, pointOnPlane: THREE.Vector3 | null, heightOnly: boolean) {
+        if (!this._selected) return;
+        if (heightOnly) {
+            const cur = getWorldPosition(this._selected);
+            cur.y = wp.y;
+            wp = cur;
+        }
+        setWorldPosition(this._selected, wp);
+        setWorldPosition(this._groundLine, wp);
+        if (this._hasGroundPlane) {
+            this._groundLine.scale.y = this._groundDistance;
+        }
+        else this._groundLine.scale.y = 1000;
+
+        this._groundMarker.visible = pointOnPlane !== null;
+        if (pointOnPlane) {
+            const s = getWorldPosition(this._camera).distanceTo(pointOnPlane) * .01;
+            this._groundMarker.scale.set(s, s, s);
+            setWorldPosition(this._groundMarker, pointOnPlane);
+        }
+    }
+
+    private onUpdateScreenSpacePlane() {
+        if (!this._selected || !this._context) return;
+        const rc = this._context.input.getPointerPositionRC(0);
+        if (!rc) return;
+        this._raycaster.setFromCamera(rc, this._camera);
+        this._cameraPlane.setFromNormalAndCoplanarPoint(this._camera.getWorldDirection(this._cameraPlane.normal), this._worldPosition.setFromMatrixPosition(this._selected.matrixWorld));
+        if (this._raycaster.ray.intersectPlane(this._cameraPlane, this._intersection) && this._selected.parent) {
+            this._inverseMatrix.copy(this._selected.parent.matrixWorld).invert();
+            this._cameraPlaneOffset.copy(this._intersection).sub(this._worldPosition.setFromMatrixPosition(this._selected.matrixWorld));
+        }
+    }
+
+    private onUpdateGroundPlane() {
+        if (!this._selected || !this._context) return;
+        const wp = getWorldPosition(this._selected);
+        const ray = new THREE.Ray(new THREE.Vector3(0, .1, 0).add(wp), new THREE.Vector3(0, -1, 0));
+        const opts = new RaycastOptions();
+        opts.ignore = [this._selected];
+        const hits = this._context.physics.raycastFromRay(ray, opts);
+        for (let i = 0; i < hits.length; i++) {
+            const hit = hits[i];
+            if (!hit.face || this.contains(this._selected, hit.object)) {
+                continue;
+            }
+            const normal = new THREE.Vector3(0, 1, 0); // hit.face.normal
+            this._groundPlane.setFromNormalAndCoplanarPoint(normal, hit.point);
+            break;
+        }
+
+        this._hasGroundPlane = true;
+        this._groundPlane.setFromNormalAndCoplanarPoint(ray.direction.multiplyScalar(-1), ray.origin);
+        this._raycaster.ray.intersectPlane(this._groundPlane, this._intersection);
+        this._groundDistance = this._intersection.distanceTo(wp);
+        this._groundOffset.copy(this._intersection).sub(wp);
+    }
+
+    private onDidUpdate() {
+        // todo: when using instancing we need to mark the matrix to update
+        InstancingUtil.markDirty(this._selected);
+
+        for (const rb of this._rbs) {
+            rb.wakeUp();
+            rb.setBodyFromGameObject({ x: 0, y: 0, z: 0 });
+            rb.setAngularVelocity(0, 0, 0);
+        }
+    }
+
+    private contains(obj: THREE.Object3D, toSearch: THREE.Object3D): boolean {
+        if (obj === toSearch) return true;
+        if (obj.children) {
+            for (const child of obj.children) {
+                if (this.contains(child, toSearch)) return true;
+            }
+        }
+        return false;
+    }
+}
+