vim-web 0.5.0-dev.7 → 0.5.0-dev.9

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

@@ -24,11 +24,11 @@ export declare class ColorManager {
     getColor(color: THREE.Color): Promise<RemoteColor | undefined>;
     /**
      * Creates or retrieves cached color instances for multiple hex values.
-     * @param colors - 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(colors: THREE.Color[]): 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/core-viewers/ultra/rpcClient.d.ts

@@ -32,7 +32,9 @@ export declare class RpcClient {
     get url(): string;
     constructor(_socket: SocketClient);
     readonly API_VERSION = "6.0.0";
-    RPCClearMaterialOverrides(): 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(materialInstanceHandles: number[]): void;
@@ -46,7 +48,7 @@ export declare class RpcClient {
     RPCGetAABBForScene(): Promise<RpcTypes.Box3>;
     RPCGetAABBForVim(vimIndex: number): Promise<RpcTypes.Box3>;
     RPCGetAPIVersion(): Promise<string>;
-    RPCGetCameraView(): Promise<RpcTypes.Segment>;
+    RPCGetCameraPose(): Promise<RpcTypes.Segment>;
     RPCGetElementCountForScene(): Promise<number>;
     RPCGetElementCountForVim(vimIndex: number): Promise<number>;
     RPCGetElementIds(vimIndex: number): Promise<bigint[]>;
@@ -66,10 +68,10 @@ 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;
     RPCSetMaterialOverridesForElements(vimIndex: number, elementIndices: number[], materialInstanceHandles: number[]): void;

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

@@ -426,7 +426,18 @@ export declare class RpcSafeClient {
     /**
      * Clears all material overrides for the entire scene.
      */
-    RPCClearMaterialOverrides(): void;
+    RPCClearMaterialOverridesForScene(): void;
+    /**
+     * Clears all material overrides for a specific loaded vim.
+     * @param vimIndex - The index of the loaded vim
+     */
+    RPCClearMaterialOverridesForVim(vimIndex: number): void;
+    /**
+     * Clears all material overrides for specific elements in a loaded vim.
+     * @param vimIndex - The index of the loaded vim
+     * @param vimElementIndices - Array of vim-based element indices to clear overrides for
+     */
+    RPCClearMaterialOverridesForElements(vimIndex: number, vimElementIndices: number[]): void;
     /*******************************************************************************
      * DEBUG AND UTILITY METHODS
      * Utility methods for debugging, error handling, and misc functionality.

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

@@ -38,7 +38,7 @@ export declare class Vim implements IVim<Element3D> {
     getBoundingBox(): Promise<THREE.Box3 | undefined>;
     getColor(elementIndex: number): THREE.Color | undefined;
     setColor(elementIndex: number[], color: THREE.Color | undefined): Promise<void>;
-    setColors(nodes: number[], color: (THREE.Color | undefined)[]): Promise<void>;
+    setColors(elements: number[], color: (THREE.Color | undefined)[]): Promise<void>;
     private applyColor;
     clearColor(elements: number[] | 'all'): void;
     reapplyColors(): void;

package/dist/vim-web.iife.js

@@ -57943,9 +57943,22 @@ void main() {
     get url() {
       return this._socket.url;
     }
-    RPCClearMaterialOverrides() {
+    RPCClearMaterialOverridesForElements(vimIndex, elementIndices) {
       const marshal = new Marshal();
-      marshal.writeString("RPCClearMaterialOverrides");
+      marshal.writeString("RPCClearMaterialOverridesForElements");
+      marshal.writeUInt(vimIndex);
+      marshal.writeArrayOfUInt(elementIndices);
+      this._socket.sendRPC(marshal);
+    }
+    RPCClearMaterialOverridesForScene() {
+      const marshal = new Marshal();
+      marshal.writeString("RPCClearMaterialOverridesForScene");
+      this._socket.sendRPC(marshal);
+    }
+    RPCClearMaterialOverridesForVim(vimIndex) {
+      const marshal = new Marshal();
+      marshal.writeString("RPCClearMaterialOverridesForVim");
+      marshal.writeUInt(vimIndex);
       this._socket.sendRPC(marshal);
     }
     async RPCCreateMaterialInstances(materialHandle, smoothness, colors) {
@@ -58053,9 +58066,9 @@ void main() {
       const ret = returnMarshal.readString();
       return ret;
     }
-    async RPCGetCameraView() {
+    async RPCGetCameraPose() {
       const marshal = new Marshal();
-      marshal.writeString("RPCGetCameraView");
+      marshal.writeString("RPCGetCameraPose");
       const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readSegment();
       return ret;
@@ -58198,6 +58211,13 @@ void main() {
       marshal.writeBoolean(orbit2);
       this._socket.sendRPC(marshal);
     }
+    RPCSetCameraPose(state, blendTime) {
+      const marshal = new Marshal();
+      marshal.writeString("RPCSetCameraPose");
+      marshal.writeSegment(state);
+      marshal.writeFloat(blendTime);
+      this._socket.sendRPC(marshal);
+    }
     RPCSetCameraPosition(position, blendTime) {
       const marshal = new Marshal();
       marshal.writeString("RPCSetCameraPosition");
@@ -58218,13 +58238,6 @@ void main() {
       marshal.writeFloat(blendTime);
       this._socket.sendRPC(marshal);
     }
-    RPCSetCameraView(state, blendTime) {
-      const marshal = new Marshal();
-      marshal.writeString("RPCSetCameraView");
-      marshal.writeSegment(state);
-      marshal.writeFloat(blendTime);
-      this._socket.sendRPC(marshal);
-    }
     RPCSetGhostColor(ghostColor) {
       const marshal = new Marshal();
       marshal.writeString("RPCSetGhostColor");
@@ -58384,7 +58397,7 @@ void main() {
     }
     /**
      * Creates or retrieves cached color instances for multiple hex values.
-     * @param colors - 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
      */
@@ -58394,15 +58407,23 @@ void main() {
       const toCreate = [];
       for (let i2 = 0; i2 < colors.length; i2++) {
         const color = colors[i2];
-        const hex = color.getHex();
-        if (this._hexToColor.has(hex)) {
-          result[i2] = this._hexToColor.get(hex);
-        } else if (hexToIndices.has(hex)) {
+        if (color === void 0) {
+          result[i2] = void 0;
+          continue;
+        }
+        const hex = (color == null ? void 0 : color.getHex()) ?? -1;
+        const remoteColor = this._hexToColor.get(hex);
+        if (remoteColor) {
+          result[i2] = remoteColor;
+          continue;
+        }
+        const indices = hexToIndices.get(hex);
+        if (indices) {
           hexToIndices.get(hex).push(i2);
-        } else {
-          toCreate.push(color);
-          hexToIndices.set(hex, [i2]);
+          continue;
         }
+        toCreate.push(color);
+        hexToIndices.set(hex, [i2]);
       }
       const remoteColors = await this._createColors(toCreate);
       if (!remoteColors) return void 0;
@@ -59286,7 +59307,7 @@ void main() {
      */
     async RPCGetCameraView() {
       return await this.safeCall(
-        () => this.rpc.RPCGetCameraView(),
+        () => this.rpc.RPCGetCameraPose(),
         void 0
       );
     }
@@ -59298,7 +59319,7 @@ void main() {
     RPCSetCameraView(segment, blendTime) {
       if (!Validation.isValidSegment(segment)) return;
       blendTime = Validation.clamp01(blendTime);
-      this.rpc.RPCSetCameraView(segment, blendTime);
+      this.rpc.RPCSetCameraPose(segment, blendTime);
     }
     /**
      * Sets the camera's position without changing its target.
@@ -59680,8 +59701,23 @@ void main() {
     /**
      * Clears all material overrides for the entire scene.
      */
-    RPCClearMaterialOverrides() {
-      this.rpc.RPCClearMaterialOverrides();
+    RPCClearMaterialOverridesForScene() {
+      this.rpc.RPCClearMaterialOverridesForScene();
+    }
+    /**
+     * Clears all material overrides for a specific loaded vim.
+     * @param vimIndex - The index of the loaded vim
+     */
+    RPCClearMaterialOverridesForVim(vimIndex) {
+      this.rpc.RPCClearMaterialOverridesForVim(vimIndex);
+    }
+    /**
+     * Clears all material overrides for specific elements in a loaded vim.
+     * @param vimIndex - The index of the loaded vim
+     * @param vimElementIndices - Array of vim-based element indices to clear overrides for
+     */
+    RPCClearMaterialOverridesForElements(vimIndex, vimElementIndices) {
+      this.rpc.RPCClearMaterialOverridesForElements(vimIndex, vimElementIndices);
     }
     /*******************************************************************************
      * DEBUG AND UTILITY METHODS
@@ -61034,25 +61070,26 @@ Averrage Date/Second ${avgDataRatePS} kb
       const colors = new Array(elementIndex.length).fill(color);
       this.applyColor(elementIndex, colors);
     }
-    async setColors(nodes, color) {
-      if (color.length !== nodes.length) {
-        throw new Error("Color and nodes length must be equal");
+    async setColors(elements, color) {
+      if (color.length !== elements.length) {
+        throw new Error("Color and elements length must be equal");
       }
-      this.applyColor(nodes, color);
+      this.applyColor(elements, color);
     }
-    applyColor(nodes, color) {
+    applyColor(elements, color) {
       for (let i2 = 0; i2 < color.length; i2++) {
         const c = color[i2];
-        const n = nodes[i2];
+        const element = elements[i2];
         if (c === void 0) {
-          this._elementColors.delete(n);
+          this._elementColors.delete(element);
         } else {
-          this._elementColors.set(n, c);
+          this._elementColors.set(element, c);
         }
-        this._updatedColors.add(n);
+        this._updatedColors.add(element);
       }
       this.scheduleColorUpdate();
     }
+    //TODO: Remove and rely on element.color
     clearColor(elements) {
       if (elements === "all") {
         this._elementColors.clear();
@@ -61061,10 +61098,9 @@ Averrage Date/Second ${avgDataRatePS} kb
       }
       if (!this.connected) return;
       if (elements === "all") {
-        this._rpc.RPCClearMaterialOverrides();
+        this._rpc.RPCClearMaterialOverridesForVim(this._handle);
       } else {
-        const ids = new Array(elements.length).fill(MaterialHandles.Invalid);
-        this._rpc.RPCSetMaterialOverridesForElements(this._handle, elements, ids);
+        this._rpc.RPCClearMaterialOverridesForElements(this._handle, elements);
       }
     }
     reapplyColors() {
@@ -61085,11 +61121,11 @@ Averrage Date/Second ${avgDataRatePS} kb
       this._renderer.notifySceneUpdated();
     }
     async updateRemoteColors() {
-      const nodes = Array.from(this._updatedColors);
-      const colors = nodes.map((n) => this._elementColors.get(n));
+      const elements = Array.from(this._updatedColors);
+      const colors = elements.map((n) => this._elementColors.get(n));
       const remoteColors = await this._colors.getColors(colors);
       const colorIds = remoteColors.map((c) => (c == null ? void 0 : c.id) ?? -1);
-      this._rpc.RPCSetMaterialOverridesForElements(this._handle, nodes, colorIds);
+      this._rpc.RPCSetMaterialOverridesForElements(this._handle, elements, colorIds);
       this._updatedColors.clear();
     }
   }