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

package/dist/vim-web.js

@@ -45955,14 +45955,45 @@ class WebglAttribute {
     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 i = 0; i < total; i++) {
+    const ri = Math.floor(i / 625);
+    const gi = Math.floor(i % 625 / 25);
+    const bi = i % 25;
+    const offset = i * 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 i = 0; i < submeshCount; i++) {
+    const color = g3d2.getSubmeshColor(i);
+    indices[i] = 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;
@@ -45986,78 +46017,65 @@ class WebglColorAttribute {
     }
   }
   /**
-   * 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 i = start; i < end; i++) {
-      const v = indices.getX(i);
-      previous[c++] = colors.getX(v);
-      previous[c++] = colors.getY(v);
-      previous[c++] = colors.getZ(v);
-    }
-    sub.saveColors(previous);
-    for (let i = start; i < end; i++) {
-      const v = indices.getX(i);
-      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 i = sub.meshStart; i < sub.meshEnd; i++) {
-      const v = indices.getX(i);
-      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 i = start; i < end; i++) {
+          const v = indices.getX(i);
+          saved[i - start] = attribute.getX(v);
+        }
+        this._savedIndices.set(sub, saved);
+      }
+      const palIdx = colorToIndex(color.r, color.g, color.b);
+      for (let i = start; i < end; i++) {
+        const v = indices.getX(i);
+        attribute.setX(v, palIdx);
+      }
+    } else {
+      const saved = this._savedIndices.get(sub);
+      if (saved) {
+        for (let i = start; i < end; i++) {
+          const v = indices.getX(i);
+          attribute.setX(v, saved[i - 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 {
@@ -46123,7 +46141,7 @@ let Element3D$1 = class Element3D {
       meshes,
       (v) => v ? 1 : 0
     );
-    this._colorAttribute = new WebglColorAttribute(meshes, void 0, vim);
+    this._colorAttribute = new WebglColorAttribute(meshes, void 0);
   }
   /** @internal */
   get _vim() {
@@ -46317,7 +46335,7 @@ const _Marker = class _Marker {
     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);
   }
   /**
@@ -47537,19 +47555,19 @@ class StandardMaterial {
     __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() {
@@ -47611,7 +47629,7 @@ class StandardMaterial {
       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>",
         `
@@ -47619,23 +47637,16 @@ class StandardMaterial {
 
         // 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
@@ -47653,18 +47664,13 @@ class StandardMaterial {
         `
           // 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;
@@ -54464,20 +54470,20 @@ class ModelMaterial {
   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);
   }
@@ -54502,19 +54508,14 @@ function createModelTransparent(onUpdate) {
 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 */
       `
@@ -54523,29 +54524,16 @@ function createModelMaterialShader(transparent = false) {
       #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>
@@ -54553,28 +54541,20 @@ function createModelMaterialShader(transparent = false) {
         #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;
       }
       `
@@ -54586,7 +54566,6 @@ function createModelMaterialShader(transparent = false) {
       #include <logdepthbuf_pars_fragment>
       #include <clipping_planes_pars_fragment>
 
-      // Color and position for screen-space derivative lighting
       in vec3 vColor;
       in vec3 vViewPosition;
 
@@ -54600,13 +54579,11 @@ function createModelMaterialShader(transparent = false) {
         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"});
       }
       `
@@ -54646,8 +54623,8 @@ const _Materials = class _Materials {
     __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();
@@ -54785,55 +54762,34 @@ const _Materials = class _Materials {
     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 i = 0; i < colorCount; i++) {
-        textureData[i * 4] = Math.round(palette[i * 3] * 255);
-        textureData[i * 4 + 1] = Math.round(palette[i * 3 + 1] * 255);
-        textureData[i * 4 + 2] = Math.round(palette[i * 3 + 2] * 255);
-        textureData[i * 4 + 3] = 255;
-      }
-    } else {
-      console.warn("[Color Optimization] Palette undefined, using white fallback texture");
-      for (let i = 0; i < textureSize * textureSize * 4; i += 4) {
-        textureData[i] = 255;
-        textureData[i + 1] = 255;
-        textureData[i + 2] = 255;
-        textureData[i + 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();
@@ -56895,7 +56851,7 @@ function isTransparencyModeValid(value) {
   );
 }
 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
@@ -56906,10 +56862,10 @@ function createGeometryFromMesh(g3d2, mesh, section) {
   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);
@@ -56917,7 +56873,7 @@ function createColorPaletteIndices(g3d2, mesh, section) {
   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 i = start; i < end; i++) {
       const vertexIndex = g3d2.indices[i];
       result[vertexIndex] = index2;
@@ -56925,14 +56881,14 @@ function createColorPaletteIndices(g3d2, mesh, section) {
   }
   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;
@@ -56986,8 +56942,7 @@ class InsertableGeometry {
     __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");
@@ -57006,7 +56961,7 @@ class InsertableGeometry {
       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
     );
@@ -57017,7 +56972,7 @@ class InsertableGeometry {
     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();
@@ -57062,16 +57017,16 @@ class InsertableGeometry {
       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++;
         }
       }
@@ -57137,8 +57092,8 @@ class InsertableGeometry {
     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) {
@@ -57151,7 +57106,6 @@ class InsertableSubmesh {
   constructor(mesh, index2) {
     __publicField(this, "mesh");
     __publicField(this, "index");
-    __publicField(this, "_colors");
     this.mesh = mesh;
     this.index = index2;
   }
@@ -57203,15 +57157,6 @@ class InsertableSubmesh {
   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) {
@@ -57528,57 +57473,6 @@ function requireLogging() {
   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 i = 0; i < submeshColorCount; i++) {
-    const color = mappedG3d.getSubmeshColor(i);
-    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[i] = colorIndex;
-  }
-  let uniqueColorCount = uniqueColorsMap.size;
-  if (uniqueColorCount > MAX_COLORS) {
-    quantizeColors(mappedG3d.materialColors, QUANTIZATION_LEVELS);
-    uniqueColorsMap.clear();
-    colorPaletteArray.length = 0;
-    for (let i = 0; i < submeshColorCount; i++) {
-      const color = mappedG3d.getSubmeshColor(i);
-      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[i] = 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 i = 0; i < colors.length; i++) {
-    colors[i] = quantize(colors[i]);
-  }
-}
 function createMappedG3d(g3d2) {
   const mapped = g3d2;
   const map = /* @__PURE__ */ new Map();
@@ -57602,11 +57496,7 @@ function createMappedG3d(g3d2) {
   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 LoadRequest2 extends LoadRequest$3 {
@@ -57651,7 +57541,7 @@ let LoadRequest$2 = class LoadRequest2 extends LoadRequest$3 {
     const mapping = await ElementMapping.fromG3d(doc);
     const scene = new Scene2(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,
@@ -57716,10 +57606,10 @@ class WebglViewer {
       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,
@@ -60311,11 +60201,13 @@ class SocketClient {
    */
   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);