vim-web 0.3.23 → 0.3.24

package/dist/types/ultra-viewer/viewer/decoder.d.ts

@@ -0,0 +1,116 @@
+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
+ */
+export interface IDecoder {
+    /** Indicates if the decoder is ready to process frames */
+    ready: boolean;
+    /** Indicates if the decoder is currently paused */
+    paused: boolean;
+    /** Stops the decoder operations */
+    stop(): void;
+    /** Starts the decoder operations */
+    start(): void;
+}
+/**
+ * Decoder class responsible for decoding video frames and rendering them using WebGL.
+ * Handles frame queueing, decoding, and rendering through WebGL.
+ */
+export declare class Decoder implements IDecoder {
+    private _decoder;
+    private readonly _canvas;
+    private readonly _renderer;
+    private readonly _logger;
+    private _firstDecoded;
+    private _skipUntil;
+    private _queue;
+    private _pendingFrame;
+    private _renderId;
+    private _decodeId;
+    /**
+     * Indicates whether the decoder is ready and configured.
+     * @returns {boolean} True if the decoder is configured, false otherwise.
+     */
+    get ready(): boolean;
+    /**
+     * Creates an instance of the Decoder class.
+     * @param originalCanvas - The original HTML canvas element to render frames onto
+     * @param logger - Logger instance for debugging and error reporting
+     * @throws {Error} When video decoder configuration is not supported
+     */
+    constructor(originalCanvas: HTMLCanvasElement, logger: ILogger);
+    /**
+     * Indicates whether the decoder is currently paused.
+     * @returns {boolean} True if paused, false otherwise.
+     */
+    get paused(): boolean;
+    /**
+     * Pauses the decoder and renderer.
+     */
+    stop(): void;
+    /**
+     * Resumes the decoder and renderer.
+     */
+    start(): void;
+    /**
+     * Clears decoding and rendering callbacks.
+     */
+    private _clearCallbacks;
+    /**
+     * Enqueues a video frame message for decoding.
+     * If a key frame is received, the queue is cleared except for the first frame
+     * to maintain decoder stability.
+     * @param frame - The video frame message to be queued for decoding
+     */
+    enqueue(frame: VideoFrameMessage): void;
+    /**
+     * Processes and decodes all queued video frame messages.
+     * Skips processing if the decoder isn't ready or the queue is empty.
+     * @throws {Error} When decoding fails for a video chunk
+     */
+    decode(): void;
+    /**
+     * Clears the decoder state and renderer buffer.
+     * Does not close the decoder instance.
+     */
+    clear(): void;
+    /**
+     * Completely disposes of the decoder instance and releases all resources.
+     * Should be called when the decoder is no longer needed.
+     */
+    dispose(): void;
+    /**
+     * Cleans up internal resources and cancels ongoing operations.
+     * @private
+     */
+    private _cleanUp;
+    /**
+     * Creates an EncodedVideoChunk from a VideoFrameMessage.
+     * @param message - The video frame message to convert
+     * @returns {EncodedVideoChunk} A chunk ready for decoder processing
+     * @private
+     */
+    private createChunk;
+    /**
+     * Handles the animation loop for continuous frame rendering.
+     * Processes pending frames and manages the render timing.
+     * @private
+     */
+    private animate;
+    /**
+     * Processes a decoded video frame for rendering.
+     * Manages frame replacement and cleanup of previous frames.
+     * @param frame - The decoded video frame ready for rendering
+     * @private
+     */
+    private renderFrame;
+}

package/dist/types/ultra-viewer/viewer/decoderWithWorker.d.ts

@@ -0,0 +1,80 @@
+import type { VideoFrameMessage } from './protocol';
+import { ILogger } from './logger';
+export declare enum FrameType {
+    KeyFrame = 0,
+    DeltaFrame = 1
+}
+/**
+ * Decoder class responsible for decoding video frames and rendering them using WebGL.
+ */
+export declare class DecoderWithWorker {
+    private readonly _canvas;
+    private readonly _renderer;
+    private readonly _logger;
+    private _firstDecoded;
+    private _skipUntil;
+    private _queue;
+    private _pendingFrame;
+    private _renderId;
+    private _decodeId;
+    private _worker;
+    /**
+     * Indicates whether the decoder is ready and configured.
+     * @returns {boolean} True if the decoder is configured, false otherwise.
+     */
+    get ready(): boolean;
+    /**
+     * Creates an instance of the Decoder class.
+     * @param originalCanvas - The original HTML canvas element.
+     * @param logger - Logger for logging messages and errors.
+     */
+    constructor(originalCanvas: HTMLCanvasElement, logger: ILogger);
+    sendFrameToWorker(frame: VideoFrameMessage): void;
+    /**
+     * Indicates whether the decoder is currently paused.
+     * @returns {boolean} True if paused, false otherwise.
+     */
+    get paused(): boolean;
+    /**
+     * Pauses the decoder and renderer.
+     */
+    stop(): void;
+    /**
+     * Resumes the decoder and renderer.
+     */
+    start(): void;
+    /**
+     * Clears decoding and rendering callbacks.
+     */
+    private _clearCallbacks;
+    /**
+     * Enqueues a video frame message for decoding.
+     * @param frame - The video frame message to enqueue.
+     */
+    enqueue(frame: VideoFrameMessage): void;
+    /**
+     * Decodes enqueued video frame messages.
+     */
+    decode(): void;
+    /**
+     * Clears the decoder and renderer, resetting the internal state.
+     */
+    clear(): void;
+    /**
+     * Disposes of the decoder, releasing resources.
+     */
+    dispose(): void;
+    /**
+     * Cleans up the renderer and clears the frame queue.
+     */
+    private _cleanUp;
+    /**
+     * Animation loop for rendering frames.
+     */
+    private animate;
+    /**
+     * Handles rendering of a decoded video frame.
+     * @param frame - The decoded video frame.
+     */
+    private renderFrame;
+}

package/dist/types/ultra-viewer/viewer/inputs/InputTouch.d.ts

@@ -0,0 +1,25 @@
+import { InputHandler } from "./inputHandler";
+import { RpcSafeClient } from "../rpcSafeClient";
+export declare class InputTouch extends InputHandler {
+    private readonly _rpc;
+    private readonly _canvas;
+    private _lastTouchStartPosition;
+    private _initialTouchDistance;
+    constructor(canvas: HTMLCanvasElement, rpc: RpcSafeClient);
+    register(): void;
+    dispose(): void;
+    private handleTouchStart;
+    private handleSingleTouchStart;
+    private handleDoubleTouchStart;
+    private handleTouchMove;
+    private handleSingleTouchMove;
+    private handleDoubleTouchMove;
+    private handlePinch;
+    private handleTouchEnd;
+    private handleSingleTouchEnd;
+    private handleDoubleTouchEnd;
+    private handleTouchCancel;
+    private handleTouchClick;
+    private hasMoved;
+    private relativeTouchPosition;
+}

package/dist/types/ultra-viewer/viewer/inputs/inputHandler.d.ts

@@ -0,0 +1,7 @@
+export declare abstract class InputHandler {
+    private readonly _disconnect;
+    register(): void;
+    dispose(): void;
+    unregister(): void;
+    protected reg<T extends Event>(element: HTMLElement | Window, eventType: string, callback: (event: T) => void): void;
+}

package/dist/types/ultra-viewer/viewer/inputs/inputKeyboard.d.ts

@@ -0,0 +1,20 @@
+import { ICamera } from "../camera";
+import { RpcSafeClient } from "../rpcSafeClient";
+import { ViewerSelection } from "../selection";
+import { InputHandler } from "./inputHandler";
+import { Inputs } from "./inputs";
+export declare class InputKeyboard extends InputHandler {
+    private readonly _rpc;
+    private readonly _selection;
+    private _camera;
+    private _inputs;
+    constructor(rpc: RpcSafeClient, selection: ViewerSelection, camera: ICamera, inputs: Inputs);
+    register(): void;
+    dispose(): void;
+    private handleKeyDown;
+    private handleKeyUp;
+    private handleServerKeys;
+    private handleClientKeys;
+    private frameContext;
+    private frameSelection;
+}

package/dist/types/ultra-viewer/viewer/inputs/inputMouse.d.ts

@@ -0,0 +1,21 @@
+import { InputHandler } from "./inputHandler";
+import { RpcSafeClient } from "../rpcSafeClient";
+import { ViewerSelection } from "../selection";
+import { ICamera } from "../camera";
+export declare class InputMouse extends InputHandler {
+    private readonly _rpc;
+    private readonly _canvas;
+    private _lastMouseDownPosition;
+    private _selection;
+    private _camera;
+    constructor(canvas: HTMLCanvasElement, rpc: RpcSafeClient, selection: ViewerSelection, camera: ICamera);
+    register(): void;
+    dispose(): void;
+    private handlePointerDown;
+    private handlePointerUp;
+    private handleMouseClick;
+    private handlePointerMove;
+    private handleDoubleClick;
+    private handleMouseScroll;
+    private relativePosition;
+}

package/dist/types/ultra-viewer/viewer/inputs/inputs.d.ts

@@ -0,0 +1,27 @@
+import { InputMode, RpcSafeClient } from '../rpcSafeClient';
+import { InputHandler } from './inputHandler';
+import { ViewerSelection } from '../selection';
+import { ICamera } from '../camera';
+import { IRenderer } from '../renderer';
+export interface IInputs {
+    moveSpeed: number;
+    mode: InputMode;
+}
+export declare class Inputs extends InputHandler implements IInputs {
+    private readonly _rpc;
+    private readonly _canvas;
+    private _inputsMouse;
+    private _inputsTouch;
+    private _keyboard;
+    private _renderer;
+    private _moveSpeed;
+    private _mode;
+    constructor(canvas: HTMLCanvasElement, rpc: RpcSafeClient, selection: ViewerSelection, camera: ICamera, renderer: IRenderer);
+    onConnect(): void;
+    register(): void;
+    get moveSpeed(): number;
+    set moveSpeed(value: number);
+    get mode(): InputMode;
+    set mode(value: InputMode);
+    dispose(): void;
+}

package/dist/types/ultra-viewer/viewer/loadRequest.d.ts

@@ -0,0 +1,36 @@
+import { Vim } from './vim';
+export type LoadRequestResult = LoadSuccess | LoadError;
+export declare class LoadSuccess {
+    readonly isError = false;
+    readonly isSuccess = true;
+    readonly vim: Vim;
+    constructor(vim: Vim);
+}
+export declare class LoadError {
+    error: VimRequestErrorType;
+    readonly isError = true;
+    readonly isSuccess = false;
+    readonly type: VimRequestErrorType;
+    readonly details: string | undefined;
+    constructor(error: VimRequestErrorType, details?: string);
+}
+export interface ILoadRequest {
+    get isCompleted(): boolean;
+    getProgress(): AsyncGenerator<number>;
+    getResult(): Promise<LoadError | LoadSuccess>;
+    abort(): void;
+}
+export type VimRequestErrorType = 'loadingError' | 'downloadingError' | 'serverDisconnected' | 'unknown' | 'cancelled';
+export declare class LoadRequest implements ILoadRequest {
+    private _progress;
+    private _progressPromise;
+    private _completionPromise;
+    private _result;
+    get isCompleted(): boolean;
+    getProgress(): AsyncGenerator<number, void, unknown>;
+    getResult(): Promise<LoadError | LoadSuccess>;
+    onProgress(progress: number): void;
+    success(vim: Vim): this;
+    error(error: VimRequestErrorType, details?: string): this;
+    abort(): void;
+}

package/dist/types/ultra-viewer/viewer/logger.d.ts

@@ -0,0 +1,9 @@
+export interface ILogger {
+    log(message: string): void;
+    error: (message: string, e: unknown) => void;
+}
+export declare const defaultLogger: ILogger;
+export declare function createLogger(onMsg: (str: string) => void): {
+    log: (str: string) => void;
+    error: (str: string, e: unknown) => void;
+};

package/dist/types/ultra-viewer/viewer/marshal.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Don't modify this file, the RPC generated code depends on its interface.
+ */
+import { Box3, RGB, RGBA, RGBA32, Segment, Vector2, Vector3 } from "../utils/math3d";
+export type HitCheckResult = {
+    vimHandle: number;
+    nodeIndex: number;
+    worldPosition: Vector3;
+    worldNormal: Vector3;
+};
+export type VimStatus = {
+    status: number;
+    progress: number;
+};
+export type Vector4 = {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+};
+export declare class Marshal {
+    private buffer;
+    private dataView;
+    private readOffset;
+    private writeOffset;
+    constructor(initialSize?: number);
+    getBuffer(): ArrayBuffer;
+    private ensureCapacity;
+    writeData(data: ArrayBuffer): void;
+    writeBoolean(value: boolean): void;
+    readBoolean(): boolean;
+    writeInt(value: number): void;
+    readInt(): number;
+    writeUInt(value: number): void;
+    readUInt(): number;
+    writeFloat(value: number): void;
+    readFloat(): number;
+    writeString(value: string): void;
+    readString(): string;
+    writeHitCheckResult(data: HitCheckResult): void;
+    readHitCheckResult(): HitCheckResult;
+    writeVimStatus(data: VimStatus): void;
+    readVimStatus(): VimStatus;
+    writeVector2(data: Vector2): void;
+    readVector2(): Vector2;
+    writeVector3(data: Vector3): void;
+    readVector3(): Vector3;
+    writeVector4(data: Vector4): void;
+    readVector4(): Vector4;
+    writeRGBA(color: RGBA): void;
+    readRGBA(): RGBA;
+    writeRGB(color: RGBA): void;
+    readRGB(): RGB;
+    writeRGBA32(color: RGBA32): void;
+    readRGBA32(): RGBA32;
+    writeSegment(segment: Segment): void;
+    readSegment(): Segment;
+    writeBox3(data: Box3): void;
+    readBox3(): Box3;
+    writeArrayOfInt(values: number[]): void;
+    readArrayOfInt(): number[];
+    writeArrayOfUInt(values: number[]): void;
+    readArrayOfUInt(): number[];
+    writeArrayOfFloat(values: number[]): void;
+    readArrayOfFloat(): number[];
+    writeArrayOfBool(values: boolean[]): void;
+    readArrayOfBool(): boolean[];
+    writeArrayOfRGBA32(values: RGBA32[]): void;
+    readArrayOfRGBA32(): RGBA32[];
+    writeArray<T>(data: T[], sizeT: number, write: (data: T) => void): void;
+    readArray<T>(read: () => T): T[];
+}

package/dist/types/ultra-viewer/viewer/protocol.d.ts

@@ -0,0 +1,13 @@
+export interface VideoFrameHeader {
+    timestamp: number;
+    duration: number;
+    frameType: number;
+    dataLength: number;
+}
+export interface VideoFrameMessage {
+    header: VideoFrameHeader;
+    dataBuffer: ArrayBuffer;
+}
+export declare const HEADER_SIZE = 16;
+export declare function readHeader(buffer: ArrayBuffer): VideoFrameHeader;
+export declare function readBlob(blob: Blob): Promise<VideoFrameMessage>;

package/dist/types/ultra-viewer/viewer/renderer.d.ts

@@ -0,0 +1,142 @@
+import { RGBA } from "../utils/math3d";
+import { RpcSafeClient, SceneSettings } from "./rpcSafeClient";
+/**
+ * Render settings that extend SceneSettings with additional rendering-specific properties
+ */
+export type RenderSettings = SceneSettings & {
+    /** Whether to lock the Image-Based Lighting rotation */
+    lockIblRotation: boolean;
+    /** Color used for ghost/transparent rendering */
+    ghostColor: RGBA;
+};
+/**
+ * Default rendering settings
+ */
+export declare const defaultRenderSettings: RenderSettings;
+/**
+ * Interface defining the basic renderer capabilities
+ */
+export interface IRenderer {
+    ghostColor: RGBA;
+    lockIblRotation: boolean;
+    hdrScale: number;
+    toneMappingWhitePoint: number;
+    hdrBackgroundScale: number;
+    hdrBackgroundSaturation: number;
+    backgroundBlur: number;
+    backgroundColor: RGBA;
+}
+/**
+ * Renderer class that handles 3D scene rendering and settings management
+ */
+export declare class Renderer implements IRenderer {
+    private _rpc;
+    private _settings;
+    private _animationFrame;
+    private _updateLighting;
+    private _updateGhostColor;
+    private _updateIblRotation;
+    /**
+     * Creates a new Renderer instance
+     * @param rpc - RPC client for communication with the rendering backend
+     * @param settings - Optional partial render settings to override defaults
+     */
+    constructor(rpc: RpcSafeClient, settings?: Partial<RenderSettings>);
+    /**
+     * Initializes the renderer when connection is established
+     * Sets up initial scene settings, ghost color, and IBL rotation
+     */
+    onConnect(): void;
+    /**
+     * Gets the ghost color used for transparent rendering
+     * @returns Current ghost color as RGBA
+     */
+    get ghostColor(): RGBA;
+    /**
+     * Gets the IBL rotation lock setting
+     * @returns Whether IBL rotation is locked
+     */
+    get lockIblRotation(): boolean;
+    /**
+     * Gets the tone mapping white point value
+     * @returns Current tone mapping white point
+     */
+    get toneMappingWhitePoint(): number;
+    /**
+     * Gets the HDR scale value
+     * @returns Current HDR scale
+     */
+    get hdrScale(): number;
+    /**
+     * Gets the HDR background scale value
+     * @returns Current HDR background scale
+     */
+    get hdrBackgroundScale(): number;
+    /**
+     * Gets the HDR background saturation value
+     * @returns Current HDR background saturation
+     */
+    get hdrBackgroundSaturation(): number;
+    /**
+     * Gets the background blur value
+     * @returns Current background blur
+     */
+    get backgroundBlur(): number;
+    /**
+     * Gets the background color
+     * @returns Current background color as RGBA
+     */
+    get backgroundColor(): RGBA;
+    /**
+     * Updates the ghost color used for transparent rendering
+     * @param value - New ghost color as RGBA
+     */
+    set ghostColor(value: RGBA);
+    /**
+     * Updates the IBL rotation lock setting
+     * @param value - Whether to lock IBL rotation
+     */
+    set lockIblRotation(value: boolean);
+    /**
+     * Sets the tone mapping white point value
+     * @param value - New tone mapping white point value
+     */
+    set toneMappingWhitePoint(value: number);
+    /**
+     * Sets the HDR scale value
+     * @param value - New HDR scale value
+     */
+    set hdrScale(value: number);
+    /**
+     * Sets the HDR background scale value
+     * @param value - New HDR background scale value
+     */
+    set hdrBackgroundScale(value: number);
+    /**
+     * Sets the HDR background saturation value
+     * @param value - New HDR background saturation value
+     */
+    set hdrBackgroundSaturation(value: number);
+    /**
+     * Sets the background blur value
+     * @param value - New background blur value
+     */
+    set backgroundBlur(value: number);
+    /**
+     * Sets the background color
+     * @param value - New background color as RGBA
+     */
+    set backgroundColor(value: RGBA);
+    /**
+     * Requests an update to be performed on the next animation frame.
+     * Multiple setting changes will be batched into a single update.
+     * @private
+     */
+    private requestSettingsUpdate;
+    private applySettings;
+    /**
+     * Cleans up renderer resources
+     * Cancels any pending animation frames
+     */
+    dispose(): void;
+}

package/dist/types/ultra-viewer/viewer/rpcClient.d.ts

@@ -0,0 +1,72 @@
+import type { SocketClient } from './socketClient';
+import { HitCheckResult, VimStatus } from './marshal';
+import { Box3, RGBA, RGBA32, Segment, Vector2, Vector3 } from '../utils/math3d';
+export type MaterialHandle = 4294967295 | 6 | 2 | 0 | 1 | 3 | 4 | 5 | 7 | 8;
+export declare class MaterialHandles {
+    static readonly Invalid: MaterialHandle;
+    static readonly Wireframe: MaterialHandle;
+    static readonly FlatShaded: MaterialHandle;
+    static readonly StandardOpaque: MaterialHandle;
+    static readonly StandardGlass: MaterialHandle;
+    static readonly GhostOutline: MaterialHandle;
+    static readonly GhostFill: MaterialHandle;
+    static readonly GhostBoth: MaterialHandle;
+    static readonly Highlight: MaterialHandle;
+    static readonly Invisible: MaterialHandle;
+}
+export declare const materialHandles: MaterialHandle[];
+export declare class RpcClient {
+    private readonly _messenger;
+    constructor(_messenger: SocketClient);
+    readonly API_VERSION = "4.0.0";
+    RPCClearMaterialOverrides(componentHandle: number): void;
+    RPCClearScene(): void;
+    RPCCreateMaterialInstances(materialHandle: number, smoothness: number, colors: RGBA32[]): Promise<number>;
+    RPCCreateText(position: Vector3, color: RGBA32, text: string): Promise<number>;
+    RPCDestroyMaterialInstances(materialInstanceHandle: number[]): void;
+    RPCDestroyText(componentHandle: number): void;
+    RPCEnableSectionBox(enable: boolean): void;
+    RPCFrameAll(blendTime: number): Promise<Segment>;
+    RPCFrameBox(box: Box3, blendTime: number): Promise<Segment>;
+    RPCFrameInstances(componentHandle: number, nodes: number[], blendTime: number): Promise<Segment>;
+    RPCFrameVim(componentHandle: number, blendTime: number): Promise<Segment>;
+    RPCGetAPIVersion(): Promise<string>;
+    RPCGetBoundingBox(componentHandle: number, nodes: number[]): Promise<Box3>;
+    RPCGetCameraPosition(): Promise<Segment>;
+    RPCGetLastError(): Promise<string>;
+    RPCGetVimLoadingState(componentHandle: number): Promise<VimStatus>;
+    RPCGhost(componentHandle: number, nodes: number[]): void;
+    RPCGhostAll(componentHandle: number): void;
+    RPCHide(componentHandle: number, nodes: number[]): void;
+    RPCHideAABBs(componentHandle: number, nodes: number[]): void;
+    RPCHideAll(componentHandle: number): void;
+    RPCHideAllAABBs(componentHandle: number): void;
+    RPCHighlight(componentHandle: number, nodes: number[]): void;
+    RPCHighlightAll(componentHandle: number): void;
+    RPCKeyEvent(keyCode: number, down: boolean): void;
+    RPCLoadVim(fileName: string): Promise<number>;
+    RPCLoadVimURL(url: string, authToken: string): Promise<number>;
+    RPCLockIblRotation(lock: boolean): void;
+    RPCMouseButtonEvent(mousePos: Vector2, mouseButton: number, down: boolean): void;
+    RPCMouseDoubleClickEvent(mousePos: Vector2, mouseButton: number): void;
+    RPCMouseMoveEvent(mousePos: Vector2): void;
+    RPCMouseScrollEvent(scrollValue: number): void;
+    RPCMouseSelectEvent(mousePos: Vector2, mouseButton: number): void;
+    RPCMoveCameraTo(usePosition: boolean, useTarget: boolean, position: Vector3, target: Vector3, blendTime: number): void;
+    RPCPauseRendering(pause: boolean): void;
+    RPCPerformHitTest(pos: Vector2): Promise<HitCheckResult>;
+    RPCSetAspectRatio(width: number, height: number): void;
+    RPCSetCameraMode(orbit: boolean): void;
+    RPCSetCameraPosition(state: Segment, blendTime: number): void;
+    RPCSetGhostColor(ghostColor: RGBA): void;
+    RPCSetLighting(toneMappingWhitePoint: number, hdrScale: number, hdrBackgroundScale: number, hdrBackgroundSaturation: number, backgroundBlur: number, backgroundColor: RGBA): void;
+    RPCSetMaterialOverrides(componentHandle: number, nodes: number[], materialInstanceHandles: number[]): void;
+    RPCSetMoveSpeed(speed: number): void;
+    RPCSetSectionBox(aabb: Box3): void;
+    RPCShow(componentHandle: number, nodes: number[]): void;
+    RPCShowAABBs(componentHandle: number, nodes: number[], colors: RGBA32[]): void;
+    RPCShowAll(componentHandle: number): void;
+    RPCStartScene(toneMappingWhitePoint: number, hdrScale: number, hdrBackgroundScale: number, hdrBackgroundSaturation: number, backgroundBlur: number, backgroundColor: RGBA): void;
+    RPCTriggerRenderDocCapture(): void;
+    RPCUnloadVim(componentHandle: number): void;
+}