@configura/web-core 1.3.0-alpha.1 → 1.3.0-alpha.5

package/dist/cm/core3D/uvmapper/UVMapperCylinder.js

@@ -0,0 +1,96 @@
+import { UVMapper } from "./UVMapper.js";
+/**
+ * This mapper gives bad results in the "seam" where the wrapped texture meet itself. If you have
+ * access to prebaked UVs then use those, and if you do stretch use the for stretched method with
+ * the prebaked UVS as a start point
+ */
+export function createUVCylinderCoordinates(env, positions, bounds, normals) {
+    return createUV(env, positions, bounds, normals, undefined, undefined, undefined);
+}
+export function createUVCylinderCoordinatesForStretched(env, positions, bounds, normals, refPositions, refBounds, refUvs) {
+    return createUV(env, positions, bounds, normals, refPositions, refBounds, refUvs);
+}
+function createUV(env, positions, bounds, normals, refPositions, refBounds, refUvs) {
+    const refPositionsFallbackToPositions = refPositions || positions;
+    const transforms = env === null || env === void 0 ? void 0 : env.transforms;
+    const transformSide = transforms === null || transforms === void 0 ? void 0 : transforms[0];
+    const transformTopBottom = transforms === null || transforms === void 0 ? void 0 : transforms[1];
+    const xyzCount = positions.length;
+    const vertexCount = xyzCount / 3;
+    if (refPositions !== undefined && refPositions.length !== xyzCount) {
+        throw new Error(`Position count differs: ${refPositions.length} vs ${xyzCount}.`);
+    }
+    if (normals.length !== xyzCount) {
+        throw new Error(`Normal count differs: ${normals.length} vs ${xyzCount}.`);
+    }
+    const { refMin, refSize, textureFixMin, textureFixMax } = UVMapper.calculateLimits(bounds, refBounds);
+    // This is what this entire method aims at populating
+    const newUvs = new Float32Array(vertexCount * 2);
+    for (let i = 0; i < vertexCount; i++) {
+        const xyzOffset = i * 3;
+        const uvOffset = i * 2;
+        if (normals[xyzOffset] === 0 &&
+            normals[xyzOffset + 1] === 0 &&
+            normals[xyzOffset + 2] !== 0) {
+            // This is Top / Bottom
+            let u = (positions[xyzOffset] - refMin[0]) / refSize[0];
+            let v = (positions[xyzOffset + 1] - refMin[1]) / refSize[1];
+            const isNegAxis = normals[xyzOffset + 2] < 0;
+            if (isNegAxis) {
+                // Weird irregularity in how mapping is done in CET
+                v -= 1;
+            }
+            if (refPositions !== undefined) {
+                u += textureFixMin[0];
+                if (isNegAxis) {
+                    v += textureFixMax[1];
+                }
+                else {
+                    v += textureFixMin[1];
+                }
+            }
+            if (transformTopBottom !== undefined) {
+                [u, v] = UVMapper.applyUvTransform([u, v], transformTopBottom);
+            }
+            newUvs[uvOffset] = u;
+            newUvs[uvOffset + 1] = v;
+        }
+        else {
+            // This is a Side
+            // It is very, very hard to make a full proper cylindrical stretching UV-mapper.
+            // For the seam to look sensible there has to be double (split) vertices. Model Lab does
+            // this for us when saving a CmSym file. However, this seam will move as we stretch,
+            // and there are no guarantees that it will be straight.
+            // As a compromise we stretch the top and bottom and height, but not the curved side.
+            // This should give good results for table tops, where the edge is often narrow and not
+            // very detailed, and for table legs (where the radius is fairly constant).
+            let u = Math.atan2(refPositionsFallbackToPositions[xyzOffset + 1], refPositionsFallbackToPositions[xyzOffset]) /
+                (Math.PI * 2) +
+                0.5;
+            let refUTest = u;
+            let v = (positions[xyzOffset + 2] - refMin[2]) / refSize[2];
+            // CET fixes texture to same corner when stretching. This code makes this work
+            if (refPositions !== undefined) {
+                v += textureFixMin[2];
+            }
+            if (transformSide !== undefined) {
+                [u, v] = UVMapper.applyUvTransform([u, v], transformSide);
+            }
+            if (refUvs !== undefined && refPositions !== undefined) {
+                // We need to find vertices that are at the seam. The seam where nodes are double
+                // so that texture mapping can be sharp. By compensating the difference between our
+                // equations and what Model Lab has calculated we can adjust our stretched
+                // coordinates.
+                let refVTest = (refPositions[xyzOffset + 2] - refMin[2]) / refSize[2];
+                if (transformSide !== undefined) {
+                    [refUTest, refVTest] = UVMapper.applyUvTransform([refUTest, refVTest], transformSide);
+                }
+                u -= refUTest - refUvs[uvOffset];
+                v -= refVTest - refUvs[uvOffset + 1];
+            }
+            newUvs[uvOffset] = u;
+            newUvs[uvOffset + 1] = v;
+        }
+    }
+    return newUvs;
+}

package/dist/cm/core3D/uvmapper/UVMapperPlane.d.ts

@@ -0,0 +1,4 @@
+import { UVMapEnv } from "./UVMapEnv.js";
+export declare function createUVPlaneCoordinates(env: UVMapEnv | undefined, positions: Float32Array): Float32Array;
+export declare function createUVPlaneCoordinatesForStretched(env: UVMapEnv | undefined, positions: Float32Array, refPositions: Float32Array): Float32Array;
+//# sourceMappingURL=UVMapperPlane.d.ts.map

package/dist/cm/core3D/uvmapper/UVMapperPlane.js

@@ -0,0 +1,84 @@
+import { UVMapper } from "./UVMapper.js";
+/**
+ * Calculate base vectors for the mapping plane where the first is orthogonal with the
+ * normal-vector and flat along the ground and the other is orthogonal to the first two.
+ */
+function calculateMappingPlaneVectors(normal) {
+    const [normalX, normalY, normalZ] = normal;
+    const normalLen = Math.sqrt(normalX * normalX + normalY * normalY + normalZ * normalZ);
+    // Probably already normalized, but just to be sure
+    const normalNormalized = normal.map((n) => n / normalLen);
+    if (normalNormalized[0] === 0 && normalNormalized[1] === 0 && normalNormalized[2] === 1) {
+        return [
+            [0, 1, 0],
+            [-1, 0, 0],
+        ];
+    }
+    const [normalNormalizedX, normalNormalizedY, normalNormalizedZ] = normalNormalized;
+    const base0Len = Math.sqrt(normalNormalizedX * normalNormalizedX + normalNormalizedY * normalNormalizedY);
+    // Along the ground (z is 0) as in CET
+    const base0 = [-normalNormalizedY / base0Len, normalNormalizedX / base0Len, 0];
+    const [base0X, base0Y, base0Z] = base0;
+    // Cross product, orthogonal to the plane normal and the "along the ground vector"
+    const base1 = [
+        normalNormalizedY * base0Z - normalNormalizedZ * base0Y,
+        normalNormalizedZ * base0X - normalNormalizedX * base0Z,
+        normalNormalizedX * base0Y - normalNormalizedY * base0X,
+    ];
+    return [base0, base1];
+}
+/** From a point over to the UV-coordinates by projecting */
+function toUv(point, mappingPlaneVectors) {
+    const [b0, b1] = mappingPlaneVectors;
+    const [x, y, z] = point;
+    return [b0[0] * x + b0[1] * y + b0[2] * z, b1[0] * x + b1[1] * y + b1[2] * z];
+}
+export function createUVPlaneCoordinates(env, positions) {
+    return createUV(env, positions, undefined);
+}
+export function createUVPlaneCoordinatesForStretched(env, positions, refPositions) {
+    return createUV(env, positions, refPositions);
+}
+function createUV(env, positions, refPositions) {
+    var _a;
+    if (env === undefined) {
+        throw new Error("env needed for plane mapper");
+    }
+    const xyzCount = positions.length;
+    const vertexCount = xyzCount / 3;
+    if (refPositions !== undefined && refPositions.length !== xyzCount) {
+        throw new Error(`Position count differs: ${refPositions.length} vs ${xyzCount}.`);
+    }
+    refPositions = refPositions || positions;
+    const normal = env.normal;
+    const transform = (_a = env.transforms) === null || _a === void 0 ? void 0 : _a[0];
+    const mappingPlaneVectors = calculateMappingPlaneVectors([normal.x, normal.y, normal.z]);
+    let refMinU = Number.POSITIVE_INFINITY;
+    let refMaxU = Number.NEGATIVE_INFINITY;
+    let refMinV = Number.POSITIVE_INFINITY;
+    let refMaxV = Number.NEGATIVE_INFINITY;
+    for (let i = 0; i < vertexCount; i++) {
+        const xyzOffset = i * 3;
+        const [u, v] = toUv([refPositions[xyzOffset], refPositions[xyzOffset + 1], refPositions[xyzOffset + 2]], mappingPlaneVectors);
+        refMinU = Math.min(refMinU, u);
+        refMaxU = Math.max(refMaxU, u);
+        refMinV = Math.min(refMinV, v);
+        refMaxV = Math.max(refMaxV, v);
+    }
+    const refSizeU = refMaxU - refMinU;
+    const refSizeV = refMaxV - refMinV;
+    const newUvs = new Float32Array(vertexCount * 2);
+    for (let i = 0; i < vertexCount; i++) {
+        const xyzOffset = i * 3;
+        const uvOffset = i * 2;
+        let [u, v] = toUv([positions[xyzOffset], positions[xyzOffset + 1], positions[xyzOffset + 2]], mappingPlaneVectors);
+        u = (u - refMinU) / refSizeU;
+        v = (v - refMinV) / refSizeV;
+        if (transform !== undefined) {
+            [u, v] = UVMapper.applyUvTransform([u, v], transform);
+        }
+        newUvs[uvOffset] = u;
+        newUvs[uvOffset + 1] = v;
+    }
+    return newUvs;
+}

package/dist/cm/core3D/uvmapper/UVTransformer.d.ts

@@ -0,0 +1,6 @@
+import { Transform2D } from "../../geometry/Transform2D.js";
+export declare class UVTransformer {
+    transform: Transform2D;
+    constructor(transform: Transform2D);
+}
+//# sourceMappingURL=UVTransformer.d.ts.map

package/dist/cm/core3D/uvmapper/instantiateUVMapper.d.ts

@@ -0,0 +1,4 @@
+import { Logger } from "@configura/web-utilities";
+import { UVMapper } from "./UVMapper.js";
+export declare function instantiateUVMapper(logger: Logger, className: string): UVMapper;
+//# sourceMappingURL=instantiateUVMapper.d.ts.map

package/dist/cm/core3D/uvmapper/instantiateUVMapper.js

@@ -0,0 +1,4 @@
+import { UVMapper } from "./UVMapper.js";
+export function instantiateUVMapper(logger, className) {
+    return new UVMapper();
+}

package/dist/cm/format/cmsym/SymNode.d.ts

@@ -7,7 +7,9 @@ import { DexObjKey, SymComponent, SymComponentKey } from "./components/SymCompon
 import { SymDexObj } from "./components/SymDexObj.js";
 import { SymGMaterial } from "./components/SymGMaterial.js";
 import { SymGMaterialSelector } from "./components/SymGMaterialSelector.js";
+import { SymMeasure } from "./components/SymMeasure.js";
 import { SymMesh } from "./components/SymMesh.js";
+import { SymPlane } from "./components/SymPlane.js";
 import { SymProps } from "./components/SymProps.js";
 import { SymReps } from "./components/SymReps.js";
 import { SymSphere } from "./components/SymSphere.js";
@@ -15,6 +17,7 @@ import { SymTags } from "./components/SymTags.js";
 import { SymTransform } from "./components/SymTransform.js";
 import { SymUVMapper } from "./components/SymUVMapper.js";
 import { SymImportEnv } from "./SymImportEnv.js";
+export declare const VERBOSE_SYM_LOGGING = false;
 export declare class SymNode {
     id: string;
     _children?: Map<string, SymNode>;
@@ -53,6 +56,8 @@ export declare class SymNode {
     symSphere(safe?: boolean): SymSphere | undefined;
     symBox(safe: true): SymBox;
     symBox(safe?: boolean): SymBox | undefined;
+    symPlane(safe: true): SymPlane;
+    symPlane(safe?: boolean): SymPlane | undefined;
     symProps(safe: true): SymProps;
     symProps(safe?: boolean): SymProps | undefined;
     symReps(safe: true): SymReps;
@@ -63,6 +68,9 @@ export declare class SymNode {
     symTransform(safe?: boolean): SymTransform | undefined;
     symUVMapper(safe: true): SymUVMapper;
     symUVMapper(safe?: boolean): SymUVMapper | undefined;
+    getMeasure(): SymMeasure | undefined;
+    private _isStretch;
+    isStretch(logger: Logger, detailLevel: DetailLevel): boolean;
     getComponent(key: SymComponentKey): SymComponent | undefined;
     addComponent(component: SymComponent, invalidate?: boolean): void;
     hasComponent(key: SymComponentKey | DexObjKey): boolean;

package/dist/cm/format/cmsym/SymNode.js

@@ -19,7 +19,9 @@ import { SymComponent } from "./components/SymComponent.js";
 import { SymDexObj } from "./components/SymDexObj.js";
 import { SymGMaterial } from "./components/SymGMaterial.js";
 import { SymGMaterialSelector } from "./components/SymGMaterialSelector.js";
+import { SymMeasure } from "./components/SymMeasure.js";
 import { SymMesh } from "./components/SymMesh.js";
+import { SymPlane } from "./components/SymPlane.js";
 import { SymProps, SYM_FEATURES_KEY, SYM_GEOMETRY_KEY, SYM_LOCAL_BOUND_KEY, SYM_NODE_KEY, SYM_STRUCTURAL_KEY, } from "./components/SymProps.js";
 import { SymReps } from "./components/SymReps.js";
 import { SymSphere } from "./components/SymSphere.js";
@@ -28,10 +30,15 @@ import { SymTransform } from "./components/SymTransform.js";
 import { SymUVMapper } from "./components/SymUVMapper.js";
 import { appendInvalidation, invalidate } from "./invalidation.js";
 import { SymImportEnv } from "./SymImportEnv.js";
+export const VERBOSE_SYM_LOGGING = false;
 export class SymNode {
     constructor(id) {
         this.id = id;
         this.components = new Map();
+        this._isStretch = new Map();
+        if (VERBOSE_SYM_LOGGING) {
+            console.log("SymNode: " + id);
+        }
     }
     setId(logger, newId) {
         if (this.id === newId) {
@@ -305,6 +312,17 @@ export class SymNode {
             return component;
         }
     }
+    symPlane(safe) {
+        const component = this.getComponent("symPlane");
+        if (component instanceof SymPlane) {
+            return component;
+        }
+        else if (safe) {
+            const component = new SymPlane();
+            this.addComponent(component);
+            return component;
+        }
+    }
     symProps(safe) {
         const component = this.getComponent("symProps");
         if (component instanceof SymProps) {
@@ -360,6 +378,20 @@ export class SymNode {
             return component;
         }
     }
+    getMeasure() {
+        const component = this.components.get("symMeasure");
+        if (component instanceof SymMeasure) {
+            return component;
+        }
+    }
+    isStretch(logger, detailLevel) {
+        let isStretch = this._isStretch.get(detailLevel);
+        if (isStretch === undefined) {
+            isStretch = symNodeIsStretch(logger, this, detailLevel);
+            this._isStretch.set(detailLevel, isStretch);
+        }
+        return isStretch;
+    }
     // Components
     getComponent(key) {
         return this.components.get(key);
@@ -545,6 +577,8 @@ function toSymXRefNode(_obj, _parent, _env, _putImportEnv = false) {
 function toSymFileRoot(logger, obj, parent) {
     const version = obj.get("version");
     const semver = loadVersion(version);
+    // Enable to get CmSym version statistics in the Exerciser
+    // logger.info("CmSym version " + semver.toDisplayString());
     const env = new SymImportEnv(semver);
     const sym = obj.get("sym");
     if (!(sym instanceof DexObj)) {
@@ -575,3 +609,44 @@ export function makeSymFromDex(logger, root) {
     node.ensureChildrenLoaded(logger);
     return node;
 }
+function symNodeIsStretch(logger, symNode, detailLevel) {
+    const symMeasure = symNode.getMeasure();
+    if (symMeasure === undefined) {
+        return false;
+    }
+    const children = symNode.children(logger, true, true);
+    let nodeName;
+    for (const [name, node] of children) {
+        if (name.startsWith("3D") || name.startsWith("2D")) {
+            const symReps = node.symReps(true);
+            const details = symReps._details;
+            if (details === undefined) {
+                continue;
+            }
+            const detailMask = details.values().next().value;
+            if (detailMask.includes(detailLevel)) {
+                nodeName = name;
+                break;
+            }
+        }
+    }
+    if (nodeName === undefined) {
+        logger.warn(`No 3D/2D SymNode which covers the detailLevel ${detailLevel} found`);
+        return false;
+    }
+    const node = children.get(nodeName);
+    if (node === undefined) {
+        return false;
+    }
+    const progsNode = node.components.get("symProgs");
+    if (progsNode === undefined) {
+        return false;
+    }
+    const symProgs = progsNode;
+    for (const prog of symProgs.progs) {
+        if (prog.isStretch) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/cm/format/cmsym/components/SymBox.d.ts

@@ -4,6 +4,7 @@ import { Point } from "../../../geometry/Point.js";
 import { DexObj } from "../../dex/DexObj.js";
 import { SymImportEnv } from "../SymImportEnv.js";
 import { SymComponent, SymComponentKey } from "./SymComponent.js";
+/** @see http://web.git.configura.com/webteam/docs/cmsym/#SymBox */
 export declare class SymBox extends SymComponent {
     private _box?;
     id: SymComponentKey;

package/dist/cm/format/cmsym/components/SymBox.js

@@ -1,8 +1,9 @@
 import { fcastNumber } from "../../../basic/number.js";
 import { Box } from "../../../geometry/Box.js";
 import { Point } from "../../../geometry/Point.js";
+import { VERBOSE_SYM_LOGGING } from "../SymNode.js";
 import { SymComponent } from "./SymComponent.js";
-/// http://web.git.configura.com/webteam/docs/cmsym/#SymBox
+/** @see http://web.git.configura.com/webteam/docs/cmsym/#SymBox */
 export class SymBox extends SymComponent {
     constructor(_box, src) {
         super(src);
@@ -21,14 +22,18 @@ export class SymBox extends SymComponent {
         const p0 = Point.cast(obj.get("p0"));
         const p1 = Point.cast(obj.get("p1"));
         if (p0 !== undefined && p1 !== undefined) {
-            // logger.info(`SymBox (<${p0.x},${p0.y},${p0.z}>, <${p1.x},${p1.y},${p1.z}>)`);
+            if (VERBOSE_SYM_LOGGING) {
+                logger.info(`SymBox (<${p0.x},${p0.y},${p0.z}>, <${p1.x},${p1.y},${p1.z}>)`);
+            }
             this._box = new Box(p0, p1);
             return;
         }
         const w = fcastNumber(obj.get("w"));
         const d = fcastNumber(obj.get("d"));
         const h = fcastNumber(obj.get("h"));
-        // logger.info(`SymBox (w ${w}, d ${d}, h ${h})`);
+        if (VERBOSE_SYM_LOGGING) {
+            logger.info(`SymBox (w ${w}, d ${d}, h ${h})`);
+        }
         this._box = new Box(new Point(0, 0, 0), new Point(w, d, h));
     }
 }

package/dist/cm/format/cmsym/components/SymGMaterialSelector.d.ts

@@ -4,6 +4,11 @@ import { DexObj } from "../../dex/DexObj.js";
 import { SymImportEnv } from "../SymImportEnv.js";
 import { SymComponent, SymComponentKey } from "./SymComponent.js";
 import { SymGMaterial } from "./SymGMaterial.js";
+/**
+ * The specification says that the last option is the default / fallback if there isn't any match
+ * among the layers, so we only load and use that one.
+ * @see http://web.git.configura.com/webteam/docs/cmsym/#SymGMaterialSelector
+ */
 export declare class SymGMaterialSelector extends SymComponent {
     id: SymComponentKey;
     gm?: GMaterial3D;

package/dist/cm/format/cmsym/components/SymGMaterialSelector.js

@@ -1,8 +1,10 @@
 import { SymComponent } from "./SymComponent.js";
 import { SymGMaterial } from "./SymGMaterial.js";
-/// The specification says that the last option is the default / fallback if there isn't any
-/// match among the layers, so we only load and use that one.
-/// http://web.git.configura.com/webteam/docs/cmsym/#SymGMaterialSelector
+/**
+ * The specification says that the last option is the default / fallback if there isn't any match
+ * among the layers, so we only load and use that one.
+ * @see http://web.git.configura.com/webteam/docs/cmsym/#SymGMaterialSelector
+ */
 export class SymGMaterialSelector extends SymComponent {
     constructor() {
         super(...arguments);

package/dist/cm/format/cmsym/components/SymMeasure.d.ts

@@ -1,9 +1,8 @@
 import { Logger } from "@configura/web-utilities";
 import { DexObj } from "../../dex/DexObj.js";
 import { SymImportEnv } from "../SymImportEnv.js";
-import { SymComponent, SymComponentKey } from "./SymComponent.js";
+import { SymComponent, SymComponentKey, SymGfxMode } from "./SymComponent.js";
 import { SymMultiSelector } from "./SymMultiSelector.js";
-import { SymRep } from "./SymRep.js";
 export declare class SymMeasure extends SymComponent {
     id: SymComponentKey;
     private _sections;
@@ -21,7 +20,7 @@ export declare class SymMeasure extends SymComponent {
     get dividerSubpaths(): SymMeasureDivider[];
 }
 export declare class SymMeasureDivider {
-    readonly repToPath: Map<SymRep, string>;
+    readonly repToPath: Map<string, string>;
     readonly currentStretch: number;
     constructor(obj: DexObj, logger: Logger);
 }
@@ -29,7 +28,7 @@ export declare class SymMeasureSection {
     readonly sizeChange: number;
     readonly move: boolean;
     readonly currentStretch: number;
-    readonly repToSelector: Map<SymRep, SymMultiSelector>;
+    readonly gfxModeToDetailLevelToMultiSelector: Map<SymGfxMode, Map<number, SymMultiSelector>>;
     constructor(obj: DexObj, logger: Logger);
 }
 //# sourceMappingURL=SymMeasure.d.ts.map

package/dist/cm/format/cmsym/components/SymMeasure.js

@@ -1,4 +1,5 @@
 import { DexObj } from "../../dex/DexObj.js";
+import { VERBOSE_SYM_LOGGING } from "../SymNode.js";
 import { SymComponent } from "./SymComponent.js";
 import { SymMultiSelector } from "./SymMultiSelector.js";
 import { SymRep } from "./SymRep.js";
@@ -43,17 +44,9 @@ export class SymMeasure extends SymComponent {
             }
             this._sections.push(new SymMeasureSection(section, logger));
         }
-        // logger.info(
-        // 	`SymMeasure`,
-        // 	`originalLength ${this.originalLength}`,
-        // 	`measureParam ${this.measureParam}`,
-        // 	`spOffsetParam ${this.spOffsetParam}`,
-        // 	`stretchingEPParam ${this._stretchingEPParam}`,
-        // 	"sections:",
-        // 	this.sections,
-        // 	"dividerSubpaths",
-        // 	this.dividerSubpaths
-        // );
+        if (VERBOSE_SYM_LOGGING) {
+            logger.info(`SymMeasure`, `originalLength ${this.originalLength}`, `measureParam ${this.measureParam}`, `spOffsetParam ${this.spOffsetParam}`, `stretchingEPParam ${this._stretchingEPParam}`, "sections:", this.sections, "dividerSubpaths", this.dividerSubpaths);
+        }
     }
     get measureParam() {
         return this._measureParam;
@@ -100,19 +93,16 @@ export class SymMeasureDivider {
                 logger.warn("SymMeasureDivider loading error", "SymRep or path not correct type");
                 continue;
             }
-            this.repToPath.set(symRep, path);
+            this.repToPath.set(JSON.stringify(symRep), path);
+        }
+        if (VERBOSE_SYM_LOGGING) {
+            logger.info(`SymMeasureDivider`, `currentStretch ${this.currentStretch}`, "repToPath:", this.repToPath);
         }
-        // logger.info(
-        // 	`SymMeasureDivider`,
-        // 	`currentStretch ${this.currentStretch}`,
-        // 	"repToPath:",
-        // 	this.repToPath
-        // );
     }
 }
 export class SymMeasureSection {
     constructor(obj, logger) {
-        this.repToSelector = new Map();
+        this.gfxModeToDetailLevelToMultiSelector = new Map();
         const sizeChange = obj.get("sizeChange");
         const move = obj.get("move");
         const currentStretch = obj.get("currentStretch");
@@ -139,20 +129,21 @@ export class SymMeasureSection {
                 continue;
             }
             const symRep = SymRep.load(rep);
-            const symMultiSelector = new SymMultiSelector(selector, logger);
             if (!(symRep instanceof SymRep)) {
                 logger.warn("SymMeasureSection loading error", "SymRep failed to load");
                 continue;
             }
-            this.repToSelector.set(symRep, symMultiSelector);
+            const { mode, detail } = symRep;
+            let detailLevelToMultiSelector = this.gfxModeToDetailLevelToMultiSelector.get(mode);
+            if (detailLevelToMultiSelector === undefined) {
+                detailLevelToMultiSelector = new Map();
+                this.gfxModeToDetailLevelToMultiSelector.set(mode, detailLevelToMultiSelector);
+            }
+            const symMultiSelector = new SymMultiSelector(selector, logger);
+            detailLevelToMultiSelector.set(detail, symMultiSelector);
+        }
+        if (VERBOSE_SYM_LOGGING) {
+            logger.info(`SymMeasureSection`, `sizeChange ${this.sizeChange}`, `move ${this.move}`, `currentStretch ${this.currentStretch}`, "repToSelector:", this.gfxModeToDetailLevelToMultiSelector);
         }
-        // logger.info(
-        // 	`SymMeasureSection`,
-        // 	`sizeChange ${this.sizeChange}`,
-        // 	`move ${this.move}`,
-        // 	`currentStretch ${this.currentStretch}`,
-        // 	"repToSelector:",
-        // 	this.repToSelector
-        // );
     }
 }

package/dist/cm/format/cmsym/components/SymMultiSelector.js

@@ -1,4 +1,5 @@
 import { DexObj } from "../../dex/DexObj.js";
+import { VERBOSE_SYM_LOGGING } from "../SymNode.js";
 export class SymMultiSelector {
     constructor(obj, logger) {
         this.selectors = [];
@@ -14,7 +15,9 @@ export class SymMultiSelector {
             }
             this.selectors.push(new SymDividerSelector(selector, logger));
         }
-        //logger.info(`SymMultiSelector`, "selectors:", this.selectors);
+        if (VERBOSE_SYM_LOGGING) {
+            logger.info(`SymMultiSelector`, "selectors:", this.selectors);
+        }
     }
 }
 export class SymDividerSelector {
@@ -38,12 +41,8 @@ export class SymDividerSelector {
         this.ownerId = ownerId;
         this.outside = outside;
         this.includes = includes;
-        // logger.info(
-        // 	`SymDividerSelector`,
-        // 	`dividerId ${this.dividerId}`,
-        // 	`ownerId ${this.ownerId}`,
-        // 	`outside ${this.outside}`,
-        // 	`includes ${this.includes}`
-        // );
+        if (VERBOSE_SYM_LOGGING) {
+            logger.info(`SymDividerSelector`, `dividerId ${this.dividerId}`, `ownerId ${this.ownerId}`, `outside ${this.outside}`, `includes ${this.includes}`);
+        }
     }
 }

package/dist/cm/format/cmsym/components/SymParams.d.ts

@@ -1,5 +1,17 @@
+import { Logger } from "@configura/web-utilities";
+import { DexObj } from "../../dex/DexObj.js";
+import { SymImportEnv } from "../SymImportEnv.js";
 import { SymComponent, SymComponentKey } from "./SymComponent.js";
 export declare class SymParams extends SymComponent {
     id: SymComponentKey;
+    private _params;
+    load(logger: Logger, obj: DexObj, _env: SymImportEnv, force?: boolean): undefined;
+    get params(): Map<string, ParamValue>;
+}
+export declare class ParamValue {
+    readonly progDependencies: Set<string>;
+    readonly value: number;
+    constructor(progDependencies: Set<string>, value: number);
+    static load(obj: DexObj, logger: Logger): ParamValue | undefined;
 }
 //# sourceMappingURL=SymParams.d.ts.map

package/dist/cm/format/cmsym/components/SymParams.js

@@ -1,7 +1,58 @@
+import { DexObj } from "../../dex/DexObj.js";
+import { VERBOSE_SYM_LOGGING } from "../SymNode.js";
 import { SymComponent } from "./SymComponent.js";
 export class SymParams extends SymComponent {
     constructor() {
         super(...arguments);
         this.id = "symParams";
+        this._params = new Map();
+    }
+    load(logger, obj, _env, force = false) {
+        if (obj.get("paramsTrie") !== undefined) {
+            // After some digging it appears that "paramsTrie" was dropped in CmSym 4.0.0 but there
+            // might still be CmSym files out there using it.
+            //
+            // It is however very unlikely that such files would be used in conjunction with
+            // Catalogue Stretch which is when we need the params, so it is only an "info".
+            logger.info("CmSym file contains an outdated and unsupported version of SymParams. It is advised to re-save the CmSym using a modern version of CET.", "CmSym version used: " + _env.fileVersion.toDisplayString());
+            return undefined;
+        }
+        const params = obj.get("params");
+        if (!(params instanceof DexObj)) {
+            logger.warn("SymParams loading error", "invalid properties");
+            return undefined;
+        }
+        for (const key of params.props.keys()) {
+            const dexParamValue = params.get(key);
+            if (!(dexParamValue instanceof DexObj)) {
+                continue;
+            }
+            const paramValue = ParamValue.load(dexParamValue, logger);
+            if (paramValue !== undefined) {
+                this._params.set(key, paramValue);
+            }
+        }
+        if (VERBOSE_SYM_LOGGING) {
+            logger.info(`SymParams`, "params", this.params);
+        }
+    }
+    get params() {
+        return this._params;
+    }
+}
+export class ParamValue {
+    constructor(progDependencies, value) {
+        this.progDependencies = new Set();
+        this.progDependencies = progDependencies;
+        this.value = value;
+    }
+    static load(obj, logger) {
+        const progDependencies = obj.get("progDependencies");
+        const value = obj.get("v");
+        if (!(progDependencies instanceof Set && typeof value === "number")) {
+            logger.warn("ParamValue loading error", "invalid properties");
+            return undefined;
+        }
+        return new this(progDependencies, value);
     }
 }