bimplus-renderer/types/bimplus-renderer.d.ts

bim+ renderer

declare module 'bimplus-renderer' {

    import * as WebSdk from 'bimplus-websdk';
    import * as THREE from 'three';

    export type Radian = number;
    export type HexColor = string;

    export class Background {
        static BackgroundType_None: number; // = 0
        static BackgroundType_Color: number; // = 1
        static BackgroundType_LinearGradient: number; // = 2
    }

    export interface ColorStop {
        offset: number;
        color: string;
    }

    export interface BackgroundParams {
        alpha: number;
        colorStops: ColorStop[];
    }

    export class Diagnostics {

        dumpObjects(longInfo: boolean): void;
        dumpObjectSets(longInfo: boolean): void;
        dumpScene(): void;
    }

    export class MeasurementUnits {
        weight?: Measurement;
        length?: Measurement;
        width?: Measurement;
        height?: Measurement;
        area?: Measurement;
        volume?: Measurement;
    }

    export class Measurement {
        multiplicator: number;
        precision: number;
        unit: string;
    }

    export class ModelViewStateLayer {
        id: WebSdk.LayerId;
        background: boolean;
        visible: boolean;
    }

    export class ModelViewState {
        layers: Array<ModelViewStateLayer>;
        setLayersVisible(visible: boolean): void;
        setLeafNodesVisible(visible: boolean): void;
    }

    export interface Attribute {
        id: string,
    }
    export interface StringAttribute extends Attribute {
        value: string,
    }
    export interface NumberAttribute extends Attribute {
        value: number,
    }

    export class ObjectSets {
        // An array of selected object references
        selectedObjects: VisualObject[];

        // An array of hidden object references
        hiddenObjects: VisualObject[];

        // An array of object references on isolated set
        workingObjects: VisualObject[];

        // An array of colored object references
        coloredObjects: VisualObject[];
    }

    export class ProjectContent {
        id: string | null;
        forEachModel(func: (model: ProjectModel) => void): void;
        getModels(): ProjectModel[];
        getModel(id: string): ProjectModel | null;
        getObjectsContainer(): ObjectsContainer | null;
        unloadModel(model: ProjectModel, revisionNumber: number, onlyObjects: boolean): void;
    }

    export class ProjectLayer {
        id: WebSdk.LayerId;
        name: string;
        currentRevision: number;
        parentModel?: ProjectModel;
        opacity: number;
        userColor: THREE.Color | null;
        userOpacity: number | null;

        isExternal(): boolean;
        isInternal(): boolean;

        setVisible(value: boolean): void;
        isVisible(): boolean;

        setBackground(value: boolean): void;
        isBackground(): boolean;
    }

    export class ProjectTopologyNode {
        id: WebSdk.Guid;
        divisionTopologyId: WebSdk.DivisionTopologyId;
        isVisible(): boolean;
        getRevision(): number;
    }

    export class ProjectModel {

        constructor(id: WebSdk.ModelId, visible: boolean);

        id: WebSdk.ModelId;
        name: string;
        visible: boolean;
        divisionTopologyId: WebSdk.DivisionTopologyId;
        layers: Array<ProjectLayer> | null;

        revisions: Array<number>;
        releasedRevisions: Array<number>;
        currentRevision: number;
        parentProject?: ProjectContent;
        objectsLoaded: boolean;

        // Define other properties and methods of the ProjectModel class here if needed
        setCurrentRevision(rev: number): void;
        getCurrentRevision(): number;
        getLatestRevision(): number;

        forEachLayer(func: (layer: ProjectLayer) => void): void;
        getLayerArray(): ProjectLayer[];

        setVisible(isVisible: boolean) : void;
        isVisible(): boolean;
        forEachTopologyLeafNode(func: (node: ProjectTopologyNode) => void): void;
    }

    export class ContentLoader {
        constructor(api: WebSdk.Api, viewport?: Viewport3D);
        loadObject(objectId: string, revNr: number | undefined, projectContent: any):  Promise<any>
        checkAndRefreshProject(project: ProjectContent, models: ProjectModel[]): Promise<boolean>;
    }

    export interface ProjectLoaderSettings {
        onlyModelsFromOwnGroups?: boolean,
        modelsFor?: string[],
        filterPrivateDisciplines?: boolean
    }

    export class ProjectViewer {
        constructor(api: WebSdk.Api, viewport?: Viewport3D, concurrentModelLoadingLimit?: number, includeIfcLoader?: boolean);

        loadProject(projectId: WebSdk.ProjectId, settings: ProjectLoaderSettings | undefined): Promise<ProjectContent | null>;
        reloadProjectDetails(): Promise<boolean>;
        checkModelModified(modelId: WebSdk.ModelId, clearResponseStore: boolean, clearNodeStore: boolean): Promise<boolean>;
        getProject(): ProjectContent;
        getContentLoader(): ContentLoader;
        loadModelStructure(model: ProjectModel): Promise<void>;
        reloadModelGeometry(modelId: WebSdk.ModelId): Promise<void>;
        getModelViewState(modelId: WebSdk.ModelId): ModelViewState;
        setModelViewState(modelState: ModelViewState | undefined, viewStateStructureChangedCallback?: () => void) : Promise<void>;
        draw(): void;
        _mainViewport?: Viewport3D;
        _viewports: Array<Viewport3D>;
    }

    export class AmbientOcclusionSettings {
        usage: boolean;
        usageForInteraction: boolean;
        useShadows: boolean;
        useShadowsForInteraction: boolean;
        lightColor: THREE.Color;
        ambientLightColor: THREE.Color;
        lightRotation: Radian;
        lightElevation: Radian;
    }

    export interface ColorizeObject {
        id: WebSdk.VisualObjectId,
        color: HexColor,
    }

    export class ViewportContent {
        getClashes(): Clashes;
    }

    export class Clashes {
        getClashElement(id: string): ClashElement;
    }

    export class ClashElement {
        id?: string;
        node?: string;
        revision?: number;
        [key: string]: unknown;
    }

    export interface Layers {
        revision?: number;
        id: string;
        name?: string;
        divisionId?: string;
        divisionName?: string;
        visible?: boolean;
        opaque?: boolean;
        opacity?: number;
        valid?: boolean;
    }

    export interface SelectedObject {
        id: string;
        revision: number;
        node: unknown;
    }

    export interface SelectedClashElement {
        id: string;
        revision: number;
        node: unknown;
    }

    export interface Camera {
        [key: string]: unknown;
    }

    export interface CommandPolicy {
        noBubble: boolean;
        noTraverse: boolean;
    }

    export interface CommandPolicies {
        CommandSelect: CommandPolicy;
    }

    export class OverlayLoadingResult {
        [key: string]: unknown;
    }

    export class Viewport3D {
        constructor(options: {
            settings: ViewportSettings;
            units: MeasurementUnits;
            domElementId: string;
            GPUPick: boolean;
            api: WebSdk.Api;
            name: string;
            lookupTextureSize?: number;
            ssaoSupported?: boolean;
            shadowsSupported?: boolean;
            panningScaleFactor?: number;
            commandPolicies?: CommandPolicies;
        });

        domElement: HTMLElement;
        objectSets: ObjectSets;
        diagnostics: Diagnostics;
        camera: Camera | null;

        // Define other properties and methods of the Viewport3D class here
        setViewportSize(width?: number, height?: number): void;

        // Define functions for setting up the viewport renderer
        setAmbientOcclusionOptions(settings: AmbientOcclusionSettings) : void;
        setBackground(type: Background, params: BackgroundParams) : void;
        setUseHoverEffect(useHoverEffect: boolean) : void;

        restoreViewbox(): Promise<void>;
        resetClashScene(): void;
        setRotationCenter(c: THREE.Vector3 | null): void;
        setCameraResetAxis(a: string, fly?: boolean): void;
        setSectionAxis(a?: string): void;
        resetViewport(): void;
        draw(): void;
        dispose(): void;
        setSelectionMode(mode: string): void;
        checkSelectionMode(mode: string): boolean;
        resetSelectionMode(): void;
        setShowHiddenObjectsTransparent(showTransparent: boolean): void;
        resetSelectedObjects(): void;
        resetHiddenObjects(): void;
        resetWorkingObjects(): void;
        resetColoredObjects(): void;
        resetAllObjectSets(): void;
        makeColoredSet(objects: Array<ColorizeObject>): void;
        zoomToObjects(objectIdList: string[]): void;
        subscribeToSelectionModeChanges(handler: (selectionMode: string) => void): void;
        subscribeToConnectionElementSelected(handler: (
            object: VisualObject | null,
            mousePos: THREE.Vector2 | null,
            attributes: Record<string, Attribute> | null,
        ) => void): void;
        highlightObjects(ids: string[], multiselect: boolean, skipBubbleUp: boolean): void;
        hoverObject(id: string): void;
        resetHoveredObject(): void;
        setupProjectView(): void;
        toggleProjectionMode(viewport: Viewport3D): void;
        isPerspectiveCamera(): boolean;
        isOrthographicCamera(): boolean;
        getSlideParams(): WebSdk.Scene;
        getObject(id: string): SelectedObject;
        getContent(): ViewportContent;
        toggleObjectNode({id:string,visible:boolean}): void;
        toggleObjectNodeOpacity({id:string,opacity:boolean}): void;
        setSlideScene(scene: WebSdk.Scene, restoreRotationCenter?: boolean, overlayLoadingResult?: OverlayLoadingResult): void;
    }

    export class ViewportSettings {
        defaultOpacity: number;
        disciplineOpacity: number;
        pinSizeScaleFactor: number;
        maxWebGLBufferSize: number;
        mixedModelMode: boolean;
        useFrameSelection: boolean;
        pinFlyToDistance: number;
        nearClippingPlane: number;
        slideThmbSize: number[]; // [number, number];
        units: {
            mm?: MeasurementUnits;
            inch?: MeasurementUnits;
        };
    }

    export class VisualObject {
        id: WebSdk.VisualObjectId;
        name: string;
        revision?: number;
    }

    export class ObjectsContainer {
        getObjects(ids: string[]): VisualObject[];
        getObjectsArray(): VisualObject[];
    }
}