vim-web 0.3.44-dev.8 → 0.3.44-dev.80

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

@@ -0,0 +1,35 @@
+import { THREE } from "../..";
+export interface IVimElement {
+    vim: IVim<IVimElement>;
+    getBoundingBox(): Promise<THREE.Box3>;
+}
+export interface IVim<T extends IVimElement> {
+    /**
+     * Retrieves the element associated with the specified instance index.
+     * @param instance - The instance index of the of one of the instance included in the element.
+     * @returns The object corresponding to the instance, or undefined if not found.
+     */
+    getElementFromInstanceIndex(instance: number): T | undefined;
+    /**
+     * Retrieves the element associated with the specified id.
+     * @param id - The element ID to retrieve objects for.
+     * @returns An array of element corresponding to the given id.
+     */
+    getElementFromId(id: number): T[];
+    /**
+     * Retrieves the element associated with the given index.
+     * @param element - The index of the element.
+     * @returns The element corresponding to the element index, or undefined if not found.
+     */
+    getElementFromIndex(element: number): T | undefined;
+    /**
+     * Retrieves all elements within the Vim.
+     * @returns An array of all Vim objects.
+     */
+    getAllElements(): 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 } 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,6 +86,7 @@ export declare class Camera implements ICamera {
      */
     onConnect(): void;
     onCameraPose(pose: Segment): void;
+    set(position: THREE.Vector3, target: THREE.Vector3, blendTime?: number): void;
     /**
      * Pauses or resumes rendering
      * @param value - True to pause rendering, false to resume
@@ -94,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
@@ -103,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 { IVimElement } from "../shared/vim";
+import { NodeState } from "./nodeState";
+import { Box3, RGBA32 } from "./rpcTypes";
+import { Vim } from "./vim";
+export declare class Element3D implements IVimElement {
+    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,9 +1,29 @@
 import "./style.css";
-export * from './viewer/viewer';
-export * as utils from './utils/promise';
-export * from './viewer/vim';
-export * from './utils/math3d';
-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 * 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;

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

@@ -0,0 +1,113 @@
+import { RpcSafeClient } from './rpcSafeClient';
+/**
+ * Represents the possible states a node can have in the UltraVim system.
+ */
+export declare enum NodeState {
+    VISIBLE = "visible",
+    HIDDEN = "hidden",
+    GHOSTED = "ghosted",
+    HIGHLIGHTED = "highlighted"
+}
+/**
+ * A class that wraps a StateTracker and is responsible for synchronizing its state updates with the remote RPCs.
+ * It batches updates to optimize performance and handles the communication with the remote system.
+ */
+export declare class StateSynchronizer {
+    private _tracker;
+    private _rpc;
+    private _getHandle;
+    private _onUpdate;
+    private _isConnected;
+    private _animationFrame;
+    /**
+     * Creates a new StateSynchronizer instance.
+     *
+     * @param rpc - The RPC client used to communicate with the remote system
+     * @param getHandle - Function that returns the current handle identifier
+     * @param isConnected - Function that returns whether the connection to the remote system is active
+     * @param onUpdate - Callback function invoked when updates are sent to the remote system
+     * @param defaultState - The default state for nodes when not explicitly set (defaults to VISIBLE)
+     */
+    constructor(rpc: RpcSafeClient, getHandle: () => number, isConnected: () => boolean, onUpdate: () => void, defaultState?: NodeState);
+    /**
+     * Checks if all nodes are in the specified state(s).
+     *
+     * @param state - A single state or array of states to check against
+     * @returns True if all nodes are in the specified state(s), false otherwise
+     */
+    areAllInState(state: NodeState | NodeState[]): boolean;
+    /**
+     * Gets the current state of a specific node.
+     *
+     * @param node - The node identifier
+     * @returns The current state of the node
+     */
+    getNodeState(node: number): NodeState;
+    /**
+     * Gets all nodes that are currently in the specified state.
+     *
+     * @param state - The state to query
+     * @returns Either 'all' if all nodes are in this state, or an array of node IDs
+     */
+    getNodesInState(state: NodeState): number[] | 'all';
+    /**
+     * Gets the default state used for nodes without explicit state settings.
+     *
+     * @returns The current default state
+     */
+    getDefaultState(): NodeState;
+    /**
+     * Sets the state of a specific node.
+     *
+     * @param nodeId - The identifier of the node
+     * @param state - The new state to apply
+     */
+    setNodeState(nodeId: number, state: NodeState): void;
+    /**
+     * Sets the state of all nodes to the specified value.
+     *
+     * @param state - The state to apply to all nodes
+     * @param clear - If true, clears all node-specific overrides
+     */
+    setAllNodesState(state: NodeState): void;
+    /**
+     * Replaces all nodes in one state (or states) with another state.
+     *
+     * @param fromState - The state(s) to replace
+     * @param toState - The new state to apply
+     */
+    replaceState(fromState: NodeState | NodeState[], toState: NodeState): void;
+    /**
+     * Reapplies all current state settings, useful after a reconnection.
+     * This will remove redundant overrides and ensure consistency.
+     */
+    reapplyStates(): void;
+    /**
+     * Schedules a synchronization on the next animation frame.
+     * This batches multiple rapid state changes to avoid excessive RPC calls.
+     *
+     * @private
+     */
+    private scheduleUpdate;
+    /**
+     * Processes all pending updates and sends them to the remote system.
+     *
+     * @private
+     */
+    private remoteUpdate;
+    /**
+     * Calls the appropriate RPC method to update the state of all nodes.
+     *
+     * @param state - The state to apply to all nodes
+     * @private
+     */
+    private callRPCForStateAll;
+    /**
+     * Calls the appropriate RPC method to update the state of specific nodes.
+     *
+     * @param state - The state to apply
+     * @param nodes - Array of node IDs to update
+     * @private
+     */
+    private callRPCForStateNodes;
+}

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

@@ -0,0 +1,52 @@
+import * as THREE from "three";
+import type { IRaycastResult, IRaycaster } from "../shared/raycaster";
+import { Element3D } from "./element3d";
+import { RpcSafeClient } from "./rpcSafeClient";
+import { IReadonlyVimCollection } from "./vimCollection";
+export type IUltraRaycastResult = IRaycastResult<Element3D>;
+export type IUltraRaycaster = IRaycaster<Element3D>;
+/**
+ * Represents the result of a hit test operation.
+ */
+export declare class UltraRaycastResult implements IRaycastResult<Element3D> {
+    /** The model Object hit */
+    object: Element3D;
+    /** The 3D world position of the hit point */
+    worldPosition: THREE.Vector3;
+    /** The surface normal at the hit point */
+    worldNormal: THREE.Vector3;
+    constructor(object: Element3D, worldPosition: THREE.Vector3, worldNormal: THREE.Vector3);
+}
+/**
+ * @module ultra-webgl-viewer
+ */
+/**
+ * Handles raycasting operations in the Ultra system, enabling picking and
+ * interaction with 3D objects in the scene.
+ */
+export declare class Raycaster implements IRaycaster<Element3D> {
+    private _rpc;
+    private _vims;
+    /**
+     * Creates a new UltraCoreRaycaster instance.
+     *
+     * @param {RpcSafeClient} rpc - RPC client for communication with the viewer.
+     * @param {IReadonlyVimCollection} vims - Collection of VIM instances to manage.
+     */
+    constructor(rpc: RpcSafeClient, vims: IReadonlyVimCollection);
+    /**
+     * Performs a raycast from the camera using normalized screen coordinates.
+     * Coordinates must be within [0, 1] for both x and y.
+     *
+     * @param {Vector2} position - The normalized screen position for raycasting.
+     * @returns {Promise<UltraRaycastResult | undefined>} Promise resolving to hit test result or undefined if no hit.
+     */
+    raycastFromScreen(position: THREE.Vector2): Promise<UltraRaycastResult>;
+    /**
+     * Performs a raycast from a specific world position towards a target.
+     *
+     * @param {Vector3} position - The target world position for raycasting.
+     * @returns {Promise<UltraRaycastResult | undefined>} Promise resolving to hit test result or undefined if no hit.
+     */
+    raycastFromWorld(position: THREE.Vector3): Promise<UltraRaycastResult | undefined>;
+}

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

@@ -1,10 +1,10 @@
-import { RGBA32 } from "../utils/math3d";
-import { ColorManager } from "./colorManager";
+import { RGBA32 } from './rpcTypes';
+import { ColorManager } from './colorManager';
 /**
  * Represents a handle to a color in the color management system.
  * This class provides access to color components and manages the lifecycle of color instances.
  */
-export declare class ColorHandle {
+export declare class RemoteColor {
     private _manager;
     /** Unique identifier for the color instance */
     readonly id: number;

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

@@ -1,6 +1,8 @@
-import { Box3, RGBA } from "../utils/math3d";
+import { ISignal } from "ste-signals";
+import * as THREE from "three";
 import { ILogger } from "./logger";
 import { RpcSafeClient, SceneSettings } from "./rpcSafeClient";
+import { RGBA } from "./rpcTypes";
 import { ClientStreamError } from "./socketClient";
 /**
  * Render settings that extend SceneSettings with additional rendering-specific properties
@@ -19,6 +21,7 @@ export declare const defaultRenderSettings: RenderSettings;
  * Interface defining the basic renderer capabilities
  */
 export interface IRenderer {
+    onSceneUpdated: ISignal;
     ghostColor: RGBA;
     lockIblRotation: boolean;
     hdrScale: number;
@@ -27,7 +30,7 @@ export interface IRenderer {
     hdrBackgroundSaturation: number;
     backgroundBlur: number;
     backgroundColor: RGBA;
-    getBoundingBox(): Promise<Box3 | undefined>;
+    getBoundingBox(): Promise<THREE.Box3 | undefined>;
 }
 /**
  * Renderer class that handles 3D scene rendering and settings management
@@ -40,6 +43,8 @@ export declare class Renderer implements IRenderer {
     private _updateLighting;
     private _updateGhostColor;
     private _updateIblRotation;
+    private readonly _onSceneUpdated;
+    get onSceneUpdated(): ISignal;
     /**
      * Creates a new Renderer instance
      * @param rpc - RPC client for communication with the rendering backend
@@ -56,6 +61,7 @@ export declare class Renderer implements IRenderer {
      * Sets up initial scene settings, ghost color, and IBL rotation
      */
     onConnect(): void;
+    notifySceneUpdated(): void;
     /**
      * Gets the ghost color used for transparent rendering
      * @returns Current ghost color as RGBA
@@ -136,7 +142,7 @@ export declare class Renderer implements IRenderer {
      * @param value - New background color as RGBA
      */
     set backgroundColor(value: RGBA);
-    getBoundingBox(): Promise<Box3 | undefined>;
+    getBoundingBox(): Promise<THREE.Box3 | undefined>;
     /**
      * Requests an update to be performed on the next animation frame.
      * Multiple setting changes will be batched into a single update.

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

@@ -1,6 +1,5 @@
 import type { SocketClient } from './socketClient';
-import { HitCheckResult, VimStatus, SectionBoxState } from './marshal';
-import { Box3, RGBA, RGBA32, Segment, Vector2, Vector3, Matrix44 } from '../utils/math3d';
+import * as RpcTypes from './rpcTypes';
 export type MaterialHandle = 4294967295 | 6 | 2 | 0 | 1 | 3 | 4 | 5 | 7 | 8;
 export declare class MaterialHandles {
     static readonly Invalid: MaterialHandle;
@@ -24,24 +23,24 @@ export declare class RpcClient {
     RPCAddNodeFlags(componentHandle: number, nodes: number[], flags: number): void;
     RPCClearMaterialOverrides(componentHandle: number): void;
     RPCClearScene(): void;
-    RPCCreateMaterialInstances(materialHandle: number, smoothness: number, colors: RGBA32[]): Promise<number>;
-    RPCCreateText(position: Vector3, color: RGBA32, text: string): Promise<number>;
+    RPCCreateMaterialInstances(materialHandle: number, smoothness: number, colors: RpcTypes.RGBA32[]): Promise<number>;
+    RPCCreateText(position: RpcTypes.Vector3, color: RpcTypes.RGBA32, text: string): Promise<number>;
     RPCDestroyMaterialInstances(materialInstanceHandle: number[]): void;
     RPCDestroyText(componentHandle: number): void;
     RPCEnableSectionBox(value: 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>;
+    RPCFrameAll(blendTime: number): Promise<RpcTypes.Segment>;
+    RPCFrameBox(box: RpcTypes.Box3, blendTime: number): Promise<RpcTypes.Segment>;
+    RPCFrameInstances(componentHandle: number, nodes: number[], blendTime: number): Promise<RpcTypes.Segment>;
+    RPCFrameVim(componentHandle: number, blendTime: number): Promise<RpcTypes.Segment>;
     RPCGetAPIVersion(): Promise<string>;
-    RPCGetBoundingBox(componentHandle: number, nodes: number[]): Promise<Box3>;
-    RPCGetBoundingBoxAll(componentHandle: number): Promise<Box3>;
-    RPCGetCameraPosition(): Promise<Segment>;
-    RPCGetIblRotation(): Promise<Matrix44>;
+    RPCGetBoundingBox(componentHandle: number, nodes: number[]): Promise<RpcTypes.Box3>;
+    RPCGetBoundingBoxAll(componentHandle: number): Promise<RpcTypes.Box3>;
+    RPCGetCameraPosition(): Promise<RpcTypes.Segment>;
+    RPCGetIblRotation(): Promise<RpcTypes.Matrix44>;
     RPCGetLastError(): Promise<string>;
-    RPCGetSceneAABB(): Promise<Box3>;
-    RPCGetSectionBox(): Promise<SectionBoxState>;
-    RPCGetVimLoadingState(componentHandle: number): Promise<VimStatus>;
+    RPCGetSceneAABB(): Promise<RpcTypes.Box3>;
+    RPCGetSectionBox(): Promise<RpcTypes.SectionBoxState>;
+    RPCGetVimLoadingState(componentHandle: number): Promise<RpcTypes.VimStatus>;
     RPCGhost(componentHandle: number, nodes: number[]): void;
     RPCGhostAll(componentHandle: number): void;
     RPCHide(componentHandle: number, nodes: number[]): void;
@@ -54,28 +53,28 @@ export declare class RpcClient {
     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;
+    RPCMouseButtonEvent(mousePos: RpcTypes.Vector2, mouseButton: number, down: boolean): void;
+    RPCMouseDoubleClickEvent(mousePos: RpcTypes.Vector2, mouseButton: number): void;
+    RPCMouseMoveEvent(mousePos: RpcTypes.Vector2): void;
     RPCMouseScrollEvent(scrollValue: number): void;
-    RPCMouseSelectEvent(mousePos: Vector2, mouseButton: number): void;
-    RPCMoveCameraTo(usePosition: boolean, useTarget: boolean, position: Vector3, target: Vector3, blendTime: number): void;
+    RPCMouseSelectEvent(mousePos: RpcTypes.Vector2, mouseButton: number): void;
+    RPCMoveCameraTo(usePosition: boolean, useTarget: boolean, position: RpcTypes.Vector3, target: RpcTypes.Vector3, blendTime: number): void;
     RPCPauseRendering(pause: boolean): void;
-    RPCPerformHitTest(pos: Vector2): Promise<HitCheckResult>;
+    RPCPerformHitTest(pos: RpcTypes.Vector2): Promise<RpcTypes.HitCheckResult>;
     RPCRemoveNodeFlags(componentHandle: number, nodes: number[], flags: number): void;
     RPCSetAspectRatio(width: number, height: number): void;
     RPCSetCameraMode(orbit: boolean): void;
-    RPCSetCameraPosition(state: Segment, blendTime: number): void;
-    RPCSetGhostColor(ghostColor: RGBA): void;
-    RPCSetIblRotation(transform: Matrix44): void;
-    RPCSetLighting(toneMappingWhitePoint: number, hdrScale: number, hdrBackgroundScale: number, hdrBackgroundSaturation: number, backgroundBlur: number, backgroundColor: RGBA): void;
+    RPCSetCameraPosition(state: RpcTypes.Segment, blendTime: number): void;
+    RPCSetGhostColor(ghostColor: RpcTypes.RGBA): void;
+    RPCSetIblRotation(transform: RpcTypes.Matrix44): void;
+    RPCSetLighting(toneMappingWhitePoint: number, hdrScale: number, hdrBackgroundScale: number, hdrBackgroundSaturation: number, backgroundBlur: number, backgroundColor: RpcTypes.RGBA): void;
     RPCSetMaterialOverrides(componentHandle: number, nodes: number[], materialInstanceHandles: number[]): void;
     RPCSetMoveSpeed(speed: number): void;
-    RPCSetSectionBox(state: SectionBoxState): void;
+    RPCSetSectionBox(state: RpcTypes.SectionBoxState): void;
     RPCShow(componentHandle: number, nodes: number[]): void;
-    RPCShowAABBs(componentHandle: number, nodes: number[], colors: RGBA32[]): void;
+    RPCShowAABBs(componentHandle: number, nodes: number[], colors: RpcTypes.RGBA32[]): void;
     RPCShowAll(componentHandle: number): void;
-    RPCStartScene(toneMappingWhitePoint: number, hdrScale: number, hdrBackgroundScale: number, hdrBackgroundSaturation: number, backgroundBlur: number, backgroundColor: RGBA): Promise<boolean>;
+    RPCStartScene(toneMappingWhitePoint: number, hdrScale: number, hdrBackgroundScale: number, hdrBackgroundSaturation: number, backgroundBlur: number, backgroundColor: RpcTypes.RGBA): Promise<boolean>;
     RPCTriggerRenderDocCapture(): void;
     RPCUnloadVim(componentHandle: number): void;
 }

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

@@ -0,0 +1,62 @@
+/**
+ * Don't modify this file, the RPC generated code depends on its interface.
+ */
+import * as RpcTypes from "./rpcTypes";
+export declare class Marshal {
+    private buffer;
+    private _dataView;
+    private _offset;
+    constructor(initialSize?: number);
+    getBuffer(): ArrayBuffer;
+    private ensureCapacity;
+    writeData(data: ArrayBuffer): void;
+    writeMatrix44(data: RpcTypes.Matrix44): void;
+    writeBoolean(value: boolean): void;
+    writeInt(value: number): void;
+    writeUInt(value: number): void;
+    writeFloat(value: number): void;
+    writeString(value: string): void;
+    writeHitCheckResult(data: RpcTypes.HitCheckResult): void;
+    writeVimStatus(data: RpcTypes.VimStatus): void;
+    writeVector2(data: RpcTypes.Vector2): void;
+    writeVector3(data: RpcTypes.Vector3): void;
+    writeRGBA(color: RpcTypes.RGBA): void;
+    writeRGB(color: RpcTypes.RGB): void;
+    writeRGBA32(color: RpcTypes.RGBA32): void;
+    writeSegment(segment: RpcTypes.Segment): void;
+    writeBox3(data: RpcTypes.Box3): void;
+    writeSectionBoxState(data: RpcTypes.SectionBoxState): void;
+    writeArrayOfInt(values: number[]): void;
+    writeArrayOfUInt(values: number[]): void;
+    writeArrayOfFloat(values: number[]): void;
+    writeArrayOfBool(values: boolean[]): void;
+    writeArrayOfRGBA32(values: RpcTypes.RGBA32[]): void;
+    writeArray<T>(data: T[], sizeT: number, write: (data: T) => void): void;
+}
+export declare class ReadMarshal {
+    private _dataView;
+    private _offset;
+    constructor(buffer: ArrayBuffer);
+    readMatrix44(): RpcTypes.Matrix44;
+    readInt(): number;
+    readUInt(): number;
+    readFloat(): number;
+    readBoolean(): boolean;
+    readString(): string;
+    readHitCheckResult(): RpcTypes.HitCheckResult;
+    readVimStatus(): RpcTypes.VimStatus;
+    readVector2(): RpcTypes.Vector2;
+    readVector3(): RpcTypes.Vector3;
+    readRGBA(): RpcTypes.RGBA;
+    readRGB(): RpcTypes.RGB;
+    readRGBA32(): RpcTypes.RGBA32;
+    readBox3(): RpcTypes.Box3;
+    readSegment(): RpcTypes.Segment;
+    readSectionBoxState(): RpcTypes.SectionBoxState;
+    readArrayOfInt(): number[];
+    readArrayOfUInt(): number[];
+    readArrayOfFloat(): number[];
+    readArrayOfBool(): boolean[];
+    readArrayOfRGBA32(): RpcTypes.RGBA32[];
+    readArray<T>(read: () => T): T[];
+}