import type { Scene } from '@certe/atmos-core';
import type { Renderer } from '@certe/atmos-core';
import type { Mat4Type } from '@certe/atmos-math';
import type { GPUContext } from './webgpu-device.js';
import type { PipelineResources } from './pipeline.js';
import type { LightSettings } from './light.js';
import { MeshRenderer } from './mesh-renderer.js';
import type { SkinnedPipelineResources } from './skinned-pipeline.js';
import { Camera } from './camera.js';
import type { Material } from './material.js';
export interface CameraSettings {
    eye: Float32Array;
    target: Float32Array;
    up: Float32Array;
    fovY: number;
    near: number;
    far: number;
}
export declare function createDefaultCamera(): CameraSettings;
export type OverlayCallback = (pass: GPURenderPassEncoder, vp: Float32Array, eye: Float32Array) => void;
/** Pluggable material loader — returns a GPU-ready Material for a given asset path. */
export type MaterialLoader = (path: string) => Promise<Material>;
/** Pluggable shader source loader — reads .wgsl text from a project path. */
export type ShaderLoader = (path: string) => Promise<string>;
/**
 * Plugin interface for external renderer types (e.g. clipmap terrain).
 * Avoids circular dependency: external packages register draw callbacks.
 */
export interface RendererPlugin {
    /** Called during beginFrame() to update + collect renderers. */
    collect(vpMatrix: Float32Array, cameraEye: Float32Array, sceneBuffer: GPUBuffer): void;
    /** Draw into the main render pass. */
    draw(pass: GPURenderPassEncoder, shadowBindGroup: GPUBindGroup): void;
    /** Draw into shadow passes. Returns true if it drew anything. */
    drawShadow?(pass: GPURenderPassEncoder): void;
    /** Draw into depth prepass. */
    drawDepth?(pass: GPURenderPassEncoder): void;
    /** Draw 1.0 into AO texture for non-SSAO pixels (erase SSAO for this plugin). */
    drawSSAOErase?(pass: GPURenderPassEncoder): void;
}
export declare class RenderSystem implements Renderer {
    /** The active RenderSystem, set automatically on construction. */
    static current: RenderSystem | null;
    private readonly _gpu;
    private readonly _pipelineResources;
    private _scene;
    private readonly _camera;
    private readonly _light;
    private readonly _viewMatrix;
    private readonly _projMatrix;
    private readonly _vpMatrix;
    private readonly _sceneBuffer;
    private readonly _sceneData;
    private _encoder;
    private _pass;
    private readonly _overlayCallbacks;
    private _activeCamera;
    private readonly _eyeScratch;
    private _elapsedTime;
    private _lastFrameTime;
    private _shadowManager;
    private readonly _lightView;
    private readonly _lightProj;
    private readonly _lightDirScratch;
    private readonly _frustumPlanes;
    private _bloomPass;
    private _tonemapPass;
    private _depthPrepass;
    private _ssaoPass;
    private readonly _invProjMatrix;
    private readonly _invVPMatrix;
    private _sceneDepthPass;
    private _pendingReadbacks;
    private _activeFullReadback;
    private _meshRenderers;
    private _skinnedMeshRenderers;
    private _skinnedPipelineResources;
    private _terrainRenderers;
    private _terrainShadowPipeline;
    private _primitiveMeshes;
    private _materialLoader;
    private readonly _pendingMaterials;
    private readonly _customPipelines;
    private _shaderLoader;
    private readonly _pendingShaders;
    private readonly _rendererPlugins;
    private _skyPass;
    private readonly _sunDirScratch;
    bloomIntensity: number;
    bloomThreshold: number;
    bloomRadius: number;
    ssaoEnabled: boolean;
    ssaoRadius: number;
    ssaoBias: number;
    ssaoIntensity: number;
    exposure: number;
    vignetteIntensity: number;
    vignetteRadius: number;
    fogEnabled: boolean;
    fogMode: 'linear' | 'exponential';
    fogDensity: number;
    fogStart: number;
    fogEnd: number;
    fogColor: Float32Array<ArrayBuffer>;
    constructor(gpu: GPUContext, pipelineResources: PipelineResources, scene: Scene, camera: CameraSettings, light: LightSettings);
    get device(): GPUDevice;
    get format(): GPUTextureFormat;
    get aspect(): number;
    get camera(): CameraSettings;
    get viewProjectionMatrix(): Mat4Type;
    get pipelineResources(): PipelineResources;
    get activeCamera(): Camera | null;
    set activeCamera(cam: Camera | null);
    set scene(s: Scene);
    get meshRenderers(): readonly MeshRenderer[];
    /** Set the material loader used to auto-resolve materialSource strings. */
    setMaterialLoader(loader: MaterialLoader): void;
    /** Set the shader loader used to load custom .wgsl sources from the project. */
    setShaderLoader(loader: ShaderLoader): void;
    /** Register an external renderer plugin (e.g. clipmap terrain). */
    addRendererPlugin(plugin: RendererPlugin): void;
    /** Remove a previously registered renderer plugin. */
    removeRendererPlugin(plugin: RendererPlugin): void;
    /** Invalidate a cached custom pipeline (called on .wgsl hot-reload). */
    invalidateCustomPipeline(shaderPath: string): void;
    /** Resolve a `primitive:*` meshSource to a cached GPU Mesh. */
    private _resolvePrimitiveMesh;
    private readonly _awaitingMaterial;
    /** Auto-resolve meshSource and materialSource on a MeshRenderer. */
    private _autoResolveMeshRenderer;
    /** Asynchronously resolve and cache a custom pipeline for a MeshRenderer. */
    private _resolveCustomPipeline;
    /** Lazily create the skinned PBR pipeline resources. */
    get skinnedPipelineResources(): SkinnedPipelineResources;
    addOverlayCallback(fn: OverlayCallback): () => void;
    beginFrame(): void;
    private _makeExtraShadowDraw;
    /** Like _makeExtraShadowDraw but filters by receiveSSAO flag (for depth prepass only). */
    private _makeDepthPrepassExtraDraw;
    /** Build callback to draw RendererPlugins into the scene depth pass (for screenToWorldPoint). */
    private _makeSceneDepthPluginDraw;
    /** Build callback that writes 1.0 to AO texture for non-SSAO plugins (erases their SSAO). */
    private _makeSSAOEraseDraw;
    private _createTerrainShadowPipeline;
    private _computeCascadeVP;
    /**
     * Queue a depth readback for the next frame. The returned promise resolves
     * after endFrame() submits the GPU commands and the staging buffer is mapped.
     * Returns null if the pixel is sky (depth >= 1.0) or closer than nearClip world units.
     */
    screenToWorldPoint(x: number, y: number, nearClip?: number): Promise<Float32Array | null>;
    endFrame(): void;
}
//# sourceMappingURL=render-system.d.ts.map