vim-web 0.3.44-dev.46 → 0.3.44-dev.50

package/dist/style.css

@@ -848,6 +848,9 @@ video:where(.vim-component,.vim-component *) {
 .vc-hidden {
   display: none;
 }
+.vc-h-1\/2 {
+  height: 50%;
+}
 .vc-h-2 {
   height: 0.5rem;
 }
@@ -1515,7 +1518,7 @@ video:where(.vim-component,.vim-component *) {
     padding-left:  min(2cqmin, 1rem);
     padding-right:  min(2cqmin, 1rem);
   }
-  
+
   .vim-control-bar-button {
     height: min(8cqmin, 2.5rem);
     width: min(8cqmin, 2.5rem);
@@ -1523,6 +1526,18 @@ video:where(.vim-component,.vim-component *) {
   .vim-control-bar-section {
     gap: min(2cqmin, 0.5rem)
   }
+
+  .vim-rest-of-screen .vc-text-xs {
+    font-size: min(2.0cqmin, 0.75rem);
+    line-height: min(2.5cqmin, 0.85rem);
+  }
+
+  .vim-control-bar-counter{
+    margin-bottom: min(1cqmin, 0.5rem);
+    margin-right: min(2cqmin, 0.5rem);
+    margin-left: max(-2cqmin, -0.75rem);
+  }
+
   .vim-axes-panel{
     border-radius: min(3cqmin, 1rem);
     top: min(2cqmin, 1.5rem);

package/dist/types/core-viewers/index.d.ts

@@ -0,0 +1,3 @@
+export * as Webgl from './webgl';
+export * as Ultra from './ultra';
+export * from './shared';

package/dist/types/core-viewers/shared/baseInputHandler.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @module viw-webgl-viewer/inputs
+ */
+/**
+ * TODO: Use the same code for ULTRA and webgl.
+ * Base class for various input handlers.
+ * It provides convenience to register to and unregister from events.
+ */
+export declare class BaseInputHandler {
+    protected _canvas: HTMLCanvasElement;
+    protected _disconnect: Function[];
+    constructor(canvas: HTMLCanvasElement);
+    protected reg<T extends Event>(element: Document | HTMLElement | Window, eventType: string, callback: (event: T) => void): void;
+    /**
+     * Register handler to related browser events
+     * Prevents double registrations
+     */
+    register(): void;
+    protected addListeners(): void;
+    /**
+     * Unregister handler from related browser events
+     * Prevents double unregistration
+     */
+    unregister(): void;
+    /**
+     * Reset handler states such as button down, drag, etc.
+     */
+    reset(): void;
+}

package/dist/types/core-viewers/shared/index.d.ts

@@ -0,0 +1,9 @@
+export * from './inputHandler';
+export type * from './baseInputHandler';
+export { PointerMode } from './inputHandler';
+export type * from './keyboardHandler';
+export type * from './mouseHandler';
+export type * from './raycaster';
+export type * from './selection';
+export type * from './touchHandler';
+export type * from './vim';

package/dist/types/core-viewers/shared/inputHandler.d.ts

@@ -1,29 +1,116 @@
-/**
- * @module viw-webgl-viewer/inputs
- */
-/**
- * TODO: Use the same code for ULTRA and webgl.
- * Base class for various input handlers.
- * It provides convenience to register to and unregister from events.
- */
-export declare class InputHandler {
-    protected _canvas: HTMLCanvasElement;
-    protected _disconnect: Function[];
-    constructor(canvas: HTMLCanvasElement);
-    protected reg<T extends Event>(element: Document | HTMLElement | Window, eventType: string, callback: (event: T) => void): void;
-    /**
-     * Register handler to related browser events
-     * Prevents double registrations
-     */
-    register(): void;
-    protected addListeners(): void;
-    /**
-     * Unregister handler from related browser events
-     * Prevents double unregistration
-     */
-    unregister(): void;
-    /**
-     * Reset handler states such as button down, drag, etc.
-     */
-    reset(): void;
+import * as THREE from 'three';
+import { BaseInputHandler } from './baseInputHandler';
+import { KeyboardHandler } from './keyboardHandler';
+import { MouseHandler } from './mouseHandler';
+import { TouchHandler } from './touchHandler';
+export declare enum PointerMode {
+    ORBIT = "orbit",
+    LOOK = "look",
+    PAN = "pan",
+    ZOOM = "zoom",
+    RECT = "rect"
 }
+export interface IInputAdapter {
+    init: () => void;
+    toggleOrthographic: () => void;
+    resetCamera: () => void;
+    clearSelection: () => void;
+    frameCamera: () => void;
+    moveCamera: (value: THREE.Vector3) => void;
+    orbitCamera: (value: THREE.Vector2) => void;
+    rotateCamera: (value: THREE.Vector2) => void;
+    panCamera: (value: THREE.Vector2) => void;
+    keyDown: (keyCode: string) => boolean;
+    keyUp: (keyCode: string) => boolean;
+    mouseDown: (pos: THREE.Vector2, button: number) => void;
+    mouseUp: (pos: THREE.Vector2, button: number) => void;
+    mouseMove: (pos: THREE.Vector2) => void;
+    selectAtPointer: (pos: THREE.Vector2, add: boolean) => void;
+    frameAtPointer: (pos: THREE.Vector2) => void;
+    zoom: (value: number) => void;
+}
+interface InputSettings {
+    orbit: boolean;
+    scrollSpeed: number;
+    moveSpeed: number;
+    rotateSpeed: number;
+    orbitSpeed: number;
+}
+export declare class InputHandler extends BaseInputHandler {
+    /**
+     * Touch input handler
+     */
+    touch: TouchHandler;
+    /**
+     * Mouse input handler
+     */
+    mouse: MouseHandler;
+    /**
+     * Keyboard input handler
+     */
+    keyboard: KeyboardHandler;
+    scrollSpeed: number;
+    private _moveSpeed;
+    rotateSpeed: number;
+    orbitSpeed: number;
+    private _pointerActive;
+    private _pointerFallback;
+    private _pointerOverride;
+    private _onPointerOverrideChanged;
+    private _onPointerModeChanged;
+    private _onSettingsChanged;
+    private _adapter;
+    constructor(canvas: HTMLCanvasElement, adapter: IInputAdapter, settings?: Partial<InputSettings>);
+    init(): void;
+    get moveSpeed(): number;
+    set moveSpeed(value: number);
+    get onSettingsChanged(): import("ste-signals").ISignal;
+    /**
+     * Returns the last main mode (orbit, look) that was active.
+     */
+    get pointerFallback(): PointerMode;
+    /**
+     * Returns current pointer mode.
+     */
+    get pointerActive(): PointerMode;
+    /**
+     * A temporary pointer mode used for temporary icons.
+     */
+    get pointerOverride(): PointerMode;
+    set pointerOverride(value: PointerMode | undefined);
+    /**
+     * Changes pointer interaction mode. Look mode will set camera orbitMode to false.
+     */
+    set pointerActive(value: PointerMode);
+    /**
+     * Event called when pointer interaction mode changes.
+     */
+    get onPointerModeChanged(): import("ste-signals").ISignal;
+    /**
+     * Event called when the pointer is temporarily overriden.
+     */
+    get onPointerOverrideChanged(): import("ste-signals").ISignal;
+    private _onContextMenu;
+    /**
+     * Event called when when context menu could be displayed
+     */
+    get onContextMenu(): import("ste-simple-events").ISimpleEvent<THREE.Vector2>;
+    /**
+     * Calls context menu action
+     */
+    ContextMenu(position: THREE.Vector2 | undefined): void;
+    /**
+   * Register inputs handlers for default viewer behavior
+   */
+    registerAll(): void;
+    /**
+     * Unregisters all input handlers
+     */
+    unregisterAll: () => void;
+    /**
+     * Resets all input state
+     */
+    resetAll(): void;
+    dispose(): void;
+}
+export {};

package/dist/types/core-viewers/shared/keyboardHandler.d.ts

@@ -2,7 +2,7 @@
  * @module viw-webgl-viewer/inputs
  */
 import * as THREE from 'three';
-import { InputHandler } from './inputHandler';
+import { BaseInputHandler } from './baseInputHandler';
 type CallbackMode = 'replace' | 'append' | 'prepend';
 /**
  * KeyboardHandler
@@ -11,7 +11,7 @@ type CallbackMode = 'replace' | 'append' | 'prepend';
  * It supports separate handlers for key down, key up, and continuous key pressed events.
  * The handler calculates a movement vector based on currently pressed keys.
  */
-export declare class KeyboardHandler extends InputHandler {
+export declare class KeyboardHandler extends BaseInputHandler {
     /**
      * Callback invoked whenever the calculated movement vector is updated.
      */

package/dist/types/core-viewers/shared/mouseHandler.d.ts

@@ -1,16 +1,16 @@
-import { InputHandler } from "./inputHandler";
-import { Vector2 } from "../utils/math3d";
-type DragCallback = (delta: Vector2, button: number) => void;
-export declare class MouseHandler extends InputHandler {
+import { BaseInputHandler } from "./baseInputHandler";
+import * as THREE from 'three';
+type DragCallback = (delta: THREE.Vector2, button: number) => void;
+export declare class MouseHandler extends BaseInputHandler {
     private _lastMouseDownPosition;
     private _capture;
     private _dragHandler;
-    onButtonDown: (pos: Vector2, button: number) => void;
-    onButtonUp: (pos: Vector2, button: number) => void;
-    onMouseMove: (event: Vector2) => void;
+    onButtonDown: (pos: THREE.Vector2, button: number) => void;
+    onButtonUp: (pos: THREE.Vector2, button: number) => void;
+    onMouseMove: (event: THREE.Vector2) => void;
     onDrag: DragCallback;
-    onClick: (position: Vector2, ctrl: boolean) => void;
-    onDoubleClick: (position: Vector2) => void;
+    onClick: (position: THREE.Vector2, ctrl: boolean) => void;
+    onDoubleClick: (position: THREE.Vector2) => void;
     onWheel: (value: number, ctrl: boolean) => void;
     constructor(canvas: HTMLCanvasElement);
     protected addListeners(): void;

package/dist/types/core-viewers/shared/raycaster.d.ts

@@ -0,0 +1,13 @@
+import { THREE } from "../..";
+export interface IRaycastResult<T> {
+    /** The model Object hit */
+    object: T | undefined;
+    /** The 3D world position of the hit point */
+    worldPosition: THREE.Vector3;
+    /** The surface normal at the hit point */
+    worldNormal: THREE.Vector3;
+}
+export interface IRaycaster<T> {
+    raycastFromScreen(position: THREE.Vector2): Promise<IRaycastResult<T>>;
+    raycastFromWorld(position: THREE.Vector3): Promise<IRaycastResult<T>>;
+}

package/dist/types/core-viewers/shared/selection.d.ts

@@ -0,0 +1,45 @@
+import { ISignal } from "ste-signals";
+import { IVimObject, IVim } from "./vim";
+import { THREE } from "../..";
+export interface ISelection<T extends IVimObject> {
+    select(object: T | T[]): void;
+    toggle(object: T | T[]): void;
+    add(object: T | T[]): void;
+    remove(object: T | T[]): void;
+    clear(): void;
+    getAll(): T[];
+    GetFromVim(vim: IVim<T>): T[];
+    removeFromVim(vim: IVim<T>): void;
+    getBoundingBox(): Promise<THREE.Box3>;
+    count(): number;
+    any(): boolean;
+    has(object: T): boolean;
+    onSelectionChanged: ISignal;
+}
+export interface ISelectionAdapter<T extends IVimObject> {
+    outline(object: T, state: boolean): void;
+}
+export declare class Selection<T extends IVimObject> implements ISelection<T> {
+    private _onSelectionChanged;
+    private _selection;
+    private _adapter;
+    constructor(adapter: ISelectionAdapter<T>);
+    has(object: T): boolean;
+    count(): number;
+    any(): boolean;
+    get onSelectionChanged(): ISignal;
+    private _dispatchIfChanged;
+    select(object: T): void;
+    select(objects: T[]): void;
+    toggle(object: T): void;
+    toggle(objects: T[]): void;
+    add(object: T): void;
+    add(objects: T[]): void;
+    remove(object: T): void;
+    remove(objects: T[]): void;
+    clear(): void;
+    getAll(): T[];
+    GetFromVim(vim: IVim<T>): T[];
+    removeFromVim(vim: IVim<T>): void;
+    getBoundingBox(): Promise<THREE.Box3>;
+}

package/dist/types/core-viewers/shared/touchHandler.d.ts

@@ -2,11 +2,11 @@
  * @module viw-webgl-viewer/inputs
  */
 import * as THREE from 'three';
-import { InputHandler } from './inputHandler';
+import { BaseInputHandler } from './baseInputHandler';
 /**
  * Manages user touch inputs.
  */
-export declare class TouchHandler extends InputHandler {
+export declare class TouchHandler extends BaseInputHandler {
     private readonly TAP_DURATION_MS;
     private readonly DOUBLE_TAP_DELAY_MS;
     private readonly TAP_MAX_MOVE_PIXEL;

package/dist/types/core-viewers/shared/vim.d.ts

@@ -0,0 +1,35 @@
+import { THREE } from "../..";
+export interface IVimObject {
+    vim: IVim<IVimObject>;
+    getBoundingBox(): Promise<THREE.Box3>;
+}
+export interface IVim<T extends IVimObject> {
+    /**
+     * Retrieves the object associated with the specified instance number.
+     * @param instance - The instance number of the object.
+     * @returns The object corresponding to the instance, or undefined if not found.
+     */
+    getObjectFromInstance(instance: number): T | undefined;
+    /**
+     * Retrieves the objects associated with the specified element ID.
+     * @param id - The element ID to retrieve objects for.
+     * @returns An array of objects corresponding to the element ID.
+     */
+    getObjectsFromElementId(id: number): T[];
+    /**
+     * Retrieves the Vim object associated with the given Vim element index.
+     * @param element - The index of the Vim element.
+     * @returns The Vim object corresponding to the element index, or undefined if not found.
+     */
+    getObjectFromElementIndex(element: number): T | undefined;
+    /**
+     * Retrieves all objects within the Vim.
+     * @returns An array of all Vim objects.
+     */
+    getAllObjects(): T[];
+    /**
+     * Retrieves the bounding box of the Vim object.
+     * @returns The bounding box of the Vim object.
+     */
+    getBoundingBox(): Promise<THREE.Box3>;
+}

package/dist/types/core-viewers/ultra/{viewer/camera.d.ts → camera.d.ts}

@@ -1,6 +1,8 @@
-import { Box3, Segment, Vector3 } from '../../utils/math3d';
 import { RpcSafeClient } from './rpcSafeClient';
+import { Element3D } from './element3d';
 import { Vim } from './vim';
+import { Segment } from './rpcTypes';
+import * as THREE from 'three';
 /**
  * Interface defining camera control operations in the 3D viewer
  * @interface
@@ -18,7 +20,7 @@ export interface ICamera {
      * @param {number} [blendTime=0.5] - Animation duration in seconds
      * @returns {Promise<Segment | undefined>} Promise resolving to the final camera position segment
      */
-    frameBox(box: Box3, blendTime?: number): Promise<Segment | undefined>;
+    frameBox(box: THREE.Box3, blendTime?: number): Promise<Segment | undefined>;
     /**
      * Frames specified nodes of a Vim model in the camera view
      * @param {Vim} vim - The target Vim model
@@ -27,6 +29,13 @@ export interface ICamera {
      * @returns {Promise<Segment | undefined>} Promise resolving to the final camera position segment
      */
     frameVim(vim: Vim, nodes: number[] | 'all', blendTime?: number): Promise<Segment | undefined>;
+    /**
+     * Frames a specific object in the camera view
+     * @param {Element3D} object - The target object to frame
+     * @param {number} [blendTime=0.5] - Animation duration in seconds
+     * @returns {Promise<Segment | undefined>} Promise resolving to the final camera position segment
+     */
+    frameObject(object: Element3D, blendTime?: number): Promise<Segment | undefined>;
     /**
      * Saves the current camera position for later restoration
      * @param {Segment} [segment] - Optional specific camera position to save
@@ -51,7 +60,6 @@ export interface ICamera {
 export declare class Camera implements ICamera {
     private _rpc;
     private _lastPosition;
-    private _interval;
     private _defaultBlendTime;
     private _savedPosition;
     /**
@@ -78,7 +86,7 @@ export declare class Camera implements ICamera {
      */
     onConnect(): void;
     onCameraPose(pose: Segment): void;
-    set(position: Vector3, target: Vector3, blendTime?: number): void;
+    set(position: THREE.Vector3, target: THREE.Vector3, blendTime?: number): void;
     /**
      * Pauses or resumes rendering
      * @param value - True to pause rendering, false to resume
@@ -95,7 +103,7 @@ export declare class Camera implements ICamera {
      * @param box - The 3D bounding box to frame in the camera view
      * @param blendTime - Duration of the camera animation in seconds (defaults to 0.5)
      */
-    frameBox(box: Box3, blendTime?: number): Promise<Segment | undefined>;
+    frameBox(box: THREE.Box3, blendTime?: number): Promise<Segment | undefined>;
     /**
      * Frames specific nodes of a Vim model in the camera view
      * @param vim - The Vim model containing the nodes to frame
@@ -104,4 +112,5 @@ export declare class Camera implements ICamera {
      * @returns Promise that resolves when the framing animation is complete
      */
     frameVim(vim: Vim, nodes: number[] | 'all', blendTime?: number): Promise<Segment | undefined>;
+    frameObject(object: Element3D, blendTime?: number): Promise<Segment | undefined>;
 }

package/dist/types/core-viewers/ultra/{viewer/colorManager.d.ts → colorManager.d.ts}

@@ -1,6 +1,6 @@
 import { RpcSafeClient } from './rpcSafeClient';
-import { ColorHandle } from './color';
-import { RGBA32 } from '../../utils/math3d';
+import { RemoteColor } from './remoteColor';
+import { RGBA32 } from './rpcTypes';
 /**
  * Manages the creation, caching, and deletion of color instances.
  * Handles batched deletion of colors to optimize RPC calls.
@@ -21,25 +21,25 @@ export declare class ColorManager {
      * @param hex - The RGBA32 color value
      * @returns Promise resolving to a ColorHandle, or undefined if creation fails
      */
-    getColor(hex: RGBA32): Promise<ColorHandle | undefined>;
+    getColor(hex: RGBA32): Promise<RemoteColor | undefined>;
     /**
      * Creates or retrieves cached color instances for multiple hex values.
      * @param c - Array of RGBA32 color values
      * @returns Promise resolving to an array of ColorHandles in the same order as input, or undefined if creation fails
      * @remarks Duplicate hex values will be mapped to the same color instance for efficiency
      */
-    getColors(c: RGBA32[]): Promise<ColorHandle[]>;
+    getColors(c: RGBA32[]): Promise<RemoteColor[]>;
     /**
      * Retrieves a color instance by its unique identifier.
      * @param id - The unique identifier of the color
      * @returns The ColorHandle associated with the ID, or undefined if not found
      */
-    getFromId(id: number): ColorHandle;
+    getFromId(id: number): RemoteColor;
     /**
      * Destroys a color instance and removes it from the cache.
      * @param color - The ColorHandle to destroy
      */
-    destroy(color: ColorHandle): void;
+    destroy(color: RemoteColor): void;
     /**
      * Destroys all color instances and clears the cache.
      */

package/dist/types/core-viewers/ultra/{viewer/decoder.d.ts → decoder.d.ts}

@@ -1,13 +1,5 @@
 import type { VideoFrameMessage } from './protocol';
 import { ILogger } from './logger';
-/**
- * Configuration for the video decoder.
- */
-export declare const videoDecoderConfig: globalThis.VideoDecoderConfig;
-export declare enum FrameType {
-    KeyFrame = 0,
-    DeltaFrame = 1
-}
 /**
  * Interface defining the basic decoder operations
  */

package/dist/types/core-viewers/ultra/element3d.d.ts

@@ -0,0 +1,15 @@
+import { IVimObject } from "../shared/vim";
+import { NodeState } from "./nodeState";
+import { Box3, RGBA32 } from "./rpcTypes";
+import { Vim } from "./vim";
+export declare class Element3D implements IVimObject {
+    readonly vim: Vim;
+    get vimHandle(): number;
+    constructor(vim: Vim, instance: number);
+    readonly instance: number;
+    get state(): NodeState;
+    set state(state: NodeState);
+    get color(): RGBA32 | undefined;
+    set color(color: RGBA32 | undefined);
+    getBoundingBox(): Promise<Box3>;
+}

package/dist/types/core-viewers/ultra/index.d.ts

@@ -1,10 +1,29 @@
 import "./style.css";
-export * from './viewer/ultraCoreViewer';
-export * as utils from '../utils/promise';
-export * from '../utils/math3d';
-export * from './viewer/vim';
-export * from './viewer/color';
-export type { ILoadRequest, VimRequestErrorType } from './viewer/loadRequest';
-export type { ClientState, ConnectionSettings } from './viewer/socketClient';
-export type { VimSource } from './viewer/rpcSafeClient';
-export type { SectionBoxState } from './viewer/marshal';
+export * from './viewer';
+export { RGB, RGBA, RGBA32, Segment, type SectionBoxState, type HitCheckResult, type VimStatus } from './rpcTypes';
+export { materialHandles, MaterialHandles, type MaterialHandle, } from './rpcClient';
+export type * from './camera';
+export type * from './colorManager';
+export type * from './decoder';
+export type * from './nodeState';
+export { NodeState } from './nodeState';
+export type * from './element3d';
+export type * from './inputAdapter';
+export type * from './loadRequest';
+export type * from './logger';
+export type * from './protocol';
+export type * from './raycaster';
+export type * from './remoteColor';
+export type * from './renderer';
+export type * from './rpcClient';
+export type * from './rpcMarshal';
+export type * from './rpcSafeClient';
+export { InputMode, VimLoadingStatus } from './rpcSafeClient';
+export type * from './sectionBox';
+export type * from './selection';
+export type * from './socketClient';
+export type * from './streamLogger';
+export type * from './streamRenderer';
+export type * from './viewport';
+export type * from './vim';
+export type * from './vimCollection';

package/dist/types/core-viewers/ultra/inputAdapter.d.ts

@@ -0,0 +1,5 @@
+import * as Shared from "../shared";
+import { Viewer } from "./viewer";
+declare const CODE_TO_KEYCODE: Record<string, number>;
+export default CODE_TO_KEYCODE;
+export declare function ultraInputAdapter(viewer: Viewer): Shared.InputHandler;