@navaramap/three 0.0.4 → 0.0.5

package/src/evaluations/FeatureEvaluator.ts

@@ -14,7 +14,7 @@ import { BufferGeometry, Mesh, Object3D } from "three";
 import type { NormalBufferAttributes } from "three";
 
 import { Color } from "../Color";
-import type { FeatureHandler } from "../event";
+import type { FeatureHandler } from "../event/context";
 import {
   InstancedMesh,
   isFeatureMesh,
@@ -25,6 +25,8 @@ import {
   type BatchedAttributeName,
   InstancedSpriteMesh,
   BatchedSdfTextMesh,
+  type GeometryType,
+  VALID_GEOMETRY_TYPES,
 } from "../mesh";
 
 type AvailableMaterialProperty = ExtractProperties<
@@ -86,6 +88,13 @@ export type EvaluatedValue = {
   [K in EvaluatableMaterialPropertyKey]: EvaluatedMaterialProperty[K];
 };
 
+/**
+ * Re-export GeometryType from mesh constants for convenience.
+ * Geometry type for feature evaluation context.
+ * Tells the evaluator which geometry type is being rendered.
+ */
+export type { GeometryType };
+
 /**
  * Information about a feature batch, passed to evaluation callbacks.
  */
@@ -93,6 +102,8 @@ export type FeatureInfo = {
   batchId: number;
   properties: Record<string, unknown> | undefined;
   layerId: LayerId | undefined;
+  /** Mesh geometry type (e.g., "billboard", "text"). Not GeoJSON geometry ("Point", "Polygon"). */
+  meshGeomType?: GeometryType;
 };
 
 /**
@@ -185,6 +196,49 @@ export class FeatureEvaluator {
     this.obj = obj;
   }
 
+  /**
+   * Track objects we've already warned about to avoid log spam.
+   * Uses WeakSet so objects can be garbage collected.
+   */
+  private static readonly warnedObjects = new WeakSet<Object3D>();
+
+  /**
+   * Type guard to check if an Object3D has a geometryType getter.
+   */
+  private hasGeometryType(
+    obj: Object3D,
+  ): obj is Object3D & { geometryType: unknown } {
+    return "geometryType" in obj;
+  }
+
+  /**
+   * Determine geometry type from the mesh object.
+   * Reads geometryType getter if available on the mesh.
+   * Validates that the returned value is a valid GeometryType literal.
+   */
+  private determineGeometryType(obj: Object3D): GeometryType | undefined {
+    if (this.hasGeometryType(obj)) {
+      const value = obj.geometryType;
+
+      // Runtime validation: ensure the returned value is a valid GeometryType
+      if (
+        typeof value === "string" &&
+        VALID_GEOMETRY_TYPES.includes(value as GeometryType)
+      ) {
+        return value as GeometryType;
+      }
+
+      // Invalid value from geometryType - warn once per object to avoid log spam
+      if (!FeatureEvaluator.warnedObjects.has(obj)) {
+        FeatureEvaluator.warnedObjects.add(obj);
+        console.warn(
+          `Invalid geometry type returned from geometryType getter: "${value}". Expected one of: ${VALID_GEOMETRY_TYPES.join(", ")}`,
+        );
+      }
+    }
+    return undefined;
+  }
+
   /**
    * Gets the unique identifier of this feature set.
    */
@@ -214,6 +268,9 @@ export class FeatureEvaluator {
    * ```
    */
   readFeatureProperties(f: (info: FeatureInfo, batchIndex: number) => void) {
+    // Read geometry type dynamically to handle cases where it changes after evaluator creation
+    const meshGeomType = this.determineGeometryType(this.obj);
+
     if (this.cachedBatchedProperties) {
       for (const [batchIdx, properties] of this.cachedBatchedProperties) {
         f(
@@ -221,6 +278,7 @@ export class FeatureEvaluator {
             layerId: this.layerId,
             batchId: this.batchIds[batchIdx],
             properties,
+            meshGeomType,
           },
           batchIdx,
         );
@@ -241,6 +299,7 @@ export class FeatureEvaluator {
               layerId: this.layerId,
               batchId,
               properties,
+              meshGeomType,
             },
             batchIdx,
           );
@@ -267,6 +326,9 @@ export class FeatureEvaluator {
     keys: string[],
     f: (info: FeatureInfo, batchIndex: number) => void,
   ) {
+    // Read geometry type dynamically to handle cases where it changes after evaluator creation
+    const meshGeomType = this.determineGeometryType(this.obj);
+
     const cacheKey = keys.join("|");
     if (this.filterCacheKey === cacheKey && this.cachedFilteredProperties) {
       for (const [batchIndex, filtered] of this.cachedFilteredProperties) {
@@ -275,6 +337,7 @@ export class FeatureEvaluator {
             layerId: this.layerId,
             batchId: this.batchIds[batchIndex],
             properties: filtered,
+            meshGeomType,
           },
           batchIndex,
         );
@@ -293,7 +356,15 @@ export class FeatureEvaluator {
           }
           this.cachedFilteredProperties?.set(batchIndex, properties);
           this.batchIds[batchIndex] = batchId;
-          f({ layerId: this.layerId, batchId, properties }, batchIndex);
+          f(
+            {
+              layerId: this.layerId,
+              batchId,
+              properties,
+              meshGeomType,
+            },
+            batchIndex,
+          );
         },
       );
     }

package/src/event/features/billboard.ts

@@ -13,6 +13,7 @@ export async function renderBillboard(
   const mesh = new InstancedSpriteMesh({
     renderOrder: FEATURE_RENDER_ORDER,
     ctx,
+    geometryType: "billboard",
   });
   await mesh._init(m);
   mesh.setActive(m.active);

package/src/event/features/point.ts

@@ -8,6 +8,7 @@ export async function renderPoint(ctx: EventContext, m: NavaraPointMesh) {
   const mesh = new InstancedSpriteMesh({
     renderOrder: FEATURE_RENDER_ORDER,
     ctx,
+    geometryType: "point",
   });
   await mesh._init(m);
   mesh.setActive(m.active);

package/src/index.ts

@@ -1044,6 +1044,9 @@ export default class ThreeView<
       this._camera,
     );
     this._atmosphere.on("needsUpdate", this.forceUpdate);
+    // Textures load lazily, kicked off by the first consumer registering via
+    // onTexturesReady(); re-render whenever they arrive.
+    this._atmosphere.on("textureLoaded", this.forceUpdate);
 
     this.on("layer", (e, id, ...args) => {
       this.layersManager.emitById(e, id, ...args);
@@ -1327,14 +1330,9 @@ export default class ThreeView<
         budgets.maxWorkerHeapBytes,
     });
 
-    // 1. Pre-fetch atmosphere resources. Non-blocking: consumers receive
-    // the textures through onTexturesReady() once they arrive.
-    this._atmosphere._init().then(
-      () => this.forceUpdate(),
-      (e) => console.error("Failed to load atmosphere textures:", e),
-    );
-
-    // 2. Fetch WASM resources.
+    // Fetch WASM resources. Atmosphere textures are not fetched here: they
+    // load lazily once a consumer (sky, sun light, aerial perspective, ...)
+    // registers via atmosphere.onTexturesReady().
     await Promise.all([initCore(), initNavaraApi()]);
 
     this._core = new Core(newId());
@@ -1480,7 +1478,7 @@ export default class ThreeView<
 
     this.viewContext._setRenderPass(this.renderPass);
 
-    // 3. Warm up workers. Non-blocking: warms one worker, the rest follow
+    // Warm up workers. Non-blocking: warms one worker, the rest follow
     // in the background off the HTTP cache; tasks dispatched to a still-cold
     // worker just await WASM inside the task.
     warmUpWorkerPool().catch((e) =>

package/src/material/enhancer/sdfText/sdfTextBaseEnhancer/index.ts

@@ -21,15 +21,18 @@ import type {
 /**
  * Factory function to create an sdfText base enhancer.
  *
- * This enhancer handles:
- * - Text color, font size, centering
- * - Outline (width, color, opacity)
+ * One enhancer drives the whole tile-layer batch, so it owns only batch-wide
+ * state:
+ * - Anchor centering, outline (width, color, opacity)
  * - Background quad (color, border)
- * - Height offset, depth offset
- * - Picking
+ * - Depth offset and picking mode
  * - RTE (Relative-To-Eye) support for high-precision coordinates
  * - Billboard scaling by distance
- * - SDF atlas texture management
+ * - SDF atlas and per-label data texture management
+ *
+ * Per-label values (position, colour, opacity, font size, height, block
+ * metrics, batch id, declutter fade) are not here — they live in the label
+ * data texture the mesh owns.
  *
  * Supports ShaderMaterial with custom sdfText shaders.
  *
@@ -71,7 +74,7 @@ export function createSdfTextBaseEnhancer(
       };
       state = updateState(mergedProps, initialState);
       // Create mutates (refs are created inside with default values)
-      mutates = createBaseMutates(mergedProps.useRTE, mergedProps.rtcCenter);
+      mutates = createBaseMutates(mergedProps.rtcCenter);
       mutates.update(state);
 
       // Set atlas texture external ref if provided

package/src/material/enhancer/sdfText/sdfTextBaseEnhancer/mutates.test.ts

@@ -19,11 +19,8 @@ describe("sdfTextBaseEnhancer/mutates", () => {
     it("should sync core refs from state", () => {
       const state: SdfTextBaseState = {
         ...DEFAULT_BASE_STATE,
-        color: new Color(0xff0000),
-        fontSize: 24,
         center: [0.5, 0.5],
         sizeInMeters: true,
-        addHeight: 50,
         offsetDepth: false,
         outlineWidth: 0.1,
         outlineColor: new Color(0x00ff00),
@@ -34,18 +31,15 @@ describe("sdfTextBaseEnhancer/mutates", () => {
         backgroundOutlineWidth: 0.2,
         pickable: true,
       };
-      const mutates = createBaseMutates(false);
+      const mutates = createBaseMutates();
       mutates.update(state);
 
       const uniforms: ShaderUniforms = {};
       mutates.updateUniforms(uniforms, state);
 
-      expect(uniforms.uColor?.value.getHex()).toBe(0xff0000);
-      expect(uniforms.uFontSize?.value).toBe(24);
       expect(uniforms.uCenter?.value.x).toBe(0.5);
       expect(uniforms.uCenter?.value.y).toBe(0.5);
       expect(uniforms.uSizeInMeters?.value).toBe(true);
-      expect(uniforms.uAddHeight?.value).toBe(50);
       expect(uniforms.uOffsetDepth?.value).toBe(false);
       expect(uniforms.uOutlineWidth?.value).toBe(0.1);
       expect(uniforms.uOutlineColor?.value.getHex()).toBe(0x00ff00);
@@ -61,7 +55,7 @@ describe("sdfTextBaseEnhancer/mutates", () => {
   describe("RTC center", () => {
     it("should initialize uRTCCenter from constructor args", () => {
       const state: SdfTextBaseState = { ...DEFAULT_BASE_STATE };
-      const mutates = createBaseMutates(false, [10, 20, 30]);
+      const mutates = createBaseMutates([10, 20, 30]);
       mutates.update(state);
 
       const uniforms: ShaderUniforms = {};
@@ -73,41 +67,60 @@ describe("sdfTextBaseEnhancer/mutates", () => {
     });
   });
 
-  describe("RTE position refs", () => {
-    it("should create RTE position uniforms when useRTE=true", () => {
-      const state: SdfTextBaseState = {
-        ...DEFAULT_BASE_STATE,
-        useRTE: true,
-      };
-      const mutates = createBaseMutates(true);
-      mutates.update(state);
-
-      const uniforms: ShaderUniforms = {};
-      mutates.updateUniforms(uniforms, state);
-
-      expect(uniforms.uRTEPositionLOW).toBeDefined();
-      expect(uniforms.uRTEPositionHIGH).toBeDefined();
-      expect(uniforms.uRTCPosition).toBeUndefined();
-    });
-
-    it("should create RTC position uniform when useRTE=false", () => {
+  describe("per-label state is not uniform state", () => {
+    // Anchors used to be uRTEPositionHIGH/LOW (RTE) or uRTCPosition (RTC) —
+    // one material per label. Batched, every label's anchor is a texel in
+    // uLabelData, so these uniforms must not come back: a single one would
+    // silently place the whole batch at one point.
+    it.each([true, false])(
+      "exposes no position uniforms (useRTE=%s)",
+      (useRTE) => {
+        const state: SdfTextBaseState = { ...DEFAULT_BASE_STATE, useRTE };
+        const mutates = createBaseMutates();
+        mutates.update(state);
+
+        const uniforms: ShaderUniforms = {};
+        mutates.updateUniforms(uniforms, state);
+
+        expect(uniforms.uRTEPositionLOW).toBeUndefined();
+        expect(uniforms.uRTEPositionHIGH).toBeUndefined();
+        expect(uniforms.uRTCPosition).toBeUndefined();
+        // The batch-wide RTC origin does stay a uniform.
+        expect(uniforms.uRTCCenter).toBeDefined();
+        expect(uniforms.uLabelData).toBeDefined();
+      },
+    );
+
+    it("exposes no per-label style or batch-id uniforms", () => {
       const state: SdfTextBaseState = { ...DEFAULT_BASE_STATE };
-      const mutates = createBaseMutates(false);
+      const mutates = createBaseMutates();
       mutates.update(state);
 
       const uniforms: ShaderUniforms = {};
       mutates.updateUniforms(uniforms, state);
 
-      expect(uniforms.uRTCPosition).toBeDefined();
-      expect(uniforms.uRTEPositionLOW).toBeUndefined();
-      expect(uniforms.uRTEPositionHIGH).toBeUndefined();
+      for (const name of [
+        "uColor",
+        "uOpacity",
+        "uFontSize",
+        "uAddHeight",
+        "uTextWidth",
+        "uTextHeight",
+        "uBgYBounds",
+        "uDeclutterHide",
+        "nvr_uBatchId",
+      ]) {
+        expect(uniforms).not.toHaveProperty(name);
+      }
+      // Pick mode is still batch-wide.
+      expect(uniforms.nvr_uPickable).toBeDefined();
     });
   });
 
   describe("atlas texture ref", () => {
     it("should update uAtlas value without replacing uniform ref", () => {
       const state: SdfTextBaseState = { ...DEFAULT_BASE_STATE };
-      const mutates = createBaseMutates(false);
+      const mutates = createBaseMutates();
       mutates.update(state);
 
       const uniforms: ShaderUniforms = {};
@@ -130,7 +143,7 @@ describe("sdfTextBaseEnhancer/mutates", () => {
   describe("updateAtlasSizes", () => {
     it("should sync uSdfAtlasSize and uColorAtlasSize from bound texture images", () => {
       const state: SdfTextBaseState = { ...DEFAULT_BASE_STATE };
-      const mutates = createBaseMutates(false);
+      const mutates = createBaseMutates();
       mutates.update(state);
 
       const sdfTex = {
@@ -155,7 +168,7 @@ describe("sdfTextBaseEnhancer/mutates", () => {
 
     it("should pick up new dimensions after the atlas grows", () => {
       const state: SdfTextBaseState = { ...DEFAULT_BASE_STATE };
-      const mutates = createBaseMutates(false);
+      const mutates = createBaseMutates();
       mutates.update(state);
 
       const sdfTex = {
@@ -184,7 +197,7 @@ describe("sdfTextBaseEnhancer/mutates", () => {
 
     it("should leave atlas size uniforms unchanged when textures are null", () => {
       const state: SdfTextBaseState = { ...DEFAULT_BASE_STATE };
-      const mutates = createBaseMutates(false);
+      const mutates = createBaseMutates();
       mutates.update(state);
 
       // Both uAtlas and uColorAtlas default to null.
@@ -202,7 +215,7 @@ describe("sdfTextBaseEnhancer/mutates", () => {
 
     it("should leave atlas size uniforms unchanged when image has zero dimensions", () => {
       const state: SdfTextBaseState = { ...DEFAULT_BASE_STATE };
-      const mutates = createBaseMutates(false);
+      const mutates = createBaseMutates();
       mutates.update(state);
 
       const sdfTex = {
@@ -222,7 +235,7 @@ describe("sdfTextBaseEnhancer/mutates", () => {
   describe("updatePerFrame", () => {
     it("should update camera uniforms", () => {
       const state: SdfTextBaseState = { ...DEFAULT_BASE_STATE };
-      const mutates = createBaseMutates(false);
+      const mutates = createBaseMutates();
       mutates.update(state);
 
       mutates.updatePerFrame(1.5, 1080, 10000, 0, 0, 0, new Matrix4(), state);
@@ -240,7 +253,7 @@ describe("sdfTextBaseEnhancer/mutates", () => {
         ...DEFAULT_BASE_STATE,
         useRTE: true,
       };
-      const mutates = createBaseMutates(true);
+      const mutates = createBaseMutates();
       mutates.update(state);
 
       mutates.updatePerFrame(
@@ -268,7 +281,7 @@ describe("sdfTextBaseEnhancer/mutates", () => {
 
     it("should not update RTE eye uniforms when useRTE=false", () => {
       const state: SdfTextBaseState = { ...DEFAULT_BASE_STATE };
-      const mutates = createBaseMutates(false);
+      const mutates = createBaseMutates();
       mutates.update(state);
 
       mutates.updatePerFrame(
@@ -292,7 +305,7 @@ describe("sdfTextBaseEnhancer/mutates", () => {
 
     it("should transform the RTC center into view space when useRTE=false", () => {
       const state: SdfTextBaseState = { ...DEFAULT_BASE_STATE };
-      const mutates = createBaseMutates(false, [6_400_000, 0, 0]);
+      const mutates = createBaseMutates([6_400_000, 0, 0]);
       mutates.update(state);
 
       // View matrix cancels the center's large X so it lands near the origin.
@@ -308,74 +321,54 @@ describe("sdfTextBaseEnhancer/mutates", () => {
     });
   });
 
-  describe("updateTextDimensions", () => {
-    it("should update text dimension uniforms", () => {
+  describe("setLabelDataTexture", () => {
+    it("should bind the texture and its dimensions", () => {
       const state: SdfTextBaseState = { ...DEFAULT_BASE_STATE };
-      const mutates = createBaseMutates(false);
-      mutates.update(state);
-
-      mutates.updateTextDimensions(5.0, 1.0, -0.2, 0.8);
-
-      const uniforms: ShaderUniforms = {};
-      mutates.updateUniforms(uniforms, state);
-
-      expect(uniforms.uTextWidth?.value).toBe(5.0);
-      expect(uniforms.uTextHeight?.value).toBe(1.0);
-      expect(uniforms.uBgYBounds?.value.x).toBe(-0.2);
-      expect(uniforms.uBgYBounds?.value.y).toBe(0.8);
-    });
-  });
-
-  describe("setPosition", () => {
-    it("should set RTE position uniforms", () => {
-      const state: SdfTextBaseState = {
-        ...DEFAULT_BASE_STATE,
-        useRTE: true,
-      };
-      const mutates = createBaseMutates(true);
+      const mutates = createBaseMutates();
       mutates.update(state);
 
-      const high = new Float32Array([100, 200, 300]);
-      const low = new Float32Array([0.1, 0.2, 0.3]);
-      mutates.setPosition({ high, low }, true);
+      const tex = { isDataTexture: true } as unknown as DataTexture;
+      mutates.setLabelDataTexture(tex, 64, 5);
 
       const uniforms: ShaderUniforms = {};
       mutates.updateUniforms(uniforms, state);
 
-      expect(uniforms.uRTEPositionHIGH?.value.x).toBe(100);
-      expect(uniforms.uRTEPositionLOW?.value.x).toBeCloseTo(0.1);
+      expect(uniforms.uLabelData?.value).toBe(tex);
+      expect(uniforms.uLabelTexSize?.value.x).toBe(64);
+      expect(uniforms.uLabelTexSize?.value.y).toBe(5);
     });
 
-    it("should set RTC position uniforms", () => {
+    // The shader does `i % size.x` and `i / size.x`; a zero would divide by
+    // zero before the mesh has bound anything.
+    it("should never expose a zero dimension", () => {
       const state: SdfTextBaseState = { ...DEFAULT_BASE_STATE };
-      const mutates = createBaseMutates(false);
+      const mutates = createBaseMutates();
       mutates.update(state);
 
-      const pos = new Float32Array([10, 20, 30]);
-      mutates.setPosition(pos, false, [100, 200, 300]);
+      mutates.setLabelDataTexture(null, 0, 0);
 
       const uniforms: ShaderUniforms = {};
       mutates.updateUniforms(uniforms, state);
 
-      expect(uniforms.uRTCPosition?.value.x).toBe(10);
-      expect(uniforms.uRTCPosition?.value.y).toBe(20);
-      expect(uniforms.uRTCCenter?.value.x).toBe(100);
-      expect(uniforms.uRTCCenter?.value.y).toBe(200);
+      expect(uniforms.uLabelTexSize?.value.x).toBe(1);
+      expect(uniforms.uLabelTexSize?.value.y).toBe(1);
     });
   });
 
-  describe("setBatchId", () => {
-    it("should update nvr_uBatchId value", () => {
+  describe("setRtcCenter", () => {
+    it("should update uRTCCenter after a transform change", () => {
       const state: SdfTextBaseState = { ...DEFAULT_BASE_STATE };
-      const mutates = createBaseMutates(false);
+      const mutates = createBaseMutates([1, 2, 3]);
       mutates.update(state);
 
-      mutates.setBatchId(42);
+      mutates.setRtcCenter([100, 200, 300]);
 
       const uniforms: ShaderUniforms = {};
       mutates.updateUniforms(uniforms, state);
 
-      expect(uniforms.nvr_uBatchId?.value).toBe(42);
+      expect(uniforms.uRTCCenter?.value.x).toBe(100);
+      expect(uniforms.uRTCCenter?.value.y).toBe(200);
+      expect(uniforms.uRTCCenter?.value.z).toBe(300);
     });
   });
 });