@navaramap/three 0.0.2 → 0.0.4

package/dist/index.d.ts

@@ -6,10 +6,10 @@ import { BufferAttribute } from 'three';
 import { BufferGeometry } from 'three';
 import { BufferGeometryEventMap } from 'three';
 import { Camera } from 'three';
-import { CascadedShadowMaps } from '@navaramap/three_csm';
+import { CascadedShadowMaps } from '@navaramap/three-csm';
 import { Color as Color_3 } from 'three';
 import { CopyPass as CopyPass_2 } from 'postprocessing';
-import { CSMHelper } from '@navaramap/three_csm';
+import { CSMHelper } from '@navaramap/three-csm';
 import { CssFontFaceFilter } from '@navaramap/font';
 import { DataTexture } from 'three';
 import { DepthCopyPass } from 'postprocessing';
@@ -224,6 +224,40 @@ export declare class Atmosphere extends EventHandler<AtmosphereEvents> {
      * @returns `true` if the position is on the night side, `false` otherwise.
      */
     isAtNight(position: XYZ): boolean;
+    /**
+     * Returns the sun's elevation angle in degrees above the local horizon at
+     * `location` for the current {@link date}. Positive is above the horizon,
+     * negative below (night); includes atmospheric refraction.
+     *
+     * @example
+     * const elevation = view.atmosphere.getSunElevation(view.camera.positionGeographic);
+     * if (elevation < 0) console.log("The sun has set.");
+     */
+    getSunElevation(location: {
+        lat: number;
+        lng: number;
+    }): number;
+    /**
+     * Returns the local apparent solar time at `lng` for the current
+     * {@link date}, in hours in the range [0, 24) where 12 is solar noon.
+     * Accounts for the equation of time.
+     *
+     * @example
+     * const hours = view.atmosphere.getSolarTime({ lng: 139.69 }); // e.g. 6.3 = 06:18
+     */
+    getSolarTime(location: {
+        lng: number;
+    }): number;
+    /**
+     * Sets {@link date} so the local apparent solar time at `lng` equals `hours`
+     * (0–24), keeping the same solar day. Inverse of {@link getSolarTime}.
+     *
+     * @example
+     * view.atmosphere.setSolarTime({ lng: 139.69 }, 6.3); // sunrise over Tokyo
+     */
+    setSolarTime(location: {
+        lng: number;
+    }, hours: number): void;
     /**
      * Gets the current date used for calculating sun/moon positions.
      */
@@ -881,6 +915,15 @@ export declare class BatchedSdfTextMesh extends InstancedMesh<SDFTextMesh> imple
      * and must be balanced with unloadFont() on dispose or font change.
      */
     private _loadedFaceUrls;
+    /** Geometry-extracted anchor data; per-index meshes slice it lazily. */
+    private _positions;
+    /** Sparse batchIndex → mesh; `allMeshes` holds only created meshes. */
+    private _meshByIndex;
+    /** Evaluator state received before a feature's mesh exists. */
+    private _pending;
+    /** Material/transform used when creating meshes lazily. */
+    private _material;
+    private _transform;
     constructor(ctx: EventContext, m: TextMesh, fontIdentifier: string, options: InstancedMeshOptions, loadedFaceUrls?: Set<string>);
     collectDeclutterCandidates(out: DeclutterCandidate[]): void;
     applyDeclutter(handle: number, hidden: boolean): void;
@@ -898,13 +941,43 @@ export declare class BatchedSdfTextMesh extends InstancedMesh<SDFTextMesh> imple
     private _revalidateStaleMeshes;
     get fontIdentifier(): string;
     get highQuality(): boolean;
+    /**
+     * A mesh per anchor is expensive (geometry + ShaderMaterial + enhancer
+     * mount), and with per-feature texts (MVT) most features never receive a
+     * non-empty text — they'd sit invisible while still costing construction and
+     * every per-frame loop. So meshes are created lazily by `_ensureMeshAt` on
+     * the first non-empty `setTextByBatchIndex`. Only a non-empty material-level
+     * default text (single-label sources) renders without the evaluator ever
+     * setting text, so only that case creates all meshes eagerly.
+     */
     private initMeshes;
+    /** The font-level shared atlas textures for this batch's font+quality (the
+     *  color atlas is `null` for monochrome fonts). */
+    private _sharedTextures;
+    /**
+     * The feature's mesh, created on first need (see `initMeshes`). `shared`
+     * lets a batch creation pass hoist the atlas lookups; when omitted (a single
+     * lazy creation) they are fetched here, since the atlas may have been
+     * (re)allocated since this batch was constructed.
+     */
+    private _ensureMeshAt;
+    /** Pending-state slot for a feature whose mesh doesn't exist yet. */
+    private _pendingAt;
     _update(m: TextMesh, needRender?: () => void): Promise<void>;
     private _applyUpdate;
     onBeforePicking(): void;
     onAfterPicking(): void;
     private extractPositions;
     setTextByBatchIndex(batchIndex: number, text: string): void;
+    /**
+     * The mesh for a feature's `batchIndex`, or `undefined` if not created yet.
+     * Meshes are created lazily and pushed onto `allMeshes` in creation order, so
+     * `allMeshes[batchIndex]` (the base-class mapping) does NOT hold here; the
+     * batchIndex→mesh mapping lives in `_meshByIndex`. Overriding this one
+     * accessor keeps the base-class setters and any external caller (picking,
+     * plugins) correct without patching each call site.
+     */
+    getMeshByBatchIndex(batchIndex: number): SDFTextMesh | undefined;
     setFeatureColorByBatchIndex(batchIndex: number, color: Color_3): void;
     setFeatureShowByBatchIndex(batchIndex: number, rawVisible: boolean): void;
     setFeatureHeightByBatchIndex(batchIndex: number, height: number): void;
@@ -3548,6 +3621,18 @@ declare class GeoJsonLayerDescription {
     get crs(): string | undefined;
     set crs(value: string | null | undefined);
     data: any;
+    /**
+     * Per-layer horizon dynamic-SSE relaxation strength for the tiled render
+     * path (`0.0` off … `1.0` raster-equivalent). Omit for a content-based
+     * default.
+     */
+    get dynamicSseScale(): number | undefined;
+    /**
+     * Per-layer horizon dynamic-SSE relaxation strength for the tiled render
+     * path (`0.0` off … `1.0` raster-equivalent). Omit for a content-based
+     * default.
+     */
+    set dynamicSseScale(value: number | null | undefined);
     get point(): PointMaterial | undefined;
     set point(value: PointMaterial | null | undefined);
     get polygon(): PolygonMaterial | undefined;
@@ -4036,7 +4121,7 @@ export declare class InstancedMesh<M extends Object3D> extends Mesh_2 implements
     addWithBatchIndex(m: M, batchIndex: number): void;
     markVisibility(m: M): void;
     meshes(): M[];
-    getMeshByBatchIndex(batchIndex: number): M;
+    getMeshByBatchIndex(batchIndex: number): M | undefined;
     setFeatureColorByBatchIndex(batchIndex: number, color: Color_3): void;
     setFeatureShowByBatchIndex(batchIndex: number, rawVisible: boolean): void;
     setFeatureHeightByBatchIndex(batchIndex: number, height: number): void;
@@ -4215,6 +4300,8 @@ declare type InstancedSpriteBaseRefs = {
     uRTCCenterView: UniformValue<Vector3>;
     uEyeRTELow: UniformValue<Vector3>;
     uEyeRTEHigh: UniformValue<Vector3>;
+    /** Always 1.0 — blocks fast-math reassociation of the RTE recombination. */
+    u_rteOne?: UniformValue<number>;
     uScale: UniformValue<number>;
     uCenter: UniformValue<Vector2>;
     uSizeInMeters: UniformValue<boolean>;
@@ -4642,6 +4729,16 @@ declare class LegacyVectorTileMaterial {
     [Symbol.dispose](): void;
     get castShadow(): boolean | undefined;
     set castShadow(value: boolean | null | undefined);
+    /**
+     * Per-layer horizon dynamic-SSE relaxation strength (`0.0` off … `1.0`
+     * raster-equivalent). Omit for a content-based default.
+     */
+    get dynamicSseScale(): number | undefined;
+    /**
+     * Per-layer horizon dynamic-SSE relaxation strength (`0.0` off … `1.0`
+     * raster-equivalent). Omit for a content-based default.
+     */
+    set dynamicSseScale(value: number | null | undefined);
     /**
      * Sub-layer filter (MapLibre's `source-layer`). This is the only render-side
      * field; the rest is fetch config carried onto the implicit source.
@@ -4656,6 +4753,8 @@ declare class LegacyVectorTileMaterial {
     set maxSse(value: number | null | undefined);
     get maxZoom(): number | undefined;
     set maxZoom(value: number | null | undefined);
+    get minZoom(): number | undefined;
+    set minZoom(value: number | null | undefined);
     get overscaledMaxZoom(): number | undefined;
     set overscaledMaxZoom(value: number | null | undefined);
     get receiveShadow(): boolean | undefined;
@@ -6532,6 +6631,8 @@ declare type PolygonBaseRefs = {
     modelViewMatrixRTE?: UniformValue<Matrix4>;
     u_cameraPositionHigh?: UniformValue<Vector3>;
     u_cameraPositionLow?: UniformValue<Vector3>;
+    /** Always 1.0 — blocks fast-math reassociation of the RTE recombination. */
+    u_rteOne?: UniformValue<number>;
 };
 
 /**
@@ -7027,6 +7128,8 @@ declare type PolylineBaseRefs = {
     modelViewMatrixRTE?: UniformValue<Matrix4>;
     u_cameraPositionHigh?: UniformValue<Vector3>;
     u_cameraPositionLow?: UniformValue<Vector3>;
+    /** Always 1.0 — blocks fast-math reassociation of the RTE recombination. */
+    u_rteOne?: UniformValue<number>;
 };
 
 /**
@@ -7761,6 +7864,20 @@ declare class ReturnedTransferablePolylineBatchedFeature {
     material: PolylineMaterial;
 }
 
+/**
+ * Shared `u_rteOne` uniform for RTE vertex shaders. Always 1.0.
+ *
+ * Multiplying the high-order difference by a uniform the shader compiler
+ * cannot constant-fold blocks fast-math reassociation of
+ * `(high - camHigh) + (low - camLow)` into `(high + low) - (camHigh + camLow)`,
+ * which would collapse the math to absolute-ECEF f32 precision and make
+ * geometry freeze/snap in ~0.25-0.5 m steps as the camera moves
+ * (observed on ANGLE Metal). One frozen object is shared by every material.
+ */
+export declare const RTE_ONE_UNIFORM: {
+    readonly value: number;
+};
+
 /**
  * Interface for objects that need RTE (Relative-To-Eye) rendering support
  */
@@ -7900,6 +8017,8 @@ declare type SdfTextBaseRefs = {
     uRTCCenterView: UniformValue<Vector3>;
     uEyeRTELow: UniformValue<Vector3>;
     uEyeRTEHigh: UniformValue<Vector3>;
+    /** Always 1.0 — blocks fast-math reassociation of the RTE recombination. */
+    u_rteOne?: UniformValue<number>;
     nvr_uBatchId: UniformValue<number>;
     nvr_uPickable: UniformValue<number>;
     uAtlas: UniformValue<DataTexture | null>;
@@ -8007,7 +8126,7 @@ export declare class SDFTextMesh extends Mesh_2<InstancedBufferGeometry, ShaderM
     constructor(position: Float32Array | {
         high: Float32Array;
         low: Float32Array;
-    }, material: TextMaterial, transform: Transform_2, fontManager: FontManager, fontUrl: string, batchId: number | undefined, RTE: boolean);
+    }, material: TextMaterial, transform: Transform_2, fontManager: FontManager, fontUrl: string, batchId: number | undefined, RTE: boolean, highQuality: boolean);
     /** The text this mesh currently renders (its baked glyph string). */
     get text(): string;
     /**
@@ -10330,10 +10449,22 @@ export declare class UnknownTypeError extends Error {
      [Symbol.dispose](): void;
      get crs(): string | undefined;
      set crs(value: string | null | undefined);
+     /**
+      * Per-layer horizon dynamic-SSE relaxation strength (`0.0` off … `1.0`
+      * raster-equivalent). Omit for a content-based default.
+      */
+     get dynamicSseScale(): number | undefined;
+     /**
+      * Per-layer horizon dynamic-SSE relaxation strength (`0.0` off … `1.0`
+      * raster-equivalent). Omit for a content-based default.
+      */
+     set dynamicSseScale(value: number | null | undefined);
      get maxSse(): number | undefined;
      set maxSse(value: number | null | undefined);
      get maxZoom(): number | undefined;
      set maxZoom(value: number | null | undefined);
+     get minZoom(): number | undefined;
+     set minZoom(value: number | null | undefined);
      get overscaledMaxZoom(): number | undefined;
      set overscaledMaxZoom(value: number | null | undefined);
      get type(): string | undefined;