vim-web 0.5.0-dev.0 → 0.5.0-dev.10

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

@@ -107,10 +107,10 @@ export declare class Camera implements ICamera {
     /**
      * Frames specific nodes of a Vim model in the camera view
      * @param vim - The Vim model containing the nodes to frame
-     * @param nodes - Array of node indices to frame, or 'all' to frame the entire model
+     * @param elements - Array of element indices to frame, or 'all' to frame the entire model
      * @param blendTime - Duration of the camera animation in seconds (defaults to 0.5)
      * @returns Promise that resolves when the framing animation is complete
      */
-    frameVim(vim: Vim, nodes: number[] | 'all', blendTime?: number): Promise<Segment | undefined>;
+    frameVim(vim: Vim, elements: number[] | 'all', blendTime?: number): Promise<Segment | undefined>;
     frameObject(object: Element3D, blendTime?: number): Promise<Segment | undefined>;
 }

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

@@ -1,6 +1,6 @@
 import { RpcSafeClient } from './rpcSafeClient';
 import { RemoteColor } from './remoteColor';
-import { RGBA32 } from './rpcTypes';
+import * as THREE from 'three';
 /**
  * Manages the creation, caching, and deletion of color instances.
  * Handles batched deletion of colors to optimize RPC calls.
@@ -21,14 +21,14 @@ 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<RemoteColor | undefined>;
+    getColor(color: THREE.Color): Promise<RemoteColor | undefined>;
     /**
      * Creates or retrieves cached color instances for multiple hex values.
-     * @param c - Array of RGBA32 color values
+     * @param colors - Array of color values or undefined for no color
      * @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<RemoteColor[]>;
+    getColors(colors: (THREE.Color | undefined)[]): Promise<RemoteColor[]>;
     /**
      * Retrieves a color instance by its unique identifier.
      * @param id - The unique identifier of the color

package/dist/types/{vim-web/core-viewers → core-viewers}/ultra/element3d.d.ts

@@ -1,7 +1,7 @@
 import { IVimElement } from "../shared/vim";
 import { VisibilityState } from "./visibility";
-import { Box3, RGBA32 } from "./rpcTypes";
 import { Vim } from "./vim";
+import * as THREE from "three";
 /**
  * Represents a single 3D element within a `Vim` model.
  * Provides access to per-instance state, color, and bounding box.
@@ -33,12 +33,12 @@ export declare class Element3D implements IVimElement {
     /**
      * Gets or sets the color override of the element.
      */
-    get color(): RGBA32 | undefined;
-    set color(color: RGBA32 | undefined);
+    get color(): THREE.Color | undefined;
+    set color(color: THREE.Color | undefined);
     /**
      * Computes and returns the bounding box of the element.
      * Returns undefined if the element is abstract.
      * @returns A promise resolving to the element's bounding box.
      */
-    getBoundingBox(): Promise<Box3 | undefined>;
+    getBoundingBox(): Promise<THREE.Box3 | undefined>;
 }

package/dist/types/{vim-web/core-viewers → core-viewers}/ultra/index.d.ts

@@ -1,6 +1,6 @@
 import "./style.css";
 export * from './viewer';
-export { RGB, RGBA, RGBA32, Segment, type SectionBoxState, type HitCheckResult, type VimStatus } from './rpcTypes';
+export { Segment, type SectionBoxState, type HitCheckResult, type VimStatus } from './rpcTypes';
 export { materialHandles, MaterialHandles, type MaterialHandle, } from './rpcClient';
 export { InputMode, VimLoadingStatus } from './rpcSafeClient';
 export { VisibilityState } from './visibility';

package/dist/types/{vim-web/core-viewers → core-viewers}/ultra/remoteColor.d.ts

@@ -1,5 +1,5 @@
-import { RGBA32 } from './rpcTypes';
 import { ColorManager } from './colorManager';
+import * as THREE from 'three';
 /**
  * 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.
@@ -9,7 +9,7 @@ export declare class RemoteColor {
     /** Unique identifier for the color instance */
     readonly id: number;
     /** The RGBA color value */
-    readonly color: RGBA32;
+    readonly color: THREE.Color;
     private _disposed;
     /**
      * Indicates whether the color handle has been disposed.
@@ -21,33 +21,13 @@ export declare class RemoteColor {
      * @returns {number} The color value as a hexadecimal number.
      */
     get hex(): number;
-    /**
-     * Gets the red component of the color.
-     * @returns {number} The red component value in the range [0-255].
-     */
-    get r(): number;
-    /**
-     * Gets the green component of the color.
-     * @returns {number} The green component value in the range [0-255].
-     */
-    get g(): number;
-    /**
-     * Gets the blue component of the color.
-     * @returns {number} The blue component value in the range [0-255].
-     */
-    get b(): number;
-    /**
-     * Gets the alpha (opacity) component of the color.
-     * @returns {number} The alpha component value in the range [0-255].
-     */
-    get a(): number;
     /**
      * Creates a new ColorHandle instance.
      * @param {RGBA32} color - The RGBA color value.
      * @param {number} serverId - The unique identifier assigned by the server.
      * @param {ColorManager} manager - The color manager instance that manages this color handle.
      */
-    constructor(color: RGBA32, serverId: number, manager: ColorManager);
+    constructor(color: THREE.Color, serverId: number, manager: ColorManager);
     /**
      * Disposes of the color handle and releases associated resources.
      * Once disposed, the color handle cannot be used anymore.

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

@@ -2,14 +2,14 @@ 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
  */
 export type RenderSettings = SceneSettings & {
     /** Color used for ghost/transparent rendering */
-    ghostColor: RGBA;
+    ghostColor: THREE.Color;
+    ghostOpacity: number;
 };
 /**
  * Default rendering settings
@@ -20,13 +20,14 @@ export declare const defaultRenderSettings: RenderSettings;
  */
 export interface IRenderer {
     onSceneUpdated: ISignal;
-    ghostColor: RGBA;
+    ghostColor: THREE.Color;
+    ghostOpacity: number;
     hdrScale: number;
     toneMappingWhitePoint: number;
     hdrBackgroundScale: number;
     hdrBackgroundSaturation: number;
     backgroundBlur: number;
-    backgroundColor: RGBA;
+    backgroundColor: THREE.Color;
     getBoundingBox(): Promise<THREE.Box3 | undefined>;
 }
 /**
@@ -60,9 +61,10 @@ export declare class Renderer implements IRenderer {
     notifySceneUpdated(): void;
     /**
      * Gets the ghost color used for transparent rendering
-     * @returns Current ghost color as RGBA
+     * @returns Current ghost color as a THREE.Color
      */
-    get ghostColor(): RGBA;
+    get ghostColor(): THREE.Color;
+    get ghostOpacity(): number;
     /**
      * Gets the tone mapping white point value
      * @returns Current tone mapping white point
@@ -92,12 +94,13 @@ export declare class Renderer implements IRenderer {
      * Gets the background color
      * @returns Current background color as RGBA
      */
-    get backgroundColor(): RGBA;
+    get backgroundColor(): THREE.Color;
     /**
      * Updates the ghost color used for transparent rendering
-     * @param value - New ghost color as RGBA
+     * @param value - New ghost color as THREE.Color
      */
-    set ghostColor(value: RGBA);
+    set ghostColor(value: THREE.Color);
+    set ghostOpacity(value: number);
     /**
      * Sets the tone mapping white point value
      * @param value - New tone mapping white point value
@@ -125,9 +128,9 @@ export declare class Renderer implements IRenderer {
     set backgroundBlur(value: number);
     /**
      * Sets the background color
-     * @param value - New background color as RGBA
+     * @param value - New background color as THREE.Color
      */
-    set backgroundColor(value: RGBA);
+    set backgroundColor(value: THREE.Color);
     getBoundingBox(): Promise<THREE.Box3 | undefined>;
     /**
      * Requests an update to be performed on the next animation frame.

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

@@ -32,27 +32,30 @@ export declare class RpcClient {
     get url(): string;
     constructor(_socket: SocketClient);
     readonly API_VERSION = "6.0.0";
-    RPCClearMaterialOverrides(componentHandle: number): void;
+    RPCClearMaterialOverridesForElements(vimIndex: number, elementIndices: number[]): void;
+    RPCClearMaterialOverridesForScene(): void;
+    RPCClearMaterialOverridesForVim(vimIndex: number): void;
     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;
+    RPCDestroyMaterialInstances(materialInstanceHandles: number[]): void;
     RPCDestroyText(componentHandle: number): void;
     RPCEnableSectionBox(value: boolean): void;
     RPCFrameAABB(box: RpcTypes.Box3, blendTime: number): Promise<RpcTypes.Segment>;
-    RPCFrameAll(blendTime: number): Promise<RpcTypes.Segment>;
-    RPCFrameElements(componentHandle: number, elementIndices: number[], blendTime: number): Promise<RpcTypes.Segment>;
-    RPCFrameVim(componentHandle: number, blendTime: number): Promise<RpcTypes.Segment>;
-    RPCGetAABBForAll(): Promise<RpcTypes.Box3>;
-    RPCGetAABBForElements(componentHandle: number, elementIndices: number[]): Promise<RpcTypes.Box3>;
-    RPCGetAABBForVim(componentHandle: number): Promise<RpcTypes.Box3>;
+    RPCFrameElements(vimIndex: number, elementIndices: number[], blendTime: number): Promise<RpcTypes.Segment>;
+    RPCFrameScene(blendTime: number): Promise<RpcTypes.Segment>;
+    RPCFrameVim(vimIndex: number, blendTime: number): Promise<RpcTypes.Segment>;
+    RPCGetAABBForElements(vimIndex: number, elementIndices: number[]): Promise<RpcTypes.Box3>;
+    RPCGetAABBForScene(): Promise<RpcTypes.Box3>;
+    RPCGetAABBForVim(vimIndex: number): Promise<RpcTypes.Box3>;
     RPCGetAPIVersion(): Promise<string>;
-    RPCGetCameraView(): Promise<RpcTypes.Segment>;
-    RPCGetElementCount(componentHandle: number): Promise<number>;
-    RPCGetElementIds(componentHandle: number): Promise<bigint[]>;
+    RPCGetCameraPose(): Promise<RpcTypes.Segment>;
+    RPCGetElementCountForScene(): Promise<number>;
+    RPCGetElementCountForVim(vimIndex: number): Promise<number>;
+    RPCGetElementIds(vimIndex: number): Promise<bigint[]>;
     RPCGetLastError(): Promise<string>;
-    RPCGetRoomElements(componentHandle: number): Promise<number[]>;
+    RPCGetRoomElements(vimIndex: number): Promise<number[]>;
     RPCGetSectionBox(): Promise<RpcTypes.SectionBoxState>;
-    RPCGetVimLoadingState(componentHandle: number): Promise<RpcTypes.VimStatus>;
+    RPCGetVimLoadingState(vimIndex: number): Promise<RpcTypes.VimStatus>;
     RPCKeyEvent(keyCode: number, down: boolean): void;
     RPCLoadVim(fileName: string): Promise<number>;
     RPCLoadVimURL(url: string, authToken: string): Promise<number>;
@@ -65,19 +68,19 @@ export declare class RpcClient {
     RPCPerformHitTest(pos: RpcTypes.Vector2): Promise<RpcTypes.HitCheckResult>;
     RPCSetCameraAspectRatio(width: number, height: number): void;
     RPCSetCameraMode(orbit: boolean): void;
+    RPCSetCameraPose(state: RpcTypes.Segment, blendTime: number): void;
     RPCSetCameraPosition(position: RpcTypes.Vector3, blendTime: number): void;
     RPCSetCameraSpeed(speed: number): void;
     RPCSetCameraTarget(target: RpcTypes.Vector3, blendTime: number): void;
-    RPCSetCameraView(state: RpcTypes.Segment, blendTime: number): void;
     RPCSetGhostColor(ghostColor: RpcTypes.RGBA): void;
     RPCSetLighting(toneMappingWhitePoint: number, hdrScale: number, hdrBackgroundScale: number, hdrBackgroundSaturation: number, backgroundBlur: number, backgroundColor: RpcTypes.RGBA): void;
-    RPCSetMaterialOverrides(componentHandle: number, elementIndices: number[], materialInstanceHandles: number[]): void;
+    RPCSetMaterialOverridesForElements(vimIndex: number, elementIndices: number[], materialInstanceHandles: number[]): void;
     RPCSetSectionBox(state: RpcTypes.SectionBoxState): void;
-    RPCSetStateVim(componentHandle: number, state: number): void;
-    RPCSetStateElements(componentHandle: number, elementIndices: number[], state: number): void;
-    RPCSetStatesElements(componentHandle: number, elementIndices: number[], states: number[]): void;
+    RPCSetStateElements(vimIndex: number, elementIndices: number[], state: number): void;
+    RPCSetStateScene(state: number): void;
+    RPCSetStateVim(vimIndex: number, state: number): void;
+    RPCSetStatesElements(vimIndex: number, elementIndices: number[], states: number[]): void;
     RPCStartScene(toneMappingWhitePoint: number, hdrScale: number, hdrBackgroundScale: number, hdrBackgroundSaturation: number, backgroundBlur: number, backgroundColor: RpcTypes.RGBA): Promise<boolean>;
     RPCTriggerRenderDocCapture(): void;
     RPCUnloadAll(): void;
-    RPCUnloadVim(componentHandle: number): void;
 }