@synchronized-console/viewer 2.26.0-rev.1 → 2.31.14

package/dist/modules/EventEmitter.d.ts

@@ -1,7 +1,8 @@
 export default class EventEmitter {
-    _events: {};
-    on(name: any, listener: any): void;
-    removeListener(name: any, listenerToRemove: any): void;
-    emit(name: any, ...args: any[]): void;
+    protected _events: Record<string, Function[]>;
+    constructor();
+    on(name: string, listener: Function): void;
+    removeListener(name: string, listenerToRemove: Function): void;
+    emit(name: string, ...args: unknown[]): void;
     dispose(): void;
 }

package/dist/modules/LegacyViewer.d.ts

@@ -4,11 +4,11 @@ import type { Query, QueryArgsResultMap, QueryResult } from './queries/Query.js'
 import { type SynchronizedView, type SunLightConfiguration, type ViewerParams } from '../IViewer.js';
 import { Viewer } from './Viewer.js';
 import { WorldTree } from './tree/WorldTree.js';
-import { type MeasurementOptions } from './extensions/measurements/MeasurementsExtension.js';
 import { type DiffResult, VisualDiffMode } from './extensions/DiffExtension.js';
 import { type PropertyInfo } from './filtering/PropertyManager.js';
 import { BatchObject } from './batching/BatchObject.js';
 import { SynchronizedViewer } from '@synchronized-console/shared';
+import { MeasurementOptions } from '@synchronized-console/shared/viewer/state';
 export declare class LegacyViewer extends Viewer {
     private cameraController;
     private selection;

package/dist/modules/SynchronizedRenderer.d.ts

@@ -38,6 +38,12 @@ export declare class RenderingStats {
     frameStart(): void;
     frameEnd(): void;
 }
+export interface ObjectPickConfiguration {
+    pickedObjectsFilter: ((arg: [NodeRenderView, Material]) => boolean) | null;
+}
+export declare const DefaultObjectPickConfiguration: {
+    pickedObjectsFilter: (arg: [NodeRenderView, Material]) => boolean;
+};
 export default class SynchronizedRenderer {
     protected readonly SHOW_HELPERS = false;
     protected readonly IGNORE_ZERO_OPACITY_OBJECTS = true;
@@ -62,6 +68,7 @@ export default class SynchronizedRenderer {
     protected _clippingPlanes: Plane[];
     protected _clippingVolume: OBB;
     protected _renderOverride: (() => void) | null;
+    objectPickConfiguration: ObjectPickConfiguration;
     viewer: Viewer;
     batcher: Batcher;
     input: Input;
@@ -73,6 +80,7 @@ export default class SynchronizedRenderer {
     /**********************
      * Bounds and volumes */
     get sceneBox(): Box3;
+    get visibleSceneBox(): Box3;
     get sceneSphere(): Sphere;
     get sceneCenter(): Vector3;
     get clippingVolume(): OBB;
@@ -146,7 +154,7 @@ export default class SynchronizedRenderer {
         nodeId: string;
         point: Vector3;
     }> | null;
-    renderViewFromIntersection(intersection: ExtendedIntersection): NodeRenderView | null;
+    renderViewFromIntersection(intersection: ExtendedIntersection): [NodeRenderView, Material];
     private onClick;
     private onDoubleClick;
     boxFromObjects(objectIds: string[]): Box3;

package/dist/modules/Viewer.d.ts

@@ -27,7 +27,6 @@ export declare class Viewer extends EventEmitter implements IViewer {
     synchronizedRenderer: SynchronizedRenderer;
     protected propertyManager: PropertyManager;
     /** Misc members */
-    protected inProgressOperations: number;
     protected clock: Clock;
     protected loaders: {
         [id: string]: Loader;
@@ -41,6 +40,7 @@ export declare class Viewer extends EventEmitter implements IViewer {
     get World(): World;
     get Utils(): Utils;
     get input(): Input;
+    get params(): ViewerParams;
     private getConstructorChain;
     createExtension<T extends Extension>(type: Constructor<T>): T;
     getExtension<T extends Extension>(type: Constructor<T>): T;
@@ -48,6 +48,7 @@ export declare class Viewer extends EventEmitter implements IViewer {
     private getExtensionInternal;
     constructor(container: HTMLElement, params?: ViewerParams);
     getContainer(): HTMLElement;
+    getCanvas(): HTMLCanvasElement;
     getRenderer(): SynchronizedRenderer;
     resize(): void;
     requestRender(flags?: UpdateFlags): void;

package/dist/modules/batching/Batch.d.ts

@@ -1,6 +1,9 @@
 import { Box3, Material, Object3D, WebGLRenderer } from 'three';
 import { type FilterMaterialOptions } from '../materials/Materials.js';
 import { NodeRenderView } from '../tree/NodeRenderView.js';
+import { MeshBatch } from './MeshBatch.js';
+import { InstancedMeshBatch } from './InstancedMeshBatch.js';
+import TextBatch from './TextBatch.js';
 export declare enum GeometryType {
     MESH = 0,
     LINE = 1,
@@ -60,3 +63,7 @@ export declare const AllBatchUpdateRange: BatchUpdateRange;
 export declare const INSTANCE_TRANSFORM_BUFFER_STRIDE = 16;
 export declare const INSTANCE_GRADIENT_BUFFER_STRIDE = 1;
 export declare const getNextBatchIndex: () => number;
+export type AcceleratedBatchTypes = MeshBatch | InstancedMeshBatch | TextBatch;
+export declare function isAcceleratedBatchType(batch: Batch): batch is AcceleratedBatchTypes;
+export declare function isNoneBatchUpdateRange(range: BatchUpdateRange): boolean;
+export declare function isAllBatchUpdateRange(range: BatchUpdateRange, totalCount?: number): boolean;

package/dist/modules/batching/BatchObject.d.ts

@@ -48,6 +48,7 @@ export declare class BatchObject {
     set euler(euler: Euler);
     set scale(scale: Vector3);
     constructor(renderView: NodeRenderView, batchIndex: number);
-    buildAccelerationStructure(bvh?: MeshBVH): void;
+    buildAccelerationStructure(position: Float32Array | Float64Array, indices: Uint16Array | Uint32Array): void;
+    buildAccelerationStructure(bvh: MeshBVH): void;
     transformTRS(translation: Vector3Like, euler?: Vector3Like, scale?: Vector3Like, pivot?: Vector3Like): void;
 }

package/dist/modules/batching/Batcher.d.ts

@@ -23,6 +23,7 @@ export default class Batcher {
     private maxBatchObjects;
     private maxBatchVertices;
     private minInstancedBatchVertices;
+    private maxBatchTextObjects;
     materials: Materials;
     batches: {
         [id: string]: Batch;
@@ -30,6 +31,7 @@ export default class Batcher {
     constructor(caps: WebGLCapabilities);
     makeBatches(worldTree: WorldTree, renderTree: RenderTree, synchronizedType: SynchronizedType[], batchType?: GeometryType): AsyncGenerator<Batch, void, unknown>;
     private splitBatch;
+    private getMaxObjectCount;
     private buildInstancedBatch;
     private buildBatch;
     update(deltaTime: number): void;
@@ -47,6 +49,7 @@ export default class Batcher {
     restoreBatchMaterial(ranges: Record<string, BatchUpdateRange>): void;
     purgeBatches(subtreeId: string): void;
     getBatches<K extends GeometryType>(subtreeId?: string, geometryType?: K): BatchTypeMap[K][];
+    getBatches<K extends GeometryType>(subtreeId?: string, geometryType?: Array<K>): BatchTypeMap[K][];
     private isBatchType;
     getBatch(rv: NodeRenderView): Batch | undefined;
     getRenderView(batchId: string, index: number): NodeRenderView | null;

package/dist/modules/batching/LineBatch.d.ts

@@ -3,7 +3,7 @@ import { LineSegments2 } from 'three/examples/jsm/lines/LineSegments2.js';
 import { LineSegmentsGeometry } from 'three/examples/jsm/lines/LineSegmentsGeometry.js';
 import SynchronizedLineMaterial from '../materials/SynchronizedLineMaterial.js';
 import { NodeRenderView } from '../tree/NodeRenderView.js';
-import { type Batch, type BatchUpdateRange, type DrawGroup, GeometryType } from './Batch.js';
+import { type Batch, type BatchUpdateRange, DrawGroup, GeometryType } from './Batch.js';
 export default class LineBatch implements Batch {
     id: string;
     subtreeId: string;
@@ -14,24 +14,28 @@ export default class LineBatch implements Batch {
     protected batchOpacity: number;
     protected mesh: LineSegments2;
     colorBuffer: InstancedInterleavedBuffer;
-    private static readonly vector4Buffer;
+    protected visibilityRanges: {
+        [offset: number]: boolean;
+    };
     get bounds(): Box3;
     get drawCalls(): number;
     get minDrawCalls(): number;
     get triCount(): number;
     get vertCount(): number;
     constructor(id: string, subtreeId: string, renderViews: NodeRenderView[]);
+    get groups(): DrawGroup[];
     get pointCount(): number;
     get lineCount(): number;
     get renderObject(): Object3D;
     get geometryType(): GeometryType;
     get materials(): Material[];
-    get groups(): DrawGroup[];
     getCount(): number;
     setBatchMaterial(material: SynchronizedLineMaterial): void;
     onUpdate(deltaTime: number): void;
     onRender(renderer: WebGLRenderer): void;
     setVisibleRange(ranges: BatchUpdateRange[]): void;
+    /** Line batches do not sort their ranges. This means we can have hidden/transparent objects anywhere inside the batch.
+     */
     getVisibleRange(): BatchUpdateRange;
     getOpaque(): BatchUpdateRange;
     getDepth(): BatchUpdateRange;

package/dist/modules/batching/MeshBatch.d.ts

@@ -29,7 +29,7 @@ export declare class MeshBatch extends PrimitiveBatch {
     setDrawRanges(ranges: BatchUpdateRange[]): void;
     resetDrawRanges(): void;
     buildBatch(): Promise<void>;
-    protected makeMeshGeometry(indices: Uint32Array | Uint16Array, position: Float64Array, normals: Float32Array, batchIndices: Float32Array, color?: Float32Array): BufferGeometry;
+    protected makeMeshGeometry(indices: Uint32Array | Uint16Array, position: Float64Array | Float32Array, normals: Float32Array, batchIndices: Float32Array, color?: Float32Array): BufferGeometry;
     getRenderView(index: number): NodeRenderView | null;
     getMaterialAtIndex(index: number): Material | null;
 }

package/dist/modules/batching/PointBatch.d.ts

@@ -23,7 +23,7 @@ export declare class PointBatch extends PrimitiveBatch {
         maxIndex: number;
     };
     buildBatch(): Promise<void>;
-    protected makePointGeometry(index: Int32Array, position: Float64Array, color: Float32Array): BufferGeometry;
+    protected makePointGeometry(index: Uint32Array | Uint16Array, position: Float64Array | Float32Array, color: Float32Array): BufferGeometry;
     getRenderView(index: number): NodeRenderView | null;
     getMaterialAtIndex(index: number): Material | null;
 }

package/dist/modules/batching/TextBatch.d.ts

@@ -1,41 +1,60 @@
 import { Box3, Material, Object3D, WebGLRenderer } from 'three';
 import { NodeRenderView } from '../tree/NodeRenderView.js';
 import { type Batch, type BatchUpdateRange, type DrawGroup, GeometryType } from './Batch.js';
-import { SynchronizedText } from '../objects/SynchronizedText.js';
+import { SynchronizedBatchedText } from '../objects/SynchronizedBatchedText.js';
+import { AnchorX, AnchorY } from 'troika-three-text';
+import { DrawRanges } from './DrawRanges.js';
 export default class TextBatch implements Batch {
     id: string;
     subtreeId: string;
     renderViews: NodeRenderView[];
     batchMaterial: Material;
-    mesh: SynchronizedText;
+    mesh: SynchronizedBatchedText;
+    protected drawRanges: DrawRanges;
     get bounds(): Box3;
     get drawCalls(): number;
     get minDrawCalls(): number;
+    get maxDrawCalls(): number;
     get triCount(): number;
     get vertCount(): number;
-    constructor(id: string, subtreeId: string, renderViews: NodeRenderView[]);
     get pointCount(): number;
     get lineCount(): number;
     get geometryType(): GeometryType;
     get renderObject(): Object3D;
     getCount(): number;
     get materials(): Material[];
-    get groups(): DrawGroup[];
+    get groups(): Array<DrawGroup>;
+    constructor(id: string, subtreeId: string, renderViews: NodeRenderView[]);
     setBatchMaterial(material: Material): void;
     onUpdate(deltaTime: number): void;
     onRender(renderer: WebGLRenderer): void;
     setVisibleRange(ranges: BatchUpdateRange[]): void;
     getVisibleRange(): BatchUpdateRange;
+    /** TODO: Need to give this a glow up */
     getOpaque(): BatchUpdateRange;
+    /** TODO: Need to give this a glow up */
     getDepth(): BatchUpdateRange;
+    /** TODO: Need to give this a glow up */
     getTransparent(): BatchUpdateRange;
+    /** TODO: Need to give this a glow up */
     getStencil(): BatchUpdateRange;
-    setBatchBuffers(range: BatchUpdateRange[]): void;
+    /** Text batches are mix between how mesh and line batches work.
+     * - They still keep track of various draw groups each with it's material
+     * - However that material is not really being used, but rather the properies are copied over to the batch fp32 data texture
+     * - For filtering we cheat and use `SynchronizedTextColoredMaterial` only to store the gradient/ramp texture + gradient indices for each text in the batch
+     * - The color from the gradient/ramp texture will be used only if the gradient index > 0, otherwise the regular color will be used
+     * - The gradient index is stored in each text object in it's `userData` and written to the 27'th float in the batch data texture, where the shader reads if from
+     * - Even if, the **text batch does not use the materials in it's draw groups**, it emulates the behavior as if it would
+     */
+    setBatchBuffers(ranges: BatchUpdateRange[]): void;
     setDrawRanges(ranges: BatchUpdateRange[]): void;
+    private cleanMaterials;
     resetDrawRanges(): void;
+    protected alignmentXToAnchorX(value: number): AnchorX;
+    protected alignmentYToAnchorY(value: number): AnchorY;
     buildBatch(): Promise<void>;
-    getRenderView(index: number): NodeRenderView;
-    getMaterialAtIndex(index: number): Material;
-    getMaterial(rv: NodeRenderView): Material;
+    getRenderView(index: number): NodeRenderView | null;
+    getMaterialAtIndex(index: number): Material | null;
+    getMaterial(rv: NodeRenderView): Material | null;
     purge(): void;
 }

package/dist/modules/batching/TextBatchObject.d.ts

@@ -0,0 +1,9 @@
+import { Box3, Matrix4 } from 'three';
+import { BatchObject, Vector3Like } from './BatchObject.js';
+import { NodeRenderView } from '../tree/NodeRenderView.js';
+export declare class TextBatchObject extends BatchObject {
+    textTransform: Matrix4;
+    constructor(renderView: NodeRenderView, batchIndex: number);
+    get aabb(): Box3;
+    transformTRS(translation: Vector3Like, euler: Vector3Like, scale: Vector3Like, pivot: Vector3Like): void;
+}

package/dist/modules/converter/Geometry.d.ts

@@ -1,5 +1,6 @@
 import { Box3, BufferGeometry, Matrix4, Vector2, Vector3 } from 'three';
 import { type SynchronizedObject } from '../../IViewer.js';
+import { ChunkArray } from './VirtualArray.js';
 export declare enum GeometryAttributes {
     POSITION = "POSITION",
     COLOR = "COLOR",
@@ -8,21 +9,29 @@ export declare enum GeometryAttributes {
     TANGENT = "TANGENT",
     INDEX = "INDEX"
 }
+type RequiredKeys = GeometryAttributes.POSITION | GeometryAttributes.INDEX;
+type OptionalKeys = Exclude<GeometryAttributes, RequiredKeys>;
+type GeometryAttributesShape = {
+    [K in RequiredKeys]: ChunkArray;
+} & {
+    [K in OptionalKeys]?: ChunkArray;
+};
 export interface GeometryData {
-    attributes: ({
-        [GeometryAttributes.POSITION]: number[];
-    } & Partial<Record<Exclude<GeometryAttributes, GeometryAttributes.POSITION>, number[]>>) | null;
+    attributes: GeometryAttributesShape | null;
     bakeTransform: Matrix4 | null;
     transform: Matrix4 | null;
     metaData?: SynchronizedObject;
     instanced?: boolean;
+    flipNormals?: boolean;
 }
 export declare class Geometry {
     static updateRTEGeometry(geometry: BufferGeometry, doublePositions: Float64Array | Float32Array): void;
-    static mergeGeometryAttribute(attributes: (number[] | undefined)[], target: Float32Array | Float64Array): ArrayLike<number>;
-    static mergeIndexAttribute(indexAttributes: (number[] | undefined)[], positionAttributes: (number[] | undefined)[]): number[];
+    static mergeGeometryAttribute(attributes: ChunkArray[], target: Float32Array | Float64Array): ArrayLike<number>;
+    static mergeIndexAttribute(indexAttributes: ChunkArray[], positionAttributes: ChunkArray[]): number[];
     static mergeGeometryData(geometries: GeometryData[]): GeometryData;
     static transformGeometryData(geometryData: GeometryData, m: Matrix4 | null): void;
+    static transformArray(array: number[] | Float32Array | Float64Array, m: Matrix4 | null, offset?: number, count?: number): void;
+    static isMatrix4Identity(matrix: Matrix4): boolean;
     static unpackColors(int32Colors: number[]): number[];
     /** Please see https://bim2bi.ir/blog/improving-synchronizeds-rte-implementation/ for additional details
      *  regarding double -> <float low; float high> encoding.
@@ -33,6 +42,9 @@ export declare class Geometry {
     static getFP32ProjectionDelta(point: Vector3, projection: Matrix4, screenSize: Vector2, relativeOffset?: number): Vector2;
     /** Only supports indexed geometry */
     static computeVertexNormalsBuffer(buffer: number[], position: number[], index: number[]): void;
-    static computeVertexNormals(buffer: BufferGeometry, doublePositions: Float64Array): void;
+    static computeVertexNormalsBufferVirtual(buffer: number[], position: ChunkArray, index: ChunkArray, flip?: boolean): void;
+    static flipNormalsBuffer(buffer: Float32Array): void;
+    static computeVertexNormals(buffer: BufferGeometry, positions: Float64Array | Float32Array): void;
     static triangulatePolygon(points: Vector2[]): number[];
 }
+export {};

package/dist/modules/converter/MeshTriangulationHelper.d.ts

@@ -1,7 +1,3 @@
-/**
- * Set of functions to triangulate n-gon faces (i.e. polygon faces with an arbitrary (n) number of vertices).
- * This class is a JavaScript port of https://github.com/KingDaryush1/synchronized-sharp/blob/main/Objects/Objects/Utils/MeshTriangulationHelper.cs
- */
 export default class MeshTriangulationHelper {
     /**
      * Calculates the triangulation of the face at given faceIndex.
@@ -9,42 +5,7 @@ export default class MeshTriangulationHelper {
      * @param {Number}   faceIndex      The index of the face's cardinality indicator `n`
      * @param {Number[]}   faces      The list of faces in the mesh
      * @param {Number[]}   vertices   The list of vertices in the mesh
-     * @return {Number[]} flat list of triangle faces (without cardinality indicators)
+     * @return {Number} flat list of triangle faces (without cardinality indicators)
      */
-    static triangulateFace(faceIndex: number, faces: number[], vertices: number[]): number[];
-    /**
-     * Tests if point v is within the triangle *abc*.
-     * @param {Vector3} v
-     * @param {Vector3} a
-     * @param {Vector3} b
-     * @param {Vector3} c
-     * @returns {boolean} true if v is within triangle.
-     */
-    static testPointTriangle(v: Vector3, a: Vector3, b: Vector3, c: Vector3): boolean;
-    /**
-     * Checks that triangle abc is clockwise with reference to referenceNormal.
-     * @param {Vector3} referenceNormal The normal direction of the face.
-     * @param {Vector3} a
-     * @param {Vector3} b
-     * @param {Vector3} c
-     * @returns {boolean} true if triangle is ccw
-     */
-    static triangleIsCCW(referenceNormal: Vector3, a: Vector3, b: Vector3, c: Vector3): boolean;
-}
-/**
- * Encapsulates vector maths operations required for polygon triangulation
- */
-declare class Vector3 {
-    constructor(x: any, y: any, z: any);
-    x: any;
-    y: any;
-    z: any;
-    add(v: any): Vector3;
-    sub(v: any): Vector3;
-    mul(n: any): Vector3;
-    dot(v: any): number;
-    cross(v: any): Vector3;
-    squareSum(): number;
-    normalize(): void;
+    static triangulateFace(faceIndex: number, faces: number[], vertices: number[], _inout_targetArray: any, _in_offset: any): number;
 }
-export {};

package/dist/modules/converter/VirtualArray.d.ts

@@ -0,0 +1,30 @@
+import { TypedArray } from 'type-fest';
+import { DataChunk } from '../../IViewer.js';
+import { Box3 } from 'three';
+export declare class VirtualArray {
+    chunks: Array<Array<number>>;
+    private offsets;
+    constructor(chunks: Array<Array<number>>);
+    get length(): number;
+    get(index: number): number;
+    set(index: number, value: number): void;
+    findChunkIndex(index: number): number;
+    updateOffsets(): void;
+}
+export declare class ChunkArray extends VirtualArray {
+    chunkArray: Array<DataChunk>;
+    protected flatArray: TypedArray;
+    constructor(chunks: Array<DataChunk>);
+    slice(): ChunkArray;
+    copyToBuffer(buffer: TypedArray, offset: number): void;
+    computeBox3(): Box3;
+    protected getFlatArray<T extends TypedArray>(Type: {
+        new (length: number): T;
+    }): T;
+    getFloat32Array(): Float32Array;
+    getFloat64Array(): Float64Array;
+    getInt16Array(): Int16Array;
+    getInt32Array(): Int32Array;
+    getUint16Array(): Uint16Array;
+    getUint32Array(): Uint32Array;
+}

package/dist/modules/extensions/ExplodeExtension.d.ts

@@ -1,3 +1,4 @@
+import { Box3 } from 'three';
 import { Extension } from './Extension.js';
 export declare enum ExplodeEvent {
     Finshed = "explode-finished"
@@ -9,8 +10,11 @@ export declare class ExplodeExtension extends Extension {
     protected _enabled: boolean;
     get enabled(): boolean;
     set enabled(value: boolean);
+    /** Similar to SynchronizedRenderer's visibleSceneBox, but with static boxes from render views */
+    get visibleWorld(): Box3;
     private explodeTime;
     private explodeRange;
+    private explodeOrigin;
     onEarlyUpdate(): void;
     setExplode(time: number): void;
     private explode;

package/dist/modules/extensions/controls/FlyControls.d.ts

@@ -3,6 +3,7 @@ import { Damper } from '../../utils/Damper.js';
 import { SynchronizedControls } from './SynchronizedControls.js';
 import { World } from '../../World.js';
 import { AngleDamper } from '../../utils/AngleDamper.js';
+import Input from '../../input/Input.js';
 type MoveType = 'forward' | 'back' | 'left' | 'right' | 'up' | 'down';
 export interface FlyControlsOptions {
     [name: string]: unknown;
@@ -13,9 +14,9 @@ export interface FlyControlsOptions {
     relativeUpDown?: boolean;
 }
 declare class FlyControls extends SynchronizedControls {
+    protected input: Input;
     protected _options: Required<FlyControlsOptions>;
     protected _targetCamera: PerspectiveCamera | OrthographicCamera;
-    protected container: HTMLElement;
     protected velocity: Vector3;
     protected euler: Euler;
     protected position: Vector3;
@@ -43,7 +44,7 @@ declare class FlyControls extends SynchronizedControls {
     get up(): Vector3;
     set up(value: Vector3);
     set minDist(value: number);
-    constructor(camera: PerspectiveCamera | OrthographicCamera, container: HTMLElement, world: World, options: Required<FlyControlsOptions>);
+    constructor(camera: PerspectiveCamera | OrthographicCamera, input: Input, world: World, options: Required<FlyControlsOptions>);
     isStationary(): boolean;
     update(delta?: number): boolean;
     protected updatePositionRotation(delta: number): void;
@@ -73,7 +74,9 @@ declare class FlyControls extends SynchronizedControls {
     protected disconnect(): void;
     dispose(): void;
     protected rotate(euler: Euler): void;
-    protected onMouseMove: (event: PointerEvent) => void;
+    protected onMouseMove: (arg: Vector2 & {
+        event: PointerEvent;
+    }) => void;
     protected onKeyDown: (event: KeyboardEvent) => void;
     protected onKeyUp: (event: KeyboardEvent) => void;
     protected onContextMenu: () => void;

package/dist/modules/extensions/measurements/AreaMeasurement.d.ts

@@ -1,13 +1,16 @@
 import { Box3, Camera, Plane, Raycaster, Vector2, Vector3, type Intersection } from 'three';
 import { Measurement } from './Measurement.js';
 import { ExtendedMeshIntersection } from '../../objects/SynchronizedRaycaster.js';
+import { MeasurementData, MeasurementType } from '@synchronized-console/shared/viewer/state';
 export declare class AreaMeasurement extends Measurement {
     /** We store all gizmos here */
     private pointGizmos;
     /** This stores the last touched point position and normal */
     private surfacePoint;
     private surfaceNormal;
-    /** The plane params defined by the first placed point */
+    /** The plane params defined by the first placed point
+     *  When serialized they will go in the measurements startPoint and startNormal
+     */
     private planeOrigin;
     private planeNormal;
     /** The location of the area text label */
@@ -24,6 +27,7 @@ export declare class AreaMeasurement extends Measurement {
     private snapDistance;
     set isVisible(value: boolean);
     get bounds(): Box3;
+    get measurementType(): MeasurementType;
     constructor();
     /** Frame */
     frameUpdate(camera: Camera, size: Vector2, bounds: Box3): void;
@@ -32,7 +36,7 @@ export declare class AreaMeasurement extends Measurement {
     /** Called whenver a location is selected for measuring*/
     locationSelected(): void;
     /** Adds a point to the area measurement */
-    addPoint(): number;
+    addPoint(point: Vector3): number;
     /** Removes point from the measurement */
     removePoint(): number;
     /** Auto completes the measurement by joining with the first point */
@@ -61,4 +65,6 @@ export declare class AreaMeasurement extends Measurement {
     /** Area calculation */
     private shoelaceArea;
     private shoelaceArea3D;
+    toMeasurementData(): MeasurementData;
+    fromMeasurementData(data: MeasurementData): void;
 }

package/dist/modules/extensions/measurements/Measurement.d.ts

@@ -1,5 +1,6 @@
 import { Box3, Camera, Object3D, Plane, Raycaster, Vector2, Vector3, type Intersection } from 'three';
 import { ExtendedMeshIntersection } from '../../objects/SynchronizedRaycaster.js';
+import { MeasurementData, MeasurementType } from '@synchronized-console/shared/viewer/state';
 export declare enum MeasurementState {
     HIDDEN = 0,
     DANGLING_START = 1,
@@ -16,12 +17,15 @@ export declare abstract class Measurement extends Object3D {
     value: number;
     units: string;
     precision: number;
+    measurementId: string;
     protected _state: MeasurementState;
     protected renderingCamera: Camera | null;
     protected renderingSize: Vector2;
+    constructor();
     set state(value: MeasurementState);
     get state(): MeasurementState;
     abstract set isVisible(value: boolean);
+    abstract get measurementType(): MeasurementType;
     get bounds(): Box3;
     frameUpdate(camera: Camera | null, size: Vector2, _bounds?: Box3): void;
     abstract update(): Promise<void>;
@@ -31,4 +35,6 @@ export declare abstract class Measurement extends Object3D {
     abstract locationUpdated(point?: Vector3, normal?: Vector3, ndcScreen?: Vector2): void;
     abstract locationSelected(point?: Vector3, normal?: Vector3, ndcScreen?: Vector2): void;
     snap?(ndcPoint: Vector2, intersection: ExtendedMeshIntersection, outPoint: Vector3, outNormal: Vector3): boolean;
+    toMeasurementData(): MeasurementData;
+    fromMeasurementData(data: MeasurementData): void;
 }

package/dist/modules/extensions/measurements/MeasurementPointGizmo.d.ts

@@ -1,4 +1,7 @@
-import { Camera, Group, Plane, Quaternion, Raycaster, Vector2, Vector3, type Intersection } from 'three';
+import { Camera, CircleGeometry, Group, Mesh, Plane, Quaternion, Raycaster, Vector2, Vector3, type Intersection } from 'three';
+import { LineSegments2 } from 'three/examples/jsm/lines/LineSegments2.js';
+import { TextLabel } from '../../objects/TextLabel.js';
+import SynchronizedBasicMaterial from '../../materials/SynchronizedBasicMaterial.js';
 export interface MeasurementPointGizmoStyle {
     dashedLine?: boolean;
     normalIndicatorPixelSize?: number;
@@ -14,21 +17,20 @@ export interface MeasurementPointGizmoStyle {
     pointPixelHeight?: number;
 }
 export declare class MeasurementPointGizmo extends Group {
-    private normalIndicator;
+    normalIndicator: LineSegments2;
     private normalIndicatorBuffer;
     private normalIndicatorNormal;
     private normalIndicatorTangent;
     private normalIndicatorBitangent;
-    private line;
-    private point;
-    private text;
+    line: LineSegments2;
+    point: Mesh<CircleGeometry, SynchronizedBasicMaterial>;
+    text: TextLabel;
     private _style;
     set style(value: MeasurementPointGizmoStyle);
     set highlight(value: boolean);
     private getNormalIndicatorMaterial;
     private getLineMaterial;
     private getPointMaterial;
-    private getTextMaterial;
     constructor(style?: MeasurementPointGizmoStyle);
     enable(normalIndicator: boolean, line: boolean, point: boolean, text: boolean): void;
     frameUpdate(camera: Camera, size: Vector2): void;