bimplus-renderer 1.6.72 → 1.6.73

package/package.json

@@ -1,7 +1,8 @@
 {
     "name": "bimplus-renderer",
-    "version": "1.6.72",
+    "version": "1.6.73",
     "description": "bim+ renderer",
+    "types": "types/bimplus-renderer.d.ts",
     "keywords": [
         "Allplan",
         "Bimplus",

package/types/bimplus-renderer.d.ts

@@ -0,0 +1,266 @@
+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;
+        isVisible(): boolean;
+    }
+
+    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);
+        isVisible(): boolean;
+        forEachTopologyLeafNode(func: (node: ProjectTopologyNode) => void): void;
+    }
+
+    export class ContentLoader {
+        async 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);
+
+        async loadProject(projectId: WebSdk.ProjectId, settings: ProjectLoaderSettings | undefined = undefined): Promise<ProjectContent | null>;
+        async reloadProjectDetails(): Promise<boolean>;
+        async checkModelModified(modelId: WebSdk.ModelId, clearResponseStore: boolean = true, clearNodeStore: boolean = true): Promise<boolean>;
+        getProject(): ProjectContent;
+        getContentLoader(): ContentLoader;
+        async loadModelStructure(model: ProjectModel): Promise<void>;
+        async reloadModelGeometry(modelId: WebSdk.ModelId): Promise<void>;
+        getModelViewState(modelId: WebSdk.ModelId): ModelViewState;
+        async setModelViewState(modelState: ModelViewState | undefined, viewStateStructureChangedCallback?: () => 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 Viewport3D {
+        constructor(options: {
+            settings: ViewportSettings;
+            units: MeasurementUnits;
+            domElementId: string;
+            GPUPick: boolean;
+            api: WebSdk.Api;
+            name: string;
+        });
+
+        domElement: HTMLElement;
+        objectSets: ObjectSets;
+        diagnostics: Diagnostics;
+
+        // 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);
+        setBackground(type: BackgroundType, params: BackgroundParams)
+        setUseHoverEffect(useHoverEffect: boolean);
+
+        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;
+        async 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: Renderer.VisualObject | null,
+            mousePos: THREE.Vector2 | null,
+            attributes: Record<string, Renderer.Attribute> | null,
+        ) => void): void;
+        highlightObjects(ids: string[], multiselect: boolean, skipBubbleUp: boolean): void;
+        hoverObject(id: string): void;
+        resetHoveredObject(): void;
+        setupProjectView(): void;
+        toggleProjectionMode(viewport: Viewport3D): void;
+    }
+
+    export class ViewportSettings {
+        defaultOpacity: number;
+        disciplineOpacity: number;
+        pinSizeScaleFactor: number;
+        maxWebGLBufferSize: number;
+        mixedModelMode: boolean;
+        pinFlyToDistance: number;
+        nearClippingPlane: number;
+        slideThmbSize: number[]; // [number, number];
+        units: {
+            mm?: MeasurementUnits;
+            inch?: MeasurementUnits;
+        };
+    }
+
+    export class VisualObject {
+        id: WebSdk.VisualObjectId;
+        name: string;
+    }
+
+    export class ObjectsContainer {
+        getObjects(ids: string[]): VisualObject[];
+        getObjectsArray(): VisualObject[];
+    }
+}