@needle-tools/engine 3.2.3-alpha → 3.2.4-alpha

package/src/engine-components/Component.ts

@@ -1,15 +1,14 @@
-import * as THREE from "three";
 import { Mathf } from "../engine/engine_math";
 import * as threeutils from "../engine/engine_three_utils";
 import { activeInHierarchyFieldName } from "../engine/engine_constants";
 import { Context, FrameEvent } from "../engine/engine_setup";
 import * as main from "../engine/engine_mainloop_utils";
-import { Object3D } from "three";
 import { syncDestroy, syncInstantiate } from "../engine/engine_networking_instantiate";
-import { ConstructorConcrete, SourceIdentifier, IComponent, IGameObject, Constructor, GuidsMap, UIDProvider, Collision, ICollider } from "../engine/engine_types";
+import { ConstructorConcrete, SourceIdentifier, IComponent, IGameObject, Constructor, GuidsMap, Collision, ICollider } from "../engine/engine_types";
 import { addNewComponent, destroyComponentInstance, findObjectOfType, findObjectsOfType, getComponent, getComponentInChildren, getComponentInParent, getComponents, getComponentsInChildren, getComponentsInParent, getOrAddComponent, moveComponentInstance, removeComponent } from "../engine/engine_components";
 import { findByGuid, destroy, InstantiateOptions, instantiate, HideFlags, foreachComponent, markAsInstancedRendered, isActiveInHierarchy, isActiveSelf, isUsingInstancing, setActive, isDestroyed } from "../engine/engine_gameobject";
 
+import { Euler, Object3D, Quaternion, Scene, Vector3 } from "three";
 
 // export interface ISerializationCallbackReceiver {
 //     onBeforeSerialize?(): object | void;
@@ -19,7 +18,7 @@ import { findByGuid, destroy, InstantiateOptions, instantiate, HideFlags, foreac
 //     onDeserialize?(key: string, value: any): any | void;
 // }
 
-abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGameObject {
+abstract class GameObject extends Object3D implements Object3D, IGameObject {
 
     guid: string | undefined;
 
@@ -27,13 +26,13 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
     abstract destroy();
 
     // The actual implementation / prototype of threejs is modified in js-extensions/Object3D
-    abstract get transform(): THREE.Object3D;
+    abstract get transform(): Object3D;
 
-    public static isDestroyed(go: THREE.Object3D): boolean {
+    public static isDestroyed(go: Object3D): boolean {
         return isDestroyed(go);
     }
 
-    public static setActive(go: THREE.Object3D, active: boolean, processStart: boolean = true) {
+    public static setActive(go: Object3D, active: boolean, processStart: boolean = true) {
         if (!go) return;
         setActive(go, active);
 
@@ -44,29 +43,29 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
     }
 
     /** If the object is active (same as go.visible) */
-    public static isActiveSelf(go: THREE.Object3D): boolean {
+    public static isActiveSelf(go: Object3D): boolean {
         return isActiveSelf(go);
     }
 
     /** If the object is active in the hierarchy (e.g. if any parent is invisible or not in the scene it will be false) 
      * @param go object to check
     */
-    public static isActiveInHierarchy(go: THREE.Object3D): boolean {
+    public static isActiveInHierarchy(go: Object3D): boolean {
         return isActiveInHierarchy(go);
     }
 
-    public static markAsInstancedRendered(go: THREE.Object3D, instanced: boolean) {
+    public static markAsInstancedRendered(go: Object3D, instanced: boolean) {
         markAsInstancedRendered(go, instanced);
     }
 
-    public static isUsingInstancing(instance: THREE.Object3D): boolean { return isUsingInstancing(instance); }
+    public static isUsingInstancing(instance: Object3D): boolean { return isUsingInstancing(instance); }
 
     /** Run a callback for all components of the provided type on the provided object and its children (if recursive is true)
      * @param instance object to run the method on
      * @param cb callback to run on each component
      * @param recursive if true, the method will be run on all children as well
      */
-    public static foreachComponent(instance: THREE.Object3D, cb: (comp: Component) => any, recursive: boolean = true): any {
+    public static foreachComponent(instance: Object3D, cb: (comp: Component) => any, recursive: boolean = true): any {
         return foreachComponent(instance, cb as (comp: IComponent) => any, recursive);
     }
 
@@ -90,7 +89,7 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
     /** Destroys a object on all connected clients (if you are in a networked session) 
      * @param instance object to destroy
     */
-    public static destroySynced(instance: THREE.Object3D | Component, context?: Context, recursive: boolean = true) {
+    public static destroySynced(instance: Object3D | Component, context?: Context, recursive: boolean = true) {
         if (!instance) return;
         const go = instance as GameObject;
         context = context ?? Context.Current;
@@ -101,14 +100,14 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
      * @param instance object to destroy
      * @param recursive if true, all children will be destroyed as well
      */
-    public static destroy(instance: THREE.Object3D | Component, recursive: boolean = true, isRoot: boolean = true) {
+    public static destroy(instance: Object3D | Component, recursive: boolean = true, isRoot: boolean = true) {
         return destroy(instance, recursive, isRoot);
     }
 
     /**
      * Add an object to parent and also ensure all components are being registered
      */
-    public static add(instance: THREE.Object3D | null | undefined, parent: THREE.Object3D, context?: Context) {
+    public static add(instance: Object3D | null | undefined, parent: Object3D, context?: Context) {
         if (!instance || !parent) return;
         if (instance === parent) {
             console.warn("Can not add object to self", instance);
@@ -137,7 +136,7 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
     /**
      * Removes the object from its parent and deactivates all of its components
      */
-    public static remove(instance: THREE.Object3D | null | undefined) {
+    public static remove(instance: Object3D | null | undefined) {
         if (!instance) return;
         instance.parent?.remove(instance);
         setActive(instance, false);
@@ -148,7 +147,7 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
     }
 
     /** Invokes a method on all components including children (if a method with that name exists) */
-    public static invokeOnChildren(go: THREE.Object3D | null | undefined, functionName: string, ...args: any) {
+    public static invokeOnChildren(go: Object3D | null | undefined, functionName: string, ...args: any) {
         this.invoke(go, functionName, true, args);
     }
 
@@ -156,7 +155,7 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
      * @param go object to invoke the method on all components
      * @param functionName name of the method to invoke
      */
-    public static invoke(go: THREE.Object3D | null | undefined, functionName: string, children: boolean = false, ...args: any) {
+    public static invoke(go: Object3D | null | undefined, functionName: string, children: boolean = false, ...args: any) {
         if (!go) return;
         this.foreachComponent(go, c => {
             const fn = c[functionName];
@@ -172,7 +171,7 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
      * @param type type of the component to add
      * @param callAwake if true, the component will be added and awake will be called immediately
      */
-    public static addNewComponent<T>(go: GameObject | THREE.Object3D, type: ConstructorConcrete<T>, callAwake: boolean = true): T {
+    public static addNewComponent<T>(go: IGameObject | Object3D, type: ConstructorConcrete<T>, callAwake: boolean = true): T {
         const instance = new type();
         //@ts-ignore
         addNewComponent(go, instance, callAwake);
@@ -185,7 +184,7 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
      * @param go component to move the component to
      * @param instance component to move to the GO
      */
-    public static addComponent(go: GameObject, instance: Component): void {
+    public static addComponent(go: IGameObject, instance: Component): void {
         return this.moveComponent(go, instance);
     }
 
@@ -194,7 +193,7 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
      * @param go component to move the component to
      * @param instance component to move to the GO
      */
-    public static moveComponent(go: GameObject, instance: Component): void {
+    public static moveComponent(go: IGameObject, instance: Component): void {
         if (instance.gameObject == null) {
             throw new Error("Did you mean to create a new component? Use addNewComponent");
         }
@@ -209,12 +208,12 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
         return instance;
     }
 
-    public static getOrAddComponent<T>(go: GameObject | THREE.Object3D, typeName: ConstructorConcrete<T>): T {
+    public static getOrAddComponent<T>(go: IGameObject | Object3D, typeName: ConstructorConcrete<T>): T {
         return getOrAddComponent<any>(go, typeName);
     }
 
     /** Gets a component on the provided object */
-    public static getComponent<T>(go: GameObject | THREE.Object3D | null, typeName: Constructor<T> | null): T | null {
+    public static getComponent<T>(go: IGameObject | Object3D | null, typeName: Constructor<T> | null): T | null {
         if (go === null) return null;
         // if names are minified we could also use the type store and work with strings everywhere
         // not ideal, but I dont know a good/sane way to do this otherwise
@@ -223,49 +222,49 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
         return getComponent(go, typeName as any);
     }
 
-    public static getComponents<T>(go: GameObject | THREE.Object3D | null, typeName: Constructor<T>, arr: T[] | null = null): T[] {
+    public static getComponents<T>(go: IGameObject | Object3D | null, typeName: Constructor<T>, arr: T[] | null = null): T[] {
         if (go === null) return arr ?? [];
         return getComponents(go, typeName, arr);
     }
 
-    public static findByGuid(guid: string, hierarchy: THREE.Object3D): GameObject | Component | null | undefined {
+    public static findByGuid(guid: string, hierarchy: Object3D): GameObject | Component | null | undefined {
         const res = findByGuid(guid, hierarchy);
         return res as GameObject | Component | null | undefined;
     }
 
-    public static findObjectOfType<T>(typeName: Constructor<T>, context?: Context | THREE.Object3D, includeInactive: boolean = true): T | null {
+    public static findObjectOfType<T>(typeName: Constructor<T>, context?: Context | Object3D, includeInactive: boolean = true): T | null {
         return findObjectOfType(typeName, context ?? Context.Current, includeInactive);
     }
 
-    public static findObjectsOfType<T>(typeName: Constructor<T>, context?: Context | THREE.Object3D): Array<T> {
+    public static findObjectsOfType<T>(typeName: Constructor<T>, context?: Context | Object3D): Array<T> {
         const arr = [];
         findObjectsOfType(typeName, arr, context);
         return arr;
     }
 
-    public static getComponentInChildren<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T>): T | null {
+    public static getComponentInChildren<T>(go: IGameObject | Object3D, typeName: Constructor<T>): T | null {
         return getComponentInChildren(go, typeName);
     }
 
-    public static getComponentsInChildren<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T>, arr: T[] | null = null): Array<T> {
+    public static getComponentsInChildren<T>(go: IGameObject | Object3D, typeName: Constructor<T>, arr: T[] | null = null): Array<T> {
         return getComponentsInChildren<T>(go, typeName, arr ?? undefined) as T[]
     }
 
-    public static getComponentInParent<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T>): T | null {
+    public static getComponentInParent<T>(go: IGameObject | Object3D, typeName: Constructor<T>): T | null {
         return getComponentInParent(go, typeName);
     }
 
-    public static getComponentsInParent<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T>, arr: Array<T> | null = null): Array<T> {
+    public static getComponentsInParent<T>(go: IGameObject | Object3D, typeName: Constructor<T>, arr: Array<T> | null = null): Array<T> {
         return getComponentsInParent(go, typeName, arr);
     }
 
-    public static getAllComponents(go: GameObject | THREE.Object3D): Behaviour[] {
+    public static getAllComponents(go: IGameObject | Object3D): Behaviour[] {
         const componentsList = go.userData?.components;
         const newList = [...componentsList];
         return newList;
     }
 
-    public static *iterateComponents(go: GameObject | THREE.Object3D) {
+    public static *iterateComponents(go: IGameObject | Object3D) {
         const list = go?.userData?.components;
         if (list && Array.isArray(list)) {
             for (let i = 0; i < list.length; i++) {
@@ -300,7 +299,7 @@ class Component implements IComponent, EventTarget {
     set context(context: Context) {
         this.__context = context;
     }
-    get scene(): THREE.Scene { return this.context.scene; }
+    get scene(): Scene { return this.context.scene; }
 
     get layer(): number {
         return this.gameObject?.userData?.layer;
@@ -367,7 +366,7 @@ class Component implements IComponent, EventTarget {
     gameObject!: GameObject;
     guid: string = "invalid";
     sourceId?: SourceIdentifier;
-    // transform: THREE.Object3D = nullObject;
+    // transform: Object3D = nullObject;
 
     /** called on a component with a map of old to new guids (e.g. when instantiate generated new guids and e.g. timeline track bindings needs to remape them) */
     resolveGuids?(guidsMap: GuidsMap): void;
@@ -521,24 +520,24 @@ class Component implements IComponent, EventTarget {
 
     // TODO move this to threeutils
     // we need a copy for modifying the values to local space
-    private static _worldPositionBuffer: THREE.Vector3 = new THREE.Vector3();
-    private static _worldQuaternionBuffer: THREE.Quaternion = new THREE.Quaternion();
-    private static _worldEulerBuffer: THREE.Euler = new THREE.Euler();
-
-    private _worldPosition: THREE.Vector3 | undefined = undefined;
-    private _worldQuaternion: THREE.Quaternion | undefined = undefined;
-    private static _tempQuaternionBuffer2: THREE.Quaternion = new THREE.Quaternion();
-    private _worldEuler: THREE.Euler | undefined = undefined;
-    private _worldRotation: THREE.Vector3 | undefined = undefined;
-
-    get worldPosition(): THREE.Vector3 {
-        if (!this._worldPosition) this._worldPosition = new THREE.Vector3();
+    private static _worldPositionBuffer: Vector3 = new Vector3();
+    private static _worldQuaternionBuffer: Quaternion = new Quaternion();
+    private static _worldEulerBuffer: Euler = new Euler();
+
+    private _worldPosition: Vector3 | undefined = undefined;
+    private _worldQuaternion: Quaternion | undefined = undefined;
+    private static _tempQuaternionBuffer2: Quaternion = new Quaternion();
+    private _worldEuler: Euler | undefined = undefined;
+    private _worldRotation: Vector3 | undefined = undefined;
+
+    get worldPosition(): Vector3 {
+        if (!this._worldPosition) this._worldPosition = new Vector3();
         threeutils.getWorldPosition(this.gameObject, this._worldPosition);
         // this.gameObject.getWorldPosition(this._worldPosition);
         return this._worldPosition;
     }
 
-    set worldPosition(val: THREE.Vector3) {
+    set worldPosition(val: Vector3) {
         threeutils.setWorldPosition(this.gameObject, val);
     }
 
@@ -548,11 +547,11 @@ class Component implements IComponent, EventTarget {
     }
 
 
-    get worldQuaternion(): THREE.Quaternion {
-        if (!this._worldQuaternion) this._worldQuaternion = new THREE.Quaternion();
+    get worldQuaternion(): Quaternion {
+        if (!this._worldQuaternion) this._worldQuaternion = new Quaternion();
         return threeutils.getWorldQuaternion(this.gameObject, this._worldQuaternion);
     }
-    set worldQuaternion(val: THREE.Quaternion) {
+    set worldQuaternion(val: Quaternion) {
         threeutils.setWorldQuaternion(this.gameObject, val);
     }
     setWorldQuaternion(x: number, y: number, z: number, w: number) {
@@ -562,23 +561,23 @@ class Component implements IComponent, EventTarget {
 
 
     // world euler (in radians)
-    get worldEuler(): THREE.Euler {
-        if (!this._worldEuler) this._worldEuler = new THREE.Euler();
+    get worldEuler(): Euler {
+        if (!this._worldEuler) this._worldEuler = new Euler();
         this._worldEuler.setFromQuaternion(this.worldQuaternion);
         return this._worldEuler;
     }
 
     // world euler (in radians)
-    set worldEuler(val: THREE.Euler) {
-        if (!this._worldQuaternion) this._worldQuaternion = new THREE.Quaternion();
+    set worldEuler(val: Euler) {
+        if (!this._worldQuaternion) this._worldQuaternion = new Quaternion();
         this._worldQuaternion?.setFromEuler(val);
         this.worldQuaternion = this._worldQuaternion;
     }
 
     // returns rotation in degrees
-    get worldRotation(): THREE.Vector3 {
+    get worldRotation(): Vector3 {
         const rot = this.worldEuler;
-        if (!this._worldRotation) this._worldRotation = new THREE.Vector3();
+        if (!this._worldRotation) this._worldRotation = new Vector3();
         const wr = this._worldRotation;
         wr.set(rot.x, rot.y, rot.z);
         wr.x = Mathf.toDegrees(wr.x);
@@ -587,7 +586,7 @@ class Component implements IComponent, EventTarget {
         return wr;
     }
 
-    set worldRotation(val: THREE.Vector3) {
+    set worldRotation(val: Vector3) {
         this.setWorldRotation(val.x, val.y, val.z, true);
     }
 
@@ -602,16 +601,16 @@ class Component implements IComponent, EventTarget {
         this.worldQuaternion = Component._worldQuaternionBuffer;
     }
 
-    private static _forward: THREE.Vector3 = new THREE.Vector3();
-    public get forward(): THREE.Vector3 {
+    private static _forward: Vector3 = new Vector3();
+    public get forward(): Vector3 {
         return Component._forward.set(0, 0, -1).applyQuaternion(this.worldQuaternion);
     }
-    private static _right: THREE.Vector3 = new THREE.Vector3();
-    public get right(): THREE.Vector3 {
+    private static _right: Vector3 = new Vector3();
+    public get right(): Vector3 {
         return Component._right.set(1, 0, 0).applyQuaternion(this.worldQuaternion);
     }
-    private static _up: THREE.Vector3 = new THREE.Vector3();
-    public get up(): THREE.Vector3 {
+    private static _up: Vector3 = new Vector3();
+    public get up(): Vector3 {
         return Component._up.set(0, 1, 0).applyQuaternion(this.worldQuaternion);
     }
 

package/src/engine-components/DragControls.ts

@@ -1,19 +1,18 @@
-import { Behaviour, GameObject } from "./Component";
-// import { DragControls as Control } from "../include/three/DragControls";
+import { GameObject } from "./Component";
 import { SyncedTransform } from "./SyncedTransform";
-import * as THREE from "three";
-import { IPointerClickHandler, IPointerDownHandler, IPointerEnterHandler, IPointerExitHandler, IPointerUpHandler, PointerEventData } from "./ui/PointerEvents";
+import { 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 { Avatar_POI } from "./avatar/Avatar_Brain_LookAt";
 import { RaycastOptions } from "../engine/engine_physics";
-import { getWorldPosition, getWorldQuaternion, setWorldPosition } from "../engine/engine_three_utils";
+import { getWorldPosition, setWorldPosition } from "../engine/engine_three_utils";
 import { KeyCode } from "../engine/engine_input";
 import { nameofFactory } from "../engine/engine_utils";
 import { InstancingUtil } from "../engine/engine_instancing";
 import { OrbitControls } from "./OrbitControls";
+import { BufferGeometry, Camera, Color, Line, LineBasicMaterial, Matrix4, Mesh, MeshBasicMaterial, Object3D, Plane, Ray, Raycaster, SphereGeometry, Vector2, Vector3 } from "three";
 
 const debug = false;
 
@@ -23,8 +22,8 @@ export enum DragEvents {
 }
 
 interface SelectArgs {
-    selected: THREE.Object3D;
-    attached: THREE.Object3D | GameObject | null;
+    selected: Object3D;
+    attached: Object3D | GameObject | null;
 }
 
 
@@ -41,7 +40,7 @@ export class DragControls extends Interactable implements IPointerDownHandler, I
 
     public transformSelf: boolean = true;
     // public transformGroup: boolean = true;
-    // public targets: THREE.Object3D[] | null = null;
+    // public targets: Object3D[] | null = null;
 
     // private controls: Control | null = null;
     private orbit: OrbitControls | null = null;
@@ -53,7 +52,7 @@ export class DragControls extends Interactable implements IPointerDownHandler, I
         super();
         this.selectStartEventListener = [];
         this.selectEndEventListener = [];
-        this._dragDelta = new THREE.Vector2();
+        this._dragDelta = new Vector2();
     }
 
     addDragEventListener(type: DragEvents, cb: (ctrls: DragControls, args: SelectArgs) => void | Function) {
@@ -74,10 +73,10 @@ export class DragControls extends Interactable implements IPointerDownHandler, I
         this.orbit = GameObject.findObjectOfType(OrbitControls, this.context);
     }
 
-    private static lastHovered: THREE.Object3D;
+    private static lastHovered: Object3D;
     private _draggingRigidbodies: Rigidbody[] = [];
 
-    private allowEdit(_obj: THREE.Object3D | null = null) {
+    private allowEdit(_obj: Object3D | null = null) {
         return this.context.connection.allowEditing;
     }
 
@@ -160,7 +159,7 @@ export class DragControls extends Interactable implements IPointerDownHandler, I
 
     private _isDragging: boolean = false;
     private _marker: UsageMarker | null = null;
-    private _dragDelta!: THREE.Vector2;
+    private _dragDelta!: Vector2;
     private _didDrag: boolean = false;
     private _activePointerId?: number;
 
@@ -177,14 +176,14 @@ export class DragControls extends Interactable implements IPointerDownHandler, I
         if (!dc || dc !== this) return;
 
 
-        let object: THREE.Object3D = evt.object;
+        let object: Object3D = evt.object;
 
         if (this.transformSelf) {
             object = this.gameObject;
         }
 
         // raise event
-        const args: { selected: THREE.Object3D, attached: THREE.Object3D | null } = { selected: object, attached: object };
+        const args: { selected: Object3D, attached: Object3D | null } = { selected: object, attached: object };
         for (const listener of this.selectStartEventListener) {
             listener(this, args);
         }
@@ -285,54 +284,54 @@ class DragHelper {
         return this._selected !== null && this._selected !== undefined;
     }
 
-    public get selected(): THREE.Object3D | null {
+    public get selected(): Object3D | null {
         return this._selected;
     }
 
-    private _selected: THREE.Object3D | null = null;
+    private _selected: Object3D | null = null;
     private _context: Context | null = null;
-    private _camera: THREE.Camera;;
-    private _cameraPlane: THREE.Plane = new THREE.Plane();
+    private _camera: Camera;
+    private _cameraPlane: Plane = new Plane();
 
     private _hasGroundPlane: boolean = false;
-    private _groundPlane: THREE.Plane = new THREE.Plane();
-    private _groundOffset: THREE.Vector3 = new THREE.Vector3();
+    private _groundPlane: Plane = new Plane();
+    private _groundOffset: Vector3 = new Vector3();
     private _groundOffsetFactor: number = 0;
     private _groundDistance: number = 0;
-    private _groundPlanePoint: THREE.Vector3 = new THREE.Vector3();
+    private _groundPlanePoint: Vector3 = new 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 _raycaster = new Raycaster();
+    private _cameraPlaneOffset = new Vector3();
+    private _intersection = new Vector3();
+    private _worldPosition = new Vector3();
+    private _inverseMatrix = new 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)]);
+    private _groundLine: Line;
+    private _groundMarker: Object3D;
+    private static geometry = new BufferGeometry().setFromPoints([new Vector3(0, 0, 0), new Vector3(0, -1, 0)]);
 
-    constructor(camera: THREE.Camera) {
+    constructor(camera: 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);
+        const line = new Line(DragHelper.geometry);
+        const mat = line.material as LineBasicMaterial;
+        mat.color = new 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);
+        const geometry = new SphereGeometry(.5, 22, 22);
+        const material = new MeshBasicMaterial({ color: mat.color });
+        const sphere = new Mesh(geometry, material);
         sphere.visible = false;
         sphere.layers.set(2);
         this._groundMarker = sphere;
     }
 
-    setSelected(newSelected: THREE.Object3D | null, context: Context) {
+    setSelected(newSelected: Object3D | null, context: Context) {
         if (this._selected && context) {
             for (const rb of this._rbs) {
                 rb.wakeUp();
@@ -376,7 +375,7 @@ class DragHelper {
         }
     }
 
-    private _groundOffsetVector = new THREE.Vector3(0, 1, 0);
+    private _groundOffsetVector = new Vector3(0, 1, 0);
     private _requireUpdateGroundPlane = true;
     private _didDragOnGroundPlaneLastFrame: boolean = false;
 
@@ -429,7 +428,7 @@ class DragHelper {
             this._requireUpdateGroundPlane = false;
             if (this._hasGroundPlane) {
                 // const wp = getWorldPosition(this._selected);
-                // const ray = new THREE.Ray(wp, new THREE.Vector3(0, -1, 0));
+                // const ray = new Ray(wp, new Vector3(0, -1, 0));
 
                 if (this._raycaster.ray.intersectPlane(this._groundPlane, this._intersection)) {
                     const y = this._intersection.y;
@@ -466,7 +465,7 @@ class DragHelper {
         }
     }
 
-    private onUpdateWorldPosition(wp: THREE.Vector3, pointOnPlane: THREE.Vector3 | null, heightOnly: boolean) {
+    private onUpdateWorldPosition(wp: Vector3, pointOnPlane: Vector3 | null, heightOnly: boolean) {
         if (!this._selected) return;
         if (heightOnly) {
             const cur = getWorldPosition(this._selected);
@@ -503,7 +502,7 @@ class DragHelper {
     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 ray = new Ray(new Vector3(0, .1, 0).add(wp), new Vector3(0, -1, 0));
         const opts = new RaycastOptions();
         opts.ignore = [this._selected];
         const hits = this._context.physics.raycastFromRay(ray, opts);
@@ -512,7 +511,7 @@ class DragHelper {
             if (!hit.face || this.contains(this._selected, hit.object)) {
                 continue;
             }
-            const normal = new THREE.Vector3(0, 1, 0); // hit.face.normal
+            const normal = new Vector3(0, 1, 0); // hit.face.normal
             this._groundPlane.setFromNormalAndCoplanarPoint(normal, hit.point);
             break;
         }
@@ -536,7 +535,7 @@ class DragHelper {
         }
     }
 
-    private contains(obj: THREE.Object3D, toSearch: THREE.Object3D): boolean {
+    private contains(obj: Object3D, toSearch: Object3D): boolean {
         if (obj === toSearch) return true;
         if (obj.children) {
             for (const child of obj.children) {