@configura/babylon-view 2.0.0-alpha.0 → 2.0.0-alpha.3

package/dist/nodes/CfgTransformNode.js

@@ -1,83 +1,83 @@
-import { TransformNode } from "@babylonjs/core/Meshes/transformNode.js";
-import { InspectableType } from "@babylonjs/core/Misc/iInspectable.js";
-export class CfgTransformNode extends TransformNode {
-    constructor(_renderEnvironment, name) {
-        super(name, _renderEnvironment.scene);
-        this._renderEnvironment = _renderEnvironment;
-        this.addInspectorProperties();
-    }
-    /**
-     * Provides a class name to show in the Babylon.js Inspector.
-     * Override in subclasses.
-     */
-    get cfgClassName() {
-        return "CfgTransformNode";
-    }
-    getChildrenForAnimation() {
-        const result = [];
-        for (const c of this.getChildren()) {
-            if (c instanceof CfgTransformNode) {
-                result.push(c);
-            }
-        }
-        return result;
-    }
-    clear(dispose) {
-        const children = this.getChildren();
-        if (children.length > 0) {
-            this.remove(dispose, ...children.slice());
-        }
-    }
-    add(...objects) {
-        for (const obj of objects) {
-            if (obj === this) {
-                console.error("CfgTransformNode.add: object can't be added as a child of itself.", obj);
-                continue;
-            }
-            obj.parent = this;
-        }
-    }
-    /**
-     * Recursively calculates the world matrix based on originalMatrix on nodes which inherits
-     * CfgTransformNode.
-     */
-    get worldOriginalMatrix() {
-        const o = this.originalMatrix;
-        const p = this.parent;
-        if (p && p instanceof CfgTransformNode) {
-            return o.multiply(p.worldOriginalMatrix);
-        }
-        return o;
-    }
-    remove(dispose, ...objects) {
-        for (const obj of objects) {
-            if (dispose) {
-                obj.dispose();
-            }
-            else {
-                obj.parent = null;
-            }
-        }
-        return this;
-    }
-    /**
-     * Adds the property to the instance so it shows up in the Babylon.js Inspector.
-     *
-     * TODO Babylon: Currently they show up as editable, even though they are used to display
-     * read-only information. Metadata seems to be more correct, but is not (yet?) included by the
-     * Inspector.
-     */
-    addInspectableCustomProperty(property) {
-        if (this.inspectableCustomProperties === undefined) {
-            this.inspectableCustomProperties = [];
-        }
-        this.inspectableCustomProperties.push(property);
-    }
-    addInspectorProperties() {
-        this.addInspectableCustomProperty({
-            label: "Cfg Class",
-            propertyName: "cfgClassName",
-            type: InspectableType.String,
-        });
-    }
-}
+import { TransformNode } from "@babylonjs/core/Meshes/transformNode.js";
+import { InspectableType } from "@babylonjs/core/Misc/iInspectable.js";
+export class CfgTransformNode extends TransformNode {
+    constructor(_renderEnvironment, name) {
+        super(name, _renderEnvironment.scene);
+        this._renderEnvironment = _renderEnvironment;
+        this.addInspectorProperties();
+    }
+    /**
+     * Provides a class name to show in the Babylon.js Inspector.
+     * Override in subclasses.
+     */
+    get cfgClassName() {
+        return "CfgTransformNode";
+    }
+    getChildrenForAnimation() {
+        const result = [];
+        for (const c of this.getChildren()) {
+            if (c instanceof CfgTransformNode) {
+                result.push(c);
+            }
+        }
+        return result;
+    }
+    clear(dispose) {
+        const children = this.getChildren();
+        if (children.length > 0) {
+            this.remove(dispose, ...children.slice());
+        }
+    }
+    add(...objects) {
+        for (const obj of objects) {
+            if (obj === this) {
+                console.error("CfgTransformNode.add: object can't be added as a child of itself.", obj);
+                continue;
+            }
+            obj.parent = this;
+        }
+    }
+    /**
+     * Recursively calculates the world matrix based on originalMatrix on nodes which inherits
+     * CfgTransformNode.
+     */
+    get worldOriginalMatrix() {
+        const o = this.originalMatrix;
+        const p = this.parent;
+        if (p && p instanceof CfgTransformNode) {
+            return o.multiply(p.worldOriginalMatrix);
+        }
+        return o;
+    }
+    remove(dispose, ...objects) {
+        for (const obj of objects) {
+            if (dispose) {
+                obj.dispose();
+            }
+            else {
+                obj.parent = null;
+            }
+        }
+        return this;
+    }
+    /**
+     * Adds the property to the instance so it shows up in the Babylon.js Inspector.
+     *
+     * TODO Babylon: Currently they show up as editable, even though they are used to display
+     * read-only information. Metadata seems to be more correct, but is not (yet?) included by the
+     * Inspector.
+     */
+    addInspectableCustomProperty(property) {
+        if (this.inspectableCustomProperties === undefined) {
+            this.inspectableCustomProperties = [];
+        }
+        this.inspectableCustomProperties.push(property);
+    }
+    addInspectorProperties() {
+        this.addInspectableCustomProperty({
+            label: "Cfg Class",
+            propertyName: "cfgClassName",
+            type: InspectableType.String,
+        });
+    }
+}

package/dist/scene/SceneCreator.d.ts

@@ -1,7 +1,7 @@
-import { Engine } from "@babylonjs/core/Engines/engine.js";
-import "@babylonjs/core/Materials/Textures/Loaders/envTextureLoader.js";
-import "@babylonjs/core/Misc/dds.js";
-import { Scene } from "@babylonjs/core/scene.js";
-export declare type SceneCreator = (engine: Engine) => Scene;
-export declare function getDefaultScene(engine: Engine, envUrl?: string): Scene;
+import { Engine } from "@babylonjs/core/Engines/engine.js";
+import "@babylonjs/core/Materials/Textures/Loaders/envTextureLoader.js";
+import "@babylonjs/core/Misc/dds.js";
+import { Scene } from "@babylonjs/core/scene.js";
+export declare type SceneCreator = (engine: Engine) => Scene;
+export declare function getDefaultScene(engine: Engine, envUrl?: string): Scene;
 //# sourceMappingURL=SceneCreator.d.ts.map

package/dist/scene/SceneCreator.js

@@ -1,22 +1,22 @@
-import { CubeTexture } from "@babylonjs/core/Materials/Textures/cubeTexture.js";
-import "@babylonjs/core/Materials/Textures/Loaders/envTextureLoader.js"; // Needed for environment map
-import { Color4 } from "@babylonjs/core/Maths/math.color.js";
-import "@babylonjs/core/Misc/dds.js"; // Needed for environment map
-import { Scene } from "@babylonjs/core/scene.js";
-const DEFAULT_ENV_URL = "https://catalogueapi-demo.configura.com/envmap/default.env";
-export function getDefaultScene(engine, envUrl) {
-    const scene = new Scene(engine);
-    // If the alpha component of the clearColor is set to 0, then the color components MUST also be
-    // set to 0. Otherwise the color components will sneak into transparent objects in the scene.
-    //
-    // This is because WebGL uses premultiplied alpha colors by default. In premultiplied alpha the
-    // color components have already been multiplied by the alpha value, and "X * 0" is always
-    // zero, no matter what X is. A color like "1, 0, 0, 0" is thus not an valid premultiplied
-    // color and the results is per the WebGL specs undefined.
-    scene.clearColor = new Color4(0, 0, 0, 0).toLinearSpace();
-    const hdrTexture = CubeTexture.CreateFromPrefilteredData(envUrl || DEFAULT_ENV_URL, scene);
-    hdrTexture.gammaSpace = false;
-    scene.environmentTexture = hdrTexture;
-    scene.environmentIntensity = 0.55;
-    return scene;
-}
+import { CubeTexture } from "@babylonjs/core/Materials/Textures/cubeTexture.js";
+import "@babylonjs/core/Materials/Textures/Loaders/envTextureLoader.js"; // Needed for environment map
+import { Color4 } from "@babylonjs/core/Maths/math.color.js";
+import "@babylonjs/core/Misc/dds.js"; // Needed for environment map
+import { Scene } from "@babylonjs/core/scene.js";
+const DEFAULT_ENV_URL = "https://catalogueapi-demo.configura.com/envmap/default.env";
+export function getDefaultScene(engine, envUrl) {
+    const scene = new Scene(engine);
+    // If the alpha component of the clearColor is set to 0, then the color components MUST also be
+    // set to 0. Otherwise the color components will sneak into transparent objects in the scene.
+    //
+    // This is because WebGL uses premultiplied alpha colors by default. In premultiplied alpha the
+    // color components have already been multiplied by the alpha value, and "X * 0" is always
+    // zero, no matter what X is. A color like "1, 0, 0, 0" is thus not an valid premultiplied
+    // color and the results is per the WebGL specs undefined.
+    scene.clearColor = new Color4(0, 0, 0, 0).toLinearSpace();
+    const hdrTexture = CubeTexture.CreateFromPrefilteredData(envUrl || DEFAULT_ENV_URL, scene);
+    hdrTexture.gammaSpace = false;
+    scene.environmentTexture = hdrTexture;
+    scene.environmentIntensity = 0.55;
+    return scene;
+}

package/dist/utilities/CfgBoundingBox.d.ts

@@ -1,22 +1,22 @@
-import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-export declare class CfgBoundingBox {
-    minimum: Vector3;
-    maximum: Vector3;
-    constructor(minimum?: Vector3, maximum?: Vector3);
-    /**
-     * Means that the bounding box should be seen as "undefined", which is not the same as "zero"
-     */
-    private _isEmpty;
-    reConstruct(minimum: Vector3, maximum: Vector3): CfgBoundingBox;
-    copyFrom(source: CfgBoundingBox): CfgBoundingBox;
-    clone(): CfgBoundingBox;
-    get center(): Vector3;
-    translate(vec: Vector3): CfgBoundingBox;
-    expand(otherBoundingBox: CfgBoundingBox): CfgBoundingBox;
-    expandWithPoint(point: Vector3): CfgBoundingBox;
-    applyMatrix(matrix: Matrix): CfgBoundingBox;
-    get spaceDiagonal(): number;
-    get isEmpty(): boolean;
-    get corners(): Vector3[];
-}
+import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+export declare class CfgBoundingBox {
+    minimum: Vector3;
+    maximum: Vector3;
+    constructor(minimum?: Vector3, maximum?: Vector3);
+    /**
+     * Means that the bounding box should be seen as "undefined", which is not the same as "zero"
+     */
+    private _isEmpty;
+    reConstruct(minimum: Vector3, maximum: Vector3): CfgBoundingBox;
+    copyFrom(source: CfgBoundingBox): CfgBoundingBox;
+    clone(): CfgBoundingBox;
+    get center(): Vector3;
+    translate(vec: Vector3): CfgBoundingBox;
+    expand(otherBoundingBox: CfgBoundingBox): CfgBoundingBox;
+    expandWithPoint(point: Vector3): CfgBoundingBox;
+    applyMatrix(matrix: Matrix): CfgBoundingBox;
+    get spaceDiagonal(): number;
+    get isEmpty(): boolean;
+    get corners(): Vector3[];
+}
 //# sourceMappingURL=CfgBoundingBox.d.ts.map

package/dist/utilities/CfgBoundingBox.js

@@ -1,81 +1,81 @@
-import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-export class CfgBoundingBox {
-    constructor(minimum, maximum) {
-        /**
-         * Means that the bounding box should be seen as "undefined", which is not the same as "zero"
-         */
-        this._isEmpty = true;
-        this.minimum = (minimum === null || minimum === void 0 ? void 0 : minimum.clone()) || Vector3.Zero();
-        this.maximum = (maximum === null || maximum === void 0 ? void 0 : maximum.clone()) || Vector3.Zero();
-        this._isEmpty = minimum === undefined && maximum === undefined;
-    }
-    reConstruct(minimum, maximum) {
-        this.minimum.copyFrom(minimum);
-        this.maximum.copyFrom(maximum);
-        this._isEmpty = false;
-        return this;
-    }
-    copyFrom(source) {
-        this.reConstruct(source.minimum, source.maximum);
-        this._isEmpty = source.isEmpty;
-        return this;
-    }
-    clone() {
-        return new CfgBoundingBox(this.minimum, this.maximum);
-    }
-    get center() {
-        return Vector3.Center(this.minimum, this.maximum);
-    }
-    translate(vec) {
-        this.minimum.addInPlace(vec);
-        this.maximum.addInPlace(vec);
-        return this;
-    }
-    expand(otherBoundingBox) {
-        if (otherBoundingBox.isEmpty) {
-            return this;
-        }
-        if (this.isEmpty) {
-            this.reConstruct(otherBoundingBox.minimum, otherBoundingBox.maximum);
-            return this;
-        }
-        this.reConstruct(this.minimum.minimizeInPlace(otherBoundingBox.minimum), this.maximum.maximizeInPlace(otherBoundingBox.maximum));
-        return this;
-    }
-    expandWithPoint(point) {
-        if (this.isEmpty) {
-            this.reConstruct(point, point);
-            return this;
-        }
-        this.reConstruct(this.minimum.minimizeInPlace(point), this.maximum.maximizeInPlace(point));
-        return this;
-    }
-    applyMatrix(matrix) {
-        if (this.isEmpty) {
-            return this;
-        }
-        // Transform can be rotation, in which case we might need to re-minimize/maximize
-        const transformedMin = Vector3.TransformCoordinates(this.minimum, matrix);
-        const transformedMax = Vector3.TransformCoordinates(this.maximum, matrix);
-        this.reConstruct(transformedMin.clone().minimizeInPlace(transformedMax), transformedMax.maximizeInPlace(transformedMin));
-        return this;
-    }
-    get spaceDiagonal() {
-        if (this.isEmpty) {
-            return 0;
-        }
-        const minimum = this.minimum.asArray();
-        const maximum = this.maximum.asArray();
-        return Math.sqrt(minimum.reduce((a, c, i) => a + Math.pow(maximum[i] - c, 2)));
-    }
-    get isEmpty() {
-        return this._isEmpty;
-    }
-    get corners() {
-        const corners = [];
-        for (let a = 0; a < 8; a++) {
-            corners.push(new Vector3(((a & 1) === 0 ? this.minimum : this.maximum).x, ((a & 2) === 0 ? this.minimum : this.maximum).y, ((a & 4) === 0 ? this.minimum : this.maximum).z));
-        }
-        return corners;
-    }
-}
+import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+export class CfgBoundingBox {
+    constructor(minimum, maximum) {
+        /**
+         * Means that the bounding box should be seen as "undefined", which is not the same as "zero"
+         */
+        this._isEmpty = true;
+        this.minimum = (minimum === null || minimum === void 0 ? void 0 : minimum.clone()) || Vector3.Zero();
+        this.maximum = (maximum === null || maximum === void 0 ? void 0 : maximum.clone()) || Vector3.Zero();
+        this._isEmpty = minimum === undefined && maximum === undefined;
+    }
+    reConstruct(minimum, maximum) {
+        this.minimum.copyFrom(minimum);
+        this.maximum.copyFrom(maximum);
+        this._isEmpty = false;
+        return this;
+    }
+    copyFrom(source) {
+        this.reConstruct(source.minimum, source.maximum);
+        this._isEmpty = source.isEmpty;
+        return this;
+    }
+    clone() {
+        return new CfgBoundingBox(this.minimum, this.maximum);
+    }
+    get center() {
+        return Vector3.Center(this.minimum, this.maximum);
+    }
+    translate(vec) {
+        this.minimum.addInPlace(vec);
+        this.maximum.addInPlace(vec);
+        return this;
+    }
+    expand(otherBoundingBox) {
+        if (otherBoundingBox.isEmpty) {
+            return this;
+        }
+        if (this.isEmpty) {
+            this.reConstruct(otherBoundingBox.minimum, otherBoundingBox.maximum);
+            return this;
+        }
+        this.reConstruct(this.minimum.minimizeInPlace(otherBoundingBox.minimum), this.maximum.maximizeInPlace(otherBoundingBox.maximum));
+        return this;
+    }
+    expandWithPoint(point) {
+        if (this.isEmpty) {
+            this.reConstruct(point, point);
+            return this;
+        }
+        this.reConstruct(this.minimum.minimizeInPlace(point), this.maximum.maximizeInPlace(point));
+        return this;
+    }
+    applyMatrix(matrix) {
+        if (this.isEmpty) {
+            return this;
+        }
+        // Transform can be rotation, in which case we might need to re-minimize/maximize
+        const transformedMin = Vector3.TransformCoordinates(this.minimum, matrix);
+        const transformedMax = Vector3.TransformCoordinates(this.maximum, matrix);
+        this.reConstruct(transformedMin.clone().minimizeInPlace(transformedMax), transformedMax.maximizeInPlace(transformedMin));
+        return this;
+    }
+    get spaceDiagonal() {
+        if (this.isEmpty) {
+            return 0;
+        }
+        const minimum = this.minimum.asArray();
+        const maximum = this.maximum.asArray();
+        return Math.sqrt(minimum.reduce((a, c, i) => a + Math.pow(maximum[i] - c, 2)));
+    }
+    get isEmpty() {
+        return this._isEmpty;
+    }
+    get corners() {
+        const corners = [];
+        for (let a = 0; a < 8; a++) {
+            corners.push(new Vector3(((a & 1) === 0 ? this.minimum : this.maximum).x, ((a & 2) === 0 ? this.minimum : this.maximum).y, ((a & 4) === 0 ? this.minimum : this.maximum).z));
+        }
+        return corners;
+    }
+}

package/dist/utilities/anchor/anchor.d.ts

@@ -1,51 +1,51 @@
-import { Matrix, Vector3 } from "@babylonjs/core";
-import { DtoMeasureParam } from "@configura/web-api";
-import { CfgMeasureDefinition, CfgMeasurePriority } from "@configura/web-api/dist/CfgMeasure";
-import { CfgProductNode } from "../../nodes/CfgProductNode.js";
-import { CfgSymRootNode } from "../../nodes/CfgSymRootNode.js";
-export declare type CfgAnchorTargetNode = CfgSymRootNode;
-export declare type CfgAnchorableNode = CfgSymRootNode | CfgProductNode;
-export declare function nodeEqualsMeasurePriorityNodeReference(node: CfgAnchorTargetNode, ref: CfgMeasurePriority): boolean;
-/**
- * The measureParamCode points to Measures inside Models. A Model can be used multiple times in a Product.
- * More than one Model can use the same measureParamCode. Therefore what Measure an AnchorRef points to
- * can be ambiguous. To help resolve the ambiguities, an anchorRef can have measurePriorities that
- * governs which target it prefers to be anchored to.
- *
- * This method sorts the targets so that the highest priority (lowest index) one is first.
- * Sorting is done in place on the original array.
- */
-export declare const getAnchorTargetPriorityComparer: (measureDefinitions: CfgMeasureDefinition[]) => (measureParamCode: string, l: CfgAnchorTargetNode, r: CfgAnchorTargetNode) => number;
-/**
- * It might be possible in the future to anchor to other things than Measures (which are primarily)
- * used for stretch, but for now we can only support anchoring to the ends of a Measure.
- * toSp means anchor to start point, else end point.
- * The DtoMeasureParam class is used in several different contexts. To make the intent inside Stage
- * clear CfgAnchorRef exists, which including only what is relevant for when used for anchoring.
- */
-export declare class CfgAnchorRef {
-    readonly stretchSymNodeId: string;
-    readonly toSp: boolean;
-    static make(m: DtoMeasureParam | undefined): CfgAnchorRef | undefined;
-    /**
-     * The name stretchSymNodeId might seem confusing. And it is. Turns out CET is implemented so
-     * that it bases its anchoring on symNode Id containing the stretch. Not the measureParamId.
-     */
-    private constructor();
-    equal(other: CfgAnchorRef): boolean;
-}
-/** Gets the coordinates of the anchor point relative the anchor target. */
-export declare function getRawAnchorPoint(anchorTarget: CfgAnchorTargetNode | undefined, anchorRef: CfgAnchorRef | undefined): Vector3 | undefined;
-/**
- * Calculate a matrix which is the translation that makes a point move as if it was a child of
- * anchorTarget and then moved to the end of the anchorPoint.
- *
- * It is assumed that all anchoring happens on symRoot/additionalProduct-level and therefore all anchorees are
- * siblings to the anchorers.
- *
- * Application of anchoring happens from anchor tree root and out, so that originalMatrix of
- * anchorTarget will already have any anchoring and stretch applied.
- */
-export declare function getStretchedAnchorPointMatrix(anchorRef: CfgAnchorRef | undefined, anchorTarget: CfgAnchorTargetNode | undefined): Matrix | undefined;
-export declare function updatedStretchedAnchorPointMatrix(anchorRef: CfgAnchorRef | undefined, anchorTarget: CfgAnchorTargetNode | undefined, currentStretchedAnchorPointMatrix: Matrix | undefined): Matrix | undefined;
+import { Matrix, Vector3 } from "@babylonjs/core";
+import { DtoMeasureParam } from "@configura/web-api";
+import { CfgMeasureDefinition, CfgMeasurePriority } from "@configura/web-api/dist/CfgMeasure";
+import { CfgProductNode } from "../../nodes/CfgProductNode.js";
+import { CfgSymRootNode } from "../../nodes/CfgSymRootNode.js";
+export declare type CfgAnchorTargetNode = CfgSymRootNode;
+export declare type CfgAnchorableNode = CfgSymRootNode | CfgProductNode;
+export declare function nodeEqualsMeasurePriorityNodeReference(node: CfgAnchorTargetNode, ref: CfgMeasurePriority): boolean;
+/**
+ * The measureParamCode points to Measures inside Models. A Model can be used multiple times in a Product.
+ * More than one Model can use the same measureParamCode. Therefore what Measure an AnchorRef points to
+ * can be ambiguous. To help resolve the ambiguities, an anchorRef can have measurePriorities that
+ * governs which target it prefers to be anchored to.
+ *
+ * This method sorts the targets so that the highest priority (lowest index) one is first.
+ * Sorting is done in place on the original array.
+ */
+export declare const getAnchorTargetPriorityComparer: (measureDefinitions: CfgMeasureDefinition[]) => (measureParamCode: string, l: CfgAnchorTargetNode, r: CfgAnchorTargetNode) => number;
+/**
+ * It might be possible in the future to anchor to other things than Measures (which are primarily)
+ * used for stretch, but for now we can only support anchoring to the ends of a Measure.
+ * toSp means anchor to start point, else end point.
+ * The DtoMeasureParam class is used in several different contexts. To make the intent inside Stage
+ * clear CfgAnchorRef exists, which including only what is relevant for when used for anchoring.
+ */
+export declare class CfgAnchorRef {
+    readonly stretchSymNodeId: string;
+    readonly toSp: boolean;
+    static make(m: DtoMeasureParam | undefined): CfgAnchorRef | undefined;
+    /**
+     * The name stretchSymNodeId might seem confusing. And it is. Turns out CET is implemented so
+     * that it bases its anchoring on symNode Id containing the stretch. Not the measureParamId.
+     */
+    private constructor();
+    equal(other: CfgAnchorRef): boolean;
+}
+/** Gets the coordinates of the anchor point relative the anchor target. */
+export declare function getRawAnchorPoint(anchorTarget: CfgAnchorTargetNode | undefined, anchorRef: CfgAnchorRef | undefined): Vector3 | undefined;
+/**
+ * Calculate a matrix which is the translation that makes a point move as if it was a child of
+ * anchorTarget and then moved to the end of the anchorPoint.
+ *
+ * It is assumed that all anchoring happens on symRoot/additionalProduct-level and therefore all anchorees are
+ * siblings to the anchorers.
+ *
+ * Application of anchoring happens from anchor tree root and out, so that originalMatrix of
+ * anchorTarget will already have any anchoring and stretch applied.
+ */
+export declare function getStretchedAnchorPointMatrix(anchorRef: CfgAnchorRef | undefined, anchorTarget: CfgAnchorTargetNode | undefined): Matrix | undefined;
+export declare function updatedStretchedAnchorPointMatrix(anchorRef: CfgAnchorRef | undefined, anchorTarget: CfgAnchorTargetNode | undefined, currentStretchedAnchorPointMatrix: Matrix | undefined): Matrix | undefined;
 //# sourceMappingURL=anchor.d.ts.map