viral-viewer-2 6.9.3 → 6.9.5

package/dist/components/visibility-manager/viral-visibility-manager.d.ts

@@ -56,10 +56,23 @@ export declare class ViralVisibilityManager {
             b: number;
         };
     }[];
+    /**
+     * Select elements (replaces current selection)
+     */
     selectElements(elements: {
         modelId: string;
         elementId: string;
     }[]): void;
+    /**
+     * Add elements to current selection (multi-select with Shift)
+     */
+    addToSelection(elements: {
+        modelId: string;
+        elementId: string;
+    }[]): void;
+    /**
+     * Unselect all elements
+     */
     unselectElements(): void;
     isolateModelId: string;
     isolateModel(isolateModelIds?: string[]): void;
@@ -73,6 +86,33 @@ export declare class ViralVisibilityManager {
     private _updateLightShadowCamera;
     enableEdge(): void;
     disableEdge(): void;
+    /**
+     * Enable screen-space edge detection (Speckle-style)
+     *
+     * This is much more efficient than geometry-based edges because:
+     * - No edge geometry is generated (constant GPU memory)
+     * - Cost is fixed regardless of model complexity (~2-3ms per frame)
+     * - Instanced meshes don't explode into per-instance edges
+     * - Edges are detected on-the-fly using depth/normal/ID discontinuities
+     *
+     * @param mode - 'shaded' (subtle edges) or 'pen' (technical drawing style)
+     */
+    enableScreenSpaceEdge(mode?: 'shaded' | 'pen'): void;
+    /**
+     * Disable screen-space edge detection
+     */
+    disableScreenSpaceEdge(): void;
+    /**
+     * Configure screen-space edge detection
+     */
+    configureScreenSpaceEdge(options: {
+        color?: number;
+        opacity?: number;
+        thickness?: number;
+        depthEdges?: boolean;
+        normalEdges?: boolean;
+        objectIdEdges?: boolean;
+    }): void;
     enableAllWhite(): void;
     disableAllWhite(): void;
     enableAmbientOcclusion(): void;
@@ -116,6 +156,37 @@ export declare class ViralVisibilityManager {
      */
     enableSampling(numberOfSampling?: number): void;
     disableSampling(): void;
+    /**
+     * Set opacity for specific elements
+     * @param elements - Elements to set opacity for
+     * @param opacity - Opacity value (0-1)
+     */
+    setElementOpacity(elements: {
+        modelId: string;
+        elementId: string;
+    }[], opacity: number): void;
+    /**
+     * Set elements to "ghost" mode (semi-transparent)
+     * @param elements - Elements to ghost
+     * @param ghostOpacity - Opacity for ghosted elements (default 0.1)
+     */
+    setElementGhost(elements: {
+        modelId: string;
+        elementId: string;
+    }[], ghostOpacity?: number): void;
+    /**
+     * Ghost all elements EXCEPT the specified ones (highlight effect)
+     * @param elements - Elements to keep fully opaque
+     * @param ghostOpacity - Opacity for all other elements (default 0.1)
+     */
+    ghostExcept(elements: {
+        modelId: string;
+        elementId: string;
+    }[], ghostOpacity?: number): void;
+    /**
+     * Reset all elements to full opacity
+     */
+    resetElementOpacity(): void;
     generateLOD(): void;
     private _batchColors;
     private _originalBatchMaterials;

package/dist/components/worker/load-element-batch.worker.d.ts

@@ -41,9 +41,16 @@ export declare class LoadElementBatchWorker {
     private createSingleMergedMesh;
     private createSingleInstancedMesh;
     /**
-     * Create optimized material for merging
+     * Create optimized material for merging with per-element opacity support
+     * Uses onBeforeCompile to inject custom shader code for RGBA vertex colors
      */
     private createOptimizedMaterial;
+    /**
+     * 🎨 Inject custom shader modifications for per-element opacity
+     * This modifies the material's shaders to support RGBA vertex colors
+     * where the alpha channel controls per-element transparency
+     */
+    private injectPerElementOpacityShader;
     /**
      * Throttled render to avoid excessive render calls
      */