@configura/babylon-view 1.3.0-alpha.3 → 1.3.0

package/dist/utilities/anchor/anchorMap.js

@@ -0,0 +1,111 @@
+// Tests do not work if we have Babylon-imports in the same file, so this has to be a separate file
+/**
+ * Returns a map from child to parent guaranteed to be loop free.
+ * The anchor children (keys in the map) will all have a "anchorRef" and there is what
+ * measureParam they are linked on is found.
+ * Sorted so that parents are always before their children
+ * This function is a bit of a "best effort". These things are not well defined in CET - you
+ * can anchor A on B and B on A at the same time for example. You can also anchor B to A
+ * while there exists multiple A:s. The code below is a naive implementation as in it will
+ * not make the solution which allows the most things to be linked. But that is fine as you
+ * should never create a catalogue with strange anchoring anyhow.
+ */
+export function makeAnchoredToAnchorMap(nodes, targetCandidateComparer) {
+    function isAnchoree(n) {
+        return "anchorRef" in n;
+    }
+    function isTarget(n) {
+        return "stretchDatas" in n;
+    }
+    const anchoredToAnchorMap = new Map();
+    // Step 1: build a legal tree
+    for (const node of nodes) {
+        if (!isAnchoree(node)) {
+            continue;
+        }
+        const anchorRef = node.anchorRef;
+        if (anchorRef === undefined) {
+            continue;
+        }
+        const measureParam = anchorRef.measureParamCode;
+        const targetCandidates = nodes
+            .filter((n) => {
+            // Ignore self
+            if (node === n) {
+                return false;
+            }
+            if (!isTarget(n)) {
+                return false;
+            }
+            // Can we anchor to this node?
+            return n.stretchDatas.some((stretchData) => measureParam === stretchData.measureParam);
+        })
+            .map((t, i) => ({ t, i }))
+            .sort((l, r) => {
+            // As sort is not stable in JS-versions older than EcmaScript 2019 we add the
+            // array original index to have as a fallback when there is a draw
+            const comp = targetCandidateComparer(anchorRef.measureParamCode, l.t, r.t);
+            if (comp === 0) {
+                return l.i - r.i;
+            }
+            return comp;
+        })
+            .map((tt) => tt.t);
+        let okay = true;
+        for (const otherNode of targetCandidates) {
+            okay = true;
+            // Loop control, the candidate can not be a child, then we would get a loop
+            let loopCandidate = otherNode;
+            while (loopCandidate !== undefined) {
+                if (!isAnchoree(loopCandidate)) {
+                    break;
+                }
+                loopCandidate = anchoredToAnchorMap.get(loopCandidate);
+                if (loopCandidate === node) {
+                    okay = false;
+                    break;
+                }
+            }
+            if (okay) {
+                anchoredToAnchorMap.set(node, otherNode);
+                break;
+            }
+        }
+        if (!okay) {
+            console.warn("No SymRootNode to anchor to found.");
+        }
+    }
+    // From anchored to anchor
+    const unplaced = Array.from(anchoredToAnchorMap);
+    // Step 2: Build a sorted map so that parents are before their children
+    const result = [];
+    while (true) {
+        const candidate = unplaced.pop();
+        if (candidate === undefined) {
+            //done
+            break;
+        }
+        const parent = candidate[1];
+        const indexInResult = result.findIndex((otherAnchoredToAnchor) => parent === otherAnchoredToAnchor[0]);
+        if (indexInResult === -1) {
+            // Candidates parent is not in the result, see if it in those waiting
+            const indexInUnplaced = unplaced.findIndex((item) => item[0] === parent);
+            if (indexInUnplaced === -1) {
+                // The parent was not part of the original nodes, so we just add this node.
+                result.push(candidate);
+            }
+            else {
+                const toMoveUp = unplaced.splice(indexInUnplaced, 1)[0];
+                // Put back to candidate
+                unplaced.push(candidate);
+                // Move up the parent
+                unplaced.push(toMoveUp);
+            }
+        }
+        else {
+            // Parent is in result
+            result.splice(indexInResult + 1, 0, candidate);
+        }
+    }
+    return new Map(result);
+}

package/dist/utilities/utilities3D.d.ts

@@ -1,27 +1,71 @@
-import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-import { Transform as ModelTransform } from "@configura/web-api";
-import { ATriMeshF } from "@configura/web-core/dist/cm/core3D/ATriMeshF.js";
-import { SymTransform } from "@configura/web-core/dist/cm/format/cmsym/components/SymTransform.js";
-import { Point } from "@configura/web-core/dist/cm/geometry/Point.js";
-import { Transform as GeoTransform } from "@configura/web-core/dist/cm/geometry/Transform.js";
-import { CfgBoundingBox } from "./CfgBoundingBox.js";
-export declare function vector3Equals(left: Vector3, right: Vector3): boolean;
-declare type Axis = "x" | "y" | "z";
-export declare const getBoundingBoxChangeForAxis: (bbOld: CfgBoundingBox, bbNew: CfgBoundingBox, forMax: boolean, axis: Axis) => number;
-export declare const boundingBoxChangeIsSignificantForAxis: (bbOld: CfgBoundingBox, bbNew: CfgBoundingBox, forMax: boolean, axis: Axis, acceptableDifferenceShrink: number, acceptableDifferenceGrow: number) => boolean;
-export declare function boundingBoxesAreSignificantlyDifferent(bbOld: CfgBoundingBox, bbNew: CfgBoundingBox, acceptableDifferenceShrink: number, acceptableDifferenceGrow: number): boolean;
-export declare function unifyBoundingRect(boundingRect: ClientRect | DOMRect): {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-};
-export declare function symTransformToMatrix(symTransform: GeoTransform): Matrix;
-export declare function modelTransformsEqual(left: ModelTransform, right: ModelTransform): boolean;
-export declare function modelTransformToSymTransform(modelTransform: ModelTransform): SymTransform;
-export declare function cloneName(name: string): string;
-export declare function measureLongestDistanceToCorner(bb: CfgBoundingBox, measureComponents: number[]): number;
-export declare function aTriMeshSphere(radius?: number, center?: Point, segments?: number): ATriMeshF;
-export declare function aTriMeshBox(p0?: Point, p1?: Point): ATriMeshF;
-export {};
+import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { Transform as ModelTransform } from "@configura/web-api";
+import { ATriMeshF } from "@configura/web-core/dist/cm/core3D/ATriMeshF.js";
+import { SymTransform } from "@configura/web-core/dist/cm/format/cmsym/components/SymTransform.js";
+import { Point } from "@configura/web-core/dist/cm/geometry/Point.js";
+import { Transform as GeoTransform } from "@configura/web-core/dist/cm/geometry/Transform.js";
+import { CfgBoundingBox } from "./CfgBoundingBox.js";
+export declare function vector3Equals(left: Vector3, right: Vector3): boolean;
+export declare function cmPointToVector3(point: Point): Vector3;
+declare type Axis = "x" | "y" | "z";
+/**
+ * Calculates the change in one component for min or max when moving from one bounding box to
+ * another. Negative result is shrink, positive is grow. forMax is accounted for.
+ */
+export declare const getBoundingBoxChangeForAxis: (bbOld: CfgBoundingBox, bbNew: CfgBoundingBox, forMax: boolean, axis: Axis) => number;
+/**
+ * Given an old bounding box and a new tells if the size difference in one component is significant.
+ */
+export declare const boundingBoxChangeIsSignificantForAxis: (bbOld: CfgBoundingBox, bbNew: CfgBoundingBox, forMax: boolean, axis: Axis, acceptableDifferenceShrink: number, acceptableDifferenceGrow: number) => boolean;
+/**
+ * Returns true if either:
+ * - One bounding box was empty and the other not.
+ * - There is a size change in any of the six primary directions which is larger than
+ * acceptableDifferenceShrink or acceptableDifferenceGrow depending if the change from bbOld to
+ * bbNew in that direction is shrink or grow.
+ */
+export declare function boundingBoxesAreSignificantlyDifferent(bbOld: CfgBoundingBox, bbNew: CfgBoundingBox, acceptableDifferenceShrink: number, acceptableDifferenceGrow: number): boolean;
+export declare function unifyBoundingRect(boundingRect: ClientRect | DOMRect): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export declare function symTransformToMatrix(symTransform: GeoTransform): Matrix;
+export declare function modelTransformsEqual(left: ModelTransform, right: ModelTransform): boolean;
+export declare function modelTransformToSymTransform(modelTransform: ModelTransform): SymTransform;
+export declare function cloneName(name: string): string;
+export declare function measureLongestDistanceToCorner(bb: CfgBoundingBox, measureComponents: number[]): number;
+/**
+ * Creates an ATriMeshF instance containing a mesh of a sphere of the given radius (default 1)
+ * centered on the given position (default <0,0,0>). The "resolution" of the mesh is set by the
+ * segments value (default 32).
+ *
+ * UV coordinates are generated by wrapping the texture around the sphere like a world map.
+ */
+export declare function aTriMeshSphere(radius?: number, center?: Point, segments?: number): ATriMeshF;
+/**
+ * Creates an ATriMeshF instance containing a mesh of a box between the two points.
+ * Default value of p0 is <0,0,0> and p1 is <1,1,1>.
+ *
+ * UV coordinates are generated, repeating the texture on each side.
+ */
+export declare function aTriMeshBox(p0?: Point, p1?: Point): ATriMeshF;
+/**
+ * Creates an ATriMeshF instance containing a mesh representing an infinite plane with the given
+ * normal, offset by the given distance along the normal.
+ *
+ * Due to automatic bounding box calculations, the infinite plane is represented by a circular disc
+ * with the given radius centered on a point offset from the origin along the normal vector.
+ *
+ * The number of triangles in the disc is controlled by the refine parameter. The minimum number of
+ * triangles is 4, each refine step doubles the triangle count.
+ *
+ * Default normal: 1, 0, 0
+ * Default offset: 0
+ * Default radius: 1
+ * Default refinement: 4 (64 triangles)
+ */
+export declare function aTriMeshPlane(normal?: Point, offset?: number, radius?: number, refine?: number): ATriMeshF;
+export {};
 //# sourceMappingURL=utilities3D.d.ts.map