/*!
 * Copyright (c) Microsoft Corporation.
 * Licensed under the MIT License.
 */
import { mat4, quat, vec3 } from "gl-matrix";
import { StereoMode } from "../../main.js";
export declare class RayTracer {
    private _maxDepth;
    private _camera;
    private _width;
    private _height;
    private _world;
    private _attenuations;
    private _emitteds;
    private _colors;
    private _scatteredRays;
    private _hitRecords;
    private _backgroundColor;
    get world(): HittableList;
    constructor(camera: Camera, width: number, height: number, backgroundColor: vec3);
    render(offsetX: number, offsetY: number, blockSize: number, samplesPerPixel: number): void;
    protected _rayColor(ray: Ray, depth: number): vec3;
}
export declare abstract class Material {
    protected _albedo: vec3;
    get albedo(): vec3;
    abstract scatter(rayIn: Ray, hitRecord: HitRecord, attenuation: vec3, rayScattered: Ray): boolean;
    constructor();
    protected _randomUnitVector(position: vec3): void;
    protected _randomInUnitSphere(position: vec3): void;
    protected _reflect(ray: vec3, normal: vec3, reflected: vec3): void;
    emitted(color: vec3, u: number, v: number, hitRecord: HitRecord): void;
    protected _reflectance(cos: number, refractiveIndex: number): number;
}
export declare class LambertianMaterial extends Material {
    private _texture;
    get texture(): Texture;
    constructor(texture: Texture);
    scatter(rayIn: Ray, hitRecord: HitRecord, attenuation: vec3, rayScattered: Ray): boolean;
}
export declare class GlossyMaterial extends Material {
    private _random;
    private _refractiveIndex;
    private _fuzz;
    private _texture;
    get texture(): Texture;
    constructor(texture: Texture, refractiveIndex: number, fuzz: number);
    scatter(rayIn: Ray, hitRecord: HitRecord, attenuation: vec3, rayScattered: Ray): boolean;
}
export declare class MetalMaterial extends Material {
    private _random;
    fuzz: number;
    private _fuzzTexture;
    get fuzzTexture(): Texture;
    constructor(albedo: vec3, fuzz: number, fuzzMap: ImageData);
    scatter(rayIn: Ray, hitRecord: HitRecord, attenuation: vec3, rayScattered: Ray): boolean;
}
export declare class DielectricMaterial extends Material {
    private _rOutPerpendicular;
    private _rOutParallel;
    private _attenuation;
    refractiveIndex: number;
    constructor(refractiveIndex: number, attenuation: vec3);
    scatter(rayIn: Ray, hitRecord: HitRecord, attenuation: vec3, rayScattered: Ray): boolean;
    private _refract;
}
export declare class DiffuseLightMaterial extends Material {
    protected _color: vec3;
    get color(): vec3;
    constructor(color: vec3);
    scatter(rayIn: Ray, hitRecord: HitRecord, attenuation: vec3, rayScattered: Ray): boolean;
    emitted(color: vec3, u: number, v: number, hitRecord: HitRecord): void;
}
export declare class IsotropicMaterial extends Material {
    private _solidColor;
    private _density;
    get density(): number;
    constructor(color: vec3, density: number);
    scatter(rayIn: Ray, hitRecord: HitRecord, attenuation: vec3, rayScattered: Ray): boolean;
}
export declare abstract class Texture {
    value(color: vec3, u: number, v: number, position: vec3): void;
}
export declare class SolidColorTexture extends Texture {
    protected _color: vec3;
    get color(): vec3;
    constructor(color: vec3);
    value(color: vec3, u: number, v: number, position: vec3): void;
}
export declare class PaletteColorTexture extends Texture {
    protected _u0: number;
    protected _u1: number;
    protected _palette: Uint8Array;
    get u0(): number;
    get u1(): number;
    get palette(): Uint8Array;
    constructor(u0: number, u1: number, palette: Uint8Array);
    value(color: vec3, u: number, v: number, position: vec3): void;
}
export declare class CheckerTexture extends Texture {
    private _color0;
    private _color1;
    private _sizeX;
    private _sizeY;
    private _offsetX;
    private _offsetY;
    constructor(color0: vec3, color1: vec3, sizeX: number, sizeY: number, offsetX: number, offsetY: number);
    value(color: vec3, u: number, v: number, position: vec3): void;
}
export declare class GridTexture extends Texture {
    private _background;
    private _color;
    private _sizeX;
    private _sizeY;
    private _minorSizeX;
    private _minorSizeY;
    private _thicknessX;
    private _thicknessY;
    private _minorThicknessX;
    private _minorThicknessY;
    private _offsetX;
    private _offsetY;
    constructor(color: vec3, background: vec3, sizeX: number, sizeY: number, minorSizeX: number, minorSizeY: number, thicknessX: number, thicknessY: number, minorThicknessX: number, minorThicknessY: number, offsetX: number, offsetY: number);
    value(color: vec3, u: number, v: number, position: vec3): void;
}
export declare class ImageTexture extends Texture {
    private _sampler;
    constructor(imageData: ImageData, u0: number, u1: number, v0: number, v1: number);
    value(color: vec3, u: number, v: number, position: vec3): void;
}
export declare class FuzzTexture extends ImageTexture {
}
export declare class BumpTexture extends ImageTexture {
}
export declare class NormalTexture extends ImageTexture {
}
export declare class MarbleTexture extends Texture {
    private _perlin;
    private _scale;
    private _position;
    private _color;
    constructor(scale: number, seed: number, color: vec3);
    value(color: vec3, u: number, v: number, position: vec3): void;
}
export declare class HitRecord {
    hittable: Hittable;
    t: number;
    u: number;
    v: number;
    material: Material;
    frontFace: boolean;
    position: vec3;
    outwardNormal: vec3;
    constructor();
    setFaceNormal(ray: Ray): void;
}
export declare abstract class Hittable {
    protected _boundingBox: AABB;
    get boundingBox(): AABB;
    material: Material;
    abstract hit(ray: Ray, tMin: number, tMax: number, hitRecord: HitRecord): boolean;
    protected _surroundingBox(surroundingBox: AABB, box0: AABB, box1: AABB): void;
    protected _maximumExtent(min: vec3, max: vec3): 0 | 1 | 2;
    protected _surfaceArea(min: vec3, max: vec3): number;
}
export declare class HittableList extends Hittable {
    private _list;
    get list(): Hittable[];
    constructor();
    hit(ray: Ray, tMin: number, tMax: number, hitRecord: HitRecord): boolean;
    get boundingBox(): AABB;
}
export declare const SplitMethod: {
    readonly middle: "middle";
    readonly equalCounts: "equalCounts";
    readonly sah: "sah";
};
export type SplitMethod = (typeof SplitMethod)[keyof typeof SplitMethod];
export declare class BVHNode extends Hittable {
    private _left;
    private _right;
    private _hittables0;
    private _axis;
    private _hittables1;
    constructor(hittables0: Uint32Array, hittables1: Hittable[], start: number, end: number, splitMethod: SplitMethod);
    hit(ray: Ray, tMin: number, tMax: number, hitRecord: HitRecord): boolean;
}
export declare class Sphere extends Hittable {
    protected _center: vec3;
    protected _radius: number;
    protected _oc: vec3;
    constructor(center: vec3, radius: number);
    hit(ray: Ray, tMin: number, tMax: number, hitRecord: HitRecord): boolean;
    setUV(position: vec3, hitRecord: HitRecord): void;
}
export declare class RotatedSphere extends Sphere {
    private _rotation;
    private _invRotation;
    private _rotatedRay;
    private _tempVec3;
    constructor(center: vec3, radius: number, rotation: quat);
    hit(ray: Ray, tMin: number, tMax: number, hitRecord: HitRecord): boolean;
}
export declare abstract class HittableSdf extends Hittable {
    protected _position0: vec3;
    protected _position1: vec3;
    protected _oc: vec3;
    constructor();
    protected _sdSphere(p: vec3, s: number): number;
    protected _sdPlane(p: vec3, n: vec3, h: number): number;
    protected _sdBox(p: vec3, b: vec3): number;
    protected _sdCappedCylinder(p: vec3, h: number, r: number): number;
    protected _sdRotatedCappedCylinder(p: vec3, a: vec3, b: vec3, r: number): number;
    protected _sdBoxFrame(p: vec3, b: vec3, e: number): number;
    private _kx;
    private _ky;
    private _kz;
    protected _sdHexPrism(p: vec3, hx: number, hy: number): number;
    protected abstract _map(position: vec3): number;
    protected readonly _maxMarchingSteps = 128;
    protected readonly _epsilon = 0.00001;
    protected _kxyy: vec3;
    protected _kyyx: vec3;
    protected _kyxy: vec3;
    protected _kxxx: vec3;
    protected _calcNormal(position: vec3, outwardNormal: vec3): void;
    hit(ray: Ray, tMin: number, tMax: number, hitRecord: HitRecord): boolean;
}
export declare class SphereSdf extends HittableSdf {
    protected _center: vec3;
    protected _radius: number;
    constructor(center: vec3, radius: number);
    protected _map(position: vec3): number;
}
export declare class XzPlaneSdf extends HittableSdf {
    private _normal;
    private _h;
    constructor(x0: number, x1: number, z0: number, z1: number, h: number);
    protected _map(position: vec3): number;
}
export declare class BoxSdf extends HittableSdf {
    protected _center: vec3;
    protected _size: vec3;
    constructor(center: vec3, size: vec3);
    protected _map(position: vec3): number;
}
export declare class RoundedBoxSdf extends BoxSdf {
    protected _radius: number;
    constructor(center: vec3, size: vec3, radius: number);
    protected _map(position: vec3): number;
}
export declare class BoxFrameSdf extends HittableSdf {
    protected _center: vec3;
    protected _size: vec3;
    protected _e: number;
    constructor(center: vec3, size: vec3, e: number);
    protected _map(position: vec3): number;
}
export declare class RoundedBoxFrameSdf extends BoxFrameSdf {
    protected _radius: number;
    constructor(center: vec3, size: vec3, e: number, radius: number);
    protected _map(position: vec3): number;
}
export declare class HexPrismSdf extends HittableSdf {
    private _center;
    private _radius;
    private _length;
    constructor(center: vec3, length: number, radius: number);
    protected _map(position: vec3): number;
}
export declare class CylinderSdf extends HittableSdf {
    private _center;
    protected _length: number;
    protected _radius: number;
    constructor(center: vec3, length: number, radius: number);
    protected _map(position: vec3): number;
}
export declare class RoundedCylinderSdf extends CylinderSdf {
    protected _rb: number;
    constructor(center: vec3, length: number, radius: number, rb: number);
    protected _map(position: vec3): number;
}
export declare class RotatedCylinderSdf extends HittableSdf {
    private _identityRotation;
    protected _pa: vec3;
    protected _pb: vec3;
    protected _ca: vec3;
    protected _radius: number;
    constructor(center: vec3, length: number, radius: number, rotation: quat);
    protected _map(position: vec3): number;
}
export declare class RoundedRotatedCylinderSdf extends RotatedCylinderSdf {
    protected _rb: number;
    constructor(center: vec3, length: number, radius: number, rotation: quat, rb: number);
    protected _map(position: vec3): number;
}
export declare class Box extends Hittable {
    protected _center: vec3;
    protected _size: vec3;
    constructor(center: vec3, size: vec3);
    hit(ray: Ray, tMin: number, tMax: number, hitRecord: HitRecord): boolean;
}
export declare class RotatedBox extends Box {
    private _rotation;
    private _invRotation;
    private _rotatedRay;
    private _rotatedBoundingBox;
    private _tempVec3;
    constructor(center: vec3, size: vec3, rotation: quat);
    hit(ray: Ray, tMin: number, tMax: number, hitRecord: HitRecord): boolean;
    get boundingBox(): AABB;
}
export declare class SidedBox extends Hittable {
    protected _center: vec3;
    protected _size: vec3;
    protected _sides: Hittable[];
    get center(): vec3;
    get size(): vec3;
    constructor(center: vec3, size: vec3);
    hit(ray: Ray, tMin: number, tMax: number, hitRecord: HitRecord): boolean;
}
export declare class RotatedSidedBox extends SidedBox {
    private _rotation;
    private _invRotation;
    private _rotatedRay;
    private _rotatedBoundingBox;
    private _tempVec3;
    constructor(center: vec3, size: vec3, rotation: quat);
    hit(ray: Ray, tMin: number, tMax: number, hitRecord: HitRecord): boolean;
    get boundingBox(): AABB;
}
export declare class Cylinder extends Hittable {
    private _identityRotation;
    private _center;
    private _pa;
    private _pb;
    private _length;
    private _radius;
    private _oc;
    private _ca;
    constructor(center: vec3, length: number, radius: number, rotation: quat);
    hit(ray: Ray, tMin: number, tMax: number, hitRecord: HitRecord): boolean;
}
export declare class HexPrism extends Hittable {
    private _length;
    private _radius;
    private _center;
    private _ro;
    private _n1;
    private _n2;
    private _n3;
    private _n4;
    private _t1;
    private _t2;
    private _t3;
    private _t4;
    constructor(center: vec3, length: number, radius: number);
    hit(ray: Ray, tMin: number, tMax: number, hitRecord: HitRecord): boolean;
}
export declare class XyRect extends Hittable {
    protected _x0: number;
    protected _x1: number;
    protected _y0: number;
    protected _y1: number;
    protected _k: number;
    protected _direction: number;
    protected _center: vec3;
    constructor(x0: number, x1: number, y0: number, y1: number, k: number, direction: number);
    hit(ray: Ray, tMin: number, tMax: number, hitRecord: HitRecord): boolean;
}
export declare class RotatedXyRect extends XyRect {
    private _rotation;
    private _invRotation;
    private _rotatedRay;
    private _rotatedBoundingBox;
    private _tempVec3;
    constructor(x0: number, x1: number, y0: number, y1: number, k: number, direction: number, rotation: quat);
    hit(ray: Ray, tMin: number, tMax: number, hitRecord: HitRecord): boolean;
    get boundingBox(): AABB;
}
export declare class XzRect extends Hittable {
    private _x0;
    private _x1;
    private _z0;
    private _z1;
    private _k;
    private _direction;
    constructor(x0: number, x1: number, z0: number, z1: number, k: number, direction: number);
    hit(ray: Ray, tMin: number, tMax: number, hitRecord: HitRecord): boolean;
}
export declare class YzRect extends Hittable {
    private _y0;
    private _y1;
    private _z0;
    private _z1;
    private _k;
    private _direction;
    constructor(y0: number, y1: number, z0: number, z1: number, k: number, direction: number);
    hit(ray: Ray, tMin: number, tMax: number, hitRecord: HitRecord): boolean;
}
export declare class ConstantMedium extends Hittable {
    private _boundary;
    private _negativeInverseDensity;
    private _phaseFunction;
    constructor(boundary: Hittable, isotropic: IsotropicMaterial);
    private _hitRecord1;
    private _hitRecord2;
    hit(ray: Ray, tMin: number, tMax: number, hitRecord: HitRecord): boolean;
    get boundingBox(): AABB;
}
export declare abstract class Sampler {
    protected _u0: number;
    protected _u1: number;
    protected _v0: number;
    protected _v1: number;
    protected _data: Uint8ClampedArray;
    protected _width: number;
    protected _height: number;
    constructor(u0: number, u1: number, v0: number, v1: number, imageData: ImageData);
    abstract channel(i: number, j: number, channel: number): number;
    abstract color(i: number, j: number, color: vec3): void;
}
export declare class PointSampler extends Sampler {
    private _offset;
    channel(u: number, v: number, channel: number): number;
    color(u: number, v: number, color: vec3): void;
}
export declare class BilinearSampler extends Sampler {
    private _offset0;
    private _offset1;
    private _offset2;
    private _offset3;
    private _x0Scale;
    private _x1Scale;
    private _y0Scale;
    private _y1Scale;
    private _offsets;
    channel(u: number, v: number, channel: number): number;
    color(u: number, v: number, color: vec3): void;
}
export declare class FontXyRect extends XyRect {
    private _normal;
    private _sampler;
    constructor(x0: number, x1: number, y0: number, y1: number, k: number, direction: number, u0: number, u1: number, v0: number, v1: number, imageData: ImageData);
    hit(ray: Ray, tMin: number, tMax: number, hitRecord: HitRecord): boolean;
}
export declare class RotatedFontXyRect extends FontXyRect {
    private _rotation;
    private _invRotation;
    private _transformedRay;
    private _rotatedBoundingBox;
    private _tempVec3;
    constructor(x0: number, x1: number, y0: number, y1: number, k: number, direction: number, u0: number, u1: number, v0: number, v1: number, imageData: ImageData, rotation: quat);
    hit(ray: Ray, tMin: number, tMax: number, hitRecord: HitRecord): boolean;
    get boundingBox(): AABB;
}
export declare class Ray {
    private _origin;
    get origin(): vec3;
    private _direction;
    get direction(): vec3;
    debugMarchingSteps: number;
    constructor();
    at(position: vec3, t: number): void;
}
export declare class AABB {
    min: vec3;
    max: vec3;
    constructor();
    hit(ray: Ray, tMin: number, tMax: number): boolean;
}
export declare class Perlin {
    private _random;
    private _randomCount;
    private _randomValues;
    private _permuteX;
    private _permuteY;
    private _permuteZ;
    private _weight;
    private _position;
    private _cell;
    constructor(seed: number);
    noise(position: vec3): number;
    turb(position: vec3, depth: number): number;
    fbm(position: vec3, H: number, numOctaves: number): number;
    fbm2(position: vec3, H: number, numOctaves: number): number;
    private _interpolate;
    private _permute;
}
export declare class Camera {
    private _aspectRatio;
    private _lowerLeftCorner;
    private _horizontal;
    private _vertical;
    private _positions;
    private _aperture;
    private _focusDistance;
    private _u;
    private _v;
    private _w;
    private _rd;
    private _offset;
    private _stereoMode;
    get stereoMode(): StereoMode;
    constructor(inverseVMatrices: mat4[], stereoMode: StereoMode, vFov: number, aspectRatio: number, aperture: number, focusPosition: vec3);
    ray(index: number, s: number, t: number, ray: Ray): void;
    private _randomInUnitDisk;
}