@inweb/client 25.2.2

package/src/Viewer/Draggers/OdaWalkDragger.ts

@@ -0,0 +1,278 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2021, Open Design Alliance (the "Alliance").
+// All rights reserved.
+//
+// This software and its documentation and related materials are owned by
+// the Alliance. The software may only be incorporated into application
+// programs owned by members of the Alliance, subject to a signed
+// Membership Agreement and Supplemental Software License Agreement with the
+// Alliance. The structure and organization of this software are the valuable
+// trade secrets of the Alliance and its suppliers. The software is also
+// protected by copyright law and international treaty provisions. Application
+// programs incorporating this software must include the following statement
+// with their copyright notices:
+//
+//   This application incorporates Open Design Alliance software pursuant to a
+//   license agreement with Open Design Alliance.
+//   Open Design Alliance Copyright (C) 2002-2021 by Open Design Alliance.
+//   All rights reserved.
+//
+// By use of this software, its documentation or related materials, you
+// acknowledge and accept the above terms.
+///////////////////////////////////////////////////////////////////////////////
+import { Viewer } from "../Viewer";
+import { Point2d, Vector3 } from "./Common/Geometry";
+import { OdBaseDragger } from "./Common/OdBaseDragger";
+
+const FocalLengthConst = 42.0;
+
+const calcFocalLength = (lensLength: number, fieldWidth: number, fieldHeight: number): number => {
+  return (lensLength / FocalLengthConst) * Math.sqrt(fieldWidth * fieldWidth + fieldHeight * fieldHeight);
+};
+
+export class OdaWalkDragger extends OdBaseDragger {
+  protected lastCoord: Point2d;
+  protected speed: number;
+  protected delta: number;
+  protected keyPressMap: Set<string>;
+  protected oldWCSEnableValue: boolean;
+  protected viewParams: any;
+  protected cameraId: any;
+  protected cameraWalker: any;
+  protected viewer: any;
+  protected multiplier: number;
+  protected lastFrameTS: number;
+  protected animationId: any;
+  protected deltaAngle: number;
+  protected enableZoomWheelPreviousValue: boolean;
+
+  constructor(subject: Viewer) {
+    super(subject);
+    this.viewer = undefined;
+
+    this.multiplier = 5;
+    this.speed = 1;
+
+    this.keyPressMap = new Set();
+    this.keydown = this.keydown.bind(this);
+    this.keyup = this.keyup.bind(this);
+
+    this.lastFrameTS = 0;
+    this.animationId = undefined;
+    this.processMovement = this.processMovement.bind(this);
+
+    this.deltaAngle = Math.PI / 3600;
+    this.autoSelect = true;
+  }
+
+  override initialize() {
+    super.initialize();
+    this.viewer = this.getViewer();
+
+    window.addEventListener("keydown", this.keydown, false);
+    window.addEventListener("keyup", this.keyup, false);
+
+    this.oldWCSEnableValue = this.viewer.getEnableWCS();
+    this.viewer.setEnableWCS(false);
+
+    const view = this.viewer.activeView;
+    const maxDimension = this.getMaxDimension(view);
+    this.speed = maxDimension / 30000;
+
+    this.subject.emitEvent({ type: "walkstart" });
+
+    this.viewParams = this.getViewParams();
+    //this.viewParams.lensLength = view.lensLength;
+
+    this.setViewParams(this.viewParams);
+    //view.lensLength = (view.lensLength * 42) / 120;
+
+    const model = this.viewer.getActiveModel();
+    this.cameraId = model.appendCamera("Camera0");
+    this.setupCamera(view);
+    model.delete();
+
+    //pCamera.setAdjustLensLength(true);
+    this.cameraWalker = new this.m_module.OdTvCameraWalker();
+    this.cameraWalker.setCamera(this.cameraId);
+
+    this.subject.update();
+    this.enableZoomWheelPreviousValue = this.subject.options.enableZoomWheel;
+    this.subject.options.enableZoomWheel = false;
+  }
+
+  override dispose() {
+    this.oldWCSEnableValue =
+      this.oldWCSEnableValue !== undefined ? this.oldWCSEnableValue : this.subject.options.showWCS;
+    this.viewer.setEnableWCS(this.oldWCSEnableValue);
+
+    super.dispose();
+
+    this.keyPressMap.clear();
+
+    window.removeEventListener("keydown", this.keydown);
+    window.removeEventListener("keyup", this.keyup);
+
+    if (this.animationId) {
+      window.cancelAnimationFrame(this.animationId);
+      this.animationId = undefined;
+    }
+
+    if (this.cameraId) {
+      const model = this.viewer.getActiveModel();
+      model.removeEntity(this.cameraId);
+      model.delete();
+      this.cameraWalker?.delete();
+    }
+
+    if (this.viewParams) {
+      this.setViewParams(this.viewParams);
+
+      const avp = this.viewer.activeView;
+      //avp.lensLength = this.viewParams.lensLength;
+      avp.delete();
+    }
+
+    this.subject.update();
+    this.subject.options.enableZoomWheel = this.enableZoomWheelPreviousValue;
+  }
+
+  keydown(ev) {
+    switch (ev.code) {
+      case "NumpadSubtract":
+      case "Minus":
+        if (this.multiplier > 1) {
+          this.multiplier = this.multiplier - 1;
+          this.subject.emitEvent({ type: "walkspeedchange", data: this.multiplier });
+        }
+        break;
+      case "NumpadAdd":
+      case "Equal":
+        if (this.multiplier < 10) {
+          this.multiplier = this.multiplier + 1;
+          this.subject.emitEvent({ type: "walkspeedchange", data: this.multiplier });
+        }
+        break;
+      case "KeyW":
+      case "KeyA":
+      case "KeyS":
+      case "KeyD":
+      case "KeyQ":
+      case "KeyE":
+        this.keyPressMap.add(ev.code);
+        if (!this.animationId) this.processMovement(0);
+        break;
+    }
+  }
+
+  keyup(ev) {
+    this.keyPressMap.delete(ev.code);
+    if (this.keyPressMap.size < 1 && this.animationId) {
+      window.cancelAnimationFrame(this.animationId);
+      this.animationId = undefined;
+      this.lastFrameTS = 0;
+    }
+  }
+
+  processMovement(timestamp) {
+    this.animationId = requestAnimationFrame(this.processMovement);
+
+    if (this.lastFrameTS !== 0) {
+      const deltaTS = timestamp - this.lastFrameTS;
+      const currentDelta = this.multiplier * deltaTS * this.speed;
+
+      for (const keyCode of this.keyPressMap) {
+        switch (keyCode) {
+          case "KeyW":
+            this.cameraWalker.moveForward(currentDelta);
+            break;
+          case "KeyS":
+            this.cameraWalker.moveBackward(currentDelta);
+            break;
+          case "KeyA":
+            this.cameraWalker.moveLeft(currentDelta);
+            break;
+          case "KeyD":
+            this.cameraWalker.moveRight(currentDelta);
+            break;
+          case "KeyQ":
+            this.cameraWalker.moveUp(currentDelta);
+            break;
+          case "KeyE":
+            this.cameraWalker.moveDown(currentDelta);
+            break;
+        }
+      }
+      this.subject.update();
+    }
+
+    this.lastFrameTS = timestamp;
+  }
+
+  override drag(x, y, dltX, dltY) {
+    if (this.cameraId && this.isDragging) {
+      if (dltX !== 0.0) this.turnLeft(-dltX * this.deltaAngle);
+      if (dltY !== 0.0) this.cameraWalker.turnDown(dltY * this.deltaAngle);
+      this.subject.update();
+    }
+  }
+
+  turnLeft(angle) {
+    //TODO: migrate to VisualizeJS
+    const pCamera = this.cameraWalker.camera().openObjectAsCamera();
+    const dir = this.toVector(pCamera.direction());
+    const up = this.toVector(pCamera.upVector());
+
+    const pos = pCamera.position();
+
+    const rotMatrix = this.createMatrix3d();
+    const zAxisVector: Vector3 = [0, 0, 1];
+    rotMatrix.setToRotation(angle, zAxisVector, pos);
+    dir.transformBy(rotMatrix);
+    up.transformBy(rotMatrix);
+    pCamera.setupCameraByDirection(pos, dir.toArray(), up.toArray());
+    pCamera.delete();
+  }
+
+  setupCamera(view) {
+    const pCamera = this.cameraId.openObjectAsCamera();
+    const target = view.viewTarget;
+
+    pCamera.setDisplayGlyph(false);
+    pCamera.setDisplayTarget(false);
+    pCamera.setAutoAdjust(true);
+    pCamera.setupCamera(view.viewPosition, target, view.upVector);
+    pCamera.setNearClip(false, 1.0);
+    pCamera.setFarClip(false, 0);
+    pCamera.setViewParameters(view.viewFieldWidth, view.viewFieldHeight, true);
+
+    const focalL = calcFocalLength(view.lensLength, view.viewFieldWidth, view.viewFieldHeight);
+
+    const pTarget = this.toPoint(view.viewTarget);
+    const viewDir = this.toPoint(view.viewPosition);
+    const viewDirSub = viewDir.sub(pTarget);
+    const viewDirVec = viewDirSub.asVector();
+    const viewDirVecNormal = viewDirVec.normalize();
+
+    const geViewDir = this.toGeVector(viewDirVecNormal);
+    const newGeViewDir = [geViewDir[0] * focalL, geViewDir[1] * focalL, geViewDir[2] * focalL];
+
+    const pTarget2 = this.toPoint(view.viewTarget);
+    const newGeViewDirPt = this.toPoint(newGeViewDir);
+
+    const newPos = pTarget2.add(newGeViewDirPt);
+    pCamera.setupCamera(this.toGePoint(newPos), view.viewTarget, view.upVector);
+
+    this.deleteAll([pTarget, viewDir, viewDirSub, viewDirVec, viewDirVecNormal, pTarget2, newGeViewDirPt, newPos]);
+
+    pCamera.assignView(view);
+    pCamera.delete();
+  }
+
+  getMaxDimension(view) {
+    const [xmax, ymax, zmax] = view.sceneExtents.max();
+    const [xmin, ymin, zmin] = view.sceneExtents.min();
+    const volume = [xmax - xmin, ymax - ymin, zmax - zmin];
+    return Math.max(...volume);
+  }
+}

package/src/Viewer/Draggers/OrbitAroundBuildingDragger.ts

@@ -0,0 +1,184 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2021, Open Design Alliance (the "Alliance").
+// All rights reserved.
+//
+// This software and its documentation and related materials are owned by
+// the Alliance. The software may only be incorporated into application
+// programs owned by members of the Alliance, subject to a signed
+// Membership Agreement and Supplemental Software License Agreement with the
+// Alliance. The structure and organization of this software are the valuable
+// trade secrets of the Alliance and its suppliers. The software is also
+// protected by copyright law and international treaty provisions. Application
+// programs incorporating this software must include the following statement
+// with their copyright notices:
+//
+//   This application incorporates Open Design Alliance software pursuant to a
+//   license agreement with Open Design Alliance.
+//   Open Design Alliance Copyright (C) 2002-2021 by Open Design Alliance.
+//   All rights reserved.
+//
+// By use of this software, its documentation or related materials, you
+// acknowledge and accept the above terms.
+///////////////////////////////////////////////////////////////////////////////
+/* eslint-disable no-unused-vars */
+import { Viewer } from "../Viewer";
+import { Point2d } from "./Common/Geometry";
+import { ViewParams } from "./Common/OdaGeAction";
+import { OdBaseDragger } from "./Common/OdBaseDragger";
+
+export class OrbitAroundBuildingDragger extends OdBaseDragger {
+  protected maxPolarAngle: number;
+  protected minPolarAngle: number;
+  protected m_viewCenter: any;
+  protected m_startPoint: Point2d;
+  protected startCameraParams: ViewParams;
+  protected m_delta: number;
+
+  constructor(viewer: Viewer) {
+    super(viewer);
+    this.autoSelect = true;
+    this.press = false;
+    this.maxPolarAngle = Math.PI / 2;
+    this.minPolarAngle = 0; // radians
+  }
+
+  override start(x: number, y: number): void {
+    this.press = true;
+
+    this.m_viewCenter = this.getCenter();
+    this.m_startPoint = { x, y };
+
+    const view = this.getViewer().activeView;
+
+    this.startCameraParams = this.getViewParams();
+
+    const corners = view.vportRect;
+
+    this.m_delta = Math.max(corners[1] - corners[0], corners[2] - corners[3]);
+
+    this.beginInteractivity();
+  }
+
+  setDefaultViewParams(): void {
+    this.setViewParams(this.startCameraParams);
+  }
+
+  override drag(x: number, y: number, dltX: number, dltY: number): void {
+    if (this.press) {
+      let dX = x - this.m_startPoint.x;
+      let dY = y - this.m_startPoint.y;
+
+      dX *= Math.PI / this.m_delta;
+      dY *= Math.PI / this.m_delta;
+
+      this.setDefaultViewParams();
+
+      const { Vector3d, Matrix3d } = this.m_module;
+
+      const target = Vector3d.createFromArray(this.startCameraParams.target);
+      const offset = Vector3d.createFromArray(this.startCameraParams.position).sub(target);
+      const dir = offset.normalize();
+
+      const zMatrix = new Matrix3d();
+      zMatrix.setToIdentity();
+      const xMatrix = new Matrix3d();
+      xMatrix.setToIdentity();
+
+      // ---- restore start rotation ----
+
+      const yAxis = Vector3d.createFromArray([dir.x, dir.y, dir.z]);
+      const zAxis = Vector3d.createFromArray(this.startCameraParams.upVector);
+      const xAxis = yAxis.crossProduct(zAxis);
+
+      // ----------- zAxis rotation restore -----------
+      let xyDir = Vector3d.createFromArray([yAxis.x, yAxis.y, 0]);
+
+      if (xyDir.length() <= 0.00001) {
+        xyDir.set(-xAxis.y, xAxis.x, 0);
+      } else {
+        xyDir = xyDir.normalize();
+      }
+      const xyAngle =
+        Math.sign(xyDir.dotProduct(Vector3d.createFromArray([-1, 0, 0]))) *
+        xyDir.angleTo(Vector3d.createFromArray([0, 1, 0]));
+      dX -= xyAngle;
+      // ----------- zAxis rotation restore -----------
+
+      // ----------- xAxis rotation restore -----------
+      let yzDir = Vector3d.createFromArray([dir.x, dir.y, 0]);
+      let yzAngle = 0;
+      if (yzDir.length() <= 0.00001) {
+        yzAngle = (-dir.z * Math.PI) / 2;
+      } else {
+        yzDir = yzDir.normalize();
+        yzAngle = -yzDir.angleTo(dir);
+      }
+      dY -= yzAngle;
+      // ----------- xAxis rotation restore -----------
+
+      // ---- restore start rotation ----
+
+      zMatrix.setToRotation(-dX, [0, 0, 1], [0, 0, 0]);
+
+      const xAngle = Math.max(this.minPolarAngle, Math.min(this.maxPolarAngle, dY));
+      xMatrix.setToRotation(xAngle, [1, 0, 0], [0, 0, 0]);
+
+      const endMatrix = zMatrix.postMultBy(xMatrix);
+
+      let pos = Vector3d.createFromArray([0, 1, 0]).transformBy(endMatrix);
+      const up = Vector3d.createFromArray([0, 0, 1]).transformBy(endMatrix);
+
+      pos.setLength(offset.length());
+      pos = target.add(pos);
+
+      const current = this.getViewParams();
+
+      current.position = pos.toArray();
+      current.upVector = up.toArray();
+
+      this.setViewParams(current);
+    }
+  }
+
+  override end(): void {
+    this.press = false;
+    this.endInteractivity();
+  }
+
+  getCenter(): any {
+    const viewer = this.getViewer();
+
+    let ext = viewer.getActiveExtents();
+
+    const pSet = viewer.getSelected();
+    if (!pSet.isNull() && pSet.numItems() !== 0) {
+      const itr = pSet.getIterator();
+      const entId = itr.getEntity();
+
+      if (entId.getType() === 1) {
+        const obj = entId.openObject();
+
+        ext.delete();
+        ext = obj.getExtents();
+
+        obj.delete();
+      } else if (entId.getType() === 2) {
+        const obj = entId.openObjectAsInsert();
+        const extTuple = obj.getExtents();
+
+        ext.delete();
+        ext = extTuple.ext;
+
+        extTuple.delete();
+        obj.delete();
+      }
+
+      itr.delete();
+    }
+
+    const center = ext.center();
+
+    ext.delete();
+    return center;
+  }
+}

package/src/Viewer/EventEmitter2.ts

@@ -0,0 +1,116 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2021, Open Design Alliance (the "Alliance").
+// All rights reserved.
+//
+// This software and its documentation and related materials are owned by
+// the Alliance. The software may only be incorporated into application
+// programs owned by members of the Alliance, subject to a signed
+// Membership Agreement and Supplemental Software License Agreement with the
+// Alliance. The structure and organization of this software are the valuable
+// trade secrets of the Alliance and its suppliers. The software is also
+// protected by copyright law and international treaty provisions. Application
+// programs incorporating this software must include the following statement
+// with their copyright notices:
+//
+//   This application incorporates Open Design Alliance software pursuant to a
+//   license agreement with Open Design Alliance.
+//   Open Design Alliance Copyright (C) 2002-2021 by Open Design Alliance.
+//   All rights reserved.
+//
+// By use of this software, its documentation or related materials, you
+// acknowledge and accept the above terms.
+///////////////////////////////////////////////////////////////////////////////
+
+import { IEvent, IEventEmitter } from "./IEventEmitter2";
+
+/**
+ * The minimal basic Event that can be emitted by a {@link EventEmitter2}.
+ */
+export interface Event<T extends string = string> extends IEvent {
+  type: T;
+}
+
+/**
+ * Event emitter for custom objects.
+ */
+export class EventEmitter2<EventMap extends Record<string, any> = Record<string, any>> implements IEventEmitter {
+  private _listeners = undefined;
+
+  /**
+   * Registers a new listener for an event type.
+   *
+   * @param type - The type of event to listen to.
+   * @param listener - The function that gets called when the event is fired.
+   */
+  addEventListener<T extends keyof EventMap>(type: T, listener: (event: EventMap[T]) => void): this {
+    if (this._listeners === undefined) this._listeners = {};
+    if (this._listeners[type] === undefined) this._listeners[type] = [];
+    this._listeners[type].push(listener);
+    return this;
+  }
+
+  /**
+   * Removes the listener from an event type.
+   *
+   * @param type - The type of the listener that gets removed.
+   * @param listener - The listener function that gets removed.
+   */
+  removeEventListener<T extends keyof EventMap>(type: T, listener: (event: EventMap[T]) => void): this {
+    if (this._listeners === undefined) return this;
+    if (this._listeners[type] === undefined) return this;
+    const listeners = this._listeners[type].filter((x) => x !== listener);
+    this._listeners[type] = listeners.length === 0 ? undefined : listeners;
+    return this;
+  }
+
+  /**
+   * If `type` is specified, removes all registered listeners for type, otherwise removes all
+   * registered listeners.
+   *
+   * @param type - The type of the listener that gets removed.
+   */
+  removeAllListeners<T extends keyof EventMap>(type?: T): this {
+    if (type) this._listeners[type] = undefined;
+    else this._listeners = undefined;
+    return this;
+  }
+
+  /**
+   * Fires the event. Calls each of the listeners registered for the event type `event.type`,
+   * in the order they were registered.
+   *
+   * @param event - The event that gets fired.
+   */
+  emitEvent<T extends keyof EventMap>(event: Event<Extract<T, string>> & EventMap[T]): boolean {
+    if (this._listeners === undefined) return false;
+    if (this._listeners[event.type] === undefined) return false;
+    const invoke = this._listeners[event.type].slice();
+    invoke.forEach((listener) => listener.call(this, event));
+    return true;
+  }
+
+  // Node.js style, to emit custom events
+
+  /**
+   * Alias to {@link EventEmitter2.addEventListener()}
+   */
+  on(type: string, listener: (event: object) => void): this {
+    return this.addEventListener(type as any, listener as any);
+  }
+
+  /**
+   * Alias to {@link EventEmitter2.removeEventListener()}.
+   */
+  off(type: string, listener: (event: object) => void): this {
+    return this.removeEventListener(type as any, listener as any);
+  }
+
+  /**
+   * Alias to {@link EventEmitter2.emitEvent()}.
+   */
+  emit(event: string | object, ...args: any[]): boolean {
+    if (typeof event === "string") return this.emitEvent({ type: event, args } as any);
+    else if (typeof event === "object") return this.emitEvent(event as any);
+    else return false;
+  }
+}

package/src/Viewer/ICommands.ts

@@ -0,0 +1,53 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2023, Open Design Alliance (the "Alliance").
+// All rights reserved.
+//
+// This software and its documentation and related materials are owned by
+// the Alliance. The software may only be incorporated into application
+// programs owned by members of the Alliance, subject to a signed
+// Membership Agreement and Supplemental Software License Agreement with the
+// Alliance. The structure and organization of this software are the valuable
+// trade secrets of the Alliance and its suppliers. The software is also
+// protected by copyright law and international treaty provisions. Application
+// programs incorporating this software must include the following statement
+// with their copyright notices:
+//
+//   This application incorporates Open Design Alliance software pursuant to a
+//   license agreement with Open Design Alliance.
+//   Open Design Alliance Copyright (C) 2002-2021 by Open Design Alliance.
+//   All rights reserved.
+//
+// By use of this software, its documentation or related materials, you
+// acknowledge and accept the above terms.
+///////////////////////////////////////////////////////////////////////////////
+
+import { IViewer } from "./IViewer";
+
+export interface ICommandService {
+  executeCommand(id: string, ...args: any[]): any;
+}
+
+export type ICommandsMap = Map<string, ICommand>;
+
+export interface ICommandHandler {
+  (viewer: any, ...args: any[]): any;
+}
+
+export interface ICommand {
+  id: string;
+  handler: ICommandHandler;
+  thisArg?: any;
+  description?: ICommandDescription;
+}
+
+export interface ICommandDescription {
+  readonly description: string;
+}
+
+export interface ICommands {
+  registerCommand(id: string, handler: ICommandHandler, description?: ICommandDescription, thisArg?: any): void;
+  registerCommandAlias(id: string, alias: string): void;
+  getCommands(): ICommandsMap;
+  getCommand(id: string): ICommand | undefined;
+  executeCommand(id: string, viewer: IViewer, ...args: any[]): any;
+}

package/src/Viewer/IEventEmitter2.ts

@@ -0,0 +1,36 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2021, Open Design Alliance (the "Alliance").
+// All rights reserved.
+//
+// This software and its documentation and related materials are owned by
+// the Alliance. The software may only be incorporated into application
+// programs owned by members of the Alliance, subject to a signed
+// Membership Agreement and Supplemental Software License Agreement with the
+// Alliance. The structure and organization of this software are the valuable
+// trade secrets of the Alliance and its suppliers. The software is also
+// protected by copyright law and international treaty provisions. Application
+// programs incorporating this software must include the following statement
+// with their copyright notices:
+//
+//   This application incorporates Open Design Alliance software pursuant to a
+//   license agreement with Open Design Alliance.
+//   Open Design Alliance Copyright (C) 2002-2021 by Open Design Alliance.
+//   All rights reserved.
+//
+// By use of this software, its documentation or related materials, you
+// acknowledge and accept the above terms.
+///////////////////////////////////////////////////////////////////////////////
+
+export interface IEvent {
+  type: string;
+}
+
+export interface IEventEmitter {
+  addEventListener(type: string, listener: (event: IEvent) => void): this;
+  removeEventListener(type: string, listener: (event: IEvent) => void): this;
+  removeAllListeners(type?: string): this;
+  emitEvent(event: IEvent): boolean;
+  on(type: string, listener: (event: object) => void): this;
+  off(type: string, listener: (event: object) => void): this;
+  emit(event: string | object, ...args: any[]): boolean;
+}