@openglobus/og 1.0.0-rc2 → 1.0.0-rc21

package/lib/quadTree/EntityCollectionsTreeStrategy.d.ts

@@ -19,6 +19,9 @@ export declare class EntityCollectionsTreeStrategy {
     constructor(quadTreeStrategy: QuadTreeStrategy, layer: Vector, nodeCapacity: number);
     insertEntity(entity: Entity, rightNow?: boolean): void;
     setPickingEnabled(pickingEnabled: boolean): void;
+    setReceiveProjectors(receiveProjectors: boolean): void;
+    setReceiveShadows(receiveShadows: boolean): void;
+    setReceiveFrameTransparency(receiveFrameTransparency: boolean): void;
     dispose(): void;
     insertEntities(entitiesForTree: Entity[]): void;
     collectVisibleEntityCollections(outArr: EntityCollection[]): void;

package/lib/quadTree/QuadTreeStrategy.d.ts

@@ -21,9 +21,12 @@ export interface QuadTreeStrategyParams {
 }
 export declare class QuadTreeStrategy {
     events: EventsHandler<QuadTreeStrategyEventsList>;
+    maxZoomLimit: number;
     name: string;
     projection: Proj;
     readonly planet: Planet;
+    lodCamera: PlanetCamera | null;
+    disableNeighbors: boolean;
     /**
      * grid tree list.
      * @protected
@@ -42,9 +45,16 @@ export declare class QuadTreeStrategy {
      * @type {Node}
      */
     _renderedNodes: Node[];
+    /**
+     * Geocentric distance range of the terrain collected for the current rendering frame.     * @public
+     * @type {number}
+     */
+    minTerrainRadius: number;
+    maxTerrainRadius: number;
+    _minTerrainRadiusAcc: number;
+    _maxTerrainRadiusAcc: number;
     _renderedNodesInFrustum: Node[][];
     _fadingNodes: Map<number, Node>;
-    _fadingNodesInFrustum: Node[][];
     _fadingOpaqueSegments: Segment[];
     _transparentSegments: Segment[];
     /**
@@ -90,6 +100,13 @@ export declare class QuadTreeStrategy {
      */
     clearLayerMaterial(layer: Layer, keepRendered?: boolean): void;
     get terrainReady(): boolean;
+    /**
+     * Returns true when every rendered segment has got its materials applied and
+     * the completion has already been announced.
+     * @public
+     * @returns {boolean}
+     */
+    get renderReady(): boolean;
     protected _checkRendercompleted(): void;
     protected _initEvents(): void;
     protected _updateRenderedNodesInFrustumArray(camera: PlanetCamera): void;

package/lib/quadTree/earth/EarthEntityCollectionsTreeStrategy.d.ts

@@ -14,6 +14,9 @@ export declare class EarthEntityCollectionsTreeStrategy extends EntityCollection
     constructor(quadTreeStrategy: QuadTreeStrategy, layer: Vector, nodeCapacity: number);
     insertEntity(entity: Entity, rightNow?: boolean): void;
     setPickingEnabled(pickingEnabled: boolean): void;
+    setReceiveProjectors(receiveProjectors: boolean): void;
+    setReceiveShadows(receiveShadows: boolean): void;
+    setReceiveFrameTransparency(receiveFrameTransparency: boolean): void;
     dispose(): void;
     insertEntities(entitiesForTree: Entity[]): void;
     collectVisibleEntityCollections(outArr: EntityCollection[]): void;

package/lib/quadTree/equi/EquiEntityCollectionsTreeStrategy.d.ts

@@ -12,6 +12,9 @@ export declare class EquiEntityCollectionsTreeStrategy extends EntityCollections
     constructor(quadTreeStrategy: QuadTreeStrategy, layer: Vector, nodeCapacity: number);
     insertEntity(entity: Entity, rightNow?: boolean): void;
     setPickingEnabled(pickingEnabled: boolean): void;
+    setReceiveProjectors(receiveProjectors: boolean): void;
+    setReceiveShadows(receiveShadows: boolean): void;
+    setReceiveFrameTransparency(receiveFrameTransparency: boolean): void;
     dispose(): void;
     insertEntities(entitiesForTree: Entity[]): void;
     collectVisibleEntityCollections(outArr: EntityCollection[]): void;

package/lib/renderer/PhongDeferredShading.d.ts

@@ -1,9 +1,11 @@
 import { Framebuffer } from "../webgl/Framebuffer";
+import { ProjectorsPass } from "./projectors/ProjectorsPass";
 import type { IDeferredShadingPass } from "./IDeferredShadingPass";
 import type { Renderer } from "./Renderer";
 export declare class PhongDeferredShading implements IDeferredShadingPass {
     protected _renderer: Renderer;
     protected _framebuffer: Framebuffer | null;
+    protected _projectorPass: ProjectorsPass;
     constructor(renderer: Renderer);
     init(): void;
     beginPass(): void;

package/lib/renderer/Renderer.d.ts

@@ -10,6 +10,9 @@ import { LabelWorker } from "../entity/label/LabelWorker";
 import { Scene } from "../scene/Scene";
 import type { IDeferredShadingPass } from "./IDeferredShadingPass";
 import type { ITransparencyPass } from "./ITransparencyPass";
+import { ProjectorManager } from "./projectors/ProjectorManager";
+import { CascadeShadowManager } from "./cascadeShadows/CascadeShadowManager";
+import { ShadowManager } from "./shadows/ShadowManager";
 import { TextureResourceManager } from "../utils/TextureResourceManager";
 import type { RendererTextureRequest } from "../utils/TextureResourceManager";
 import { TextureAtlas } from "../utils/TextureAtlas";
@@ -22,15 +25,19 @@ export interface IRendererParams {
     controls?: Control[];
     msaa?: number;
     autoActivate?: boolean;
+    deferredDisabled?: boolean;
     fontsSrc?: string;
     gamma?: number;
     exposure?: number;
+    frameOpacity?: number;
+    toneMapping?: string;
     dpi?: number;
     clearColor?: [number, number, number, number];
     lightPosition?: NumberArray3;
     lightAmbient?: NumberArray3;
     lightDiffuse?: NumberArray3;
     lightSpecular?: NumberArray4;
+    idleMode?: boolean;
 }
 interface IPickingObject {
     _pickingColor?: Vec3;
@@ -49,16 +56,19 @@ interface IFrameCallbackHandler {
  *     - controls: Control instances to add to the renderer
  *     - msaa: MSAA (Multi-Sample Anti-Aliasing) level
  *     - autoActivate: Start rendering automatically after creation
+ *     - deferredDisabled: Disable deferred shading pipeline and render deferred objects with forward shaders
  *     - fontsSrc: Path to font resources
  *     - gamma: Gamma correction value
  *     - exposure: HDR exposure value
+ *     - frameOpacity: Scene objects opacity used with transparentBackground to achieve an AR effect
+ *     - toneMapping: HDR tone mapping operator
  *     - dpi: Device pixel ratio
  *     - clearColor: RGBA clear color array
  *     - lightPosition: Light position `[x, y, z]`
  *     - lightAmbient: Light ambient color `[r, g, b]`
  *     - lightDiffuse: Light diffuse color `[r, g, b]`
  *     - lightSpecular: Light specular `[r, g, b, shininess]`
- * @fires draw - Triggered before each frame is rendered.
+ * @fires predraw - Triggered before each frame is rendered.
  * @fires resize - Triggered when the canvas is resized.
  * @fires mousemove - Triggered when the mouse moves over the canvas.
  * @fires mousestop - Triggered when the mouse stops moving.
@@ -96,6 +106,10 @@ declare class Renderer {
      * @type {HTMLElement | null}
      */
     div: HTMLDivElementExt | null;
+    /**
+     * Where dialogs or any other external elements are put.
+     */
+    uiContainer: HTMLElement | null;
     protected _topLeftContainer: HTMLDivElement;
     protected _topRightContainer: HTMLDivElement;
     protected _bottomRightContainer: HTMLDivElement;
@@ -105,10 +119,11 @@ declare class Renderer {
      * @type {Handler}
      */
     handler: Handler;
-    exposure: number;
-    gamma: number;
-    whitepoint: number;
-    brightThreshold: number;
+    protected _exposure: number;
+    protected _gamma: number;
+    protected _whitepoint: number;
+    protected _toneMapping: string;
+    protected _brightThreshold: number;
     /**
      * Render nodes drawing queue.
      * @public
@@ -128,7 +143,7 @@ declare class Renderer {
      */
     activeCamera: Camera;
     /**
-     * Renderer events. Represents interface for setting events like mousemove, draw, keypress etc.
+     * Renderer events. Represents interface for setting events like mousemove, predraw, keypress etc.
      * @public
      * @type {RendererEvents}
      */
@@ -174,6 +189,8 @@ declare class Renderer {
     protected _depthRefreshRequired: boolean;
     forwardFramebuffer: Multisample | null;
     protected hdrFramebuffer: Framebuffer | null;
+    deferredDisabled: boolean;
+    protected _frameOpacity: number;
     deferredShadingPass: IDeferredShadingPass;
     transparencyPass: ITransparencyPass;
     protected toneMappingFramebuffer: Framebuffer | null;
@@ -209,6 +226,9 @@ declare class Renderer {
     _lightAmbient: Float32Array;
     _lightDiffuse: Float32Array;
     _lightSpecular: Float32Array;
+    projectors: ProjectorManager;
+    cascadeShadowManager: CascadeShadowManager;
+    shadows: ShadowManager;
     constructor(handler: Handler | string | HTMLCanvasElement, params?: IRendererParams);
     enableBlendOneSrcAlpha(): void;
     set lightAmbient(lightAmbient: NumberArray3 | Float32Array);
@@ -217,6 +237,53 @@ declare class Renderer {
     get lightDiffuse(): NumberArray3;
     set lightSpecular(lightSpecular: NumberArray4 | Float32Array);
     get lightSpecular(): NumberArray4;
+    /**
+     * HDR exposure.
+     * @public
+     * @type {number}
+     */
+    set exposure(exposure: number);
+    get exposure(): number;
+    /**
+     * Gamma correction value.
+     * @public
+     * @type {number}
+     */
+    set gamma(gamma: number);
+    get gamma(): number;
+    /**
+     * Tone mapping white point.
+     * @public
+     * @type {number}
+     */
+    set whitepoint(whitepoint: number);
+    get whitepoint(): number;
+    /**
+     * Scene objects opacity used with transparentBackground to achieve an AR effect.
+     * @public
+     * @type {number}
+     */
+    set frameOpacity(frameOpacity: number);
+    get frameOpacity(): number;
+    /**
+     * Bloom bright pass threshold.
+     * @public
+     * @type {number}
+     */
+    set brightThreshold(brightThreshold: number);
+    get brightThreshold(): number;
+    /**
+     * Sets HDR tone mapping operator and recompiles tone mapping shader.
+     * @public
+     * @param {string} operator - Tone mapping operator name.
+     */
+    setToneMapping(operator: string): this;
+    /**
+     * Returns HDR tone mapping operator.
+     * @public
+     * @returns {string}
+     */
+    getToneMapping(): string;
     enableBlendDefault(): void;
     enableBlendWoit(): void;
     /**
@@ -307,6 +374,11 @@ declare class Renderer {
     protected _appendControlContainers(): void;
     acquireTexture(params: RendererTextureRequest): WebGLTextureExt | null;
     releaseTexture(texture: WebGLTextureExt | null | undefined): void;
+    /** The element the canvas is drawn in. */
+    getInnerContainer(): HTMLElement;
+    getAttributionsContainer(): HTMLElement | null;
+    /** Where the interface goes: the container given for it, or the inner one. */
+    getUIContainer(): HTMLElement;
     topLeftContainer(): HTMLDivElement;
     topRightContainer(): HTMLDivElement;
     bottomRightContainer(): HTMLDivElement;
@@ -354,11 +426,22 @@ declare class Renderer {
     markForDepthRefresh(): void;
     protected _drawGBufferEntityCollections(depthOrder: number): void;
     protected _drawForwardEntityCollections(depthOrder: number): void;
+    protected _drawLabelsForwardEntityCollections(depthOrder: number): void;
     protected _drawTransparentEntityCollections(depthOrder: number): void;
     protected _drawTransparentEntityCollectionsForward(depthOrder: number): void;
     protected _drawPickingEntityCollections(depthOrder: number): void;
     protected _drawDepthEntityCollections(depthOrder: number): void;
     protected _clearEntityCollectionQueue(depthOrder: number): void;
+    /**
+     * Requests the next frame to be rendered.
+     * @public
+     */
+    requestRedraw(): void;
+    /**
+     * Returns true when the renderer skips frames because nothing has been changed.
+     * @public
+     */
+    get isIdle(): boolean;
     /**
      * Draw nodes.
      * @public

package/lib/renderer/RendererEvents.d.ts

@@ -13,6 +13,7 @@ export declare function createRendererEvents(renderer: Renderer): RendererEvents
 export type RendererEventsType = [
     "projchanged",
     "changerelativecenter",
+    "predraw",
     "draw",
     "forwardpass",
     "postforwardpass",
@@ -217,6 +218,7 @@ declare class RendererEvents extends Events<RendererEventsType> implements Rende
     handleEvents(): void;
     on(name: string, p0: EventCallback | number, p1?: number | EventCallback, p2?: any, keyPriority?: number): void;
     off(name: string, p1?: EventCallback | number | null, p2?: EventCallback): void;
+    destroy(): void;
     /**
      * Check key is pressed.
      * @public

package/lib/renderer/cascadeShadows/CascadeShadowManager.d.ts

@@ -0,0 +1,34 @@
+import type { Planet } from "../../scene/Planet";
+import type { ShaderProgram } from "../../webgl/ShaderProgram";
+import type { Renderer } from "../Renderer";
+import { CascadeShadowMap } from "./CascadeShadowMap";
+export declare class CascadeShadowManager {
+    protected _renderer: Renderer;
+    protected _planet: Planet | null;
+    protected _cascadeShadowMaps: CascadeShadowMap[];
+    protected _activeCascadeShadowMaps: CascadeShadowMap[];
+    protected _viewProjData: Float32Array;
+    protected _eyeRelData: Float32Array;
+    protected _paramsData: Float32Array;
+    protected _splitsData: Float32Array;
+    protected _viewForwardData: Float32Array;
+    protected _layerData: Int32Array;
+    protected _updateActiveCascadeShadowMaps: boolean;
+    protected _initialized: boolean;
+    constructor(renderer: Renderer);
+    get activeCount(): number;
+    get active(): CascadeShadowMap[];
+    init(): void;
+    bindPlanet(planet: Planet): void;
+    unbindPlanet(): void;
+    add(cascadeShadowMap: CascadeShadowMap): number;
+    update(cascadeShadowMap: CascadeShadowMap): boolean;
+    remove(cascadeShadowMap: CascadeShadowMap): boolean;
+    clear(): void;
+    destroy(): void;
+    bindForward(program: ShaderProgram, textureUnitStart?: number): number;
+    protected _initCascadeShadowMap(cascadeShadowMap: CascadeShadowMap): void;
+    protected _collectActiveCascadeShadowMaps(): CascadeShadowMap[];
+    protected _getActiveCascadeShadowMaps(): CascadeShadowMap[];
+    protected _onDraw: () => void;
+}

package/lib/renderer/cascadeShadows/CascadeShadowMap.d.ts

@@ -0,0 +1,110 @@
+import { Sphere } from "../../bv/Sphere";
+import { Camera } from "../../camera/Camera";
+import { PlanetCamera } from "../../camera/PlanetCamera";
+import { Vector } from "../../layer/Vector";
+import { Vec3 } from "../../math/Vec3";
+import { QuadTreeStrategy } from "../../quadTree";
+import type { Node } from "../../quadTree/Node";
+import type { Renderer } from "../../renderer/Renderer";
+import type { Planet } from "../../scene/Planet";
+import type { Segment } from "../../segment/Segment";
+import { Framebuffer } from "../../webgl";
+import type { CascadeShadowManager } from "./CascadeShadowManager";
+/**
+ * Cascade shadow map split configuration.
+ * @property enabled - Enables the cascade.
+ * @property splitNear - Near split distance.
+ * @property splitFar - Far split distance.
+ * @property depthBiasWorld - Occlusion bias in meters.
+ * @property normalBias - Surface normal offset in RTC/world units.
+ */
+export interface CascadeParams {
+    enabled: boolean;
+    splitNear: number;
+    splitFar: number;
+    depthBiasWorld: number;
+    normalBias: number;
+}
+/**
+ * Cascade shadow map configuration options.
+ * @property enabled - Enables cascade shadow rendering.
+ * @property size - Shadow map texture size in pixels.
+ * @property cascadeCount - Number of generated cascade splits when cascades is not provided.
+ * @property maxDistance - Maximum camera distance covered by all cascade splits.
+ * @property splitLambda - Blend factor between uniform and logarithmic split distribution.
+ * @property verticalViewAngle - Vertical view angle for the orthographic cascade camera.
+ * @property casterMargin - Minimum light-space depth margin for shadow casters in world units.
+ * @property excludeLayers - Vector layers excluded from cascade shadow rendering.
+ * @property cascades - Per-cascade parameter overrides. When provided, its length defines cascade count.
+ */
+export interface ICascadeShadowMapParams {
+    enabled?: boolean;
+    size?: number;
+    cascadeCount?: number;
+    maxDistance?: number;
+    splitLambda?: number;
+    verticalViewAngle?: number;
+    casterMargin?: number;
+    excludeLayers?: Vector[];
+    cascades?: Partial<CascadeParams>[];
+}
+export declare class CascadeShadowMap {
+    protected static __counter__: number;
+    readonly id: number;
+    readonly size: number;
+    readonly maxDistance: number;
+    readonly splitLambda: number;
+    readonly verticalViewAngle: number;
+    readonly casterMargin: number;
+    readonly excludeLayers: Vector[];
+    depthCamera: Camera;
+    framebuffer: Framebuffer | null;
+    quadTreeStrategy: QuadTreeStrategy | null;
+    readonly cascades: CascadeParams[];
+    _manager: CascadeShadowManager | null;
+    protected _planet: Planet | null;
+    protected _renderer: Renderer | null;
+    protected _initialized: boolean;
+    protected _enabled: boolean;
+    protected _depthArrayTexture: WebGLTexture | null;
+    protected _lastPlanetHeightFactor: number;
+    protected _cascadeBoundingSpheres: Sphere[];
+    protected _depthCameraBoundingSphere: Sphere;
+    constructor(params?: ICascadeShadowMapParams);
+    get initialized(): boolean;
+    get enabled(): boolean;
+    set enabled(enabled: boolean);
+    get depthArrayTexture(): WebGLTexture | null;
+    init(renderer: Renderer): void;
+    bindPlanet(planet: Planet): void;
+    unbindPlanet(): void;
+    destroy(): void;
+    frame(): void;
+    protected _prepareFrame(): void;
+    protected _finishFrame(): void;
+    protected _createCascadeParams(params: ICascadeShadowMapParams, cascadeCount: number): CascadeParams[];
+    protected _computeCascadeSplitDistance(splitIndex: number, splitDistributionNear: number, cascadeCount: number): number;
+    protected _createCascadeBoundingSpheres(): Sphere[];
+    protected _createDepthCamera(planet?: Planet | null): Camera;
+    protected _createFramebuffer(renderer: Renderer): Framebuffer;
+    protected _createDepthArrayTexture(renderer: Renderer): WebGLTexture | null;
+    protected _validateFramebufferLayers(): void;
+    protected _createQuadTreeStrategy(planet: Planet, camera: PlanetCamera): QuadTreeStrategy;
+    protected _initPlanetSource(planet: Planet): void;
+    protected _syncPlanetHeightFactor(): void;
+    protected _updateCascadeBounds(): void;
+    protected _updateDepthCamera(): void;
+    protected _computeDepthCameraBoundingSphere(outSphere: Sphere): number;
+    protected _extendSphereBySphere(outSphere: Sphere, sphere: Sphere): void;
+    protected _getDepthCameraUp(lightDirection: Vec3): Vec3;
+    /**
+     * Computes a minimum bounding sphere for the main camera perspective frustum slice.
+     * Cascade split distances are linear distances from the main camera eye.
+     */
+    protected _computeCascadeBoundingSphere(cascade: CascadeParams, outSphere: Sphere): void;
+    protected _collectRenderNodes(): QuadTreeStrategy | null;
+    protected _drawFrame(): void;
+    protected _renderCascade(cascade: CascadeParams, cascadeIndex: number, renderedNodes: Node[], fadingOpaqueSegments: Segment[]): void;
+    protected _segmentsPass(camera: Camera, renderedNodes: Node[], fadingOpaqueSegments: Segment[]): void;
+    protected _geoObjectsPass(camera: Camera): void;
+}

package/lib/renderer/cascadeShadows/cascade_shadow_depth.d.ts

@@ -0,0 +1,2 @@
+import { ShaderProgram } from "../../webgl";
+export declare function cascade_shadow_depth(): ShaderProgram;

package/lib/renderer/projectors/Projector.d.ts

@@ -0,0 +1,67 @@
+import type { DepthCamera } from "../../control/depthCamera/DepthCamera";
+import type { NumberArray3 } from "../../math/Vec3";
+import type { NumberArray4 } from "../../math/Vec4";
+import { TypedArray } from "../../utils/shared";
+import type { ProjectorManager } from "./ProjectorManager";
+export type ProjectorSourceType = "color" | "image" | "video" | "texture";
+export type ProjectorRenderMode = "color" | "light";
+export type ProjectorColor = NumberArray3 | NumberArray4 | TypedArray | string;
+export declare const PROJECTOR_RENDER_MODE_COLOR = 0;
+export declare const PROJECTOR_RENDER_MODE_LIGHT = 1;
+export interface IProjectorParams {
+    enabled?: boolean;
+    depthCamera: DepthCamera;
+    color?: ProjectorColor;
+    sourceType?: ProjectorSourceType;
+    renderMode?: ProjectorRenderMode;
+    priority?: number;
+}
+export declare class Projector {
+    protected static __staticCounter__: number;
+    readonly id: number;
+    depthCamera: DepthCamera;
+    color: Float32Array;
+    sourceType: ProjectorSourceType;
+    protected _enabled: boolean;
+    protected _renderMode: number;
+    protected _priority: number;
+    /**
+     * Layer index in the manager-owned depth array texture. -1 if not yet added.
+     */
+    _slot: number;
+    /**
+     * Manager that owns this projector. Set in ProjectorManager.add(), cleared on remove().
+     */
+    _manager: ProjectorManager | null;
+    constructor(params: IProjectorParams);
+    get enabled(): boolean;
+    set enabled(enabled: boolean);
+    get renderMode(): number;
+    set renderMode(renderMode: ProjectorRenderMode | number);
+    get priority(): number;
+    set priority(priority: number);
+    protected static _resolveRenderMode(renderMode?: ProjectorRenderMode | number): number;
+    protected static _resolveColor(color?: ProjectorColor): Float32Array;
+    setColorHTML(color: string): void;
+    setColor(r: number, g: number, b: number, a?: number): void;
+    setOpacity(a: number): void;
+    getColor(): string;
+    getOpacity(): number;
+    /**
+     * @public
+     * @return number
+     * Gets allocated layer index inside the depth array texture.
+     */
+    get slot(): number;
+    /**
+     * Gets Manager-owned TEXTURE_2D_ARRAY used as the depth target.
+     * @return WebGLTexture | null
+     */
+    get arrayTexture(): WebGLTexture | null;
+    /**
+     * Gets original framebuffer color texture (TEXTURE_2D) used by projector depth pass.
+     * ProjectorManager temporarily rebinds framebuffer attachment to array-layer,
+     * but framebuffer.textures[0] remains the original texture reference.
+     */
+    get depthTexture(): WebGLTexture | null;
+}

package/lib/renderer/projectors/ProjectorManager.d.ts

@@ -0,0 +1,86 @@
+import { Mat4 } from "../../math/Mat4";
+import type { ShaderProgram } from "../../webgl/ShaderProgram";
+import type { DepthCamera } from "../../control/depthCamera/DepthCamera";
+import type { Renderer } from "../Renderer";
+import { Projector } from "./Projector";
+/**
+ * Maximum number of depth layers allocated in manager-owned projector array texture.
+ * Defines how many projectors can be added to the manager at once.
+ */
+export declare const MAX_PROJECTOR_LAYERS = 64;
+/**
+ * Maximum number of projectors processed in a single shader invocation.
+ * Used by forward / WOIT paths as top-K by priority per draw call.
+ * Deferred projector pass binds one projector per draw (`chunkSize = 1`).
+ */
+export declare const MAX_FORWARD_PROJECTORS = 8;
+/** Default texture unit where the depth array sampler is bound. */
+export declare class ProjectorManager {
+    protected _renderer: Renderer;
+    protected _projectors: Projector[];
+    protected _activeProjectors: Projector[];
+    protected _viewProjData: Float32Array;
+    protected _invViewProjData: Float32Array;
+    protected _eyeRelData: Float32Array;
+    protected _colorIntensityData: Float32Array;
+    protected _paramsData: Float32Array;
+    protected _depthRangeData: Float32Array;
+    protected _layerData: Int32Array;
+    protected _updateActiveProjectors: boolean;
+    protected _depthArrayTexture: WebGLTexture | null;
+    /** Layer size of `_depthArrayTexture`. Determined by the first projector added. */
+    protected _depthSize: number;
+    protected _depthCapacity: number;
+    protected _freeSlots: number[];
+    protected _tmpInverse: Mat4;
+    constructor(renderer: Renderer);
+    /** Total active projectors count (used by consumers to choose _proj / _noproj programs). */
+    get activeCount(): number;
+    /** Manager-owned TEXTURE_2D_ARRAY containing depth maps for all projectors. */
+    get depthArrayTexture(): WebGLTexture | null;
+    /** Snapshot of currently active projectors (sorted by priority desc). */
+    get active(): Projector[];
+    add(projector: Projector): number;
+    /**
+     * Rebinds projector.depthCamera.framebuffer COLOR_ATTACHMENT0 from its own TEXTURE_2D
+     * to (this._depthArrayTexture, projector._slot) so renders go directly into
+     * the array layer without any per-frame copy. The original TEXTURE_2D stays
+     * referenced inside framebuffer.textures[0] so framebuffer.destroy() can free it
+     * normally — we never overwrite that slot with the shared array texture.
+     */
+    protected _rebindFramebufferToLayer(projector: Projector): boolean;
+    /**
+     * Restores projector.depthCamera.framebuffer COLOR_ATTACHMENT0 back to its original TEXTURE_2D
+     * so subsequent depth renders no longer touch the freed array layer.
+     */
+    protected _restoreFramebufferAttachment(projector: Projector): void;
+    update(projector: Projector): boolean;
+    getByDepthCamera(depthCamera: DepthCamera): Projector | null;
+    remove(projector: Projector): boolean;
+    clear(): void;
+    dispose(): void;
+    /**
+     * Binds forward/WOIT projectors to the given shader program.
+     * Uses top-K projectors by priority for current draw call.
+     *
+     * @returns Actual projector count uploaded (0..MAX_FORWARD_PROJECTORS).
+     */
+    bindForward(program: ShaderProgram, textureUnitStart?: number): number;
+    /**
+     * Binds exactly one projector for deferred frustum-geometry draw call.
+     *
+     * @param projectorIndex - Active projector index in priority-sorted array.
+     * @returns 1 if projector was bound, 0 if index is out of range.
+     */
+    bindDeferred(program: ShaderProgram, textureUnitStart?: number, projectorIndex?: number): number;
+    /**
+     * Lazily allocates the manager-owned TEXTURE_2D_ARRAY at the size of the first
+     * projector to be added.
+     * Returns false if a size mismatch is detected.
+     */
+    protected _ensureDepthArrayTexture(size: number, capacity: number): boolean;
+    protected _createDepthArrayTexture(size: number, capacity: number): boolean;
+    protected _growDepthArrayTexture(): boolean;
+    protected _collectActiveProjectors(): Projector[];
+    protected _getActiveProjectors(): Projector[];
+}

package/lib/renderer/projectors/ProjectorsPass.d.ts

@@ -0,0 +1,37 @@
+import { Mat4 } from "../../math/Mat4";
+import type { Renderer } from "../Renderer";
+import type { Framebuffer } from "../../webgl/Framebuffer";
+import type { Projector } from "./Projector";
+import type { NumberArray16 } from "../../math/Mat4";
+import type { Vec3 } from "../../math/Vec3";
+/**
+ * Deferred projector lighting pass.
+ * For every active projector draws a fullscreen quad clipped by a per-projector screen-space.
+ * Skipped entirely when no projectors are active.
+ * Scissor gives only ~5% optimization.
+ */
+export declare class ProjectorsPass {
+    protected _renderer: Renderer;
+    protected _cornerBuffer: WebGLBuffer | null;
+    protected _indexBuffer: WebGLBuffer | null;
+    protected _indexCount: number;
+    protected _tmpInverse: Mat4;
+    protected _scissor: [number, number, number, number];
+    constructor(renderer: Renderer);
+    init(): void;
+    dispose(): void;
+    /**
+     * Compute the projector frustum screen-space AABB in pixels (origin = bottom-left).
+     * Returns:
+     *   - true  + filled `_scissor` rect when the projector is on-screen.
+     *   - false when the projector is entirely off-screen (caller should skip the draw).
+     *
+     * If any frustum corner is behind the main camera (w<=0), falls back to the full viewport
+     * (CPU-side near-plane clipping of the volume is too costly to be worth it here).
+     */
+    protected _computeScissor(projector: Projector, mainPV: NumberArray16, mainEye: Vec3, viewportW: number, viewportH: number): boolean;
+    /**
+     * Apply per-projector additive projector color(lighting) into the currently bound framebuffer.
+     */
+    apply(gBuffer: Framebuffer): void;
+}