import type { Vector3 } from '@holoscript/core';
/**
 * RayTracing.ts
 *
 * CPU-side software ray tracing engine:
 *   - Axis-Aligned Bounding Box (AABB) representation
 *   - BVH (Bounding Volume Hierarchy) construction with SAH splits
 *   - Ray-AABB intersection (slab method)
 *   - Ray-triangle intersection (Möller–Trumbore)
 *   - Simple path tracer loop (configurable bounces, Russian roulette)
 *   - Non-Local Means (NLM) bilateral denoising filter
 *   - RayTracingConfig descriptor (rt_api, features, spp, max_bounces)
 *
 * Fully CPU / TypeScript — testable without GPU.
 * Production GPU backends (DXR, OptiX, WebGPU RT extension) would
 * use these structures to generate shader pipelines.
 *
 * @module rendering
 */
export type RTApi = 'dxr' | 'optix' | 'metal_rt' | 'vulkan_rt' | 'software';
export type RTFeature = 'reflections' | 'shadows' | 'ao' | 'gi';
export interface RayTracingConfig {
    rt_api: RTApi;
    features: RTFeature[];
    /** Samples per pixel */
    spp: number;
    /** Max path tracing bounces */
    max_bounces: number;
    denoising: 'nlm' | 'none';
}
export interface AABB {
    min: Vector3;
    max: Vector3;
}
export interface Triangle {
    v0: Vector3;
    v1: Vector3;
    v2: Vector3;
    /** Pre-computed normal (optional, computed on demand) */
    normal?: Vector3;
}
export interface Ray {
    origin: Vector3;
    direction: Vector3;
    tMin: number;
    tMax: number;
}
export interface HitRecord {
    t: number;
    point: Vector3;
    normal: Vector3;
    triangleIndex: number;
}
export declare function computeTriangleNormal(tri: Triangle): Vector3;
export declare function computeAABB(triangles: Triangle[], start: number, end: number): AABB;
export declare function aabbSurfaceArea(box: AABB): number;
export declare function aabbCentroid(box: AABB): Vector3;
/**
 * Ray–AABB intersection (slab method).
 * Returns t of intersection or -1 if miss.
 */
export declare function intersectRayAABB(ray: Ray, box: AABB): number;
/**
 * Ray–triangle intersection (Möller–Trumbore).
 * Returns t of intersection or -1 if miss / back-face.
 */
export declare function intersectRayTriangle(ray: Ray, tri: Triangle): number;
export interface BVHNode {
    bound: AABB;
    leftChild: number;
    rightChild: number;
    triStart: number;
    triCount: number;
}
export declare class BVH {
    nodes: BVHNode[];
    tris: Triangle[];
    /** Build from an array of triangles using SAH binned splits */
    build(triangles: Triangle[]): void;
    getNodeCount(): number;
    getLeafCount(): number;
    private buildRecursive;
    /**
     * Traverse BVH to find nearest hit for a ray.
     */
    intersect(ray: Ray): HitRecord | null;
}
export interface PathTracerScene {
    bvh: BVH;
    /** Ambient (sky) radiance (RGB) for misses */
    skyColor: [number, number, number];
    /** Light positions for shadow rays */
    lights: Array<{
        position: Vector3;
        color: [number, number, number];
        intensity: number;
    }>;
}
/**
 * Path-trace a single ray for up to maxBounces bounces.
 * Returns linear RGB radiance estimate.
 */
export declare function pathTrace(ray: Ray, scene: PathTracerScene, maxBounces: number, seed: number): [number, number, number];
export interface NLMConfig {
    /** Search window half-size in pixels */
    searchRadius: number;
    /** Patch half-size */
    patchRadius: number;
    /** Filter strength */
    h: number;
}
/**
 * Non-Local Means bilateral denoising on a Float32Array RGBA buffer.
 * Reduces noise while preserving edges.
 */
export declare function nlmDenoise(noisy: Float32Array, width: number, height: number, config?: Partial<NLMConfig>): Float32Array;
export declare class RayTracer {
    private config;
    private scene;
    constructor(config?: Partial<RayTracingConfig>);
    getConfig(): Readonly<RayTracingConfig>;
    setFeatures(features: RTFeature[]): void;
    hasFeature(f: RTFeature): boolean;
    loadScene(triangles: Triangle[], lights?: {
        position: Vector3;
        color: [number, number, number];
        intensity: number;
    }[], sky?: [number, number, number]): void;
    getBVH(): BVH;
    /** Render a single pixel with multi-sample path tracing */
    renderPixel(rayOrigin: Vector3, rayDir: Vector3, pixelX: number, pixelY: number): [number, number, number];
}
//# sourceMappingURL=RayTracing.d.ts.map