/*!
 * Copyright (c) Microsoft Corporation.
 * Licensed under the MIT License.
 */
import { Core, StereoMode, UnitType } from "../../main.js";
import { IRendererOptionsBase, RendererBase } from "../renderer.js";
import { Config } from "./config.js";
import { mat4, quat, vec2, vec3 } from "gl-matrix";
export interface IRendererOptions extends IRendererOptionsBase {
}
export interface IRenderOptions {
    threads: number;
    samplesPerPixel: number;
    maxSamplesPerPixel: number;
    aperture: number;
    blockSize: number;
}
export interface IInitializeMessage {
    width: number;
    height: number;
    aperture: number;
    modelPosition: vec3;
    modelScale: number;
    modelRotation: quat;
    modelManipulationOrigin: vec3;
    inverseVMatrices: mat4[];
    stereoMode: StereoMode;
    fieldOfView: number;
    backgroundColor: vec3;
    transitionBuffers: ITransitionBufferMessage[];
    materials: Material[];
    lights: Light[];
    fonts: ImageData[];
    labelSets: ILabelSetMessage[];
    ground: Ground;
    images: IImageMessage[];
}
export interface IRenderMessage {
    offsetX: number;
    offsetY: number;
    samplesPerPixel: number;
    blockSize: number;
}
export interface ILabelMessage {
    font: number;
    dataView: DataView;
    translation: vec3;
    rotation: quat;
    scale: number;
    offset: number;
    count: number;
}
export interface ILabelSetMessage {
    font: number;
    dataView: DataView;
    rotations: Float64Array;
    glyphCount: number;
    color: vec3;
}
export interface ITransitionBufferMessage {
    unitType: UnitType;
    ids: Uint32Array;
    dataView: DataView;
    palette: Uint8Array;
}
export interface ICompleteMessage {
    offsetX: number;
    offsetY: number;
    data: Float32Array;
    samples: number;
}
export interface IImageMessage {
    type: ImageType;
    imageData: ImageData;
    position?: vec3;
    rotation?: quat;
    texCoord0?: vec2;
    texCoord1?: vec2;
    material?: number;
}
export interface IImageQuadMessage extends IImageMessage {
    width?: number;
    height?: number;
}
export interface IImageSphereMessage extends IImageMessage {
    radius?: number;
}
export interface IMaterialMessage {
    dataView: DataView;
    imageData: ImageData;
}
export declare class Ground {
    axis: number;
    position: vec3;
    size: vec2;
    material: Material;
}
export declare const ImageType: {
    readonly rectangle: "rectangle";
    readonly sphere: "sphere";
};
export type ImageType = (typeof ImageType)[keyof typeof ImageType];
export declare const LightType: {
    readonly rectangle: "rectangle";
    readonly sphere: "sphere";
};
export type LightType = (typeof LightType)[keyof typeof LightType];
export declare abstract class Light {
    readonly type: LightType;
    position: vec3;
    color: vec3;
    constructor(position: vec3);
}
export interface IRectangleLightOptions {
    position: vec3;
    color?: vec3;
    size?: vec2;
    rotation?: quat;
}
export declare class RectangleLight extends Light {
    readonly type: "rectangle";
    rotation: quat;
    size: vec2;
    constructor(options: IRectangleLightOptions);
}
export interface ISphereLightOptions {
    position: vec3;
    color?: vec3;
    size?: number;
}
export declare class SphereLight extends Light {
    readonly type: "sphere";
    size: number;
    constructor(options: ISphereLightOptions);
}
export declare const MaterialType: {
    readonly dielectric: "dielectric";
    readonly diffuseLight: "diffuseLight";
    readonly isotropic: "isotropic";
    readonly lambertian: "lambertian";
    readonly glossy: "glossy";
    readonly metal: "metal";
};
export type MaterialType = (typeof MaterialType)[keyof typeof MaterialType];
export declare abstract class Material {
    readonly type: MaterialType;
}
export interface ILambertianMaterialOptions {
    texture?: Texture;
}
export declare class LambertianMaterial extends Material {
    readonly type: "lambertian";
    texture: Texture;
    constructor(options?: ILambertianMaterialOptions);
}
export interface IGlossyMaterialOptions {
    texture?: Texture;
    refractiveIndex?: number;
    fuzz?: number;
}
export declare class GlossyMaterial extends Material {
    readonly type: "glossy";
    texture: Texture;
    refractiveIndex: number;
    fuzz: number;
    constructor(options?: IGlossyMaterialOptions);
}
export interface IMetalMaterialOptions {
    color?: vec3;
    fuzz?: number;
    fuzzMap?: ImageData;
}
export declare class MetalMaterial extends Material {
    readonly type: "metal";
    color: vec3;
    fuzz: number;
    fuzzMap: ImageData;
    constructor(options?: IMetalMaterialOptions);
}
export interface IDielectricMaterialOptions {
    refractiveIndex?: number;
    color?: vec3;
}
export declare class DielectricMaterial extends Material {
    readonly type: "dielectric";
    refractiveIndex: number;
    color: vec3;
    constructor(options?: IDielectricMaterialOptions);
}
export interface IDiffuseLightMaterialOptions {
    color?: vec3;
}
export declare class DiffuseLightMaterial extends Material {
    readonly type: "diffuseLight";
    color: vec3;
    constructor(options?: IDiffuseLightMaterialOptions);
}
export interface IIsotropicMaterialOptions {
    color?: vec3;
    density?: number;
}
export declare class IsotropicMaterial extends Material {
    readonly type: "isotropic";
    color: vec3;
    density: number;
    constructor(options?: IIsotropicMaterialOptions);
}
export declare const TextureType: {
    readonly checker: "checker";
    readonly grid: "grid";
    readonly marble: "marble";
    readonly solidColor: "solidColor";
    readonly paletteColor: "paletteColor";
    readonly image: "image";
    readonly specular: "specular";
    readonly normal: "normal";
    readonly bump: "bump";
};
export type TextureType = (typeof TextureType)[keyof typeof TextureType];
export declare abstract class Texture {
    readonly type: TextureType;
}
export interface ISolidColorTextureOptions {
    color?: vec3;
}
export interface IPaletteColorTextureOptions {
    palette: Uint8Array;
    u0: number;
    u1: number;
}
export declare class SolidColorTexture extends Texture {
    readonly type: "solidColor";
    color: vec3;
    constructor(options: ISolidColorTextureOptions);
}
export declare class PaletteColorTexture extends Texture {
    readonly type: "paletteColor";
    palette: Uint8Array;
    u0: number;
    u1: number;
    constructor(options: IPaletteColorTextureOptions);
}
export interface ICheckerTextureOptions {
    color0?: vec3;
    color1?: vec3;
    sizeX?: number;
    sizeY?: number;
    offsetX?: number;
    offsetY?: number;
}
export declare class CheckerTexture extends Texture {
    readonly type: "checker";
    color0: vec3;
    color1: vec3;
    sizeX: number;
    sizeY: number;
    offsetX: number;
    offsetY: number;
    constructor(options?: ICheckerTextureOptions);
}
export interface IGridTextureOptions {
    color?: vec3;
    background?: vec3;
    sizeX?: number;
    sizeY?: number;
    minorSizeX?: number;
    minorSizeY?: number;
    thicknessX?: number;
    thicknessY?: number;
    minorThicknessX?: number;
    minorThicknessY?: number;
    offsetX?: number;
    offsetY?: number;
}
export declare class GridTexture extends Texture {
    readonly type: "grid";
    color: vec3;
    background: vec3;
    sizeX: number;
    sizeY: number;
    minorSizeX: number;
    minorSizeY: number;
    thicknessX: number;
    thicknessY: number;
    minorThicknessX: number;
    minorThicknessY: number;
    offsetX: number;
    offsetY: number;
    constructor(options?: IGridTextureOptions);
}
export interface IImageTextureOptions {
    image?: ImageData;
}
export declare class ImageTexture extends Texture {
    readonly type: "image";
    imageData: ImageData;
    constructor(options?: IImageTextureOptions);
}
export declare class BumpTexture extends ImageTexture {
}
export declare class SpecularTexture extends ImageTexture {
}
export declare class NormalTexture extends ImageTexture {
}
export interface IMarbleTextureOptions {
    scale?: number;
    seed?: number;
    color?: vec3;
}
export declare class MarbleTexture extends Texture {
    readonly type: "marble";
    scale: number;
    seed: number;
    color: vec3;
    constructor(options?: IMarbleTextureOptions);
}
export declare class Main extends RendererBase {
    protected _options: IRendererOptions;
    startCallback: () => void;
    progressCallback: (progress: number, cumualtiveDuration: number) => void;
    cancelCallback: () => void;
    passCallback: (cumulativeSamples: number) => void;
    completeCallback: (cumulativeDuration: number, cumulativeSamples: number, avgLuminance: number, maxLuminance: number) => void;
    private _ctx;
    private _workers;
    private _areWorkersInitialized;
    private _isRunning;
    private _nextBlock;
    private _workersRunning;
    private _duration;
    private _cumulativeDuration;
    private _avgLuminance;
    private _maxLuminance;
    private _samplesPerPixel;
    private _cumulativeSamplesPerPixel;
    private _maxSamplesPerPixel;
    private _blockSize;
    private _totalBlocks;
    private _width;
    private _height;
    private _pixelCount;
    private _start;
    protected _config: Config;
    get config(): Config;
    private _loop;
    get loop(): boolean;
    set loop(value: boolean);
    private _rgb;
    private _raw;
    private _samples;
    get raw(): Float32Array;
    materials: Material[];
    ground: Ground;
    constructor(options?: IRendererOptions);
    initialize(core: Core): void;
    private _initializeContext;
    get isSupported(): boolean;
    start(options: IRenderOptions): void;
    private _initializeWorkers;
    clear(): void;
    postProcess(): void;
    cancel(): void;
    private _createContext;
}