@needle-tools/engine 2.56.2-pre → 2.58.0-pre

package/src/engine-components-experimental/annotation/LineDrawer.ts

@@ -1,194 +0,0 @@
-import { Behaviour, GameObject } from "../../engine-components/Component";
-import { OrbitControls } from "../../engine-components/OrbitControls";
-import * as THREE from 'three';
-import { Color, Ray, Raycaster, Vector3 } from "three";
-import { RaycastOptions } from "../../engine/engine_physics";
-import { LineHandle, LinesManager } from "./LinesManager";
-import { Mathf } from "../../engine/engine_math";
-import { getWorldPosition } from "../../engine/engine_three_utils";
-import { MeshLine, MeshLineMaterial } from 'three.meshline';
-import { KeyCode } from "../../engine/engine_input";
-import { PlayerColor } from "../../engine-components/PlayerColor";
-import { ControllerEvents, WebXRController } from "../../engine-components/WebXRController";
-
-class LineState {
-    isDrawing: boolean;
-    lastHit: Vector3;
-    currentHandle: LineHandle | null;
-    maxDistance: number;
-    prevDistance: number;
-    lastParent: THREE.Object3D | null;
-
-    constructor() {
-        this.isDrawing = false;
-        this.lastHit = new Vector3();
-        this.currentHandle = null;
-        this.maxDistance = 0;
-        this.prevDistance = 0;
-        this.lastParent = null;
-    }
-}
-
-export class LinesDrawer extends Behaviour {
-
-    lines!: LinesManager;
-    colliders?: THREE.Object3D[];
-    alignToSurface: boolean = true;
-    addToPaintedObject: boolean = true;
-
-    private orbit?: OrbitControls;
-
-    start() {
-        if (!this.lines) {
-            this.lines = GameObject.getComponent(this.gameObject, LinesManager)!;
-            if (!this.lines)
-                this.lines = GameObject.addNewComponent(this.gameObject, LinesManager);
-        }
-        this.orbit = GameObject.findObjectOfType(OrbitControls, this.context) ?? undefined;
-        this._states["mouse"] = new LineState();
-
-
-        const xrControllerSelected: { [key: string]: boolean } = {};
-
-        WebXRController.addEventListener(ControllerEvents.SelectStart, (ctrl, _) => {
-            xrControllerSelected[ctrl.controller.uuid] = true;
-        });
-        WebXRController.addEventListener(ControllerEvents.Update, (ctrl, _) => {
-            if (xrControllerSelected[ctrl.controller.uuid] === true) {
-                const ray = ctrl.getRay();
-                this.updateLine(ctrl.controller.uuid, ray, true, false, false);
-            }
-        });
-        WebXRController.addEventListener(ControllerEvents.SelectEnd, (ctrl, _) => {
-            xrControllerSelected[ctrl.controller.uuid] = false;
-            const ray = ctrl.getRay();
-            this.updateLine(ctrl.controller.uuid, ray, true, true, false);
-        });
-    }
-
-    private _states: { [id: string]: LineState } = {};
-
-    update() {
-        if (this.orbit && this._states["mouse"]) {
-            if (this.orbit) this.orbit.enabled = !this._states["mouse"].isDrawing;
-        }
-        if (!this.context.mainCamera) return;
-
-        const multi = this.context.input.getPointerPressedCount() > 1;
-        const sp = this.context.input.getPointerPositionRC(0);
-        if (!sp) return;
-        LinesDrawer._raycaster.setFromCamera(sp, this.context.mainCamera);
-        const ray = LinesDrawer._raycaster.ray;
-        this.updateLine("mouse", ray,
-            this.context.input.getPointerPressed(0),
-            this.context.input.getPointerUp(0), multi || this.context.input.isKeyPressed(KeyCode.ALT)
-        );
-    }
-
-    private updateLine(id: string, ray: THREE.Ray, active: boolean, finish: boolean, cancel: boolean = false): LineState {
-        let state = this._states[id];
-        if (!state) {
-            this._states[id] = new LineState();
-            state = this._states[id];
-        }
-
-        if (finish) {
-            state.isDrawing = false;
-            if (state.currentHandle) {
-                // this.sendLineUpdate();
-                this.lines.endLine(state.currentHandle);
-                state.currentHandle = null;
-            }
-        }
-        else if (active) {
-            if (cancel) {
-                return state;
-            }
-            const hit = this.getHit(ray);
-            let pt: THREE.Vector3 | null = null;
-            let prev = state.prevDistance;
-            if (hit) {
-                if (!state.currentHandle) {
-                    state.maxDistance = hit.distance;
-                }
-                pt = hit.point;
-                if (hit.face)
-                    pt.add(hit.face.normal.multiplyScalar(0.01));
-                state.prevDistance = hit.distance;
-            }
-            else if (state.maxDistance > 0) {
-                let dist = state.maxDistance;
-                // if we start drawing in thin air:
-                if (!state.currentHandle && state.lastHit) {
-                    const wp = getWorldPosition(this.context.mainCamera!);
-                    dist = state.lastHit.distanceTo(wp);
-                }
-                pt = ray.origin.add(ray.direction.multiplyScalar(state.maxDistance));
-                state.prevDistance = state.maxDistance;
-            }
-
-            if (pt) {
-                if (!state.currentHandle) {
-                    let parent = state.lastParent ?? this.gameObject as THREE.Object3D;
-                    if (this.addToPaintedObject && hit) parent = hit.object;
-                    state.lastParent = parent;
-                    state.currentHandle = this.lines.startLine(parent, { material: this.createRandomMaterial() });
-                }
-
-                if (this.alignToSurface) {
-                    if (state.prevDistance > state.maxDistance || Math.abs(prev - state.prevDistance) > 0.2) {
-                        const newDistance = state.maxDistance;
-                        // if (state.maxDistance === 0) state.maxDistance = newDistance;
-                        // const camPos = getWorldPosition(this.context.mainCamera);
-                        pt = ray.origin.add(ray.direction.multiplyScalar(newDistance));
-                        // pt = camPos.add(dir.multiplyScalar(newDistance));
-                        state.prevDistance = newDistance;
-                    }
-                }
-                if (state.lastHit && state.lastHit.distanceTo(pt) < state.prevDistance * .01) {
-                    return state;
-                }
-                this.lines.updateLine(state.currentHandle, { point: pt });
-                state.lastHit.copy(pt);
-            }
-
-            state.isDrawing = state.currentHandle !== null;
-        }
-        return state;
-    }
-
-    private _raycastOptions = new RaycastOptions();
-    private static _raycaster: Raycaster = new Raycaster();
-
-    private getHit(ray: THREE.Ray): THREE.Intersection | null {
-        if (!this.colliders || this.colliders.length === 0) {
-            this.colliders = [this.gameObject];
-        }
-        this._raycastOptions.targets = this.colliders;
-        this._raycastOptions.ray = ray;
-        const hits = this.context.physics.raycast(this._raycastOptions);
-        if (hits.length > 0) {
-            for (const hit of hits) {
-                if (!GameObject.isActiveInHierarchy(hit.object)) {
-                    continue;
-                }
-                return hit;
-            }
-        }
-        return null;
-    }
-
-    private createRandomMaterial() {
-        let col: Color;
-        if (this.context.connection.connectionId)
-            col = PlayerColor.colorFromHashCode(PlayerColor.hashCode(this.context.connection.connectionId));
-        else
-            col = new THREE.Color("hsl(" + (Math.random() * 100).toFixed(0) + ", 80%, 30%)");
-        // const col = new THREE.Color("hsl(0, 100%, 50%)");
-
-        return new MeshLineMaterial({
-            color: col,
-            lineWidth: Mathf.lerp(0.005, 0.01, Math.random()),
-        });
-    }
-}

package/src/engine-components-experimental/annotation/LinesManager.ts

@@ -1,218 +0,0 @@
-import { Behaviour, GameObject } from "../../engine-components/Component";
-import * as THREE from 'three';
-import { Color, Material } from "three";
-import { MeshLine, MeshLineMaterial } from 'three.meshline';
-
-
-
-export declare type LineOptions = {
-    material?: Material;
-    options?: LineMaterialOptions;
-}
-
-export declare type LineMaterialOptions = {
-    map?: THREE.Texture;
-    useMap?: number;
-    alphaMap?: THREE.Texture;
-    color?: Color;
-    opacity?: number;
-    lineWidth?: number;
-}
-
-export class LineInstanceHandler {
-    id: number = 0;
-    points: Array<any> = [];
-    line: MeshLine = new MeshLine();
-    material?: MeshLineMaterial;
-    mesh?: THREE.Mesh;
-
-    constructor(owner: THREE.Object3D, options?: LineOptions) {
-        if (options) {
-            this.material = options.material;
-        }
-
-        if (!this.material)
-            this.material = this.defaultLineMaterial;
-        if (options) {
-            const opts = options.options;
-            if (opts) {
-                Object.assign(this.material, opts);
-            }
-        }
-        this.mesh = new THREE.Mesh(this.line, this.material);
-        owner.add(this.mesh);
-    }
-
-    private static wp: THREE.Vector3 = new THREE.Vector3();
-
-    appendPoint(vec: Vec3): Vec3 {
-        let localPoint = LineInstanceHandler.wp;
-        localPoint.set(vec.x, vec.y, vec.z);
-        const parent = this.mesh?.parent;
-        if (parent) {
-            localPoint = parent.worldToLocal(localPoint);
-            vec.x = localPoint.x;
-            vec.y = localPoint.y;
-            vec.z = localPoint.z;
-        }
-
-        this.points.push(vec.x, vec.y, vec.z);
-        this.line.setPoints(this.points);
-        return vec;
-    }
-
-    private defaultLineMaterial = new MeshLineMaterial({ color: 0x999999, lineWidth: 0.01 });
-}
-
-declare type Vec3 = {
-    x: number;
-    y: number;
-    z: number;
-}
-
-declare type StartLineModel = {
-    id: number;
-    parentGuid: string;
-}
-
-declare type LineModel = {
-    parentGuid: string;
-    guid: number; // it must be named guid
-    points: Array<Vec3>;
-    width: number;
-    color: Vec3;
-    startIndex: number;
-    finished: boolean;
-}
-
-export declare type LineHandle = {
-    id: number;
-}
-
-declare type UpdateLineArgs = {
-    point: Vec3;
-}
-
-
-export class LinesManager extends Behaviour {
-
-    public startLine(parent?: THREE.Object3D, options?: LineOptions): LineHandle {
-        const id = Math.random() * Number.MAX_SAFE_INTEGER;
-        return this.internalStartLine(parent, id, true, options);
-    }
-
-    public updateLine(handle: LineHandle, args: UpdateLineArgs) {
-        const line = this.inFlight[handle.id];
-        if (!line) return;
-        if (args.point) {
-            args.point = line.appendPoint(args.point);
-        }
-        const buf = this.buffer[handle.id];
-        if (buf) {
-            if (args.point)
-                buf.push(args.point.x, args.point.y, args.point.z);
-            if (buf.length > 5) {
-                this.sendLineUpdate(line, false, undefined, buf);
-                buf.length = 0;
-            }
-        }
-    }
-
-    public endLine(handle: LineHandle, send: boolean = true): LineInstanceHandler | undefined {
-        const line = this.inFlight[handle.id];
-        if (!line) return undefined;
-        this.finished.push(line);
-        delete this.inFlight[handle.id];
-
-        if (send)
-            this.sendLineUpdate(line, true, 0);
-
-        const buf = this.buffer[handle.id];
-        if (buf) {
-            delete this.buffer[handle.id];
-            const arr = buf;
-            arr.length = 0;
-            this.freeBuffer.push(arr);
-        }
-
-        return line;
-    }
-
-    public getLine(handle: LineHandle): LineInstanceHandler | undefined {
-        return this.inFlight[handle.id];
-    }
-
-    private finished: Array<LineInstanceHandler> = [];
-    private inFlight: { [key: number]: LineInstanceHandler } = [];
-    private buffer: { [key: number]: any[] } = {};
-    private freeBuffer = new Array<Vec3[]>();
-
-    awake(): void {
-
-        this.context.connection.beginListen("line-start", (i: StartLineModel) => {
-            this.onEnsureLine(i.id, i.parentGuid);
-        });
-        this.context.connection.beginListen("line-update", (evt: LineModel) => {
-            let line = this.onEnsureLine(evt.guid, evt.parentGuid);
-            if (line && evt.points) {
-                if (evt.startIndex <= 0) {
-                    line.points = evt.points;
-                }
-                else {
-                    if (evt.startIndex >= line.points.length) {
-                        line.points.push(...evt.points);
-                    }
-                }
-                line.line.setPoints(line.points);
-                line.material!.lineWidth = evt.width;
-                line.material!.color.fromArray(evt.color);
-                if (evt.finished === true) {
-                    this.endLine({ id: line.id }, false);
-                }
-            }
-        });
-    }
-
-    private onEnsureLine(lineId: number, parentGuid: string): LineInstanceHandler | null {
-        if (this.inFlight[lineId]) return this.inFlight[lineId];
-        let obj = GameObject.findByGuid(parentGuid, this.context.scene);
-        if (!obj) {
-            return null;
-        }
-        this.internalStartLine(obj as THREE.Object3D, lineId, false);
-        return this.inFlight[lineId];
-    }
-    private internalStartLine(parent: THREE.Object3D | null | undefined, id: number, send: boolean = true, options?: LineOptions): LineHandle {
-        const line = new LineInstanceHandler(parent ?? this.context.scene, options);
-        line.id = id;
-        this.inFlight[id] = line;
-        if (send)
-            this.sendLineStart(line);
-
-        let buf;
-        if (this.freeBuffer.length <= 0) buf = new Array<Vec3>();
-        else buf = this.freeBuffer.pop();
-        this.buffer[id] = buf;
-        return { id: id };
-    }
-
-    private sendLineStart(instance: LineInstanceHandler) {
-        const parent = instance.mesh!.parent;
-        this.context.connection.send("line-start", { id: instance.id, parentGuid: parent ? parent["guid"] : undefined })
-    }
-
-    private sendLineUpdate(instance: LineInstanceHandler, finished: boolean, startIndex?: number, points?: Array<any>) {
-        if (instance) {
-            const model: LineModel = {
-                parentGuid: instance.mesh!.parent!["guid"],
-                guid: instance.id,
-                points: points ? [...points] : instance.points,
-                width: instance.material!.lineWidth,
-                color: instance.material!.color.toArray(),
-                startIndex: startIndex !== undefined ? startIndex : instance.points.length,
-                finished: finished,
-            };
-            this.context.connection.send("line-update", model)
-        }
-    }
-}