/**
 * LODTransition.ts
 *
 * LOD transition effects: crossfade, dithering,
 * morph-based transitions, and hysteresis bands.
 *
 * @module lod
 */
export type TransitionMode = 'instant' | 'crossfade' | 'dither' | 'morph';
export interface LODTransitionConfig {
    mode: TransitionMode;
    duration: number;
    hysteresisBand: number;
}
export interface TransitionState {
    entityId: string;
    fromLOD: number;
    toLOD: number;
    progress: number;
    active: boolean;
}
export declare class LODTransition {
    private config;
    private transitions;
    private ditherLUT;
    private scheduler;
    constructor(config?: Partial<LODTransitionConfig>);
    startTransition(entityId: string, fromLOD: number, toLOD: number): void;
    update(dt: number): void;
    getBlendFactor(entityId: string): number;
    getDitherThreshold(entityId: string): number;
    shouldTransition(currentDist: number, threshold: number, currentLOD: number, newLOD: number): boolean;
    private smoothstep;
    isTransitioning(entityId: string): boolean;
    getTransitionState(entityId: string): TransitionState | undefined;
    getMode(): TransitionMode;
    setMode(mode: TransitionMode): void;
    /**
     * Generate optimized dither pattern LUT for smoother visual transitions
     */
    private generateDitherLUT;
    /**
     * Get dither threshold from LUT based on screen position
     */
    getDitherPattern(x: number, y: number): number;
    /**
     * Optimized crossfade shader code (reduces overdraw)
     */
    getOptimizedCrossfadeShader(): string;
    /**
     * Geometry morphing shader for critical objects (hero characters)
     */
    getGeometryMorphShader(): string;
    /**
     * Get transition scheduler
     */
    getScheduler(): TransitionScheduler;
    /**
     * Get dither LUT for external use
     */
    getDitherLUT(): Uint8Array;
}
/**
 * Budget system for tracking GPU cost per frame
 */
export interface TransitionBudget {
    maxGPUTimeMs: number;
    currentGPUTimeMs: number;
    maxTransitions: number;
    currentTransitions: number;
}
/**
 * Scheduled transition with priority
 */
export interface ScheduledTransition {
    entityId: string;
    fromLOD: number;
    toLOD: number;
    priority: number;
    estimatedCostMs: number;
    timestamp: number;
}
/**
 * TransitionScheduler manages transition budget and scheduling
 */
export declare class TransitionScheduler {
    private budget;
    private queue;
    private activatedThisFrame;
    constructor(maxGPUTimeMs?: number, maxTransitions?: number);
    /**
     * Schedule a transition with priority
     */
    schedule(entityId: string, fromLOD: number, toLOD: number, priority?: number, estimatedCostMs?: number): boolean;
    /**
     * Process scheduled transitions within budget
     */
    process(): ScheduledTransition[];
    /**
     * Reset budget for new frame
     */
    resetFrame(): void;
    /**
     * Get current budget status
     */
    getBudget(): TransitionBudget;
    /**
     * Set budget limits
     */
    setBudget(maxGPUTimeMs: number, maxTransitions: number): void;
    /**
     * Get queue size
     */
    getQueueSize(): number;
    /**
     * Clear all scheduled transitions
     */
    clear(): void;
    /**
     * Record actual GPU cost for a transition (for budget tuning)
     */
    recordCost(entityId: string, _actualCostMs: number): void;
    /**
     * Get budget utilization (0-1)
     */
    getBudgetUtilization(): {
        gpu: number;
        transitions: number;
    };
}
//# sourceMappingURL=LODTransition.d.ts.map