vim-web 0.5.0-dev.1 → 0.5.0-dev.3

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/rpcClient.d.ts

@@ -32,7 +32,7 @@ export declare class RpcClient {
     get url(): string;
     constructor(_socket: SocketClient);
     readonly API_VERSION = "6.0.0";
-    RPCClearMaterialOverrides(componentHandle: number): void;
+    RPCClearMaterialOverrides(): 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;
@@ -47,7 +47,8 @@ export declare class RpcClient {
     RPCGetAABBForVim(componentHandle: number): Promise<RpcTypes.Box3>;
     RPCGetAPIVersion(): Promise<string>;
     RPCGetCameraView(): Promise<RpcTypes.Segment>;
-    RPCGetElementCount(componentHandle: number): Promise<number>;
+    RpcGetElementCountForScene(): Promise<number>;
+    RpcGetElementCountForVim(vimIndex: number): Promise<number>;
     RPCGetElementIds(componentHandle: number): Promise<bigint[]>;
     RPCGetLastError(): Promise<string>;
     RPCGetRoomElements(componentHandle: number): Promise<number[]>;
@@ -73,8 +74,9 @@ export declare class RpcClient {
     RPCSetLighting(toneMappingWhitePoint: number, hdrScale: number, hdrBackgroundScale: number, hdrBackgroundSaturation: number, backgroundBlur: number, backgroundColor: RpcTypes.RGBA): void;
     RPCSetMaterialOverrides(componentHandle: 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;
+    RPCSetStateScene(state: number): void;
+    RPCSetStateVim(componentHandle: number, state: number): void;
     RPCSetStatesElements(componentHandle: number, elementIndices: number[], states: number[]): void;
     RPCStartScene(toneMappingWhitePoint: number, hdrScale: number, hdrBackgroundScale: number, hdrBackgroundSaturation: number, backgroundBlur: number, backgroundColor: RpcTypes.RGBA): Promise<boolean>;
     RPCTriggerRenderDocCapture(): void;

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

@@ -56,6 +56,8 @@ export declare class RpcSafeClient {
      * @param settings - The lighting settings to apply
      */
     RPCSetLighting(settings: SceneSettings): void;
+    RpcGetElementCountForScene(): Promise<number>;
+    RpcGetElementCountForVim(vimIndex: number): Promise<number>;
     /*******************************************************************************
      * NODE VISIBILITY METHODS
      * Methods for controlling node visibility, including show/hide, ghosting,
@@ -322,7 +324,7 @@ export declare class RpcSafeClient {
      * @param componentHandle - The unique identifier of the component
      * @throws {Error} If the component handle is invalid or INVALID_HANDLE
      */
-    RPCClearMaterialOverrides(componentHandle: number): void;
+    RPCClearMaterialOverrides(): void;
     /*******************************************************************************
      * DEBUG AND UTILITY METHODS
      * Utility methods for debugging, error handling, and misc functionality.

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

@@ -50,9 +50,9 @@ export declare class RGBA32 {
     get a(): number;
 }
 export type HitCheckResult = {
-    vimHandle: number;
-    nodeIndex: number;
-    elementIndex: number;
+    vimIndex: number;
+    vimElementIndex: number;
+    sceneElementIndex: number;
     worldPosition: THREE.Vector3;
     worldNormal: THREE.Vector3;
 };

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

@@ -126,6 +126,7 @@ export declare class Viewer {
      * Clears all loaded VIMs from the viewer.
      */
     clearVims(): void;
+    getElement3Ds(): Promise<number>;
     /**
      * Disposes all resources used by the viewer and disconnects from the server.
      */

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

@@ -20,6 +20,7 @@ export declare class Vim implements IVim<Element3D> {
     private _nodeColors;
     private _updatedColors;
     private _updateScheduled;
+    private _elementCount;
     private _objects;
     constructor(rpc: RpcSafeClient, color: ColorManager, renderer: Renderer, source: VimSource, logger: ILogger);
     getElement(elementIndex: number): Element3D;
@@ -40,7 +41,7 @@ export declare class Vim implements IVim<Element3D> {
     setColor(nodes: number[], color: RGBA32 | undefined): Promise<void>;
     setColors(nodes: number[], color: (RGBA32 | undefined)[]): Promise<void>;
     private applyColor;
-    clearColor(nodes: number[] | 'all'): void;
+    clearColor(elements: number[] | 'all'): void;
     reapplyColors(): void;
     private scheduleColorUpdate;
     private updateRemote;

package/dist/vim-web.iife.js

@@ -57562,16 +57562,16 @@ void main() {
     /**
      * 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
      */
-    async frameVim(vim, nodes, blendTime = this._defaultBlendTime) {
+    async frameVim(vim, elements, blendTime = this._defaultBlendTime) {
       let segment;
-      if (nodes === "all") {
+      if (elements === "all") {
         segment = await this._rpc.RPCFrameVim(vim.handle, blendTime);
       } else {
-        segment = await this._rpc.RPCFrameElements(vim.handle, nodes, blendTime);
+        segment = await this._rpc.RPCFrameElements(vim.handle, elements, blendTime);
       }
       this._savedPosition = this._savedPosition ?? segment;
       return segment;
@@ -57654,9 +57654,9 @@ void main() {
     // -------------------- HitCheckResult -------------------
     writeHitCheckResult(data2) {
       this.ensureCapacity(4 + 4 + 4 + 4 * 3 + 4 * 3);
-      this.writeUInt(data2.vimHandle);
-      this.writeUInt(data2.nodeIndex);
-      this.writeUInt(data2.elementIndex);
+      this.writeUInt(data2.vimIndex);
+      this.writeUInt(data2.vimElementIndex);
+      this.writeUInt(data2.sceneElementIndex);
       this.writeVector3(data2.worldPosition);
       this.writeVector3(data2.worldNormal);
     }
@@ -57804,15 +57804,15 @@ void main() {
       return textDecoder.decode(stringData);
     }
     readHitCheckResult() {
-      const vimHandle = this.readUInt();
-      const nodeIndex = this.readUInt();
-      const mElementIndex = this.readUInt();
+      const vimIndex = this.readUInt();
+      const vimElementIndex = this.readUInt();
+      const sceneElementIndex = this.readUInt();
       const worldPosition = this.readVector3();
       const worldNormal = this.readVector3();
       return {
-        vimHandle,
-        nodeIndex,
-        elementIndex: mElementIndex,
+        vimIndex,
+        vimElementIndex,
+        sceneElementIndex,
         worldPosition,
         worldNormal
       };
@@ -57944,10 +57944,9 @@ void main() {
     get url() {
       return this._socket.url;
     }
-    RPCClearMaterialOverrides(componentHandle) {
+    RPCClearMaterialOverrides() {
       const marshal = new Marshal();
       marshal.writeString("RPCClearMaterialOverrides");
-      marshal.writeUInt(componentHandle);
       this._socket.sendRPC(marshal);
     }
     async RPCCreateMaterialInstances(materialHandle, smoothness, colors) {
@@ -58062,10 +58061,17 @@ void main() {
       const ret = returnMarshal.readSegment();
       return ret;
     }
-    async RPCGetElementCount(componentHandle) {
+    async RpcGetElementCountForScene() {
       const marshal = new Marshal();
-      marshal.writeString("RPCGetElementCount");
-      marshal.writeUInt(componentHandle);
+      marshal.writeString("RpcGetElementCountForScene");
+      const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
+      const ret = returnMarshal.readUInt();
+      return ret;
+    }
+    async RpcGetElementCountForVim(vimIndex) {
+      const marshal = new Marshal();
+      marshal.writeString("RpcGetElementCountForVim");
+      marshal.writeUInt(vimIndex);
       const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readUInt();
       return ret;
@@ -58251,18 +58257,24 @@ void main() {
       marshal.writeSectionBoxState(state);
       this._socket.sendRPC(marshal);
     }
-    RPCSetStateVim(componentHandle, state) {
+    RPCSetStateElements(componentHandle, elementIndices, state) {
       const marshal = new Marshal();
-      marshal.writeString("RPCSetStateVim");
+      marshal.writeString("RPCSetStateElements");
       marshal.writeUInt(componentHandle);
+      marshal.writeArrayOfUInt(elementIndices);
       marshal.writeUInt(state);
       this._socket.sendRPC(marshal);
     }
-    RPCSetStateElements(componentHandle, elementIndices, state) {
+    RPCSetStateScene(state) {
       const marshal = new Marshal();
-      marshal.writeString("RPCSetStateElements");
+      marshal.writeString("RPCSetStateScene");
+      marshal.writeUInt(state);
+      this._socket.sendRPC(marshal);
+    }
+    RPCSetStateVim(componentHandle, state) {
+      const marshal = new Marshal();
+      marshal.writeString("RPCSetStateVim");
       marshal.writeUInt(componentHandle);
-      marshal.writeArrayOfUInt(elementIndices);
       marshal.writeUInt(state);
       this._socket.sendRPC(marshal);
     }
@@ -59053,9 +59065,9 @@ void main() {
       if (!Validation.isRelativeVector2(position)) return void 0;
       const test2 = await this._rpc.RPCPerformHitTest(position);
       if (!test2) return void 0;
-      const vim = this._vims.getFromHandle(test2.vimHandle);
+      const vim = this._vims.getFromHandle(test2.vimIndex);
       if (!vim) return void 0;
-      const object = vim.getElement(test2.elementIndex);
+      const object = vim.getElement(test2.vimElementIndex);
       if (!object) return void 0;
       return new UltraRaycastResult(
         object,
@@ -59148,6 +59160,18 @@ void main() {
         Validation.clampRGBA01(s.backgroundColor)
       );
     }
+    RpcGetElementCountForScene() {
+      return this.safeCall(
+        () => this.rpc.RpcGetElementCountForScene(),
+        0
+      );
+    }
+    RpcGetElementCountForVim(vimIndex) {
+      return this.safeCall(
+        () => this.rpc.RpcGetElementCountForVim(vimIndex),
+        0
+      );
+    }
     /*******************************************************************************
      * NODE VISIBILITY METHODS
      * Methods for controlling node visibility, including show/hide, ghosting,
@@ -59657,9 +59681,8 @@ void main() {
      * @param componentHandle - The unique identifier of the component
      * @throws {Error} If the component handle is invalid or INVALID_HANDLE
      */
-    RPCClearMaterialOverrides(componentHandle) {
-      if (!Validation.isComponentHandle(componentHandle)) return;
-      this.rpc.RPCClearMaterialOverrides(componentHandle);
+    RPCClearMaterialOverrides() {
+      this.rpc.RPCClearMaterialOverrides();
     }
     /*******************************************************************************
      * DEBUG AND UTILITY METHODS
@@ -60840,6 +60863,7 @@ Averrage Date/Second ${avgDataRatePS} kb
       __publicField(this, "_updatedColors", /* @__PURE__ */ new Set());
       // Delayed update flag.
       __publicField(this, "_updateScheduled", false);
+      __publicField(this, "_elementCount", 0);
       __publicField(this, "_objects", /* @__PURE__ */ new Map());
       this._rpc = rpc;
       this.source = source;
@@ -60873,7 +60897,10 @@ Averrage Date/Second ${avgDataRatePS} kb
       throw new Error("Method not implemented.");
     }
     getAllElements() {
-      throw new Error("Method not implemented.");
+      for (var i2 = 0; i2 < this._elementCount; i2++) {
+        this.getElement(i2);
+      }
+      return Array.from(this._objects.values());
     }
     get handle() {
       return this._handle;
@@ -60932,6 +60959,7 @@ Averrage Date/Second ${avgDataRatePS} kb
               return result.error(error, details);
             case VimLoadingStatus.Done:
               this._handle = handle;
+              this._elementCount = await this._rpc.RpcGetElementCountForVim(handle);
               return result.success(this);
           }
         } catch (e) {
@@ -61012,18 +61040,18 @@ Averrage Date/Second ${avgDataRatePS} kb
       }
       this.scheduleColorUpdate();
     }
-    clearColor(nodes) {
-      if (nodes === "all") {
+    clearColor(elements) {
+      if (elements === "all") {
         this._nodeColors.clear();
       } else {
-        nodes.forEach((n) => this._nodeColors.delete(n));
+        elements.forEach((n) => this._nodeColors.delete(n));
       }
       if (!this.connected) return;
-      if (nodes === "all") {
-        this._rpc.RPCClearMaterialOverrides(this._handle);
+      if (elements === "all") {
+        this._rpc.RPCClearMaterialOverrides();
       } else {
-        const ids = new Array(nodes.length).fill(MaterialHandles.Invalid);
-        this._rpc.RPCSetMaterialOverrides(this._handle, nodes, ids);
+        const ids = new Array(elements.length).fill(MaterialHandles.Invalid);
+        this._rpc.RPCSetMaterialOverrides(this._handle, elements, ids);
       }
     }
     reapplyColors() {
@@ -61349,6 +61377,9 @@ Averrage Date/Second ${avgDataRatePS} kb
       this._vims.getAll().forEach((vim) => vim.disconnect());
       this._vims.clear();
     }
+    getElement3Ds() {
+      return this.rpc.RpcGetElementCountForScene();
+    }
     /**
      * Disposes all resources used by the viewer and disconnects from the server.
      */