vim-web 0.6.0-dev.6 → 0.6.0-dev.8

package/dist/vim-web.iife.js

@@ -45971,14 +45971,45 @@ void main() {
       attribute.clearUpdateRanges();
     }
   }
+  const LEVELS = 24;
+  const PALETTE_SIZE = 128;
+  function colorToIndex(r, g, b) {
+    const ri = Math.round(r * LEVELS);
+    const gi = Math.round(g * LEVELS);
+    const bi = Math.round(b * LEVELS);
+    return ri * 625 + gi * 25 + bi;
+  }
+  function buildPaletteTexture() {
+    const data2 = new Uint8Array(PALETTE_SIZE * PALETTE_SIZE * 4);
+    const total = (LEVELS + 1) * (LEVELS + 1) * (LEVELS + 1);
+    for (let i2 = 0; i2 < total; i2++) {
+      const ri = Math.floor(i2 / 625);
+      const gi = Math.floor(i2 % 625 / 25);
+      const bi = i2 % 25;
+      const offset = i2 * 4;
+      data2[offset] = Math.round(ri / LEVELS * 255);
+      data2[offset + 1] = Math.round(gi / LEVELS * 255);
+      data2[offset + 2] = Math.round(bi / LEVELS * 255);
+      data2[offset + 3] = 255;
+    }
+    return data2;
+  }
+  function buildColorIndices(g3d2, submeshCount) {
+    const indices = new Uint16Array(submeshCount);
+    for (let i2 = 0; i2 < submeshCount; i2++) {
+      const color = g3d2.getSubmeshColor(i2);
+      indices[i2] = colorToIndex(color[0], color[1], color[2]);
+    }
+    return indices;
+  }
   class WebglColorAttribute {
-    constructor(meshes, value, vim) {
-      __publicField(this, "vim");
+    constructor(meshes, value) {
       __publicField(this, "_meshes");
       __publicField(this, "_value");
+      /** Saved original colorIndex values per merged submesh (keyed by submesh identity) */
+      __publicField(this, "_savedIndices", /* @__PURE__ */ new Map());
       this._meshes = meshes;
       this._value = value;
-      this.vim = vim;
     }
     updateMeshes(meshes) {
       this._meshes = meshes;
@@ -46002,78 +46033,65 @@ void main() {
       }
     }
     /**
-     * Writes new color to the appropriate section of merged mesh color buffer.
-     * @param index index of the merged mesh instance
-     * @param color rgb representation of the color to apply
+     * Merged meshes: change the per-vertex colorIndex to the override palette entry.
+     * Saves original values on first override, restores on clear.
      */
     applyMergedColor(sub, color) {
-      if (!color) {
-        this.resetMergedColor(sub);
-        return;
-      }
+      const geometry = sub.three.geometry;
+      const attribute = geometry.getAttribute("colorIndex");
+      if (!attribute) return;
       const start = sub.meshStart;
       const end = sub.meshEnd;
-      const colors = sub.three.geometry.getAttribute(
-        "color"
-      );
-      const indices = sub.three.geometry.index;
-      let c = 0;
-      const previous = new Float32Array((end - start) * 3);
-      for (let i2 = start; i2 < end; i2++) {
-        const v = indices.getX(i2);
-        previous[c++] = colors.getX(v);
-        previous[c++] = colors.getY(v);
-        previous[c++] = colors.getZ(v);
-      }
-      sub.saveColors(previous);
-      for (let i2 = start; i2 < end; i2++) {
-        const v = indices.getX(i2);
-        colors.setXYZ(v, color.r, color.g, color.b);
-      }
-      colors.needsUpdate = true;
-      colors.clearUpdateRanges();
-    }
-    resetMergedColor(sub) {
-      if (!this.vim) return;
-      const previous = sub.popColors();
-      if (previous === void 0) return;
-      const indices = sub.three.geometry.index;
-      const colors = sub.three.geometry.getAttribute(
-        "color"
-      );
-      let c = 0;
-      for (let i2 = sub.meshStart; i2 < sub.meshEnd; i2++) {
-        const v = indices.getX(i2);
-        colors.setXYZ(v, previous[c], previous[c + 1], previous[c + 2]);
-        c += 3;
+      const indices = geometry.index;
+      if (color) {
+        if (!this._savedIndices.has(sub)) {
+          const saved = new Uint16Array(end - start);
+          for (let i2 = start; i2 < end; i2++) {
+            const v = indices.getX(i2);
+            saved[i2 - start] = attribute.getX(v);
+          }
+          this._savedIndices.set(sub, saved);
+        }
+        const palIdx = colorToIndex(color.r, color.g, color.b);
+        for (let i2 = start; i2 < end; i2++) {
+          const v = indices.getX(i2);
+          attribute.setX(v, palIdx);
+        }
+      } else {
+        const saved = this._savedIndices.get(sub);
+        if (saved) {
+          for (let i2 = start; i2 < end; i2++) {
+            const v = indices.getX(i2);
+            attribute.setX(v, saved[i2 - start]);
+          }
+          this._savedIndices.delete(sub);
+        }
       }
-      colors.needsUpdate = true;
-      colors.clearUpdateRanges();
+      attribute.needsUpdate = true;
+      attribute.clearUpdateRanges();
     }
     /**
-     * Adds an instanceColor buffer to the instanced mesh and sets new color for given instance
-     * @param index index of the instanced instance
-     * @param color rgb representation of the color to apply
+     * Instanced meshes: set per-instance palette index via instanceColorIndex attribute.
+     * The `colored` flag (set separately) tells the shader to use this instead of per-vertex colorIndex.
      */
     applyInstancedColor(sub, color) {
-      const colors = this.getOrAddInstanceColorAttribute(
-        sub.three
-      );
-      if (color) {
-        colors.setXYZ(sub.index, color.r, color.g, color.b);
-        colors.needsUpdate = true;
-        colors.clearUpdateRanges();
+      const mesh = sub.three;
+      const geometry = mesh.geometry;
+      let attribute = geometry.getAttribute("instanceColorIndex");
+      if (!attribute || attribute.count < mesh.instanceMatrix.count) {
+        const count = mesh.instanceMatrix.count;
+        const array = new Float32Array(count);
+        attribute = new InstancedBufferAttribute(array, 1);
+        geometry.setAttribute("instanceColorIndex", attribute);
       }
-    }
-    getOrAddInstanceColorAttribute(mesh) {
-      if (mesh.instanceColor && mesh.instanceColor.count <= mesh.instanceMatrix.count) {
-        return mesh.instanceColor;
+      if (color) {
+        const palIdx = colorToIndex(color.r, color.g, color.b);
+        attribute.setX(sub.index, palIdx);
+      } else {
+        attribute.setX(sub.index, 0);
       }
-      const count = mesh.instanceMatrix.count;
-      const colors = new Float32Array(count * 3);
-      const attribute = new InstancedBufferAttribute(colors, 3);
-      mesh.instanceColor = attribute;
-      return attribute;
+      attribute.needsUpdate = true;
+      attribute.clearUpdateRanges();
     }
   }
   let Element3D$1 = class Element3D {
@@ -46139,7 +46157,7 @@ void main() {
         meshes,
         (v) => v ? 1 : 0
       );
-      this._colorAttribute = new WebglColorAttribute(meshes, void 0, vim);
+      this._colorAttribute = new WebglColorAttribute(meshes, void 0);
     }
     /** @internal */
     get _vim() {
@@ -46333,7 +46351,7 @@ void main() {
       this._visibleAttribute = new WebglAttribute(true, "ignore", "ignore", array, (v) => v ? 0 : 1);
       this._focusedAttribute = new WebglAttribute(false, "focused", "focused", array, (v) => v ? 1 : 0);
       this._coloredAttribute = new WebglAttribute(false, "colored", "colored", array, (v) => v ? 1 : 0);
-      this._colorAttribute = new WebglColorAttribute(array, void 0, void 0);
+      this._colorAttribute = new WebglColorAttribute(array, void 0);
       this.color = new Color(16718362);
     }
     /**
@@ -47553,19 +47571,19 @@ void main() {
       __publicField(this, "_sectionStrokeWidth", 0.01);
       __publicField(this, "_sectionStrokeFalloff", 0.75);
       __publicField(this, "_sectionStrokeColor", new Color(16185078));
-      // Submesh color palette texture (shared, owned by Materials singleton)
-      __publicField(this, "_submeshColorTexture");
+      // Color palette texture (shared, owned by Materials singleton)
+      __publicField(this, "_colorPaletteTexture");
       this.three = material;
       this.patchShader(material);
     }
     /**
-     * Sets the submesh color texture for indexed color lookup.
+     * Sets the color palette texture for indexed color lookup.
      * The texture is shared between opaque and transparent materials (created in Materials singleton).
      */
-    setSubmeshColorTexture(texture) {
-      this._submeshColorTexture = texture;
+    setColorPaletteTexture(texture) {
+      this._colorPaletteTexture = texture;
       if (this.uniforms) {
-        this.uniforms.submeshColorTexture.value = texture ?? null;
+        this.uniforms.colorPaletteTexture.value = texture ?? null;
       }
     }
     get color() {
@@ -47627,7 +47645,7 @@ void main() {
         this.uniforms.sectionStrokeWidth = { value: this._sectionStrokeWidth };
         this.uniforms.sectionStrokeFalloff = { value: this._sectionStrokeFalloff };
         this.uniforms.sectionStrokeColor = { value: this._sectionStrokeColor };
-        this.uniforms.submeshColorTexture = { value: this._submeshColorTexture ?? null };
+        this.uniforms.colorPaletteTexture = { value: this._colorPaletteTexture ?? null };
         shader.vertexShader = shader.vertexShader.replace(
           "#include <color_pars_vertex>",
           `
@@ -47635,23 +47653,16 @@ void main() {
 
         // COLORING
 
-        // attribute for color override
-        // merged meshes use it as vertex attribute
-        // instanced meshes use it as an instance attribute
+        // Per-vertex color palette index
+        attribute float colorIndex;
+        // Per-instance palette override index (instanced meshes only)
+        attribute float instanceColorIndex;
+        // 1 = use instanceColorIndex, 0 = use per-vertex colorIndex
         attribute float colored;
+        // 128×128 quantized color palette (25³ = 15,625 entries)
+        uniform sampler2D colorPaletteTexture;
 
-        // There seems to be an issue where setting mehs.instanceColor
-        // doesn't properly set USE_INSTANCING_COLOR
-        // so we always use it as a fix
-        #ifndef USE_INSTANCING_COLOR
-        attribute vec3 instanceColor;
-        #endif
-
-        // Submesh index for color palette lookup
-        attribute float submeshIndex;
-        uniform sampler2D submeshColorTexture; // 128×128 RGB texture (16384 colors max)
-
-        // Passed to fragment to ignore phong model
+        // Passed to fragment to control lighting model
         varying float vColored;
 
         // VISIBILITY
@@ -47669,18 +47680,13 @@ void main() {
           `
           // COLORING
           vColored = colored;
-
-          // Get color from texture palette using texelFetch (WebGL 2, faster)
-          int texSize = 128;
-          int x = int(submeshIndex) % texSize;
-          int y = int(submeshIndex) / texSize;
-          vColor.xyz = texelFetch(submeshColorTexture, ivec2(x, y), 0).rgb;
-
-          // colored == 1 -> instance color
-          // colored == 0 -> submesh palette color
+          int palIdx = int(colorIndex);
           #ifdef USE_INSTANCING
-            vColor.xyz = colored * instanceColor.xyz + (1.0f - colored) * vColor.xyz;
+            if (colored > 0.5) palIdx = int(instanceColorIndex);
           #endif
+          int x = palIdx % 128;
+          int y = palIdx / 128;
+          vColor.xyz = texelFetch(colorPaletteTexture, ivec2(x, y), 0).rgb;
 
           // VISIBILITY
           vIgnore = ignore;
@@ -54480,20 +54486,20 @@ void main() {
     constructor(material, onUpdate) {
       __publicField(this, "three");
       __publicField(this, "_onUpdate");
-      // Submesh color palette texture (shared, owned by Materials singleton)
-      __publicField(this, "_submeshColorTexture");
+      // Color palette texture (shared, owned by Materials singleton)
+      __publicField(this, "_colorPaletteTexture");
       this.three = material ?? createModelMaterialShader();
       this._onUpdate = onUpdate;
     }
     /**
-     * Sets the submesh color texture for indexed color lookup.
+     * Sets the color palette texture for indexed color lookup.
      * The texture is shared between materials (created in Materials singleton).
      */
-    setSubmeshColorTexture(texture) {
+    setColorPaletteTexture(texture) {
       var _a3;
-      this._submeshColorTexture = texture;
+      this._colorPaletteTexture = texture;
       if (this.three.uniforms) {
-        this.three.uniforms.submeshColorTexture.value = texture ?? null;
+        this.three.uniforms.colorPaletteTexture.value = texture ?? null;
       }
       (_a3 = this._onUpdate) == null ? void 0 : _a3.call(this);
     }
@@ -54518,19 +54524,14 @@ void main() {
   function createModelMaterialShader(transparent = false) {
     return new ShaderMaterial({
       side: DoubleSide,
-      // Use GLSL ES 3.0 for WebGL 2
       glslVersion: GLSL3,
-      // Uniforms for texture-based color palette
       uniforms: {
-        submeshColorTexture: { value: null }
+        colorPaletteTexture: { value: null }
       },
-      // Enable support for clipping planes.
       clipping: true,
-      // Transparency settings
       transparent,
       opacity: transparent ? 0.25 : 1,
       depthWrite: !transparent,
-      // Disable depth write for transparent materials
       vertexShader: (
         /* glsl */
         `
@@ -54539,29 +54540,16 @@ void main() {
       #include <clipping_planes_pars_vertex>
 
       // VISIBILITY
-      // Determines if an object or vertex should be visible.
-      // Used as an instance attribute for instanced meshes or as a vertex attribute for merged meshes.
       in float ignore;
 
       // COLORING
-      // Passes the color of the vertex or instance to the fragment shader.
       out vec3 vColor;
       out vec3 vViewPosition;
 
-      // Determines whether to use instance color (1 = instance, 0 = submesh).
-      // For merged meshes, this is used as a vertex attribute.
-      // For instanced meshes, this is used as an instance attribute.
+      in float colorIndex;
+      in float instanceColorIndex;
       in float colored;
-
-      // Submesh index for color palette lookup
-      in float submeshIndex;
-      uniform sampler2D submeshColorTexture;
-
-      // Fix for a known issue where setting mesh.instanceColor does not properly enable USE_INSTANCING_COLOR.
-      // This ensures that instance colors are always used when required.
-      #ifndef USE_INSTANCING_COLOR
-        in vec3 instanceColor;
-      #endif
+      uniform sampler2D colorPaletteTexture;
 
       void main() {
         #include <begin_vertex>
@@ -54569,28 +54557,20 @@ void main() {
         #include <clipping_planes_vertex>
         #include <logdepthbuf_vertex>
 
-        // Place ignored vertices behind near plane to clip them.
         if (ignore > 0.5) {
           gl_Position = vec4(0.0, 0.0, -2.0, 1.0);
           return;
         }
 
-        // COLORING
-        // Get color from texture palette using texelFetch (WebGL 2, faster for indexed access)
-        int texSize = 128;
-        int colorIndex = int(submeshIndex);
-        int x = colorIndex % texSize;
-        int y = colorIndex / texSize;
-        vColor = texelFetch(submeshColorTexture, ivec2(x, y), 0).rgb;
-
-        // Blend instance and submesh colors based on the colored attribute.
-        // colored == 1 -> use instance color.
-        // colored == 0 -> use submesh color from texture.
+        // COLORING — unified palette lookup
+        int palIdx = int(colorIndex);
         #ifdef USE_INSTANCING
-          vColor.xyz = colored * instanceColor.xyz + (1.0 - colored) * vColor.xyz;
+          if (colored > 0.5) palIdx = int(instanceColorIndex);
         #endif
+        int x = palIdx % 128;
+        int y = palIdx / 128;
+        vColor = texelFetch(colorPaletteTexture, ivec2(x, y), 0).rgb;
 
-        // Pass view position to fragment for screen-space derivatives
         vViewPosition = -mvPosition.xyz;
       }
       `
@@ -54602,7 +54582,6 @@ void main() {
       #include <logdepthbuf_pars_fragment>
       #include <clipping_planes_pars_fragment>
 
-      // Color and position for screen-space derivative lighting
       in vec3 vColor;
       in vec3 vViewPosition;
 
@@ -54616,13 +54595,11 @@ void main() {
         vec3 fdx = dFdx(vViewPosition);
         vec3 fdy = dFdy(vViewPosition);
         vec3 normal = normalize(cross(fdx, fdy));
-        // Pre-normalized light direction (sqrt(2), sqrt(3), sqrt(5)) / sqrt(10)
         const vec3 LIGHT_DIR = vec3(0.447214, 0.547723, 0.707107);
         float light = dot(normal, LIGHT_DIR);
-        light = 0.5 + (light * 0.5); // Remap to [0.5, 1.0]
+        light = 0.5 + (light * 0.5);
         vec3 finalColor = vColor * light;
 
-        // Output final color
         fragColor = vec4(finalColor, ${transparent ? "0.25" : "1.0"});
       }
       `
@@ -54662,8 +54639,8 @@ void main() {
       __publicField(this, "_sectionStrokeFalloff", 0.75);
       __publicField(this, "_sectionStrokeColor", new Color(16185078));
       __publicField(this, "_onUpdate", new distExports$2.SignalDispatcher());
-      // Shared color palette texture for both opaque and transparent materials
-      __publicField(this, "_submeshColorTexture");
+      // Shared color palette texture for all scene materials
+      __publicField(this, "_colorPaletteTexture");
       this._opaque = opaque ?? createOpaque();
       this._transparent = transparent ?? createTransparent();
       const onUpdate = () => this._onUpdate.dispatch();
@@ -54801,55 +54778,34 @@ void main() {
       this._onUpdate.dispatch();
     }
     /**
-     * Sets the submesh color palette for both opaque and transparent materials.
-     * Creates a single shared DataTexture from the palette (128×128 RGBA, 16384 colors max).
-     * If palette is undefined, creates a white fallback texture.
+     * Creates the fixed quantized color palette texture if it doesn't exist.
+     * The palette is deterministic (25³ = 15,625 quantized colors in 128×128 texture)
+     * and shared across all scene materials.
      */
-    setColorPalette(palette) {
-      if (this._submeshColorTexture) {
-        this._submeshColorTexture.dispose();
-        this._submeshColorTexture = void 0;
-      }
-      const textureSize = 128;
-      const textureData = new Uint8Array(textureSize * textureSize * 4);
-      if (palette && palette.length > 0) {
-        const colorCount = Math.min(palette.length / 3, textureSize * textureSize);
-        for (let i2 = 0; i2 < colorCount; i2++) {
-          textureData[i2 * 4] = Math.round(palette[i2 * 3] * 255);
-          textureData[i2 * 4 + 1] = Math.round(palette[i2 * 3 + 1] * 255);
-          textureData[i2 * 4 + 2] = Math.round(palette[i2 * 3 + 2] * 255);
-          textureData[i2 * 4 + 3] = 255;
-        }
-      } else {
-        console.warn("[Color Optimization] Palette undefined, using white fallback texture");
-        for (let i2 = 0; i2 < textureSize * textureSize * 4; i2 += 4) {
-          textureData[i2] = 255;
-          textureData[i2 + 1] = 255;
-          textureData[i2 + 2] = 255;
-          textureData[i2 + 3] = 255;
-        }
-      }
-      this._submeshColorTexture = new DataTexture(
+    ensureColorPalette() {
+      if (this._colorPaletteTexture) return;
+      const textureData = buildPaletteTexture();
+      this._colorPaletteTexture = new DataTexture(
         textureData,
-        textureSize,
-        textureSize,
+        128,
+        128,
         RGBAFormat,
         UnsignedByteType
       );
-      this._submeshColorTexture.needsUpdate = true;
-      this._submeshColorTexture.minFilter = NearestFilter;
-      this._submeshColorTexture.magFilter = NearestFilter;
-      this._opaque.setSubmeshColorTexture(this._submeshColorTexture);
-      this._transparent.setSubmeshColorTexture(this._submeshColorTexture);
-      this._modelOpaque.setSubmeshColorTexture(this._submeshColorTexture);
-      this._modelTransparent.setSubmeshColorTexture(this._submeshColorTexture);
+      this._colorPaletteTexture.needsUpdate = true;
+      this._colorPaletteTexture.minFilter = NearestFilter;
+      this._colorPaletteTexture.magFilter = NearestFilter;
+      this._opaque.setColorPaletteTexture(this._colorPaletteTexture);
+      this._transparent.setColorPaletteTexture(this._colorPaletteTexture);
+      this._modelOpaque.setColorPaletteTexture(this._colorPaletteTexture);
+      this._modelTransparent.setColorPaletteTexture(this._colorPaletteTexture);
       this._onUpdate.dispatch();
     }
     /** dispose all materials. */
     dispose() {
-      if (this._submeshColorTexture) {
-        this._submeshColorTexture.dispose();
-        this._submeshColorTexture = void 0;
+      if (this._colorPaletteTexture) {
+        this._colorPaletteTexture.dispose();
+        this._colorPaletteTexture = void 0;
       }
       this._opaque.dispose();
       this._transparent.dispose();
@@ -56911,7 +56867,7 @@ void main() {
     );
   }
   function createGeometryFromMesh(g3d2, mesh, section) {
-    const colorPaletteIndex = createColorPaletteIndices(g3d2, mesh, section);
+    const colorIndices = createColorIndices(g3d2, mesh, section);
     const positions = g3d2.positions.subarray(
       g3d2.getMeshVertexStart(mesh) * 3,
       g3d2.getMeshVertexEnd(mesh) * 3
@@ -56922,10 +56878,10 @@ void main() {
     return createGeometryFromArrays(
       positions,
       indices,
-      colorPaletteIndex
+      colorIndices
     );
   }
-  function createColorPaletteIndices(g3d2, mesh, section) {
+  function createColorIndices(g3d2, mesh, section) {
     const vertexCount = g3d2.getMeshVertexCount(mesh);
     const result = new Uint16Array(vertexCount);
     const subStart = g3d2.getMeshSubmeshStart(mesh, section);
@@ -56933,7 +56889,7 @@ void main() {
     for (let submesh = subStart; submesh < subEnd; submesh++) {
       const start = g3d2.getSubmeshIndexStart(submesh);
       const end = g3d2.getSubmeshIndexEnd(submesh);
-      const index2 = g3d2.submeshColor[submesh];
+      const index2 = g3d2.colorIndices[submesh];
       for (let i2 = start; i2 < end; i2++) {
         const vertexIndex = g3d2.indices[i2];
         result[vertexIndex] = index2;
@@ -56941,14 +56897,14 @@ void main() {
     }
     return result;
   }
-  function createGeometryFromArrays(vertices, indices, colorPaletteIndex = void 0) {
+  function createGeometryFromArrays(vertices, indices, colorIndices = void 0) {
     const geometry = new BufferGeometry();
     geometry.setAttribute("position", new BufferAttribute(vertices, 3));
     geometry.setIndex(new Uint32BufferAttribute(indices, 1));
-    if (colorPaletteIndex) {
+    if (colorIndices) {
       geometry.setAttribute(
-        "submeshIndex",
-        new Uint16BufferAttribute(colorPaletteIndex, 1)
+        "colorIndex",
+        new Uint16BufferAttribute(colorIndices, 1)
       );
     }
     return geometry;
@@ -57002,8 +56958,7 @@ void main() {
       __publicField(this, "_computeBoundingBox", false);
       __publicField(this, "_indexAttribute");
       __publicField(this, "_vertexAttribute");
-      __publicField(this, "_submeshIndexAttribute");
-      // Color palette index for texture-based color lookup
+      __publicField(this, "_colorIndexAttribute");
       __publicField(this, "_packedIdAttribute");
       __publicField(this, "_mapping");
       __publicField(this, "_vimIndex");
@@ -57022,7 +56977,7 @@ void main() {
         offsets.counts.vertices * distExports$1.G3d.POSITION_SIZE,
         distExports$1.G3d.POSITION_SIZE
       );
-      this._submeshIndexAttribute = new Uint16BufferAttribute(
+      this._colorIndexAttribute = new Uint16BufferAttribute(
         offsets.counts.vertices,
         1
       );
@@ -57033,7 +56988,7 @@ void main() {
       this.geometry = new BufferGeometry();
       this.geometry.setIndex(this._indexAttribute);
       this.geometry.setAttribute("position", this._vertexAttribute);
-      this.geometry.setAttribute("submeshIndex", this._submeshIndexAttribute);
+      this.geometry.setAttribute("colorIndex", this._colorIndexAttribute);
       this.geometry.setAttribute("packedId", this._packedIdAttribute);
       this.boundingBox = new Box3();
       this.boundingBox.makeEmpty();
@@ -57078,16 +57033,16 @@ void main() {
         submesh.instance = instanceNodes[g3dInstance];
         submesh.start = indexOffset + indexOut;
         const indices = this._indexAttribute.array;
-        const submeshIndices = this._submeshIndexAttribute.array;
+        const colorIndices = this._colorIndexAttribute.array;
         const mergeOffset = instance * vertexCount;
         for (let sub = subStart; sub < subEnd; sub++) {
           const indexStart = g3d2.getSubmeshIndexStart(sub);
           const indexEnd = g3d2.getSubmeshIndexEnd(sub);
-          const colorIndex = g3d2.submeshColor[sub];
+          const colorIndex = g3d2.colorIndices[sub];
           for (let index2 = indexStart; index2 < indexEnd; index2++) {
             const v = vertexOffset + mergeOffset + g3d2.indices[index2];
             indices[indexOffset + indexOut] = v;
-            submeshIndices[v] = colorIndex;
+            colorIndices[v] = colorIndex;
             indexOut++;
           }
         }
@@ -57153,8 +57108,8 @@ void main() {
       const vSize = this._vertexAttribute.itemSize;
       this._vertexAttribute.addUpdateRange(vertexStart * vSize, (vertexEnd - vertexStart) * vSize);
       this._vertexAttribute.needsUpdate = true;
-      this._submeshIndexAttribute.addUpdateRange(vertexStart, vertexEnd - vertexStart);
-      this._submeshIndexAttribute.needsUpdate = true;
+      this._colorIndexAttribute.addUpdateRange(vertexStart, vertexEnd - vertexStart);
+      this._colorIndexAttribute.needsUpdate = true;
       this._packedIdAttribute.addUpdateRange(vertexStart, vertexEnd - vertexStart);
       this._packedIdAttribute.needsUpdate = true;
       if (this._computeBoundingBox) {
@@ -57167,7 +57122,6 @@ void main() {
     constructor(mesh, index2) {
       __publicField(this, "mesh");
       __publicField(this, "index");
-      __publicField(this, "_colors");
       this.mesh = mesh;
       this.index = index2;
     }
@@ -57219,15 +57173,6 @@ void main() {
     get object() {
       return this.mesh.vim.getElement(this.instance);
     }
-    saveColors(colors) {
-      if (this._colors) return;
-      this._colors = colors;
-    }
-    popColors() {
-      const result = this._colors;
-      this._colors = void 0;
-      return result;
-    }
   }
   class InsertableMesh {
     constructor(offsets, materials, transparent, mapping, vimIndex = 0) {
@@ -57544,57 +57489,6 @@ void main() {
     return logging;
   }
   var loggingExports = requireLogging();
-  const MAX_COLORS = 16384;
-  const QUANTIZATION_LEVELS = 25;
-  function buildColorPalette(mappedG3d, submeshColorCount) {
-    const uniqueColorsMap = /* @__PURE__ */ new Map();
-    const colorPaletteArray = [];
-    const submeshColor = new Uint16Array(submeshColorCount);
-    for (let i2 = 0; i2 < submeshColorCount; i2++) {
-      const color = mappedG3d.getSubmeshColor(i2);
-      const key = packColorKey(color[0], color[1], color[2]);
-      let colorIndex = uniqueColorsMap.get(key);
-      if (colorIndex === void 0) {
-        colorIndex = colorPaletteArray.length / 3;
-        uniqueColorsMap.set(key, colorIndex);
-        colorPaletteArray.push(color[0], color[1], color[2]);
-      }
-      submeshColor[i2] = colorIndex;
-    }
-    let uniqueColorCount = uniqueColorsMap.size;
-    if (uniqueColorCount > MAX_COLORS) {
-      quantizeColors(mappedG3d.materialColors, QUANTIZATION_LEVELS);
-      uniqueColorsMap.clear();
-      colorPaletteArray.length = 0;
-      for (let i2 = 0; i2 < submeshColorCount; i2++) {
-        const color = mappedG3d.getSubmeshColor(i2);
-        const key = packColorKey(color[0], color[1], color[2]);
-        let colorIndex = uniqueColorsMap.get(key);
-        if (colorIndex === void 0) {
-          colorIndex = colorPaletteArray.length / 3;
-          uniqueColorsMap.set(key, colorIndex);
-          colorPaletteArray.push(color[0], color[1], color[2]);
-        }
-        submeshColor[i2] = colorIndex;
-      }
-      uniqueColorCount = uniqueColorsMap.size;
-    }
-    if (uniqueColorCount <= MAX_COLORS) {
-      const palette = new Float32Array(colorPaletteArray);
-      return { palette, submeshColor, uniqueColorCount };
-    } else {
-      return { palette: void 0, submeshColor, uniqueColorCount };
-    }
-  }
-  function packColorKey(r, g, b) {
-    return (Math.round(r * 65535) * 65536 + Math.round(g * 65535)) * 65536 + Math.round(b * 65535);
-  }
-  function quantizeColors(colors, levels) {
-    const quantize = (value) => Math.round(value * levels) / levels;
-    for (let i2 = 0; i2 < colors.length; i2++) {
-      colors[i2] = quantize(colors[i2]);
-    }
-  }
   function createMappedG3d(g3d2) {
     const mapped = g3d2;
     const map = /* @__PURE__ */ new Map();
@@ -57618,11 +57512,7 @@ void main() {
     mapped._meshKeys = meshKeys;
     mapped._meshValues = meshValues;
     mapped._totalInstanceCount = totalCount;
-    const submeshColorCount = mapped.submeshMaterial.length;
-    const { palette, submeshColor, uniqueColorCount } = buildColorPalette(mapped, submeshColorCount);
-    mapped.colorPalette = palette;
-    mapped.submeshColor = submeshColor;
-    mapped.uniqueColorCount = uniqueColorCount;
+    mapped.colorIndices = buildColorIndices(mapped, mapped.submeshMaterial.length);
     return mapped;
   }
   let LoadRequest$2 = class LoadRequest extends LoadRequest$3 {
@@ -57667,7 +57557,7 @@ void main() {
       const mapping = await ElementMapping.fromG3d(doc);
       const scene = new Scene(fullSettings.matrix);
       const factory = new VimMeshFactory(mappedG3d, materials, scene, mapping, vimIndex);
-      Materials.getInstance().setColorPalette(mappedG3d.colorPalette);
+      Materials.getInstance().ensureColorPalette();
       const header = await distExports$1.requestHeader(bfast2);
       const vim = new Vim$1(
         header,
@@ -57732,10 +57622,10 @@ void main() {
         this._camera,
         this.settings
       );
+      this.selection = createSelection$1();
       this._inputs = createInputHandler(this);
       this._gizmos = new Gizmos(this._renderer, this._viewport, this, this._camera);
       this.materials.applySettings(this.settings.materials);
-      this.selection = createSelection$1();
       const size = this._renderer.three.getSize(new Vector2());
       const gpuPicker = new GpuPicker(
         this._renderer.three,
@@ -60327,11 +60217,13 @@ Averrage Date/Second ${avgDataRatePS} kb
      */
     async _onOpen(_) {
       var _a3;
+      console.log("WebSocket connection opened to ", this.url);
       clearTimeout(this._connectionTimeout);
       this.updateState({ status: "validating" });
       const issues = await this._validateConnection();
       if (issues !== void 0) {
         this._disconnect(issues);
+        this._connectPromise.resolve(false);
         return;
       }
       this._logger.log("Connected to: ", (_a3 = this._socket) == null ? void 0 : _a3.url);