import { PropertyChangeObservable } from '../PropertyChangeObservable';
import { ClipPlane, ClipPlaneOptions, ClipPlanes } from './ClipPlane';
import { DitheringTextureMode } from './CustomBabylonMaterials/DitherTexture';
import { IfcFragmentHsvColoringSettings } from './IfcFragmentHsvColoringSettings';
import { IFCLightingEnvironment, LightingEnvironment } from './IfcLightingEnvironment';
import { Color3, Effect, Vector3 } from './babylonjs-import';
import { TransparencyMode, TwinfinityViewer } from './twinfinity-viewer';
import { ColoredHighlightIndexes } from './CustomBabylonMaterials/IfcMaterial';
export type DitheringOptions = {
    readonly mode: DitheringTextureMode;
    readonly animatedFrames: number;
    readonly ditherDiscardDepth: boolean;
    readonly distanceFade: boolean;
};
/**
 * Transparency settings for IFC objects.
 */
export declare class IfcTransparencySettings {
    /**
     * Changes how transparency is handled for transparent IFC objects
     * @param transparencyMode The type of rendering that will be used for all transparent IFC objects, dithering means that pixels are
     * rendered opaque but skipping every few pixels in a screen pattern depending on the opacity
     * Seethrough is normal alpha blending
     * AnimatedFrames changes the noise from every frame in a loop, when the camera moves, to fight a visual swimming effect when the camera moves, set to 1 to dis
     */
    mode: TransparencyMode;
    /**
     * @param ditheringMode What dithering mode to use, bayer uses a bayer matrix to determine which pixels to render opaque, blue noise uses a blue noise texture
     * @param animatedFrames How many frames to use for the dithering animation when moving the camera, if 1 then no animation is used. Works best with Blue Noise
     * @param ditherDiscardDepth Wheter or not to discard fragments in the depth shader that are dithered, this is needed for transparent objects to not write to the depth buffer
     */
    ditheringOptions: DitheringOptions;
}
/**
 * Represents the visual settings for an IFC model.
 */
export declare class IfcVisualSettings {
    readonly lighting: IFCLightingEnvironment;
    static readonly _temp: {
        vectorA: Vector3;
    };
    readonly color: PropertyChangeObservable<IfcFragmentHsvColoringSettings>;
    readonly transparency: PropertyChangeObservable<IfcTransparencySettings>;
    readonly clipPlanes: ClipPlanes<PropertyChangeObservable<ClipPlane>>;
    private readonly _highlightColors;
    /**
     * Creates an instance of {@link IfcVisualSettings}.
     * @param lighting The lighting environment for the model.
     * @param viewer The {@link TwinfinityViewer} instance.
     */
    constructor(lighting: IFCLightingEnvironment, viewer: TwinfinityViewer);
    setHighlightColor(color: Color3, highlightIndex: ColoredHighlightIndexes): void;
    /**
     * Assigns effect values for the highlight colors. For internal use only.
     * @hidden
     * @internal
     * @param effect - The effect to assign values to.
     */
    _setEffectValues(effect: Effect): void;
    setClipPlane(clipPlaneOptions: ClipPlaneOptions): void;
}
/**
 * Visual settings for {@link TwinfinityViewer}. Controls things like lighting, IFC object transparency etc
 */
export declare class VisualSettings {
    private readonly _lighting;
    /**
     * Visual settings for IFC objects. These settings are applied to all IFC objects in the scene.
     */
    readonly ifc: IfcVisualSettings;
    /**
     * Constructor for the visual settings.
     * @param viewer {@link TwinfinityViewer} instance this {@link VisualSettings} instance is associated with.
     */
    constructor(viewer: TwinfinityViewer);
    /**
     * Current global lighting settings. These settings control
     * how the scene is lit and affects all objects (both IFC and standard BabylonJS objects).
     */
    get lighting(): LightingEnvironment;
}
//# sourceMappingURL=VisualSettings.d.ts.map