@navaramap/three 0.0.0 → 0.0.1

package/dist/index.d.ts

@@ -1791,6 +1791,12 @@ declare class Core {
     getMartini(martini_id: ReconstructableEntity): TransferableMartini | undefined;
     getMemoryStats(): MemoryStats_2 | undefined;
     getParentTile(handle: bigint): TransferableTile | undefined;
+    /**
+     * The WebMercator raster tiles to bake into per-layer drape render targets for a
+     * terrain tile (baked layers only; empty on WebMercator terrain, which drapes 1:1
+     * through the per-slot material path).
+     */
+    getRasterTileStates(handle: bigint): RasterTileState[];
     getTile(handle: bigint): TransferableTile | undefined;
     getTileElevationDecoder(handle: bigint): ElevationDecoder | undefined;
     getTransferablePolygonBatchedFeature(batched_feature_id: bigint): ReturnedTransferablePolygonBatchedFeature | undefined;
@@ -1813,6 +1819,12 @@ declare class Core {
     newBufferU8(byte_length: number, f: Function): number | undefined;
     newBufferU8Cloned(data: Uint8Array): number | undefined;
     newExternalBuffer(byte_length: number): number | undefined;
+    /**
+     * Monotonic revision that changes only when the raster drape resolution could have
+     * changed. The web renderer reads it once per frame and skips the per-terrain-tile
+     * `getRasterTileStates` calls while it is unchanged.
+     */
+    rasterRevision(): number;
     readAllBatchedProperties(renderable_feature_bits: bigint, callback: Function): void;
     readEvents(): Events | undefined;
     readFilteredBatchedProperties(renderable_feature_bits: bigint, keys: any[], callback: Function): void;
@@ -2376,7 +2388,7 @@ export declare type Descriptions = {
  * Why a tile's composite atlas needs to be re-rendered.
  * Aggregated per-handle so a single composite pass services multiple updates.
  */
-declare type DirtyReason = "material" | "texture-binding" | "vector-revision" | "hillshade";
+declare type DirtyReason = "material" | "texture-binding" | "vector-revision" | "raster-revision" | "hillshade";
 
 export declare class DrapedMesh<TGeometry extends BufferGeometry = BufferGeometry<NormalBufferAttributes>, TMaterial extends Material | Material[] = Material | Material[], TEventMap extends Object3DEventMap = Object3DEventMap> extends Mesh_2<TGeometry, TMaterial, TEventMap> {
     drapedEnable: boolean;
@@ -2705,6 +2717,12 @@ declare class ElevationDecoder {
 declare type ElevationHeatmapCompositeLayer = CompositeLayerBase & {
     kind: "elevationHeatmap";
     opacity: number;
+    /**
+     * Same Mercator latitude reprojection band as {@link RasterCompositeLayer}:
+     * the heatmap decode samples the reprojected per-slot UV, so a DEM draped on
+     * Geographic terrain (baked or direct) remaps identically to color imagery.
+     */
+    reproject?: [number, number];
 };
 
 /**
@@ -3467,7 +3485,7 @@ export declare function getWGS84SemiMinorAxis(): number;
  * Provides an interface for accessing and modifying globe properties
  * that are shared across different material types (VectorTile, RasterTile, RasterTerrain).
  */
-export declare class Globe implements Omit<RemoveFreeRecursively<Globe_2>, "elevationColormap" | "color"> {
+export declare class Globe implements Omit<RemoveFreeRecursively<Globe_2>, "elevationColormap" | "color" | "isGeographicTiling"> {
     private handler;
     private _elevationColormap?;
     constructor(handler: GlobeHandler, options?: GlobeOptions);
@@ -3515,6 +3533,14 @@ declare class Globe_2 {
      * Whether to hide underground geometry. Disabling this value might cause unexpected behavior when using effect.
      */
     hideUnderground: boolean;
+    /**
+     * Whether the globe tiles with the Geographic scheme (quantized-mesh
+     * terrain) rather than the default WebMercator. Engine-set output — the
+     * web renderer selects its raster drape pipeline (baked vs direct) from
+     * it at tile-mesh creation; ignored on input (the scheme is dictated by
+     * the terrain source, not configurable).
+     */
+    isGeographicTiling: boolean;
     /**
      * Screen-space error threshold for level of detail (LOD) calculations. Initialization only.
      */
@@ -3567,7 +3593,7 @@ declare type GlobeHandler = {
     setElevationColormap: (value: ColorMap) => void;
 };
 
-declare type GlobeOptions = Partial<Omit<Globe_2, "constructor" | "free" | "elevationColormap" | "color">> & {
+declare type GlobeOptions = Partial<Omit<Globe_2, "constructor" | "free" | "elevationColormap" | "color" | "isGeographicTiling">> & {
     elevationColormap?: ColorMap;
     color?: Color_2;
 };
@@ -6949,6 +6975,30 @@ export declare function radianToDegree(radian: number): number;
 
 export declare const RAIN_ASSETS_URL: string;
 
+/** One baked raster layer: its overlapping WM tile textures, mosaicked into one
+ * render target. Heatmap layers carry encoded DEM, copied raw (nearest, no
+ * color conversion) so the composite decode stays valid. */
+declare type RasterBakeSlot = {
+    isElevationHeatmap: boolean;
+    /**
+     * The decoder's no-data (boundary) color for heatmap slots: painted across
+     * the render target before the sources so uncovered regions decode as
+     * "no elevation" — the no-data story lives entirely in the encoded-elevation
+     * domain, keeping the alpha channel free for future RGBA encodings. Absent
+     * for color slots and for decoders with no byte-representable boundary.
+     */
+    noDataColor?: [number, number, number];
+    sources: RasterBakeSource[];
+};
+
+/** One WebMercator raster tile texture to bake into a layer's render target,
+ * framed by the Rust-resolved mercator affine (terrain `[0,1]` UV → source UV). */
+declare type RasterBakeSource = {
+    texture: Texture;
+    uvOffset: [number, number];
+    uvScale: [number, number];
+};
+
 /** A sampled color layer — a raster tile or a texturized vector scene. */
 declare type RasterCompositeLayer = CompositeLayerBase & {
     kind: "raster";
@@ -7123,6 +7173,27 @@ declare class RasterTileSourceDescription {
     set url(value: string | null | undefined);
 }
 
+/**
+ * One WebMercator raster tile to bake into a layer's drape render target (one per
+ * overlapping WM tile per baked layer). `layer_ordinal` pairs the entry with the k-th
+ * baked composite slot; `fragment_ind`/`fragment_gen` identify the loaded texture
+ * fragment (the web derives its `loadedTexs` key, `${ind}_${gen}`, from them);
+ * `uv_offset`/`uv_scale` place this tile into the terrain tile's `[0, 1]` UV for the
+ * bake camera; `reproject_terrain_lat` is `[south, north]` (radians) on Geographic
+ * terrain (Mercator reprojection) or empty on WebMercator terrain.
+ */
+declare class RasterTileState {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    fragment_gen: number;
+    fragment_ind: number;
+    layer_ordinal: number;
+    reproject_terrain_lat: Float32Array;
+    uv_offset: Float32Array;
+    uv_scale: Float32Array;
+}
+
 export declare type Ray = Required<NormalizeWASMClass<Ray_2>>;
 
 declare class Ray_2 {
@@ -8544,6 +8615,7 @@ declare class ThreeView<D extends Descriptions = EmptyDescriptions> extends Even
     private _buf;
     private _texFragment;
     private _vectorRevision;
+    private _rasterRevision;
     private _tileHandler;
     private _globeHandler;
     private _workerTaskHandler;
@@ -9055,6 +9127,10 @@ declare 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. */
@@ -9087,62 +9163,26 @@ export declare class TileMesh extends Mesh_2<BufferGeometry, TileMaterial, Custo
     maxTextures: number;
     texturizedSceneIndexFrom: number;
     numTexturizedVector: number;
-    private vectorSlots;
-    private prevVectorSignature;
-    private _lastVectorRevision;
+    private readonly vectorDrape;
+    private readonly rasterDrape;
     private shadowMesh?;
-    private texturizedSceneByTileCoordinates;
     private compositor;
-    texturizedSceneRenderTargets: WebGLRenderTarget[];
     private readonly drapeRtSize;
     private readonly atlasBytes;
     private reportedDrapeGpuBytes;
-    private warnedExceededTextures;
     readonly ctx: EventContext;
     constructor(ctx: EventContext, mesh: MeshAdded);
     /**
-     * Pull the Rust-resolved texturized-vector slots for this terrain tile into
-     * {@link vectorSlots}: one bake slot per clamp-to-ground layer, keyed by the
-     * rendered WM vector tile that backs it (ancestor fallback already resolved in
-     * Rust). Only layers with an actual draped scene take a slot — Rust also returns
-     * non-draped layers (rendered in the MRT scene), which must not consume the budget.
-     * Capped to the GPU slot budget; warns once when more draped layers are requested.
-     */
-    private refreshVectorSlots;
-    /**
-     * Size the drape render-target pool to the live slot count (already capped to
-     * `numTexturizedVector` by {@link refreshVectorSlots}): allocate the ones a
-     * newly-draped layer needs, dispose the ones a vanished layer freed. Then
-     * report the pool's GPU footprint to the memory ledger so it tracks drape
-     * memory that scales with terrain subdivision past the vector maxZoom — a cost
-     * per-vector-tile accounting cannot see. Reports only when the count changes.
+     * Report the tile's drape GPU footprint (composite atlas + vector and baked-raster
+     * drape render targets) to the memory ledger when it changed. The atlas is acquired
+     * in the constructor and held for the tile's lifetime regardless of draping, so it
+     * is always part of the report — otherwise a tile whose last draped layer vanished
+     * would report 0 and wipe the atlas cost Rust seeds at mesh-attach time. The render
+     * targets on top of it scale with terrain subdivision past the layers' maxZoom — a
+     * cost per-source-tile accounting cannot see.
      */
-    private syncDrapeRenderTargets;
-    /**
-     * Identity of the current slot set + the backing scenes' content. A change means
-     * the offscreen scenes must be re-baked and the per-slot material state re-bound.
-     */
-    private vectorSignature;
+    private reportDrapeGpuBytesIfChanged;
     private _onBeforeRender;
-    /**
-     * Drive each vector slot's main-shader state per frame: texture, per-slot UV
-     * transform, visibility and the draped mesh's material attributes. One slot per
-     * layer, sourced from the WM vector tile the Rust resolve picked. The resolve
-     * walks up to the nearest rendered tile (readiness derived from ECS activation
-     * / the Rust resolve, not a JS-side scene_ready flag), so the slot's scene is
-     * always bakeable (its own render target was framed by the bake) and the UV is
-     * identity — the ancestor LOD fallback lives entirely in Rust. Replaces the old
-     * scene-observer `updateTexturizedSceneTextureVisibility`.
-     */
-    private bindVectorSlots;
-    /**
-     * First available draped mesh backing any of a layer's sources. A clamp-to-ground
-     * layer's material attributes (water/specular/emissive/…) are uniform across its
-     * tiles, so any source's mesh is a faithful representative for the slot.
-     */
-    private representativeVectorMesh;
-    /** Copy a draped mesh's material attributes into the main shader's slot `lastIdx`. */
-    private copyVectorMeshAttrs;
     /**
      * Feature flags for the **main** TileMesh shader (atlas-sampling side): drives
      * its program cache key and which normal/specular branches compile. Sourced
@@ -9352,12 +9392,16 @@ declare class TileTextureCompositor {
      * per-tile GPU byte cost it reports to the memory ledger. */
     readonly size: number;
     private readonly texturizedScenes;
-    private readonly vectorCamera;
+    private readonly bakeCamera;
     private readonly quadScene;
     private readonly quadCamera;
     private readonly quadMesh;
     private readonly materialCache;
-    private readonly touchedVectorTargets;
+    private readonly touchedTargets;
+    private readonly rasterBakeScene;
+    private readonly rasterBakeMaterial;
+    private demNoDataTexture;
+    private demNoDataTextureKey;
     constructor(opts: TileTextureCompositorOptions);
     acquire(handle: TileHandle): CompositeOutputs;
     release(handle: TileHandle): void;
@@ -9390,6 +9434,53 @@ declare class TileTextureCompositor {
             uvScale: [number, number];
         }[];
     }[], renderTargets: WebGLRenderTarget[]): void;
+    /**
+     * Bake each raster layer's overlapping WM tile textures into ONE render
+     * target (slot `i` → `renderTargets[i]`), mirroring {@link renderVectorScenes}:
+     * every source is a textured quad framed by the Rust-supplied mercator affine
+     * `uvOffset`/`uvScale`, so the render target ends up spanning the terrain
+     * tile's (Mercator-projected) extent and the composite treats the whole layer
+     * as one slot with the terrain-band reprojection — instead of one composite
+     * slot per overlapping tile, which overflowed the GPU slot budget on
+     * Geographic terrain once 3+ layers were draped.
+     *
+     * Sources are drawn coarse-first (ascending `uvScale`): an ancestor fallback
+     * covers the whole terrain rect, so painting it first lets the finer tiles
+     * overwrite it instead of being buried under coarse texels. The bake is a
+     * value-preserving copy (`toneMapped: false`; per-kind color spaces below), so
+     * heatmap DEM texels survive it bit-faithfully:
+     * - color imagery: source + target declared sRGB — decode at fetch, encode at
+     *   write, decode again at the composite fetch: the same linear values the
+     *   direct (non-baked) path produced.
+     * - elevation heatmap: everything `NoColorSpace` + nearest — raw texels, no
+     *   interpolation, so the composite's decode-then-interpolate keeps working.
+     */
+    renderRasterTiles(slots: (RasterBakeSlot | undefined)[], renderTargets: (WebGLRenderTarget | undefined)[]): void;
+    /**
+     * Shared bake loop over per-layer drape render targets (slot `i` →
+     * `renderTargets[i]`): saves/restores the renderer state, clears each live
+     * target once and lets `drawSlot` accumulate that slot's sources into it —
+     * autoClear stays off so the sources mosaic instead of overwriting one
+     * another.
+     */
+    private bakeSlotTargets;
+    /**
+     * Frame the shared bake camera on the terrain tile's sub-rect of a source
+     * from the mercator affine: meshUv ∈ [0,1] → sourceUv = uvOffset +
+     * meshUv·uvScale, source NDC = 2·sourceUv − 1. A source finer than the
+     * terrain tile yields a camera wider than [-1, 1], so it draws into only
+     * its sub-rect and leaves the rest of the render target transparent.
+     */
+    private frameBakeCamera;
+    /** Draw one textured quad into the current render target through the bake
+     * camera window — the value-preserving copy described on
+     * {@link renderRasterTiles}. */
+    private drawRasterBakeQuad;
+    /** The cached 1×1 no-data texture, (re)created when the color changes. */
+    private demNoDataUnderlay;
+    /** Value-preserving sampler settings for a bake source texture (see
+     * {@link renderRasterTiles}); idempotent so re-bakes don't re-upload. */
+    private configureRasterBakeSource;
     /**
      * Run the composite MRT pass for a handle if (and only if) its atlas is
      * dirty. Consumes the dirty flags on success so the next frame skips work