@navaramap/three 0.0.8 → 0.1.1

package/src/mesh/sprite/instancedSprite.ts

@@ -66,7 +66,15 @@ export class InstancedSpriteMesh
   implements PickableMesh, DeclutterParticipant
 {
   private _geometryType: SpriteGeometryType = GEOMETRY_TYPES.Point;
-  private _batchIdToInstance = new Map<number, number>();
+  /**
+   * Feature (batch) index → this feature's instance ids. A feature owns
+   * multiple instances for MultiPoint geometry and for points derived from
+   * line/polygon vertices via `geometryTypes`, so per-feature styling must
+   * fan out to all of them. `null` means instances and features are 1:1.
+   */
+  private _batchIndexToInstances: Map<number, number[]> | null = null;
+  /** Instance count of the current geometry; bounds the identity fallback. */
+  private _instanceCount = 0;
   private _initialColor: Color = new Color(0xffffff);
   private _initialHeight = 0.0;
   private _initialSize = -1.0; // Negative value indicates "use uScale" in shader
@@ -161,7 +169,7 @@ export class InstancedSpriteMesh
     const state = enhancer.states();
     const cx = Math.min(Math.max(state.center[0], -0.5), 0.5);
     const cy = Math.min(Math.max(state.center[1], -0.5), 0.5);
-    // Mirror of instancedSprite.vert.glsl:100-104 — aspect is per-instance
+    // Mirror of instancedSprite.vert.glsl:115-118 — aspect is per-instance
     // (from the atlas rect), not a material-level uniform; there is no
     // material-wide "aspect" state to read.
     const uvRect = state.billboard
@@ -181,9 +189,14 @@ export class InstancedSpriteMesh
 
       const override = overrides ? overrides[i] : Number.NaN;
       const rectH = uvRect ? uvRect.getW(i) : 0;
-      const aspect = uvRect && rectH > 0.0 ? uvRect.getZ(i) / rectH : 1.0;
-
-      // Mirror of instancedSprite.vert.glsl:95-97 — the quad spans
+      const rectW = uvRect ? uvRect.getZ(i) : 0;
+      // Mirror of the shader's empty-rect cull: an instance with no image
+      // packed yet is not drawn, so it must not reserve declutter space and
+      // hide the labels around it.
+      if (uvRect && (rectW <= 0.0 || rectH <= 0.0)) continue;
+      const aspect = uvRect ? rectW / rectH : 1.0;
+
+      // Mirror of instancedSprite.vert.glsl:122-125 — the quad spans
       // (position.xy - center) * vec2(aspect, 1) * size around the anchor.
       out.push({
         anchorX: anchors[i * 3],
@@ -481,17 +494,15 @@ export class InstancedSpriteMesh
       colorBuffer[i * 3 + 0] = this._initialColor.r;
       colorBuffer[i * 3 + 1] = this._initialColor.g;
       colorBuffer[i * 3 + 2] = this._initialColor.b;
-
-      // Map batch ID to instance id
-      // assuming batch IDs are 32bit floats
-      const batchId = positionsInfo.batchIDs[i];
-      this._batchIdToInstance.set(batchId, i);
     }
 
+    this._instanceCount = instanceCount;
+    this._rebuildBatchIndexMap(m);
+
     if (m instanceof NavaraBillboardMesh) {
       // instanceUvRect: vec4(x, y, w, h) — this instance's atlas sub-rect in
-      // pixels. Zeroed until an image is packed; a zero-height rect samples a
-      // transparent texel, so instances stay invisible rather than garbled.
+      // pixels. Zeroed until an image is packed; the vertex shader culls empty
+      // rects, so instances stay invisible rather than garbled.
       instancedGeometry.setAttribute(
         "instanceUvRect",
         new InstancedBufferAttribute(new Float32Array(instanceCount * 4), 4),
@@ -755,6 +766,20 @@ export class InstancedSpriteMesh
       rectAttr.setXYZW(i, rect.x, rect.y, rect.w, rect.h);
     }
     rectAttr.needsUpdate = true;
+    this._onAtlasRectsChanged();
+  }
+
+  /**
+   * An instance's atlas rect changed. The rect drives the quad's aspect and
+   * whether the instance draws at all, so the declutter bounds computed before
+   * the image landed are stale — and because packs resolve long after the
+   * frame that requested them, the view has usually gone idle by now. Without
+   * the render request the page keeps showing the pre-image state until the
+   * next camera move.
+   */
+  private _onAtlasRectsChanged(): void {
+    this.ctx.declutter?.markDirty();
+    this.ctx.renderFlag.forceUpdate = true;
   }
 
   onBeforePicking(): void {
@@ -781,32 +806,85 @@ export class InstancedSpriteMesh
     return this._enhancedMaterial;
   }
 
-  setFeatureColorByBatchId(batchId: number, color: Color) {
-    const instanceId = this._batchIdToInstance.get(batchId);
-    if (instanceId === undefined) return;
+  /**
+   * Group instances by their feature's batch index from the geometry's
+   * per-instance `batch_index` buffer. The u32 view is consumed synchronously,
+   * so other wasm calls may detach views, so it must not be stored. The handle
+   * stays owned by the ECS geometry, whose destroy path frees it
+   * (`remove_from_buf`). An identity mapping (every feature owns exactly one
+   * instance, the common case) skips the map entirely.
+   */
+  private _rebuildBatchIndexMap(
+    m: NavaraPointMesh | NavaraBillboardMesh,
+  ): void {
+    const batchIndexData = m.geometry.batch_index?.data;
+    const batchIndices =
+      batchIndexData !== undefined ? this.ctx.buf.u32(batchIndexData) : null;
+    this._batchIndexToInstances = null;
+    if (!batchIndices) return;
+
+    let identity = true;
+    for (let i = 0; i < batchIndices.length; i++) {
+      if (batchIndices[i] !== i) {
+        identity = false;
+        break;
+      }
+    }
+    if (identity) return;
+
+    const map = new Map<number, number[]>();
+    for (let i = 0; i < batchIndices.length; i++) {
+      const batchIndex = batchIndices[i];
+      let instances = map.get(batchIndex);
+      if (!instances) {
+        instances = [];
+        map.set(batchIndex, instances);
+      }
+      instances.push(i);
+    }
+    this._batchIndexToInstances = map;
+  }
+
+  /** All instances owned by the feature at `batchIndex`; empty when unknown. */
+  private instancesOfBatchIndex(batchIndex: number): number[] {
+    if (this._batchIndexToInstances) {
+      return this._batchIndexToInstances.get(batchIndex) ?? [];
+    }
+    return batchIndex >= 0 && batchIndex < this._instanceCount
+      ? [batchIndex]
+      : [];
+  }
+
+  setFeatureColorByBatchIndex(batchIndex: number, color: Color) {
+    const instances = this.instancesOfBatchIndex(batchIndex);
+    if (instances.length === 0) return;
 
     const colorAttr = this.geometry.getAttribute(
       "instanceColor",
     ) as InstancedBufferAttribute;
-    colorAttr.setXYZ(instanceId, color.r, color.g, color.b);
+    for (const instanceId of instances) {
+      colorAttr.setXYZ(instanceId, color.r, color.g, color.b);
+    }
     colorAttr.needsUpdate = true;
   }
 
-  setFeatureShowByBatchId(batchId: number, rawVisible: boolean) {
-    const instanceId = this._batchIdToInstance.get(batchId);
-    if (instanceId === undefined) return;
+  setFeatureShowByBatchIndex(batchIndex: number, rawVisible: boolean) {
+    const instances = this.instancesOfBatchIndex(batchIndex);
+    if (instances.length === 0) return;
 
     const paramsAttr = this.geometry.getAttribute(
       "instanceParams",
     ) as InstancedBufferAttribute;
-    paramsAttr.setZ(instanceId, rawVisible ? 1.0 : 0.0);
+    for (const instanceId of instances) {
+      paramsAttr.setZ(instanceId, rawVisible ? 1.0 : 0.0);
+    }
     paramsAttr.needsUpdate = true;
     this.ctx.declutter?.markDirty();
   }
 
-  setFeatureOpacityByBatchId(batchId: number, opacity: number) {
-    const instanceId = this._batchIdToInstance.get(batchId);
-    if (instanceId === undefined) return;
+  setFeatureOpacityByBatchIndex(batchIndex: number, opacity: number) {
+    const instances = this.instancesOfBatchIndex(batchIndex);
+    if (instances.length === 0) return;
 
     const paramsAttr = this.geometry.getAttribute(
       "instanceParams",
@@ -814,20 +892,24 @@ export class InstancedSpriteMesh
     const clampedOpacity = Number.isFinite(opacity)
       ? Math.max(0.0, Math.min(1.0, opacity))
       : 1.0;
-    paramsAttr.setW(instanceId, clampedOpacity);
+    for (const instanceId of instances) {
+      paramsAttr.setW(instanceId, clampedOpacity);
+    }
     paramsAttr.needsUpdate = true;
   }
 
-  setFeatureHeightByBatchId(batchId: number, height: number) {
-    const instanceId = this._batchIdToInstance.get(batchId);
-    if (instanceId === undefined) return;
+  setFeatureHeightByBatchIndex(batchIndex: number, height: number) {
+    const instances = this.instancesOfBatchIndex(batchIndex);
+    if (instances.length === 0) return;
 
     const paramsAttr = this.geometry.getAttribute(
       "instanceParams",
     ) as InstancedBufferAttribute;
 
     const sanitizedHeight = Number.isFinite(height) ? height : 0.0;
-    paramsAttr.setX(instanceId, sanitizedHeight);
+    for (const instanceId of instances) {
+      paramsAttr.setX(instanceId, sanitizedHeight);
+    }
     paramsAttr.needsUpdate = true;
     this.ctx.declutter?.markDirty();
   }
@@ -854,9 +936,12 @@ export class InstancedSpriteMesh
    * layer-level `declutterPriority` for this instance. Driven by the feature
    * evaluator.
    */
-  setFeatureDeclutterPriorityByBatchId(batchId: number, priority: number) {
-    const instanceId = this._batchIdToInstance.get(batchId);
-    if (instanceId === undefined) return;
+  setFeatureDeclutterPriorityByBatchIndex(
+    batchIndex: number,
+    priority: number,
+  ) {
+    const instances = this.instancesOfBatchIndex(batchIndex);
+    if (instances.length === 0) return;
 
     if (!this._declutterPriorityOverrides) {
       const count = this._anchors ? this._anchors.length / 3 : 0;
@@ -865,15 +950,21 @@ export class InstancedSpriteMesh
         Number.NaN,
       );
     }
-    if (instanceId >= this._declutterPriorityOverrides.length) return;
-    if (this._declutterPriorityOverrides[instanceId] === priority) return;
-    this._declutterPriorityOverrides[instanceId] = priority;
-    this.ctx.declutter?.markDirty();
+    let changed = false;
+    for (const instanceId of instances) {
+      if (instanceId >= this._declutterPriorityOverrides.length) continue;
+      if (this._declutterPriorityOverrides[instanceId] === priority) continue;
+      this._declutterPriorityOverrides[instanceId] = priority;
+      changed = true;
+    }
+    if (changed) {
+      this.ctx.declutter?.markDirty();
+    }
   }
 
-  setFeatureSizeByBatchId(batchId: number, size: number) {
-    const instanceId = this._batchIdToInstance.get(batchId);
-    if (instanceId === undefined) return;
+  setFeatureSizeByBatchIndex(batchIndex: number, size: number) {
+    const instances = this.instancesOfBatchIndex(batchIndex);
+    if (instances.length === 0) return;
 
     const paramsAttr = this.geometry.getAttribute(
       "instanceParams",
@@ -884,7 +975,9 @@ export class InstancedSpriteMesh
         ? -1.0
         : size
       : -1.0;
-    paramsAttr.setY(instanceId, sanitizedSize);
+    for (const instanceId of instances) {
+      paramsAttr.setY(instanceId, sanitizedSize);
+    }
     paramsAttr.needsUpdate = true;
     this.ctx.declutter?.markDirty();
   }
@@ -897,45 +990,60 @@ export class InstancedSpriteMesh
    * reverts the feature to the material's default image. No-op for
    * non-billboard (point) meshes.
    */
-  async setFeatureImageByBatchId(
-    batchId: number,
+  async setFeatureImageByBatchIndex(
+    batchIndex: number,
     url: string | null | undefined,
   ): Promise<void> {
-    const instanceId = this._batchIdToInstance.get(batchId);
-    if (instanceId === undefined) return;
+    const instances = this.instancesOfBatchIndex(batchIndex);
+    if (instances.length === 0) return;
 
     const rectAttr = this.geometry.getAttribute("instanceUvRect") as
       InstancedBufferAttribute | undefined;
     if (!rectAttr) return;
 
     if (url == null) {
-      this._requestedImageUrls.delete(instanceId);
-      if (!this._imageOverrides.delete(instanceId)) return;
-      // Zero rect (invisible) until the default image finishes loading, same
-      // as instances that never had an override.
-      const rect = this._defaultRect;
-      rectAttr.setXYZW(
-        instanceId,
-        rect?.x ?? 0,
-        rect?.y ?? 0,
-        rect?.w ?? 0,
-        rect?.h ?? 0,
-      );
-      rectAttr.needsUpdate = true;
+      let cleared = false;
+      for (const instanceId of instances) {
+        this._requestedImageUrls.delete(instanceId);
+        if (!this._imageOverrides.delete(instanceId)) continue;
+        // Zero rect (invisible) until the default image finishes loading,
+        // same as instances that never had an override.
+        const rect = this._defaultRect;
+        rectAttr.setXYZW(
+          instanceId,
+          rect?.x ?? 0,
+          rect?.y ?? 0,
+          rect?.w ?? 0,
+          rect?.h ?? 0,
+        );
+        cleared = true;
+      }
+      if (cleared) {
+        rectAttr.needsUpdate = true;
+        this._onAtlasRectsChanged();
+      }
       return;
     }
 
-    this._requestedImageUrls.set(instanceId, url);
+    for (const instanceId of instances) {
+      this._requestedImageUrls.set(instanceId, url);
+    }
     const rect = await this._ensureAtlas().pack(url);
     this._reportAtlasBytes();
     if (!rect) return;
-    // A newer override or a clear superseded this load while it was in flight.
-    if (this._requestedImageUrls.get(instanceId) !== url) return;
-
-    this._imageOverrides.add(instanceId);
-    this._syncAtlasUniforms();
-    rectAttr.setXYZW(instanceId, rect.x, rect.y, rect.w, rect.h);
-    rectAttr.needsUpdate = true;
+    let applied = false;
+    for (const instanceId of instances) {
+      // A newer override or a clear superseded this load while in flight.
+      if (this._requestedImageUrls.get(instanceId) !== url) continue;
+      this._imageOverrides.add(instanceId);
+      rectAttr.setXYZW(instanceId, rect.x, rect.y, rect.w, rect.h);
+      applied = true;
+    }
+    if (applied) {
+      this._syncAtlasUniforms();
+      rectAttr.needsUpdate = true;
+      this._onAtlasRectsChanged();
+    }
   }
 
   dispose(): void {
@@ -958,7 +1066,7 @@ export class InstancedSpriteMesh
     (this.material as ShaderMaterial).dispose();
 
     // Clear internal collections to release references
-    this._batchIdToInstance.clear();
+    this._batchIndexToInstances = null;
     this._anchors = null;
     this._declutterTargets = null;
     this._declutterPriorityOverrides = null;