@navaramap/three 0.0.5 → 0.0.6

package/dist/index.d.ts

@@ -114,6 +114,12 @@ export declare type AnyMeshConfig = MeshConfig;
 /** The mesh descriptor hierarchy. */
 export declare type AnyMeshDesc = MeshDesc;
 
+/** Split out so `CustomRenderPass` can rebuild a target around a reused color. */
+export declare function appendOptionalGBufferAttachments(renderTarget: WebGLRenderTarget, buffers: ResolvedGBufferOptions): void;
+
+/** Applies a material's three-state `lit` option. */
+export declare function applyLitOption(material: Material, lit: boolean | undefined): void;
+
 /** Creates the per-tile MRT trio. Injected so tests can supply fakes. */
 declare type AtlasFactory = (size: number) => CompositeAtlas;
 
@@ -737,23 +743,6 @@ declare type AVAILABLE_SHADERS_9 = typeof AVAILABLE_SHADERS_9;
 
 declare type AvailableMaterialProperty = ExtractProperties<PointMaterial & PolylineMaterial & PolygonMaterial & ModelMaterial_2 & TextMaterial>;
 
-export declare type B3dmLayer = WithColorSupport<Layer_2<B3dmLayerDescription & {
-    type: "b3dm";
-}>>;
-
-declare class B3dmLayerDescription {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
-    get crs(): string | undefined;
-    set crs(value: string | null | undefined);
-    data: any;
-    get model(): ModelMaterial_2 | undefined;
-    set model(value: ModelMaterial_2 | null | undefined);
-    get type(): string | undefined;
-    set type(value: string | null | undefined);
-}
-
 /** A `b3dm` source: a single Batched 3D Model tile. */
 export declare type B3dmSource = SourceBase & WithColorSupport<Layer_2<Tiles3dSourceDescription & {
     type: "b3dm";
@@ -1587,23 +1576,6 @@ declare class CameraStatus {
 
 export { CascadedShadowMaps }
 
-export declare type Cesium3dTilesLayer = WithColorSupport<Layer_2<Cesium3dTilesLayerDescription & {
-    type: "cesium3dtiles";
-}>>;
-
-declare class Cesium3dTilesLayerDescription {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
-    get crs(): string | undefined;
-    set crs(value: string | null | undefined);
-    data: any;
-    get model(): ModelMaterial_2 | undefined;
-    set model(value: ModelMaterial_2 | null | undefined);
-    get type(): string | undefined;
-    set type(value: string | null | undefined);
-}
-
 export declare const CLOUD_LOCAL_WEATHER_URL: string;
 
 export declare const CLOUD_SHAPE_DETAIL_URL: string;
@@ -1832,6 +1804,12 @@ declare type CompositeOutputs = {
     normal: Texture;
 };
 
+/** Defines enabling the optional outputs and carrying their locations. */
+export declare function computeGBufferDefines(buffers: ResolvedGBufferOptions): Readonly<Record<string, number>>;
+
+/** Computes the attachment indices for resolved `buffers` options. */
+export declare function computeGBufferTextureIndex(buffers: ResolvedGBufferOptions): GBufferTextureIndex;
+
 declare type ConcurrencyManager = {
     /** Total concurrency */
     total: number;
@@ -2169,6 +2147,12 @@ export declare function createFullscreenQuad(): {
     geometry: PlaneGeometry;
 };
 
+/**
+ * Allocates the extra attachments in {@link computeGBufferTextureIndex} order.
+ * Disabled buffers get no placeholder texture.
+ */
+export declare function createGBufferAttachments(renderTarget: WebGLRenderTarget, buffers: ResolvedGBufferOptions): void;
+
 /**
  * Factory function to create the instancedSprite material enhancer.
  *
@@ -2406,12 +2390,64 @@ export declare class CustomRenderPass extends RenderPass {
     private shadowScene;
     private dummyShadowRenderTarget;
     private debugNormalCopyPass?;
+    private readonly gbufferScenes;
+    private readonly forwardScenes;
+    private readonly stampScenes;
     private allowTransparent;
+    private buffers;
+    private sceneLit;
+    private inputBufferTemplate;
+    /**
+     * Attachment indices of `gbufferRenderTarget.textures` for this view.
+     * Recomputed by {@link setBuffers}.
+     */
+    textureIndex: GBufferTextureIndex;
+    private gbufferDefines;
+    private gbufferDefinesStamped;
+    private litStamped;
+    private stampDirty;
+    private globeNormalActive;
+    private readonly globeNormalUniform;
+    private width;
+    private height;
+    private lastProgramCount;
+    private readonly lastSceneChildCounts;
     constructor(scenes: Scenes, camera: PerspectiveCamera, inputBuffer: WebGLRenderTarget, globe: Globe, options?: CustomRenderPassOptions);
+    /**
+     * Re-points the copy passes at the normal attachment. The attachment is
+     * freshly allocated on every {@link setBuffers}, so the reference cannot be
+     * captured once.
+     */
+    private bindNormalTexture;
     protected _renderWithLight(renderer: WebGLRenderer, scene: Scene): void;
+    /**
+     * Applies a new derived buffer configuration. Attachment locations may have
+     * shifted, so every material is re-stamped and its shader recompiled.
+     */
+    setBuffers(buffers: ResolvedGBufferOptions): void;
+    /** Applies a new scene-level `lit` default (`view.lit` changed). */
+    setLit(lit: boolean): void;
+    /**
+     * O(1) gate keeping the stamping traversal off the per-frame path. The
+     * program count catches deeply-nested async additions (a glTF populating a
+     * scene-resident group): a material must compile before it can render, so
+     * the traversal converges one frame later.
+     */
+    private shouldStampGBufferDefines;
+    private stampGBufferDefines;
+    private forEachMaterial;
+    private stampGBufferDefine;
+    /** Per-material `lit` (NVR_LIT / NVR_UNLIT) wins over this in the shader. */
+    private stampLitDefine;
     render(renderer: WebGLRenderer, inputBuffer: WebGLRenderTarget | null, _outputBuffer: WebGLRenderTarget | null): void;
     setDepthTexture(): void;
     setSize(width: number, height: number): void;
+    /**
+     * Grows the globe-normal copy target only while something consumes it, and
+     * shrinks it back to 1x1 otherwise — at full resolution it is a screen-sized
+     * RGBA16F target, the same cost again as the G-buffer's normal attachment.
+     */
+    private setGlobeNormalActive;
     protected _renderDrapedMesh(renderer: WebGLRenderer): void;
 }
 
@@ -2422,6 +2458,14 @@ export declare type CustomRenderPassOptions = {
     debugNormal?: boolean;
     disableShadow?: boolean;
     allowTransparent?: boolean;
+    /** G-buffer attachment configuration. Defaults to all optional buffers disabled. */
+    buffers?: ResolvedGBufferOptions;
+    /**
+     * Scene-level default of the `lit` material option (`view.lit`). When
+     * `false`, materials without an explicit `lit` output plain albedo.
+     * @defaultValue true
+     */
+    lit?: boolean;
 };
 
 declare class DataRequesterRemovedEvent {
@@ -2717,6 +2761,12 @@ declare class DelegatedWorkerTasksResult {
     set upsample_terrain_mesh(value: UpsampleTerrainMeshResult | null | undefined);
 }
 
+/**
+ * Three's `packing` chunk, for the MRT pass's packed depth buffers – check
+ * `depthBufferPacking` / `globeDepthBufferPacking` for the packing in use.
+ */
+export declare const DEPTH_PACKING_SHADER: string;
+
 /**
  * Base abstract class for all registry types in the Navara system.
  * Provides common functionality for registering, creating, and managing different types of components.
@@ -2761,9 +2811,10 @@ export declare abstract class DescRegistry<TConstructor, TInstance, TConfig exte
      */
     findTypeFromConfig(config: Record<string, unknown>): string | null;
     /**
-     * Get constructor by name (protected method for subclasses)
+     * Get constructor by name. Public so `ViewContext.findLight`/`findMesh`
+     * can resolve a registered key to its descriptor class.
      */
-    protected getConstructor(name: string): TConstructor | undefined;
+    getConstructor(name: string): TConstructor | undefined;
 }
 
 declare type Description = {
@@ -2806,6 +2857,13 @@ export declare class DrapedMesh<TGeometry extends BufferGeometry = BufferGeometr
      * Run the stencil-test draping passes for this mesh.
      * The caller supplies a `render` callback that performs the actual draw call
      * (e.g. `renderer.render(scene, camera)`).
+     *
+     * The final pass draws every back face with the depth test off, so a pixel
+     * can be covered several times where the volume folds over a peak. The
+     * shading must therefore not depend on world position, or the far face
+     * shows through the near one — hence the screen-space normal from
+     * {@link setupMaterialForDrape} and the forced-off `receiveShadow`. The
+     * terrain underneath keeps its own shadows; only the drape stays lit.
      */
     process(render: () => void): void;
 }
@@ -3035,6 +3093,15 @@ export declare abstract class EffectDesc<Config extends EffectConfig = EffectCon
     static insertBefore?: string[];
     /** Set to `true` to allow multiple instances of this effect in the pipeline. */
     static allowDuplication?: boolean;
+    /**
+     * Optional G-buffer attachments this effect reads. The view derives its
+     * G-buffer configuration as the union of these across active effects:
+     * adding an effect allocates what it needs, removing the last effect that
+     * needs a buffer releases it. Changing the configuration reallocates
+     * attachments and recompiles shaders, so add effects once and tune them
+     * via `update()` instead of re-adding.
+     */
+    static requiredBuffers?: readonly GBufferName[];
     private instanceId;
     constructor(view: ThreeView, ctx: ViewContext, config?: Config);
     /**
@@ -3081,6 +3148,11 @@ export declare class EffectDescRegistry extends DescRegistry<EffectDescConstruct
      * Find mesh type from config (alias for findTypeFromConfig for backward compatibility)
      */
     findEffectType(config: Record<string, unknown>): string | null;
+    /**
+     * Optional G-buffer attachments the effect type declares via the
+     * `requiredBuffers` static (empty when it declares none).
+     */
+    getRequiredBuffers(effectType: string): readonly GBufferName[];
 }
 
 export declare type EffectEvents = {
@@ -3700,6 +3772,133 @@ export { FontFamily }
 
 export { FontWorkerMemoryStats }
 
+/**
+ * The subset backed by an MRT attachment. `globeNormal` is not one of them —
+ * it is a separate copy target — so it must not take an attachment slot, a
+ * `*_LOCATION` define, or a `MAX_DRAW_BUFFERS` slot.
+ */
+export declare const GBUFFER_ATTACHMENT_NAMES: readonly ["normal", "selectiveEffect", "emissive", "shadow"];
+
+/** Stampers iterate this so defines of disabled buffers are cleared, not left stale. */
+export declare const GBUFFER_DEFINE_NAMES: readonly ["GBUFFER_NORMAL_LOCATION", "USE_GBUFFER_SELECTIVE_EFFECT", "GBUFFER_EFFECT_ID_LOCATION", "USE_GBUFFER_EMISSIVE", "GBUFFER_EMISSIVE_LOCATION", "USE_GBUFFER_SHADOW", "GBUFFER_SHADOW_LOCATION"];
+
+/** Output location of the effectIds buffer. Mirrored in the GLSL chunk. */
+export declare const GBUFFER_EFFECT_ID_LOCATION_DEFINE = "GBUFFER_EFFECT_ID_LOCATION";
+
+/**
+ * Selective-effect writes for built-in `ShaderLib` materials. The tile mesh
+ * replaces this by exact string match with
+ * `TILE_EMISSIVE_EFFECT_BUFFER_REPLACEMENT`.
+ *
+ * Effect writes are always macro invocations: the macros own the alpha, which
+ * is the per-attachment blend factor rather than data (see the pars chunk).
+ */
+export declare const GBUFFER_EFFECT_WRITE_BUILTIN = "GBUFFER_WRITE_EFFECT(uEffectIdsMask, diffuseColor.rgb * uEmissiveIntensity + emissive)";
+
+/**
+ * Selective-effect writes for materials that support the effect-id mask but
+ * not emissive (LineMaterial, sprite, points).
+ */
+export declare const GBUFFER_EFFECT_WRITE_ID_ONLY = "GBUFFER_WRITE_EFFECT_ID_ONLY(uEffectIdsMask)";
+
+/**
+ * Selective-effect writes for custom `ShaderMaterial`
+ * (emissive = (fragColor + uEmissiveColor) × intensity).
+ */
+export declare const GBUFFER_EFFECT_WRITE_SHADER_MATERIAL = "GBUFFER_WRITE_EFFECT(uEffectIdsMask, (gl_FragColor.rgb + uEmissiveColor) * uEmissiveIntensity)";
+
+/** Non-selective default — A=0.0, so a blended mesh keeps what is behind it. */
+export declare const GBUFFER_EFFECT_WRITE_ZERO = "GBUFFER_WRITE_EFFECT_ZERO";
+
+/** Output location of the emissive buffer. Mirrored in the GLSL chunk. */
+export declare const GBUFFER_EMISSIVE_LOCATION_DEFINE = "GBUFFER_EMISSIVE_LOCATION";
+
+/** Output location of the normal buffer. Mirrored in the GLSL chunk. */
+export declare const GBUFFER_NORMAL_LOCATION_DEFINE = "GBUFFER_NORMAL_LOCATION";
+
+/**
+ * `normalBuffer` write for non-physical materials (basic/lambert/phong).
+ * `polygonBaseEnhancer` matches/replaces this exact string.
+ */
+export declare const GBUFFER_NORMAL_WRITE_BASIC = "GBUFFER_WRITE_NORMAL(normal, reflectivity, roughnessFactor)";
+
+/**
+ * `normalBuffer` write for physically-based materials (standard/physical).
+ * `modelBaseEnhancer` matches/replaces this exact string.
+ */
+export declare const GBUFFER_NORMAL_WRITE_PHYSICAL = "GBUFFER_WRITE_NORMAL(normal, metalnessFactor, roughnessFactor)";
+
+/**
+ * Inject once near the top of any fragment shader rendering into the
+ * G-buffer. Raw `.glsl` shaders `#include` the chunk instead.
+ */
+export declare const GBUFFER_PARS_FRAGMENT: string;
+
+/** Output location of the shadow buffer. Mirrored in the GLSL chunk. */
+export declare const GBUFFER_SHADOW_LOCATION_DEFINE = "GBUFFER_SHADOW_LOCATION";
+
+/** The only attachment that always exists. The rest are packed after it. */
+export declare const GBUFFER_TEXTURE_INDEX: {
+    readonly color: 0;
+};
+
+/** Names an effect can declare in `requiredBuffers`. */
+export declare type GBufferName = "normal" | "selectiveEffect" | "emissive" | "shadow" | "globeNormal";
+
+/**
+ * Per-view buffer configuration. Not set by the user - derived as the union
+ * of the active effects' `requiredBuffers`. A disabled buffer costs nothing:
+ * neither the storage nor the shader-side writes exist. Only
+ * {@link GBUFFER_ATTACHMENT_NAMES} are MRT attachments.
+ */
+export declare type GBufferOptions = {
+    /**
+     * The view-space normal buffer (RG=octahedral normal, B=metalness or
+     * reflectivity, A=roughness *and* the blend factor). Required by every
+     * normal-reading effect (aerial perspective, SSR, fog light) and, via
+     * {@link globeNormal}, by draped meshes.
+     */
+    normal?: boolean;
+    /**
+     * The selective-effect id buffer (R=bitmask), required by buffer-based
+     * selective effects (`selectiveBloom`, `selectiveOutline`).
+     */
+    selectiveEffect?: boolean;
+    /**
+     * The HDR emissive buffer (RGB=emissive), required by `selectiveBloom`
+     * extraction.
+     */
+    emissive?: boolean;
+    /**
+     * The shadow buffer (R=directional/CSM shadow amount, 0=lit,
+     * 1=fully shadowed). No built-in effect requires it – declare it from a
+     * custom effect's `requiredBuffers` to read per-pixel shadowing.
+     */
+    shadow?: boolean;
+    /**
+     * The globe normal copy (the terrain's view-space normal, sampled in screen
+     * space). Kept at 1x1 unless a draped mesh needs it, so an effect reading
+     * `getGlobeNormalTexture()` has to declare it.
+     */
+    globeNormal?: boolean;
+};
+
+/**
+ * Attachment indices for one view. A disabled buffer is absent rather than a
+ * placeholder, so these shift — never hardcode them.
+ */
+export declare type GBufferTextureIndex = {
+    color: typeof GBUFFER_TEXTURE_INDEX.color;
+    /** Present only when `buffers.normal` is enabled. */
+    normal?: number;
+    /** Present only when `buffers.selectiveEffect` is enabled. */
+    effectIds?: number;
+    /** Present only when `buffers.emissive` is enabled. */
+    emissive?: number;
+    /** Present only when `buffers.shadow` is enabled. */
+    shadow?: number;
+};
+
 /**
  * Goes after `#include <common>` in the fragment shader. Declares the three
  * atlas samplers + the per-slot uniform arrays we still index by winning
@@ -3717,7 +3916,7 @@ export declare function generateTileCommonInjection(numTextures: number): string
  * generateTileEmissiveBuffer below to decide what gets written to the
  * emissive/effect MRT attachments).
  */
-export declare function generateTileMapFragment(maxTextures: number): string;
+export declare function generateTileMapFragment(maxTextures: number, features: TileShaderFeatures): string;
 
 /**
  * Goes in place of `#include <normal_fragment_maps>`. When the atlas carries
@@ -3741,52 +3940,6 @@ export declare function geodeticSurfaceNormal(lle: LatLngHeight): Vector3;
  */
 export declare function geodeticToVector3(lle: LatLngHeight): Vector3;
 
-export declare type GeoJsonLayer = WithColorSupport<Layer_2<GeoJsonLayerDescription & {
-    type: "geojson";
-}>>;
-
-/**
- * GeoJSON layer description for configuring feature rendering.
- *
- * **Note**: Model appearance is intentionally not supported for GeoJSON layers.
- * The batched feature pipeline requires per-batch coordinate transforms (model matrices)
- * and animation support, which are incompatible with the current GeoJSON batching approach.
- * For 3D model rendering at geographic coordinates, use a mesh description (e.g. `GLTFModelDesc`)
- * instead.
- */
-declare class GeoJsonLayerDescription {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
-    get billboard(): BillboardMaterial | undefined;
-    set billboard(value: BillboardMaterial | null | undefined);
-    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;
-    set polygon(value: PolygonMaterial | null | undefined);
-    get polyline(): PolylineMaterial | undefined;
-    set polyline(value: PolylineMaterial | null | undefined);
-    get text(): TextMaterial | undefined;
-    set text(value: TextMaterial | null | undefined);
-    get type(): string | undefined;
-    set type(value: string | null | undefined);
-}
-
 /** A `geojson` source: inline GeoJSON, or GeoJSON fetched from a `url`. */
 export declare type GeoJsonSource = SourceBase & Omit<WithColorSupport<Layer_2<GeoJsonSourceDescription & {
     type: "geojson";
@@ -4722,12 +4875,14 @@ export declare type LatLngHeight = Required<NormalizeWASMClass<LLE>>;
  *
  * @example
  * ```typescript
- * // Add a GeoJSON layer
- * const geoJsonLayer = view.addLayer({
+ * // Register a GeoJSON source, then render it with a vector layer
+ * const geoJsonSource = view.addSource({
  *   type: "geojson",
- *   data: {
- *     url: "https://example.com/data.geojson",
- *   },
+ *   url: "https://example.com/data.geojson",
+ * });
+ * const geoJsonLayer = view.addLayer({
+ *   type: "vector",
+ *   source: geoJsonSource,
  *   point: { color: 0xff0000 }
  * });
  *
@@ -4776,7 +4931,7 @@ export declare class Layer extends EventHandler<LayerEvent> {
 
 declare type Layer_2<LD> = NormalizeWASMClass<LD>;
 
-export declare type LayerDescription = TilesLayer | TerrainLayer | GeoJsonLayer | B3dmLayer | PntsLayer | Cesium3dTilesLayer | MvtLayer | VectorLayer | RasterLayer | TerrainSourceLayer | Tiles3dLayer;
+export declare type LayerDescription = VectorLayer | RasterLayer | TerrainSourceLayer | Tiles3dLayer;
 
 /**
  * Events emitted by Layer. Subscribe using `layer.on(eventName, callback)`.
@@ -4808,6 +4963,8 @@ declare class LayersManager {
     emitAll<K extends keyof LayerEvent>(k: K, ...args: Parameters<LayerEvent[K]>): void;
     getResourceLayers(): Generator<Layer, void, unknown>;
     getEffectDescs(): Generator<EffectHandle>;
+    getLightDescs(): Generator<LightHandle>;
+    getMeshDescs(): Generator<MeshHandle>;
 }
 
 declare type LayoutOptions = {
@@ -4821,178 +4978,6 @@ declare type LayoutOptions = {
     textAlign: number;
 };
 
-declare class LegacyElevationHeatmapMaterial {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
-    get elevationDecoder(): ElevationDecoder | undefined;
-    set elevationDecoder(value: ElevationDecoder | null | undefined);
-    get logBoundary(): number | undefined;
-    set logBoundary(value: number | null | undefined);
-    get logarithmic(): boolean | undefined;
-    set logarithmic(value: boolean | null | undefined);
-    get maxHeight(): number | undefined;
-    set maxHeight(value: number | null | undefined);
-    get minHeight(): number | undefined;
-    set minHeight(value: number | null | undefined);
-}
-
-declare class LegacyEllipsoidTerrainMaterial {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
-    get castShadow(): boolean | undefined;
-    set castShadow(value: boolean | null | undefined);
-    get maxZoom(): number | undefined;
-    set maxZoom(value: number | null | undefined);
-    get minZoom(): number | undefined;
-    set minZoom(value: number | null | undefined);
-    get receiveShadow(): boolean | undefined;
-    set receiveShadow(value: boolean | null | undefined);
-    get showBoundingBox(): boolean | undefined;
-    set showBoundingBox(value: boolean | null | undefined);
-}
-
-declare class LegacyHillshadeMaterial {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
-    get elevationDecoder(): ElevationDecoder | undefined;
-    set elevationDecoder(value: ElevationDecoder | null | undefined);
-    /**
-     * Exaggeration factor for hillshade effect (default: 1.0)
-     */
-    get exaggeration(): number | undefined;
-    /**
-     * Exaggeration factor for hillshade effect (default: 1.0)
-     */
-    set exaggeration(value: number | null | undefined);
-}
-
-declare class LegacyQuantizedMeshTerrainMaterial {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
-    get castShadow(): boolean | undefined;
-    set castShadow(value: boolean | null | undefined);
-    get geographic(): boolean | undefined;
-    set geographic(value: boolean | 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;
-    set receiveShadow(value: boolean | null | undefined);
-    get requestVertexNormals(): boolean | undefined;
-    set requestVertexNormals(value: boolean | null | undefined);
-    get requestWaterMask(): boolean | undefined;
-    set requestWaterMask(value: boolean | null | undefined);
-    get showBoundingBox(): boolean | undefined;
-    set showBoundingBox(value: boolean | null | undefined);
-    get show(): boolean | undefined;
-    set show(value: boolean | null | undefined);
-    get skirtExaggeration(): number | undefined;
-    set skirtExaggeration(value: number | null | undefined);
-    get skirt(): boolean | undefined;
-    set skirt(value: boolean | null | undefined);
-    get tms(): boolean | undefined;
-    set tms(value: boolean | null | undefined);
-    get token(): string | undefined;
-    set token(value: string | null | undefined);
-}
-
-declare class LegacyRasterTerrainMaterial {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
-    get castShadow(): boolean | undefined;
-    set castShadow(value: boolean | null | undefined);
-    get elevationDecoder(): ElevationDecoder | undefined;
-    set elevationDecoder(value: ElevationDecoder | 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;
-    set receiveShadow(value: boolean | null | undefined);
-    get showBoundingBox(): boolean | undefined;
-    set showBoundingBox(value: boolean | null | undefined);
-    get show(): boolean | undefined;
-    set show(value: boolean | null | undefined);
-    get skirtExaggeration(): number | undefined;
-    set skirtExaggeration(value: number | null | undefined);
-    get skirt(): boolean | undefined;
-    set skirt(value: boolean | null | undefined);
-    get tileSize(): number | undefined;
-    set tileSize(value: number | null | undefined);
-}
-
-declare class LegacyRasterTileMaterial {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
-    get color(): number | undefined;
-    set color(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 opacity(): number | undefined;
-    set opacity(value: number | null | undefined);
-    get overscaledMaxZoom(): number | undefined;
-    set overscaledMaxZoom(value: number | null | undefined);
-    get showBoundingBox(): boolean | undefined;
-    set showBoundingBox(value: boolean | null | undefined);
-    get show(): boolean | undefined;
-    set show(value: boolean | null | undefined);
-    get tms(): boolean | undefined;
-    set tms(value: boolean | null | undefined);
-}
-
-declare class LegacyVectorTileMaterial {
-    private constructor();
-    free(): void;
-    [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.
-     */
-    get layers(): string[] | 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.
-     */
-    set layers(value: string[] | 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 receiveShadow(): boolean | undefined;
-    set receiveShadow(value: boolean | null | undefined);
-    get show(): boolean | undefined;
-    set show(value: boolean | null | undefined);
-}
-
 export declare type Light = {
     ambient?: {
         enabled?: boolean;
@@ -5458,6 +5443,13 @@ export declare type MeshConfig = {
      * Disables Three.js's auto matrix-world update.
      */
     matrixWorld?: Matrix4;
+    /**
+     * Lighting override for every material of the mesh. `false` outputs albedo
+     * only, while normals and the shadow G-buffer keep being written.
+     * `undefined` follows `view.lit` — passing it to `update()` resets a mesh
+     * to inheriting again.
+     */
+    lit?: boolean;
 } & BaseDescConfig;
 
 export declare type MeshConfigWithSelectiveEffect = MeshConfig & {
@@ -5608,8 +5600,15 @@ export declare abstract class MeshDesc<Config extends MeshConfig = MeshConfig, U
     rotation?: XYZ;
     matrix?: Matrix4;
     matrixWorld?: Matrix4;
+    /** Three-state `lit` override (see {@link MeshConfig.lit}). */
+    lit?: boolean;
     private prevPassKey?;
     constructor(view: ThreeView, ctx: ViewContext, config?: Config);
+    /**
+     * Applies {@link lit} to every material under the mesh. Subclasses that
+     * attach materials asynchronously (glTF) call it again once they exist.
+     */
+    protected applyLit(): void;
     /**
      * Determines which render scene the mesh is added to.
      * Override this to change the rendering pass for your mesh.
@@ -5689,6 +5688,7 @@ export declare abstract class MeshDescWithSelectiveEffect<Config extends MeshCon
 }, CustomEvent extends BaseEventMap = BaseEventMap, Instance extends MeshBaseInstance<InstanceObj> = MeshBaseInstance<InstanceObj>> extends MeshDesc<Config, UpdateConfig, InstanceObj, CustomEvent, Instance> {
     protected _effectIds: string[];
     private _onSlotsChanged;
+    private _onGBufferChanged;
     constructor(view: ThreeView, ctx: ViewContext, config?: Config);
     protected getPassKey(): PassKey;
     onCreate(): void;
@@ -5721,7 +5721,7 @@ declare type MeshHandler = {
     setTileMeshPrepared: (handle: bigint) => void;
 };
 
-export declare type MeshUpdate = Pick<MeshConfig, "position" | "scale" | "rotation" | "matrix" | "matrixWorld"> & BaseDescConfigUpdate;
+export declare type MeshUpdate = Pick<MeshConfig, "position" | "scale" | "rotation" | "matrix" | "matrixWorld" | "lit"> & BaseDescConfigUpdate;
 
 export declare type MeshUpdateWithSelectiveEffect = MeshUpdate & {
     effectIds?: string[];
@@ -5865,6 +5865,18 @@ declare class ModelMaterial_2 {
     set height(value: number | null | undefined);
     get ior(): number | undefined;
     set ior(value: number | null | undefined);
+    /**
+     * Applies the lighting equation to the color output. When `false` the
+     * material outputs plain albedo (for deferred lighting) while normals and
+     * the shadow G-buffer keep being written.
+     */
+    get lit(): boolean | undefined;
+    /**
+     * Applies the lighting equation to the color output. When `false` the
+     * material outputs plain albedo (for deferred lighting) while normals and
+     * the shadow G-buffer keep being written.
+     */
+    set lit(value: boolean | null | undefined);
     get maxSse(): number | undefined;
     set maxSse(value: number | null | undefined);
     get metalness(): number | undefined;
@@ -6158,8 +6170,21 @@ export declare class MRTPassEffectDesc extends EffectDesc<MRTPassConfig, MRTPass
     constructor(view: ThreeView, ctx: ViewContext, config: MRTPassConfig);
     createPass(): CustomRenderPass;
     get normalBuffer(): Texture | undefined;
+    /**
+     * Selective-effect bitmask buffer (R=bitmask).
+     * `undefined` when the view disabled `buffers.selectiveEffect`.
+     */
     get effectIdsBuffer(): Texture | undefined;
+    /**
+     * Emissive RGB buffer (HDR).
+     * `undefined` when the view disabled `buffers.emissive`.
+     */
     get emissiveBuffer(): Texture | undefined;
+    /**
+     * Shadow buffer (R=shadow amount, 0=lit..1=fully shadowed).
+     * `undefined` unless an active effect requires the `shadow` buffer.
+     */
+    get shadowBuffer(): Texture | undefined;
     get depthBuffer(): Texture | undefined;
     get depthBufferPacking(): DepthPackingStrategies | undefined;
     get globeNormalBuffer(): Texture | undefined;
@@ -6183,32 +6208,12 @@ export declare type Mutates<States, Uniforms extends ShaderUniforms, Methods ext
     updateUniforms: (uniforms: Uniforms, states: States) => void;
 } & Methods;
 
-export declare type MvtLayer = WithColorSupport<Layer_2<MvtLayerDescription & {
-    type: "mvt";
-}>>;
-
-declare class MvtLayerDescription {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
-    get billboard(): BillboardMaterial | undefined;
-    set billboard(value: BillboardMaterial | null | undefined);
-    get crs(): string | undefined;
-    set crs(value: string | null | undefined);
-    data: any;
-    get point(): PointMaterial | undefined;
-    set point(value: PointMaterial | null | undefined);
-    get polygon(): PolygonMaterial | undefined;
-    set polygon(value: PolygonMaterial | null | undefined);
-    get polyline(): PolylineMaterial | undefined;
-    set polyline(value: PolylineMaterial | null | undefined);
-    get text(): TextMaterial | undefined;
-    set text(value: TextMaterial | null | undefined);
-    get type(): string | undefined;
-    set type(value: string | null | undefined);
-    get vectorTile(): LegacyVectorTileMaterial | undefined;
-    set vectorTile(value: LegacyVectorTileMaterial | null | undefined);
-}
+/**
+ * Codec for the normal buffer's RG channels, which are **octahedral**, not a
+ * plain `xy * 2 - 1`: decode with `unpackVec2ToNormal`. Prepend to shaders
+ * that cannot use `#include` resolution (postprocessing effect fragments).
+ */
+export declare const NORMAL_PACKING_SHADER: string;
 
 /**
  * A pass that copies normal buffer contents to a render target.
@@ -6253,6 +6258,23 @@ export declare function northWestUpToFixedFrame(origin: Vector3): Matrix4;
 
 export declare type Nullable<T> = T | null | undefined;
 
+/**
+ * Stamped from `material.transparent`. Under blending, `normalBuffer.a` is
+ * the attachment's blend factor, so a blended material must write 1.0 there
+ * instead of roughness or it keeps the normal of whatever lies behind.
+ */
+export declare const NVR_BLENDED_DEFINE = "NVR_BLENDED";
+
+/** `lit: true` – wins over {@link NVR_UNLIT_SCENE_DEFINE}. */
+export declare const NVR_LIT_DEFINE = "NVR_LIT";
+
+/** `lit: false` – only the lighting equation is bypassed; the lit pipeline
+ * still runs, so normals and the shadow G-buffer keep being written. */
+export declare const NVR_UNLIT_DEFINE = "NVR_UNLIT";
+
+/** Scene-level default, stamped by `CustomRenderPass` from `view.lit`. */
+export declare const NVR_UNLIT_SCENE_DEFINE = "NVR_UNLIT_SCENE";
+
 declare class ObjectTransformEvent {
     private constructor();
     free(): void;
@@ -6649,23 +6671,6 @@ declare abstract class Plugin_2<TView = unknown, TCtx = unknown> {
 }
 export { Plugin_2 as Plugin }
 
-export declare type PntsLayer = WithColorSupport<Layer_2<PntsLayerDescription & {
-    type: "pnts";
-}>>;
-
-declare class PntsLayerDescription {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
-    get crs(): string | undefined;
-    set crs(value: string | null | undefined);
-    data: any;
-    get model(): ModelMaterial_2 | undefined;
-    set model(value: ModelMaterial_2 | null | undefined);
-    get type(): string | undefined;
-    set type(value: string | null | undefined);
-}
-
 /** A `pnts` source: a single Point Cloud tile. */
 export declare type PntsSource = SourceBase & WithColorSupport<Layer_2<Tiles3dSourceDescription & {
     type: "pnts";
@@ -6812,11 +6817,6 @@ declare type PolygonBaseMutates = Mutates<PolygonBaseState, PolygonBaseUniforms,
      * This is needed because batchDataTexture is an external ref passed via props.
      */
     setBatchDataTexture: (texture: UniformValue<Texture | null>) => void;
-    /**
-     * Set the globe normal texture ref.
-     * This is needed because globeNormalTexture is an external ref passed via props.
-     */
-    setGlobeNormalTexture: (texture: UniformValue<Texture | null>) => void;
 }>;
 
 /**
@@ -6838,7 +6838,6 @@ declare type PolygonBaseProps = {
     roughness?: number;
     emissiveColor?: number;
     emissiveIntensity?: number;
-    globeNormalTexture?: UniformValue<Texture | null>;
     batchDataTexture?: UniformValue<Texture | null>;
     batchColorEnabled?: boolean;
     useRTE?: boolean;
@@ -6863,7 +6862,6 @@ declare type PolygonBaseRefs = {
     reflectivity: UniformValue<number>;
     roughness: UniformValue<number>;
     batchDataTexture?: UniformValue<Texture | null>;
-    uGlobeNormal?: UniformValue<Texture | null>;
     modelViewMatrixRTE?: UniformValue<Matrix4>;
     u_cameraPositionHigh?: UniformValue<Vector3>;
     u_cameraPositionLow?: UniformValue<Vector3>;
@@ -6947,6 +6945,18 @@ declare class PolygonMaterial {
     set height(value: number | null | undefined);
     get ior(): number | undefined;
     set ior(value: number | null | undefined);
+    /**
+     * Applies the lighting equation to the color output. When `false` the
+     * material outputs plain albedo (for deferred lighting) while normals and
+     * the shadow G-buffer keep being written.
+     */
+    get lit(): boolean | undefined;
+    /**
+     * Applies the lighting equation to the color output. When `false` the
+     * material outputs plain albedo (for deferred lighting) while normals and
+     * the shadow G-buffer keep being written.
+     */
+    set lit(value: boolean | null | undefined);
     /**
      * Need to enable `transparent`.
      */
@@ -7449,6 +7459,18 @@ declare class PolylineMaterial {
     set emissiveIntensity(value: number | null | undefined);
     get height(): number | undefined;
     set height(value: number | null | undefined);
+    /**
+     * Applies the lighting equation to the color output. When `false` the
+     * material outputs plain albedo (for deferred lighting) while normals and
+     * the shadow G-buffer keep being written.
+     */
+    get lit(): boolean | undefined;
+    /**
+     * Applies the lighting equation to the color output. When `false` the
+     * material outputs plain albedo (for deferred lighting) while normals and
+     * the shadow G-buffer keep being written.
+     */
+    set lit(value: boolean | null | undefined);
     /**
      * Maximum line width in pixels, clamping the rendered width regardless of zoom level.
      * Smaller values are cheaper to render as they reduce fragment shader overdraw.
@@ -7701,17 +7723,11 @@ declare class RasterLayerDescription {
     /**
      * Imagery rendering options for the raster texture. Parallel to `hillshade`
      * and `elevationHeatmap`; `show`/`color`/etc. apply only to the imagery.
-     * Accepts the legacy `rasterTile` key too so old-API tile layers can still
-     * be updated (extra legacy fields like `maxZoom`/`tms` are ignored here —
-     * they live on the source).
      */
     get raster(): RasterMaterial | undefined;
     /**
      * Imagery rendering options for the raster texture. Parallel to `hillshade`
      * and `elevationHeatmap`; `show`/`color`/etc. apply only to the imagery.
-     * Accepts the legacy `rasterTile` key too so old-API tile layers can still
-     * be updated (extra legacy fields like `maxZoom`/`tms` are ignored here —
-     * they live on the source).
      */
     set raster(value: RasterMaterial | null | undefined);
     get source(): string | undefined;
@@ -7770,6 +7786,18 @@ declare class RasterTileInternalMaterial {
     isElevationHeatmaps: Uint8Array;
     isHillshades: Uint8Array;
     layerReproject: Uint8Array;
+    /**
+     * Applies the lighting equation to the color output. When `false` the
+     * material outputs plain albedo (for deferred lighting) while normals and
+     * the shadow G-buffer keep being written.
+     */
+    get lit(): boolean | undefined;
+    /**
+     * Applies the lighting equation to the color output. When `false` the
+     * material outputs plain albedo (for deferred lighting) while normals and
+     * the shadow G-buffer keep being written.
+     */
+    set lit(value: boolean | null | undefined);
     logBoundary: number;
     logarithmic: boolean;
     opacities: Float32Array;
@@ -8038,6 +8066,8 @@ export declare class RenderTargetCopyPass extends Pass_2 {
     get autoResize(): boolean;
     set autoResize(value: boolean);
     setTexture(texture: Texture): void;
+    /** Points the pass at a rebuilt render target (same-purpose replacement). */
+    setRenderTarget(renderTarget: WebGLRenderTarget): void;
     /**
      * When a depth texture is set, the pass copies its depth into the target's
      * depth buffer via gl_FragDepth. Depth test must be enabled (with AlwaysDepth)
@@ -8075,6 +8105,12 @@ declare class Replacer {
     replaceWithCondition(search: string | RegExp, replace: string, condition: boolean, errorMessage?: string): Replacer;
 }
 
+/** {@link GBufferOptions} with defaults applied. */
+export declare type ResolvedGBufferOptions = Readonly<Required<GBufferOptions>>;
+
+/** Applies defaults (all disabled) to a partial configuration. */
+export declare function resolveGBufferOptions(options?: GBufferOptions): ResolvedGBufferOptions;
+
 declare class ReturnedTransferablePolygonBatchedFeature {
     private constructor();
     free(): void;
@@ -8300,6 +8336,12 @@ export declare type SelectiveEffectConfig = {
  * Subclasses implement {@link createPass}.
  */
 export declare abstract class SelectiveEffectDesc<Config extends SelectiveEffectConfig = SelectiveEffectConfig, UpdateConfig extends SelectiveEffectUpdate = SelectiveEffectUpdate> extends EffectDesc<Config, UpdateConfig> {
+    /**
+     * Buffer-based selective effects read the effectIds bitmask buffer.
+     * Subclasses that also read the emissive buffer (e.g. bloom) override this
+     * with `["selectiveEffect", "emissive"]`.
+     */
+    static requiredBuffers: readonly GBufferName[];
     protected config: Config;
     constructor(view: ThreeView, ctx: ViewContext, config: Config);
     /** ViewContext for accessing scenes, renderer, registry, etc. */
@@ -8308,9 +8350,9 @@ export declare abstract class SelectiveEffectDesc<Config extends SelectiveEffect
     get layerConfig(): Config;
     onCreate(): void;
     onDestroy(): void;
-    /** Emissive RGB buffer (MRT attachment[3]). */
+    /** Emissive RGB buffer. */
     getEmissiveBuffer(): Texture | null;
-    /** EffectIds bitmask buffer (MRT attachment[2]). NearestFilter, discrete data. */
+    /** EffectIds bitmask buffer (R=bitmask). NearestFilter, discrete data. */
     getEffectIdsBuffer(): Texture | null;
     /** Slot bit index for this effect instance in the EffectIds Buffer. -1 if unregistered. */
     getEffectSlot(): number;
@@ -8376,6 +8418,23 @@ export declare function setRTCPosition<T extends Object3D>(mesh: T, position: Fl
  */
 export declare function setRTEPosition<T extends Object3D>(mesh: T, positionHigh: Float32Array<ArrayBufferLike> | null | undefined, positionLow: Float32Array<ArrayBufferLike> | null | undefined, posIdx: number, transform: Transform_2): void;
 
+/**
+ * Shades a draped material with the terrain's normal instead of its own. The
+ * visible fragments are the back faces of a volume clipped to the ground by
+ * {@link DrapedMesh.process}, so the mesh's own normals point in an arbitrary
+ * direction while the ground's normal is what the lighting should use.
+ *
+ * The decoder (`unpackVec2ToNormal`) comes from the packing helpers that
+ * `overrideMaterialsForMRT` puts in every `ShaderLib` material, so a custom
+ * `ShaderMaterial` in the draped scene needs to bring its own. Idempotent.
+ *
+ * @param globeNormal - Uniform ref for the globe normal copy, kept alive by
+ *   the caller (see `CustomRenderPass`).
+ */
+export declare function setupMaterialForDrape(material: Material, globeNormal: {
+    value: Texture | null;
+}): void;
+
 /**
  * Wire a custom material into Navara's MRT G-buffer so depth/normal-based
  * effects (SSAO, SSR, outline, aerial perspective, clouds) and SelectiveEffect
@@ -8752,24 +8811,6 @@ declare class TerrainHeightUpdatedEvent {
     lle: LLE;
 }
 
-export declare type TerrainLayer = Layer_2<TerrainLayerDescription & {
-    type: "terrain";
-}>;
-
-declare class TerrainLayerDescription {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
-    data: any;
-    get ellipsoid(): LegacyEllipsoidTerrainMaterial | undefined;
-    set ellipsoid(value: LegacyEllipsoidTerrainMaterial | null | undefined);
-    get quantizedMesh(): LegacyQuantizedMeshTerrainMaterial | undefined;
-    set quantizedMesh(value: LegacyQuantizedMeshTerrainMaterial | null | undefined);
-    get rasterTerrain(): LegacyRasterTerrainMaterial | undefined;
-    set rasterTerrain(value: LegacyRasterTerrainMaterial | null | undefined);
-    type: string;
-}
-
 /**
  * Render-only appearance for a `terrain` layer's mesh, regardless of the
  * referenced source's data format (raster-dem, quantized-mesh, or the
@@ -8782,6 +8823,18 @@ declare class TerrainMaterial {
     [Symbol.dispose](): void;
     get castShadow(): boolean | undefined;
     set castShadow(value: boolean | null | undefined);
+    /**
+     * Applies the lighting equation to the color output. When `false` the
+     * material outputs plain albedo (for deferred lighting) while normals and
+     * the shadow G-buffer keep being written.
+     */
+    get lit(): boolean | undefined;
+    /**
+     * Applies the lighting equation to the color output. When `false` the
+     * material outputs plain albedo (for deferred lighting) while normals and
+     * the shadow G-buffer keep being written.
+     */
+    set lit(value: boolean | null | undefined);
     get receiveShadow(): boolean | undefined;
     set receiveShadow(value: boolean | null | undefined);
     get showBoundingBox(): boolean | undefined;
@@ -8811,9 +8864,14 @@ declare class TerrainMaterial {
 }
 
 /**
- * A `terrain` layer renders a `raster-dem` or `quantized-mesh` source as the globe surface.
+ * A `terrain` layer renders a `raster-dem` or `quantized-mesh` source as the
+ * globe surface. Alternatively, omit `source` and pass `ellipsoid` to render a
+ * flat ellipsoid surface (e.g. to drape clamp-to-ground data on).
  */
-export declare type TerrainSourceLayer = SourceLayerBase<TerrainSourceLayerBase>;
+export declare type TerrainSourceLayer = SourceLayerBase<TerrainSourceLayerBase> & {
+    /** Render a source-less flat ellipsoid surface. Mutually exclusive with `source`. */
+    ellipsoid?: TerrainSourceLayerBase["terrain"];
+};
 
 declare type TerrainSourceLayerBase = WithColorSupport<Layer_2<TerrainSourceLayerDescription & {
     type: "terrain";
@@ -8833,17 +8891,15 @@ declare class TerrainSourceLayerDescription {
     /**
      * Terrain mesh rendering options. Nested like the other layers' render
      * inputs (`raster`, `model`, ...); all fetch/geometry config lives on the
-     * referenced source. Accepts the legacy terrain material keys too so
-     * old-API terrain layers can still be updated (extra legacy fetch fields
-     * are ignored — they live on the source).
+     * referenced source. A source-less terrain layer (a flat ellipsoid surface
+     * to drape clamp-to-ground data on) is written with the `ellipsoid` key.
      */
     get terrain(): TerrainMaterial | undefined;
     /**
      * Terrain mesh rendering options. Nested like the other layers' render
      * inputs (`raster`, `model`, ...); all fetch/geometry config lives on the
-     * referenced source. Accepts the legacy terrain material keys too so
-     * old-API terrain layers can still be updated (extra legacy fetch fields
-     * are ignored — they live on the source).
+     * referenced source. A source-less terrain layer (a flat ellipsoid surface
+     * to drape clamp-to-ground data on) is written with the `ellipsoid` key.
      */
     set terrain(value: TerrainMaterial | null | undefined);
     get type(): string | undefined;
@@ -9211,6 +9267,13 @@ declare class ThreeView<D extends Descriptions = EmptyDescriptions> extends Even
     private plugins;
     /** Built-in attribution UI; unset when disabled or in a worker (no DOM). */
     private _attribution?;
+    /**
+     * Derived G-buffer attachment configuration — the union of the
+     * `requiredBuffers` declared by the active effects.
+     */
+    private _buffers;
+    /** Scene-level default of the `lit` material option (see {@link lit}). */
+    private _lit;
     private pixelRatioMatchedMedia?;
     private fixedGpuBytesReportScheduled;
     private fixedGpuBytesResyncPending;
@@ -9222,6 +9285,21 @@ declare class ThreeView<D extends Descriptions = EmptyDescriptions> extends Even
      * credits with `view.attribution?.add([...])`.
      */
     get attribution(): AttributionPlugin | undefined;
+    /**
+     * Buffers currently allocated. Not configurable — derived as the union of
+     * the active effects' `requiredBuffers`. All but `globeNormal` are G-buffer
+     * attachments.
+     */
+    get buffers(): ResolvedGBufferOptions;
+    /**
+     * Scene-level default of the `lit` material option. `false` makes every
+     * material without an explicit `lit` output plain albedo, while normals and
+     * the shadow G-buffer keep being written – the input for deferred lighting.
+     * Toggling recompiles the affected shaders once.
+     * @defaultValue true
+     */
+    get lit(): boolean;
+    set lit(value: boolean);
     constructor(options?: Options);
     /**
      * Convert a mouse event to a MapMouseEvent by adding map coordinates
@@ -9397,6 +9475,17 @@ declare class ThreeView<D extends Descriptions = EmptyDescriptions> extends Even
      * @returns An EffectHandle for controlling the added effect
      */
     addEffect<L extends EffectDesc = EffectDesc>(config: OmitType<BuiltInEffectDescription | EffectConfig | NonNullable<D["effect"]>>): EffectHandle<L>;
+    /**
+     * Re-derives the G-buffer configuration from the union of the active
+     * effects' `requiredBuffers` and applies it to the MRT pass when changed.
+     */
+    private _syncGBuffers;
+    /**
+     * Throws when enabling `effectType`'s required G-buffers would push the
+     * attachment count (color + normal + optional buffers) past the device's
+     * `MAX_DRAW_BUFFERS` limit.
+     */
+    private _assertGBufferCapacity;
     /**
      * Finds a resource layer by its ID.
      * Only returns resource layers added via `addLayer()` (not mesh, light, or
@@ -9683,18 +9772,19 @@ declare class ThreeViewCamera extends EventHandler<CameraEvent> {
 }
 
 /**
- * `effectIdBuffer = …; emissiveBuffer = …;` replacement. Only the
- * texturized-layer pixels write effect/emissive; raster pixels stay 0 so they
- * don't perturb downstream effect-mask passes.
+ * Effect/emissive write replacement, via the `GBUFFER_WRITE_EFFECT*` macros
+ * from the pars chunk (each buffer's write is compiled out when the view
+ * disables it). Only the texturized-layer pixels write effect/emissive;
+ * raster pixels stay 0 so they don't perturb downstream effect-mask passes.
  */
-export declare const TILE_EMISSIVE_EFFECT_BUFFER_REPLACEMENT = "\nif (isTexturizedLayer) {\n  effectIdBuffer = vec4(tileEffectIdsMask, 0.0, 0.0, 1.0);\n  emissiveBuffer = vec4(diffuseColor.rgb * tileEmissiveIntensity + tileEmissiveColor, 1.0);\n} else {\n  effectIdBuffer = vec4(0.0);\n  emissiveBuffer = vec4(0.0);\n}\n";
+export declare const TILE_EMISSIVE_EFFECT_BUFFER_REPLACEMENT = "\nif (isTexturizedLayer) {\n  GBUFFER_WRITE_EFFECT(tileEffectIdsMask, diffuseColor.rgb * tileEmissiveIntensity + tileEmissiveColor)\n} else {\n  GBUFFER_WRITE_EFFECT_ZERO\n}\n";
 
 /**
  * `normalBuffer = …` replacement for the MRT pass. Identical to legacy
  * behaviour: applyWaterNormals mixes the perturbed normal into the geometric
  * one before packing.
  */
-export declare const TILE_NORMAL_BUFFER_REPLACEMENT = "\nvec3 finalNormal = mix(origNormal, normalize(origNormal * 0.7 + normal), applyWaterNormals);\nnormalBuffer = vec4(packNormalToVec2(finalNormal), tileReflectivity, tileRoughness);\n";
+export declare const TILE_NORMAL_BUFFER_REPLACEMENT = "\nvec3 finalNormal = mix(origNormal, normalize(origNormal * 0.7 + normal), applyWaterNormals);\nGBUFFER_WRITE_NORMAL(finalNormal, tileReflectivity, tileRoughness)\n";
 
 /**
  * Final-stage pick override. Injected immediately AFTER
@@ -9745,21 +9835,6 @@ declare type TileHandler = {
     mercatorY: (lat: number) => number;
 };
 
-declare class TileLayerDescription {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
-    data: any;
-    get elevationHeatmap(): LegacyElevationHeatmapMaterial | undefined;
-    set elevationHeatmap(value: LegacyElevationHeatmapMaterial | null | undefined);
-    get hillshade(): LegacyHillshadeMaterial | undefined;
-    set hillshade(value: LegacyHillshadeMaterial | null | undefined);
-    get rasterTile(): LegacyRasterTileMaterial | undefined;
-    set rasterTile(value: LegacyRasterTileMaterial | null | undefined);
-    get type(): string | undefined;
-    set type(value: string | null | undefined);
-}
-
 export declare type TileMapByHandle = Map<TileHandle, TileMesh>;
 
 export declare type TileMaterial = MeshBasicMaterial | MeshLambertMaterial;
@@ -9904,12 +9979,13 @@ export declare type TileShaderFeatures = {
     hasHillshade: boolean;
     /** Some layer uses Water material → emit the water specular branch. */
     hasWater: boolean;
+    /**
+     * Quantized-mesh watermask is present (source requested `requestWaterMask`).
+     * Emits the ocean reflectivity fallback in the map fragment.
+     */
+    hasWatermask: boolean;
 };
 
-export declare type TilesLayer = WithColorSupport<Layer_2<TileLayerDescription & {
-    type: "tiles";
-}>>;
-
 /**
  * Pure cache layer for per-tile composite atlases.
  *
@@ -10353,6 +10429,12 @@ declare type UniformValue<T> = {
     value: T;
 };
 
+/**
+ * Derives the buffer configuration for a set of effect requirements
+ * (`EffectDesc.requiredBuffers` of every active effect).
+ */
+export declare function unionGBufferRequirements(requirements: Iterable<readonly GBufferName[]>): ResolvedGBufferOptions;
+
 export declare class UnknownTypeError extends Error {
     constructor(type: Exclude<(EffectConfig | MeshConfig | LightConfig)["type"], undefined>, config: EffectConfig | MeshConfig | LightConfig);
 }
@@ -10407,6 +10489,15 @@ export declare class UnknownTypeError extends Error {
      set watermask(value: number | null | undefined);
  }
 
+ /** Enables the emissive output. Mirrored in the GLSL chunk. */
+ export declare const USE_GBUFFER_EMISSIVE_DEFINE = "USE_GBUFFER_EMISSIVE";
+
+ /** Enables the effectIds output. Mirrored in the GLSL chunk. */
+ export declare const USE_GBUFFER_SELECTIVE_EFFECT_DEFINE = "USE_GBUFFER_SELECTIVE_EFFECT";
+
+ /** Enables the shadow output. Mirrored in the GLSL chunk. */
+ export declare const USE_GBUFFER_SHADOW_DEFINE = "USE_GBUFFER_SHADOW";
+
  /**
   * Array of valid geometry type values for runtime validation.
   */
@@ -10586,6 +10677,7 @@ export declare class UnknownTypeError extends Error {
      private _meshes;
      private _selectiveEffectRegistry;
      private _renderPass?;
+     private _registries?;
      constructor(
      /** Scene containers for different rendering passes. */
      _scenes: Scenes, layersManager: LayersManager, renderPassOrchestrator: RenderPassOrchestrator, 
@@ -10611,6 +10703,9 @@ export declare class UnknownTypeError extends Error {
      /** Get the input buffer from the effect composer. */
      getInputBuffer(): WebGLRenderTarget<Texture<unknown, TextureEventMap>>;
      /* Excluded from this release type: _setRenderPass */
+     /* Excluded from this release type: _setRegistries */
+     /* Excluded from this release type: _setGBufferOptions */
+     /* Excluded from this release type: _setLit */
      /**
       * Gets the globe depth texture for post-processing effects.
       */
@@ -10626,16 +10721,41 @@ export declare class UnknownTypeError extends Error {
      /**
       * Gets the scene normal texture from the G-buffer.
       */
-     getNormalTexture(): Texture<unknown, TextureEventMap>;
+     getNormalTexture(): Texture<unknown, TextureEventMap> | undefined;
      /**
       * Gets the effect IDs texture from the G-buffer.
+      * `undefined` when the view disabled `buffers.selectiveEffect`.
       */
-     getEffectIdsTexture(): Texture<unknown, TextureEventMap>;
+     getEffectIdsTexture(): Texture | undefined;
      /**
       * Gets the emissive texture from the G-buffer.
+      * `undefined` when the view disabled `buffers.emissive`.
+      */
+     getEmissiveTexture(): Texture | undefined;
+     /**
+      * Gets the shadow texture (R=shadow amount, 0=lit..1=fully shadowed) from
+      * the G-buffer. `undefined` unless an active effect requires the `shadow`
+      * buffer.
       */
-     getEmissiveTexture(): Texture<unknown, TextureEventMap>;
+     getShadowTexture(): Texture | undefined;
      /* Excluded from this release type: _getEffects */
+     /* Excluded from this release type: _getLights */
+     /* Excluded from this release type: _getMeshes */
+     /**
+      * Finds an active effect descriptor by its `key` (e.g. `"mrt"`,
+      * `"selectiveBloom"`). Returns the first match, or `undefined`.
+      */
+     findEffect<T extends EffectDesc = EffectDesc>(key: string): T | undefined;
+     /**
+      * Finds the first active light descriptor registered under `key` (e.g.
+      * `"sun"`), for inheriting the scene's lighting in a custom effect.
+      */
+     findLight<T extends LightDesc = LightDesc>(key: string): T | undefined;
+     /**
+      * Finds an active mesh descriptor by its registered key (e.g. `"box"`,
+      * `"gltfModel"`). Returns the first match, or `undefined`.
+      */
+     findMesh<T extends MeshDesc = MeshDesc>(key: string): T | undefined;
      /**
       * Register a material for CSM shadow rendering.
       * @experimental This API may change or be removed in future versions.
@@ -10682,6 +10802,18 @@ export declare class UnknownTypeError extends Error {
       * Listeners should recompute effectIdsMask to stay in sync.
       */
      effectSlotsChanged: () => void;
+     /**
+      * Emitted when the derived G-buffer configuration changes. Meshes re-evaluate
+      * their pass placement: outside the MRT pass they would leave the G-buffer
+      * holding whatever lies behind them.
+      */
+     gbufferChanged: () => void;
+     /**
+      * Emitted when a mesh moves between render scenes. The view re-derives the
+      * buffer configuration from it: draped meshes need the globe normal but,
+      * not being effects, cannot declare `requiredBuffers` themselves.
+      */
+     meshPassKeyChanged: () => void;
  };
 
  /**
@@ -10722,6 +10854,10 @@ export declare class UnknownTypeError extends Error {
 
  export declare const WATER_NORMAL_URL: string;
 
+ export declare const WATERMASK_OCEAN_REFLECTIVITY = 0.02;
+
+ export declare const WATERMASK_OCEAN_ROUGHNESS = 0.2;
+
  /**
   * Mutation functions for the water enhancer (internal only).
   */
@@ -10764,7 +10900,7 @@ export declare class UnknownTypeError extends Error {
 
  /**
   * Helper type to enable Navara Color objects in all color-related fields.
-  * This applies to model, point, billboard, text, polyline, polygon, rasterTile, etc.
+  * This applies to model, point, billboard, text, polyline, polygon, raster, etc.
   * Both number and Navara Color objects are accepted for backward compatibility.
   */
  declare type WithColorSupport<T> = ConvertColorFields<T>;