@navaramap/three 0.0.0 → 0.0.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@navaramap/three",
   "type": "module",
-  "version": "0.0.0",
+  "version": "0.0.1",
   "main": "dist/index.umd.cjs",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,7 +12,7 @@
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/eukarya-inc/navara.git",
+    "url": "git+https://github.com/reearth/navara.git",
     "directory": "web/navara_three"
   },
   "publishConfig": {
@@ -30,13 +30,13 @@
     "astronomy-engine": "2.1.19",
     "stats.js": "0.17.0",
     "three-stdlib": "2.36.1",
-    "@navaramap/core": "0.0.0",
-    "@navaramap/worker": "0.0.0",
-    "@navaramap/engine": "0.0.0",
-    "@navaramap/font": "0.0.0",
-    "@navaramap/engine-api": "0.0.0",
-    "@navaramap/three_csm": "0.0.0",
-    "@navaramap/three_api": "0.0.0"
+    "@navaramap/core": "0.0.1",
+    "@navaramap/engine-api": "0.0.1",
+    "@navaramap/engine": "0.0.1",
+    "@navaramap/three_api": "0.0.1",
+    "@navaramap/three_csm": "0.0.1",
+    "@navaramap/font": "0.0.1",
+    "@navaramap/worker": "0.0.1"
   },
   "devDependencies": {
     "@playwright/test": "1.59.1",
@@ -70,10 +70,10 @@
     "tweakpane": "4.0.5",
     "vite-plugin-glsl": "1.6.0",
     "vite-plugin-static-copy": "4.1.0",
-    "@navaramap/three_default_descs": "0.0.0",
-    "@navaramap/three_default_plugin": "0.0.0",
-    "@navaramap/three_plugins": "0.0.0",
-    "@navaramap/three_react": "0.0.0"
+    "@navaramap/three_default_descs": "0.0.1",
+    "@navaramap/three_default_plugin": "0.0.1",
+    "@navaramap/three_plugins": "0.0.1",
+    "@navaramap/three_react": "0.0.1"
   },
   "scripts": {
     "start": "vite",

package/src/event/context.ts

@@ -7,6 +7,7 @@ import type {
 import type {
   DelegatedWorkerTasksResult,
   ElevationDecoder,
+  RasterTileState,
   ReconstructableEntity,
   ReturnedTransferablePolygonBatchedFeature,
   ReturnedTransferablePolylineBatchedFeature,
@@ -106,6 +107,10 @@ export type TileHandler = {
   getTileElevationDecoder: (handle: bigint) => ElevationDecoder | undefined;
   getVectorTileStates: (handle: bigint) => VectorTileState[] | undefined;
   vectorRevision: () => number;
+  /** The WM raster tiles to bake into per-layer drape render targets for a
+   * terrain tile (Geographic terrain only; empty on WebMercator terrain). */
+  getRasterTileStates: (handle: bigint) => RasterTileState[] | undefined;
+  rasterRevision: () => number;
   /** Reports a terrain tile's drape render-target GPU footprint (bytes) so the
    * memory ledger tracks clamp-to-ground vector bakes that scale with terrain
    * subdivision past the vector `maxZoom`. Pass 0 to release on dispose. */

package/src/index.ts

@@ -632,6 +632,8 @@ export default class ThreeView<
   };
   // Per-frame snapshot of the WASM vector resolution revision, refreshed in `_render`.
   private _vectorRevision = 0;
+  // Per-frame snapshot of the WASM raster drape resolution revision, refreshed in `_render`.
+  private _rasterRevision = 0;
   private _tileHandler: TileHandler = {
     getMartini: (id) => {
       return this._core?.getMartini(id);
@@ -651,6 +653,10 @@ export default class ThreeView<
     // Returns the per-frame cached revision (read once in `_render`), so per-tile
     // `onBeforeRender` gating costs no WASM-boundary call.
     vectorRevision: () => this._vectorRevision,
+    getRasterTileStates: (handle) => {
+      return this._core?.getRasterTileStates(handle);
+    },
+    rasterRevision: () => this._rasterRevision,
     reportDrapeGpuBytes: (handle, bytes) => {
       this._core?.reportTerrainDrapeGpuBytes(handle, bytes);
     },
@@ -1739,9 +1745,11 @@ export default class ThreeView<
   }
 
   private _render(updatedAt: number) {
-    // Read the vector resolution revision once per frame so each terrain tile's
-    // `onBeforeRender` can gate its slot re-fetch against it without its own FFI call.
+    // Read the vector/raster resolution revisions once per frame so each terrain
+    // tile's `onBeforeRender` can gate its slot re-fetch against them without its
+    // own FFI calls.
     this._vectorRevision = this._core?.vectorRevision() ?? this._vectorRevision;
+    this._rasterRevision = this._core?.rasterRevision() ?? this._rasterRevision;
 
     this._uniforms.time.value = updatedAt;
 

package/src/material/enhancer/tileComposite/tileCompositeBaseEnhancer/mutates.ts

@@ -104,8 +104,13 @@ export function createCoreUniformMutates(): CoreUniformMutates {
         refs.uLayerUvScale.value[k].set(1, 1);
       }
 
+      // Reproject applies to color rasters and elevation heatmaps alike — the
+      // shader warps the per-slot UV before either sampler runs; hillshade is
+      // terrain-side and never reprojects.
       const reproject =
-        layer && layer.kind === "raster" ? layer.reproject : undefined;
+        layer && (layer.kind === "raster" || layer.kind === "elevationHeatmap")
+          ? layer.reproject
+          : undefined;
       if (reproject && layer) {
         const [Ts, Tn] = reproject;
         // Recover the source tile's latitude band [Rs, Rn] from the affine y

package/src/material/enhancer/tileComposite/tileElevationHeatmapEnhancer/shader.ts

@@ -10,6 +10,12 @@ export const elevationIncludes = (): string => ElevationParsFragment;
 /**
  * Replaces the per-slot sampler with a DEM-decode + colormap lookup; non-heatmap
  * slots fall back to the straight raster fetch in the else branch.
+ *
+ * The heatmap alpha derives from the decode's validity: a no-data (boundary)
+ * texel — including a baked drape render target's uncovered regions, which the
+ * bake paints with the boundary color — renders transparent instead of being
+ * colormapped as height 0. The DEM texel's alpha channel is never read: it is
+ * not part of any elevation encoding and stays reserved for future RGBA ones.
  */
 export const elevationSampleProducer = ({
   k,
@@ -17,8 +23,9 @@ export const elevationSampleProducer = ({
     vec4 texColor${k};
     if (uIsElevationHeatmaps[${k}]) {
       ivec2 demTexSize = textureSize(uTextures[${k}], 0);
-      float normalized_h = sampleElevationBilinear(uTextures[${k}], texUv${k}, demTexSize);
-      texColor${k} = vec4(texture2D(uColorMapTexture, vec2(normalized_h, 0.5)).rgb, 1.0);
+      bool demValid${k};
+      float normalized_h = sampleElevationBilinear(uTextures[${k}], texUv${k}, demTexSize, demValid${k});
+      texColor${k} = vec4(texture2D(uColorMapTexture, vec2(normalized_h, 0.5)).rgb, demValid${k} ? 1.0 : 0.0);
     } else {
       texColor${k} = texture2D(uTextures[${k}], texUv${k}) * vec4(uColors[${k}], 1.0);
     }`;

package/src/mesh/tile/drapeResolver.ts

@@ -0,0 +1,76 @@
+import type {
+  MagnificationTextureFilter,
+  MinificationTextureFilter,
+  Texture,
+} from "three";
+
+import type { TextureOptions } from "../../textures";
+
+/**
+ * A drape resolver owns one family of composite material slots for a terrain
+ * tile: how its layers' pixels reach those slots (direct texture binding or an
+ * offscreen bake into per-layer render targets), gated so the work only runs
+ * when the Rust-side resolve or the backing content actually changed.
+ *
+ * Three implementations, side by side, spell out the rendering differences:
+ * - {@link VectorDrapeResolver} (`vectorDrapeResolver.ts`) — clamp-to-ground
+ *   vector layers. Always baked on every tiling scheme (vector content is an
+ *   offscreen scene, so rasterizing is intrinsic); WebMercator terrain is the
+ *   degenerate single-source identity case, Geographic terrain the N:M mosaic.
+ * - `DirectRasterDrapeResolver` (`rasterDrapeResolver.ts`) — raster layers on
+ *   WebMercator terrain. Same-scheme 1:1: the fetched tile texture is bound
+ *   straight to its slot by `setupTextures`; every hook is a no-op.
+ * - `BakedRasterDrapeResolver` (`rasterDrapeResolver.ts`) — raster layers on
+ *   Geographic (quantized-mesh) terrain. Cross-scheme N:M mosaic bake with
+ *   per-slot Mercator latitude reprojection.
+ */
+export type DrapeResolver = {
+  /**
+   * Per-frame hook (`_onBeforeRender`): refresh the Rust-resolved slots when
+   * the resolve revision moved, and re-bake when the slot/content signature
+   * changed (which also catches async content landing after the resolve).
+   */
+  update(): void;
+
+  /**
+   * `setupTextures` hook, after the material's per-slot arrays were rebuilt:
+   * re-derive the resolver's slot pairing and rebind (or invalidate) its
+   * textures. `textureFragments` holds the raster region's per-slot fragment
+   * ids; the vector resolver ignores it (its region is positional).
+   */
+  syncMaterialSlots(
+    textureFragments: readonly (string | null | undefined)[] | undefined,
+  ): void;
+
+  /**
+   * Mercator latitude reprojection band (`[south, north]`, radians) for one of
+   * this resolver's composite slots, or undefined when the slot samples
+   * without reprojection.
+   */
+  slotReproject(absSlot: number): [number, number] | undefined;
+
+  /**
+   * Force a re-bake + re-bind on the next `update()` even though the resolved
+   * slots are unchanged (e.g. picking passes repaint the offscreen content).
+   */
+  invalidate(): void;
+
+  /** Live drape render targets, counted into the tile's GPU byte report. */
+  liveRenderTargetCount(): number;
+
+  dispose(): void;
+};
+
+/** Apply the shared texturized-slot sampler settings to a drape render target's
+ * texture. Returns the texture for call-site chaining. */
+export function configureTexturizedTexture(
+  tex: Texture,
+  textureOptions: TextureOptions,
+): Texture {
+  tex.minFilter = textureOptions.minFilter as MinificationTextureFilter;
+  tex.magFilter = textureOptions.magFilter as MagnificationTextureFilter;
+  tex.anisotropy = textureOptions.maxAnisotropy;
+  tex.generateMipmaps = textureOptions.useMipmaps;
+  tex.needsUpdate = true;
+  return tex;
+}

package/src/mesh/{tile.test.ts → tile/index.test.ts}

@@ -1,9 +1,9 @@
 import { Mesh, BoxGeometry, MeshBasicMaterial } from "three";
 import { describe, expect, it, vi } from "vitest";
 
-import { TexturizedSceneByTileCoordinates } from "../scene";
+import { TexturizedSceneByTileCoordinates } from "../../scene";
 
-import { TileMesh } from "./tile";
+import { TileMesh } from ".";
 
 // The package barrel pulled in by tile.ts initializes a worker pool at module
 // load (os.cpus()), which is unavailable in the test environment. Stub it.
@@ -36,6 +36,7 @@ function state(layerId: string, tileHandle: bigint) {
     uv_offset: new Float32Array([0, 0]),
     uv_scale: new Float32Array([1, 1]),
     reproject_terrain_lat: new Float32Array([]),
+    free: vi.fn(),
   };
 }
 
@@ -86,6 +87,9 @@ function makeTile(atlasSize = 512) {
 
   const meshAdded = {
     tile_handle: 1n,
+    // WebMercator tiling → the direct (no-op) raster drape resolver, keeping
+    // the baked-raster machinery out of these vector-drape tests.
+    globe: { isGeographicTiling: false, free: vi.fn() },
   } as unknown as ConstructorParameters<typeof TileMesh>[1];
 
   const tile = new TileMesh(ctx, meshAdded);
@@ -109,8 +113,11 @@ const RT_BYTES_SMALL = 256 * 256 * 4;
 const ATLAS_BYTES_SMALL = 256 * 256 * 4 * 3;
 
 function renderTargetCount(tile: TileMesh): number {
-  return (tile as unknown as { texturizedSceneRenderTargets: unknown[] })
-    .texturizedSceneRenderTargets.length;
+  return (
+    tile as unknown as {
+      vectorDrape: { liveRenderTargetCount(): number };
+    }
+  ).vectorDrape.liveRenderTargetCount();
 }
 
 /** Invoke the private onBeforeRender hook (args are ignored by the impl). */
@@ -207,8 +214,11 @@ describe("TileMesh vector bake dirty-gating", () => {
 
     frame(tile);
 
-    const slots = (tile as unknown as { vectorSlots: { layerId: string }[] })
-      .vectorSlots;
+    const slots = (
+      tile as unknown as {
+        vectorDrape: { vectorSlots: { layerId: string }[] };
+      }
+    ).vectorDrape.vectorSlots;
     expect(slots.map((s) => s.layerId).sort()).toEqual(["a", "c"]);
     expect(renderVectorScenes).toHaveBeenCalledTimes(1);
   });