import * as THREE from 'three';
import { MaterialLoader } from './loaders/MaterialLoader';
import { CameraManager } from './managers/CameraManager';
import { CanvasEngine } from '@shapediver/viewer.rendering-engine.canvas-engine';
import { EnvironmentMapLoader } from './loaders/EnvironmentMapLoader';
import { GeometryLoader } from './loaders/GeometryLoader';
import { HTMLElementAnchorLoader } from './loaders/HTMLElementAnchorLoader';
import { IRenderingEngineThreeJS } from './interfaces/IRenderingEngine';
import { ITreeNode } from '@shapediver/viewer.shared.node-tree';
import { LightEngine } from '@shapediver/viewer.rendering-engine.light-engine';
import { LightLoader } from './loaders/LightLoader';
import { PostProcessingManager } from './managers/PostProcessingManager';
import { quat, vec2, vec3 } from 'gl-matrix';
import { RenderingManager } from './managers/RenderingManager';
import { SceneTracingManager } from './managers/SceneTracingManager';
import { SceneTreeManager } from './managers/SceneTreeManager';
import { SDColor } from './objects/SDColor';
import { CameraEngine } from '@shapediver/viewer.rendering-engine.camera-engine';
import { BUSY_MODE_DISPLAY, FLAG_TYPE, SPINNER_POSITIONING, RENDERER_TYPE, SESSION_SETTINGS_MODE, TEXTURE_ENCODING, TONE_MAPPING, VISIBILITY_MODE } from '@shapediver/viewer.rendering-engine.rendering-engine';
import { DomEventEngine, EventEngine, SettingsEngine, StateEngine } from '@shapediver/viewer.shared.services';
import { ISDTFAttributeVisualizationData, ISDTFOverview, ISDTFItemData, IGeometryData, Color } from '@shapediver/viewer.shared.types';
export declare class RenderingEngine implements IRenderingEngineThreeJS {
    #private;
    private readonly _animationEngine;
    private readonly _branding;
    private readonly _cameraEngine;
    private readonly _cameraManager;
    private readonly _canvas;
    private readonly _canvasEngine;
    private readonly _colorCache;
    private readonly _converter;
    private readonly _domEventEngine;
    private readonly _environmentGeometryManager;
    private readonly _environmentMapLoader;
    private readonly _eventEngine;
    private readonly _geometryLoader;
    private readonly _htmlElementAnchorLoader;
    private readonly _id;
    private readonly _intersectionManager;
    private readonly _lightEngine;
    private readonly _lightLoader;
    private readonly _logger;
    private readonly _materialLoader;
    private readonly _postProcessingManager;
    private readonly _renderingManager;
    private readonly _sceneTracingManager;
    private readonly _sceneTreeManager;
    private readonly _stateEngine;
    private readonly _systemInfo;
    private readonly _tree;
    private readonly _uuidGenerator;
    private readonly _visibility;
    private _arRotation;
    private _arScale;
    private _arTranslation;
    private _automaticColorAdjustment;
    private _automaticResizing;
    private _beautyRenderBlendingDuration;
    private _beautyRenderDelay;
    private _busy;
    private _busyModeDisplay;
    private _clearAlpha;
    private _clearColor;
    private _closed;
    private _defaultMaterialColor;
    private _enableAR;
    private _environmentMap;
    private _environmentMapAsBackground;
    private _environmentMapBlurriness;
    private _environmentMapForUnlitMaterials;
    private _environmentMapIntensity;
    private _environmentMapResolution;
    private _environmentMapRotation;
    private _gridVisibility;
    private _groundPlaneShadowVisibility;
    private _groundPlaneVisibility;
    private _lights;
    private _logoDivElement;
    private _maximumRenderingSize;
    private _pause;
    private _pointSize;
    private _renderer;
    private _sessionSettingsId?;
    private _sessionSettingsMode;
    private _settingsEngine?;
    private _shadows;
    private _show;
    private _showStatistics;
    private _softShadows;
    private _spinnerDivElement;
    private _type;
    private _visualizeAttributes;
    constructor(properties?: {
        canvas?: HTMLCanvasElement;
        id?: string;
        branding?: {
            logo?: string | null;
            backgroundColor?: string;
            busyModeSpinner?: string;
            busyModeDisplay?: BUSY_MODE_DISPLAY;
            spinnerPositioning?: SPINNER_POSITIONING;
        };
        sessionSettingsId?: string;
        sessionSettingsMode?: SESSION_SETTINGS_MODE;
        visibility?: VISIBILITY_MODE;
    });
    get arRotation(): vec3;
    set arRotation(value: vec3);
    get arScale(): vec3;
    set arScale(value: vec3);
    get arTranslation(): vec3;
    set arTranslation(value: vec3);
    get automaticColorAdjustment(): boolean;
    set automaticColorAdjustment(value: boolean);
    get automaticResizing(): boolean;
    set automaticResizing(value: boolean);
    get beautyRenderBlendingDuration(): number;
    set beautyRenderBlendingDuration(value: number);
    get beautyRenderDelay(): number;
    set beautyRenderDelay(value: number);
    get branding(): {
        logo: string | null;
        backgroundColor: string;
        busyModeSpinner: string;
        busyModeDisplay: BUSY_MODE_DISPLAY;
        spinnerPositioning: SPINNER_POSITIONING;
    };
    get busy(): boolean;
    set busy(value: boolean);
    get busyModeDisplay(): BUSY_MODE_DISPLAY;
    set busyModeDisplay(value: BUSY_MODE_DISPLAY);
    get camera(): THREE.Camera;
    get cameraEngine(): CameraEngine;
    get cameraManager(): CameraManager;
    get canvas(): HTMLCanvasElement;
    get canvasEngine(): CanvasEngine;
    get clearAlpha(): number;
    set clearAlpha(value: number);
    get clearColor(): Color;
    set clearColor(value: Color);
    get closed(): boolean;
    get colorCache(): SDColor[];
    get continuousRendering(): boolean;
    set continuousRendering(value: boolean);
    get continuousShadowMapUpdate(): boolean;
    set continuousShadowMapUpdate(value: boolean);
    get defaultMaterialColor(): Color;
    set defaultMaterialColor(value: Color);
    get domEventEngine(): DomEventEngine;
    get enableAR(): boolean;
    set enableAR(value: boolean);
    get environmentMap(): string | string[];
    set environmentMap(value: string | string[]);
    get environmentMapAsBackground(): boolean;
    set environmentMapAsBackground(value: boolean);
    get environmentMapBlurriness(): number;
    set environmentMapBlurriness(value: number);
    get environmentMapForUnlitMaterials(): boolean;
    set environmentMapForUnlitMaterials(value: boolean);
    get environmentMapIntensity(): number;
    set environmentMapIntensity(value: number);
    get environmentMapLoader(): EnvironmentMapLoader;
    get environmentMapResolution(): string;
    set environmentMapResolution(value: string);
    get environmentMapRotation(): quat;
    set environmentMapRotation(value: quat);
    get eventEngine(): EventEngine;
    get geometryLoader(): GeometryLoader;
    get gridColor(): Color;
    set gridColor(value: Color);
    get gridVisibility(): boolean;
    set gridVisibility(value: boolean);
    get groundPlaneColor(): Color;
    set groundPlaneColor(value: Color);
    get groundPlaneShadowColor(): Color;
    set groundPlaneShadowColor(value: Color);
    get groundPlaneShadowVisibility(): boolean;
    set groundPlaneShadowVisibility(value: boolean);
    get groundPlaneVisibility(): boolean;
    set groundPlaneVisibility(value: boolean);
    get htmlElementAnchorLoader(): HTMLElementAnchorLoader;
    get id(): string;
    get lightEngine(): LightEngine;
    get lightLoader(): LightLoader;
    get lightScene(): string;
    get lightSceneId(): string;
    get lights(): boolean;
    set lights(value: boolean);
    get logoDivElement(): HTMLDivElement;
    get materialLoader(): MaterialLoader;
    get maximumRenderingSize(): {
        width: number;
        height: number;
    };
    set maximumRenderingSize(value: {
        width: number;
        height: number;
    });
    get minimalRendering(): boolean;
    get outputEncoding(): TEXTURE_ENCODING;
    set outputEncoding(value: TEXTURE_ENCODING);
    get pause(): boolean;
    set pause(value: boolean);
    get physicallyCorrectLights(): boolean;
    set physicallyCorrectLights(value: boolean);
    get pointSize(): number;
    set pointSize(value: number);
    get postProcessingManager(): PostProcessingManager;
    get renderer(): THREE.WebGLRenderer;
    get renderingManager(): RenderingManager;
    get scene(): THREE.Scene;
    get sceneTracingManager(): SceneTracingManager;
    get sceneTreeManager(): SceneTreeManager;
    get sessionSettingsId(): string | undefined;
    set sessionSettingsId(value: string | undefined);
    get sessionSettingsMode(): SESSION_SETTINGS_MODE;
    set sessionSettingsMode(value: SESSION_SETTINGS_MODE);
    get settingsEngine(): SettingsEngine | undefined;
    set settingsEngine(value: SettingsEngine | undefined);
    get shadows(): boolean;
    set shadows(value: boolean);
    get show(): boolean;
    set show(value: boolean);
    get showStatistics(): boolean;
    set showStatistics(value: boolean);
    get softShadows(): boolean;
    set softShadows(value: boolean);
    get spinnerDivElement(): HTMLDivElement;
    get stateEngine(): StateEngine;
    get textureEncoding(): TEXTURE_ENCODING;
    set textureEncoding(value: TEXTURE_ENCODING);
    get toneMapping(): TONE_MAPPING;
    set toneMapping(value: TONE_MAPPING);
    get toneMappingExposure(): number;
    set toneMappingExposure(value: number);
    get type(): RENDERER_TYPE;
    set type(value: RENDERER_TYPE);
    get usingSwiftShader(): boolean;
    get visibility(): VISIBILITY_MODE;
    get visualizeAttributes(): ((overview: ISDTFOverview, itemData?: ISDTFItemData) => ISDTFAttributeVisualizationData) | undefined;
    set visualizeAttributes(value: ((overview: ISDTFOverview, itemData?: ISDTFItemData) => ISDTFAttributeVisualizationData) | undefined);
    addFlag(flag: FLAG_TYPE): string;
    applySettings(sections?: {
        ar?: boolean;
        scene?: boolean;
        camera?: boolean;
        light?: boolean;
        environment?: boolean;
        general?: boolean;
        postprocessing?: boolean;
    }, settingsEngine?: SettingsEngine, updateViewport?: boolean): Promise<void>;
    close(): Promise<void>;
    continueRendering(): void;
    convert3Dto2D(p: vec3): {
        container: vec2;
        client: vec2;
        page: vec2;
        hidden: boolean;
    };
    createSDTFOverview(node: ITreeNode): ISDTFOverview;
    createThreeJsColor(color: Color): THREE.Color;
    displayErrorMessage(message: string): void;
    evaluateFlagState(): void;
    getEnvironmentMapImageUrl(): string;
    getScreenshot(type?: string, encoderOptions?: number): string;
    isMobileDeviceWithoutBrowserARSupport(): boolean;
    mouseEventToRay(event: MouseEvent): {
        origin: vec3;
        direction: vec3;
    };
    pauseRendering(): void;
    raytraceScene(origin: vec3, direction: vec3, root?: ITreeNode): {
        distance: number;
        node: ITreeNode;
        data?: IGeometryData;
    }[];
    removeFlag(token: string): boolean;
    reset(): void;
    resize(width: number, height: number): void;
    saveSettings(settingsEngine?: SettingsEngine): void;
    touchEventToRay(event: TouchEvent): {
        origin: vec3;
        direction: vec3;
    };
    touchToRay(event: Touch): {
        origin: vec3;
        direction: vec3;
    };
    update(id: string): void;
    updateEnvironmentGeometry(): void;
    viewInAR(file: string, options?: {
        arScale?: 'auto' | 'fixed';
        arPlacement?: 'floor' | 'wall';
        xrEnvironment?: boolean;
    }): Promise<void>;
    viewableInAR(): boolean;
    private applySyncSettings;
}
//# sourceMappingURL=RenderingEngine.d.ts.map