/**
 * WebGPU Renderer
 *
 * High-performance WebGPU-based renderer for HoloScript
 */
import type { IWebGPUInitOptions, IWebGPUContext, IRenderPipelineDescriptor, IShaderModule, IBufferDescriptor, ITextureDescriptor, ISamplerDescriptor, IGPUTexture, IDrawCall, ICameraUniforms, ISceneUniforms, IRendererStats, IVertexBuffer, IIndexBuffer } from './WebGPUTypes';
/**
 * WebGPU-based renderer for HoloScript scenes
 */
export declare class WebGPURenderer {
    private context;
    private pipelines;
    private shaderModules;
    private bindGroupLayouts;
    private pipelineLayouts;
    private depthTexture;
    private msaaTexture;
    private options;
    private xrSession;
    private xrBinding;
    private xrProjectionLayer;
    private xrFramebuffer;
    private stats;
    private lastFrameTime;
    private frameTimeHistory;
    private cameraUniformBuffer;
    private sceneUniformBuffer;
    private defaultSampler;
    private defaultTexture;
    constructor(options?: Partial<IWebGPUInitOptions>);
    /**
     * Check if WebGPU is supported
     */
    static isSupported(): boolean;
    /**
     * Initialize the WebGPU renderer
     */
    initialize(options?: Partial<IWebGPUInitOptions>): Promise<IWebGPUContext>;
    /**
     * Resolve canvas from element or selector
     */
    private resolveCanvas;
    /**
     * Get device capabilities
     */
    private getDeviceCapabilities;
    /**
     * Create default resources
     */
    private createDefaultResources;
    /**
     * Create depth buffer
     */
    private createDepthBuffer;
    /**
     * Handle canvas resize
     */
    resize(width: number, height: number): void;
    /**
     * Create a shader module
     */
    createShaderModule(descriptor: IShaderModule): GPUShaderModule;
    /**
     * Create a render pipeline
     */
    createRenderPipeline(id: string, descriptor: IRenderPipelineDescriptor): GPURenderPipeline;
    /**
     * Create a GPU buffer
     */
    createBuffer(descriptor: IBufferDescriptor): GPUBuffer;
    /**
     * Create a vertex buffer from typed array
     */
    createVertexBuffer(data: Float32Array | Uint16Array | Uint32Array, slot?: number): IVertexBuffer;
    /**
     * Create an index buffer
     */
    createIndexBuffer(data: Uint16Array | Uint32Array): IIndexBuffer;
    /**
     * Create a texture
     */
    createTexture(descriptor: ITextureDescriptor): GPUTexture;
    /**
     * Create a GPU texture from image data
     */
    createTextureFromImage(source: ImageBitmap | HTMLCanvasElement | OffscreenCanvas, options?: Partial<ITextureDescriptor>): Promise<IGPUTexture>;
    private mipmapPipeline;
    private mipmapSampler;
    /**
     * Get or create the mipmap blit pipeline.
     * Uses a fullscreen-quad vertex shader (no vertex buffers) and a
     * bilinear-sampling fragment shader to downsample each mip level.
     */
    private getOrCreateMipmapPipeline;
    /**
     * Generate mipmaps for a texture using a blit-style render pass.
     *
     * For each mip level (1..mipLevelCount-1) we render a fullscreen triangle
     * that samples the previous level with bilinear filtering, writing the
     * downsampled result into the current level.
     *
     * Requires the texture to have been created with RENDER_ATTACHMENT usage.
     */
    private generateMipmaps;
    /**
     * Create a sampler
     */
    createSampler(descriptor?: ISamplerDescriptor): GPUSampler;
    /**
     * Create a bind group
     */
    createBindGroup(layout: GPUBindGroupLayout, entries: GPUBindGroupEntry[], label?: string): GPUBindGroup;
    /**
     * Update camera uniforms
     */
    updateCameraUniforms(uniforms: ICameraUniforms): void;
    /**
     * Update scene uniforms
     */
    updateSceneUniforms(uniforms: ISceneUniforms): void;
    /**
     * Begin a render frame
     */
    beginFrame(): GPUCommandEncoder | null;
    /**
     * Begin a render pass
     */
    beginRenderPass(encoder: GPUCommandEncoder, clearColor?: GPUColor): GPURenderPassEncoder;
    /**
     * Submit draw calls
     */
    submitDrawCalls(pass: GPURenderPassEncoder, drawCalls: IDrawCall[]): void;
    /**
     * Sort draw calls for optimal rendering
     */
    private sortDrawCalls;
    /**
     * End render pass
     */
    endRenderPass(pass: GPURenderPassEncoder): void;
    /**
     * End frame and submit
     */
    endFrame(encoder: GPUCommandEncoder): void;
    /**
     * Get render statistics
     */
    getStats(): IRendererStats;
    /**
     * Get the WebGPU context
     */
    getContext(): IWebGPUContext | null;
    /**
     * Get the GPU device
     */
    getDevice(): GPUDevice | null;
    /**
     * Get the canvas
     */
    getCanvas(): HTMLCanvasElement | null;
    /**
     * Get the default texture
     */
    getDefaultTexture(): IGPUTexture | null;
    /**
     * Get the default sampler
     */
    getDefaultSampler(): GPUSampler | null;
    /**
     * Create empty frame stats
     */
    private createEmptyFrameStats;
    /**
     * Set the active XR session and bindings
     */
    setXRSession(session: XRSession | null, binding: any | null, layer: any | null): void;
    /**
     * Render a WebXR Frame
     */
    renderXR(frame: XRFrame): void;
    private multiplyMatrices;
    /**
     * Destroy the renderer and release resources
     */
    destroy(): void;
    /**
     * Render an XR frame
     */
    renderXRFrame(frame: XRFrame, refSpace: XRReferenceSpace, renderCallback: (pass: GPURenderPassEncoder, view: XRView) => void): void;
}
//# sourceMappingURL=WebGPURenderer.d.ts.map