import * as THREE from "three";
import { CameraEngine, type OrthographicCameraProperties, type PerspectiveCameraProperties } from "@shapediver/viewer.rendering-engine.camera-engine";
import { LightEngine } from "@shapediver/viewer.rendering-engine.light-engine";
import { type IConvert3Dto2DResult } from "@shapediver/viewer.rendering-engine.rendering-engine";
import { type ITreeNode, MaterialBasicLineData, MaterialPointData, MaterialStandardData } from "@shapediver/viewer.shared.node-tree";
import { DomEventEngine, SESSION_SETTINGS_MODE, SettingsEngine } from "@shapediver/viewer.shared.services";
import { BUSY_MODE_DISPLAY, type Color, FLAG_TYPE, type IGeometryData, type IIntersectionFilter, type ISDTFAttributeVisualizationData, type ISDTFItemData, type ISDTFOverview, type IViewportSettingsSections, MATERIAL_TYPE, RENDERER_TYPE, SPINNER_POSITIONING, TEXTURE_ENCODING, TONE_MAPPING, type ViewportCreationDefinition, VISIBILITY_MODE } from "@shapediver/viewer.shared.types";
import { quat, vec3 } from "gl-matrix";
import { type IRenderingEngineThreeJS } from "./interfaces/IRenderingEngine";
import { EnvironmentMapLoader } from "./loaders/EnvironmentMapLoader";
import { GeometryLoader } from "./loaders/GeometryLoader";
import { HTMLElementAnchorLoader } from "./loaders/HTMLElementAnchorLoader";
import { LightLoader } from "./loaders/LightLoader";
import { MaterialLoader } from "./loaders/MaterialLoader";
import { CameraManager } from "./managers/CameraManager";
import { EnvironmentGeometryManager } from "./managers/EnvironmentGeometryManager";
import { PostProcessingManager } from "./managers/PostProcessingManager";
import { RenderingManager } from "./managers/RenderingManager";
import { SceneTracingManager } from "./managers/SceneTracingManager";
import { SceneTreeManager } from "./managers/SceneTreeManager";
import { SDColor } from "./objects/SDColor";
export declare class RenderingEngine implements IRenderingEngineThreeJS {
    #private;
    private readonly _animationEngine;
    private readonly _arManager;
    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 _logger;
    private readonly _environmentMapLoader;
    private readonly _eventEngine;
    private readonly _flagManager;
    private readonly _geometryLoader;
    private readonly _htmlElementAnchorLoader;
    private readonly _id;
    private readonly _lightEngine;
    private readonly _lightLoader;
    private readonly _materialLoader;
    private readonly _postProcessingManager;
    private readonly _renderingManager;
    private readonly _sceneTracingManager;
    private readonly _sceneTreeManager;
    private readonly _settingsManager;
    private readonly _stateEngine;
    private readonly _systemInfo;
    private readonly _tree;
    private readonly _visibility;
    private readonly _visibilitySessionIds?;
    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 _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 _postRenderingCallback?;
    private _preRenderingCallback?;
    private _renderer;
    private _shadows;
    private _show;
    private _showStatistics;
    private _softShadows;
    private _spinnerDivElement;
    private _viewportCreationDefinition;
    private _toneMapping;
    private _type;
    private _useLegacyLights;
    private _visualizeAttributes;
    constructor(properties: Partial<ViewportCreationDefinition>);
    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 clearAlpha(): number;
    set clearAlpha(value: number);
    get clearColor(): Color;
    set clearColor(value: Color);
    get closed(): boolean;
    get colorCache(): SDColor[];
    get contactShadowBlur(): number;
    set contactShadowBlur(value: number);
    get contactShadowDarkness(): number;
    set contactShadowDarkness(value: number);
    get contactShadowHeight(): number;
    set contactShadowHeight(value: number);
    get contactShadowOpacity(): number;
    set contactShadowOpacity(value: number);
    get contactShadowVisibility(): boolean;
    set contactShadowVisibility(value: boolean);
    get continuousRendering(): boolean;
    set continuousRendering(value: boolean);
    get continuousShadowMapUpdate(): boolean;
    set continuousShadowMapUpdate(value: boolean);
    get defaultLineMaterial(): MaterialBasicLineData;
    set defaultLineMaterial(value: MaterialBasicLineData);
    get defaultMaterial(): MaterialStandardData;
    set defaultMaterial(value: MaterialStandardData);
    get defaultMaterialColor(): Color;
    set defaultMaterialColor(value: Color);
    get defaultPointMaterial(): MaterialPointData;
    set defaultPointMaterial(value: MaterialPointData);
    get domEventEngine(): DomEventEngine;
    get enableAR(): boolean;
    set enableAR(value: boolean);
    get environmentGeometryManager(): EnvironmentGeometryManager;
    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 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 loadDefaultCameras(): boolean;
    set loadDefaultCameras(value: boolean);
    get logoDivElement(): HTMLDivElement;
    get materialLoader(): MaterialLoader;
    get materialOverrideType(): MATERIAL_TYPE | undefined;
    set materialOverrideType(value: MATERIAL_TYPE | undefined);
    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 postRenderingCallback(): ((renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera) => void) | undefined;
    set postRenderingCallback(value: ((renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera) => void) | undefined);
    get preRenderingCallback(): ((renderer: THREE.WebGLRenderer) => void) | undefined;
    set preRenderingCallback(value: ((renderer: THREE.WebGLRenderer) => void) | undefined);
    get renderer(): THREE.WebGLRenderer;
    get renderingManager(): RenderingManager;
    get scene(): THREE.Scene;
    get sceneTracingManager(): SceneTracingManager;
    get sceneTreeManager(): SceneTreeManager;
    get sessionSettingsId(): string | undefined;
    get sessionSettingsMode(): SESSION_SETTINGS_MODE;
    get settingsEngine(): 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 suspendSceneUpdates(): boolean;
    set suspendSceneUpdates(value: boolean);
    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 viewportCreationDefinition(): ViewportCreationDefinition;
    get visibility(): VISIBILITY_MODE;
    get visibilitySessionIds(): string[] | undefined;
    get visualizeAttributes(): ((overview: ISDTFOverview, itemData?: ISDTFItemData) => ISDTFAttributeVisualizationData) | undefined;
    set visualizeAttributes(value: ((overview: ISDTFOverview, itemData?: ISDTFItemData) => ISDTFAttributeVisualizationData) | undefined);
    addFlag(flag: FLAG_TYPE, inputToken?: string): string;
    applySettings(sections?: IViewportSettingsSections, settingsEngine?: SettingsEngine, updateViewport?: boolean): Promise<void>;
    assignSettingsEngine(settingsEngine: SettingsEngine): void;
    close(): Promise<void>;
    continueRendering(): void;
    convert3Dto2D(p: vec3): IConvert3Dto2DResult;
    createSDTFOverview(node: ITreeNode): ISDTFOverview;
    createThreeJsColor(color: Color): THREE.Color;
    displayErrorMessage(message: string): void;
    evaluateFlagState(): void;
    getEnvironmentMapImageUrl(): string;
    getScreenshot(type?: string, encoderOptions?: number): string;
    getScreenshotAdvanced(type?: string, encoderOptions?: number, resolution?: {
        width: number;
        height: number;
    }, camera?: OrthographicCameraProperties | PerspectiveCameraProperties): Promise<string>;
    isMobileDeviceWithoutBrowserARSupport(): boolean;
    pauseRendering(): void;
    pointerEventToRay(event: PointerEvent): {
        origin: vec3;
        direction: vec3;
    };
    raytraceScene(origin: vec3, direction: vec3, filterCriteria?: IIntersectionFilter[]): {
        distance: number;
        node: ITreeNode;
        data?: IGeometryData;
    }[];
    removeFlag(token: string): boolean;
    reset(): void;
    resize(width: number, height: number): void;
    saveSettings(settingsEngine?: SettingsEngine): void;
    start(): void;
    update(id: string): void;
    updateEnvironmentGeometry(): void;
    viewInAR(file: string, options?: {
        arScale?: "auto" | "fixed";
        arPlacement?: "floor" | "wall";
        xrEnvironment?: boolean;
    }): Promise<void>;
    viewableInAR(): boolean;
}
//# sourceMappingURL=RenderingEngine.d.ts.map