@configura/web-core 1.3.0-alpha.3 → 1.3.0

package/dist/cm/core3D/MultiGMaterial3D.js

@@ -1,17 +1,17 @@
-export class MultiGMaterial3D {
-    constructor(materialMap = new Map(), realtimeMaterial3D, renderMaterial3D) {
-        this.materialMap = materialMap;
-        if (realtimeMaterial3D !== undefined) {
-            this.materialMap.set("medium", realtimeMaterial3D);
-        }
-        if (renderMaterial3D !== undefined) {
-            this.materialMap.set("super", renderMaterial3D);
-        }
-    }
-    realtimeMaterial() {
-        return this.materialMap.get("medium");
-    }
-    renderMaterial() {
-        return this.materialMap.get("super");
-    }
-}
+export class MultiGMaterial3D {
+    constructor(materialMap = new Map(), realtimeMaterial3D, renderMaterial3D) {
+        this.materialMap = materialMap;
+        if (realtimeMaterial3D !== undefined) {
+            this.materialMap.set("medium", realtimeMaterial3D);
+        }
+        if (renderMaterial3D !== undefined) {
+            this.materialMap.set("super", renderMaterial3D);
+        }
+    }
+    realtimeMaterial() {
+        return this.materialMap.get("medium");
+    }
+    renderMaterial() {
+        return this.materialMap.get("super");
+    }
+}

package/dist/cm/core3D/{UVMapEnv.d.ts → uvmapper/UVMapEnv.d.ts}

@@ -1,18 +1,20 @@
-import { Point } from "../geometry/Point.js";
-import { UVTransformer } from "./UVTransformer.js";
-export declare enum UVMapperType {
-    Box = 0,
-    Spherical = 1,
-    Planar = 2,
-    Cylindrical = 3
-}
-export declare function castUVMapperType(name: string): UVMapperType | undefined;
-export declare function fcastUVMapperType(name: string): UVMapperType;
-export declare class UVMapEnv {
-    type: UVMapperType;
-    transforms?: UVTransformer[] | undefined;
-    normal: Point;
-    uniform: boolean;
-    constructor(type: UVMapperType, transforms?: UVTransformer[] | undefined, normal?: Point, uniform?: boolean);
-}
+import { Point } from "../../geometry/Point.js";
+import { UVTransformer } from "./UVTransformer.js";
+export declare enum UVMapperType {
+    Box = 0,
+    Spherical = 1,
+    Planar = 2,
+    Cylindrical = 3
+}
+export declare function castUVMapperType(name: string): UVMapperType | undefined;
+export declare function fcastUVMapperType(name: string): UVMapperType;
+export declare class UVMapEnv {
+    type: UVMapperType;
+    transforms?: UVTransformer[] | undefined;
+    normal: Point;
+    uniform: boolean;
+    constructor(type: UVMapperType, transforms?: UVTransformer[] | undefined, normal?: Point, uniform?: boolean);
+    private _hash;
+    get hash(): number;
+}
 //# sourceMappingURL=UVMapEnv.d.ts.map

package/dist/cm/core3D/{UVMapEnv.js → uvmapper/UVMapEnv.js}

@@ -1,35 +1,47 @@
-import { Point } from "../geometry/Point.js";
-export var UVMapperType;
-(function (UVMapperType) {
-    UVMapperType[UVMapperType["Box"] = 0] = "Box";
-    UVMapperType[UVMapperType["Spherical"] = 1] = "Spherical";
-    UVMapperType[UVMapperType["Planar"] = 2] = "Planar";
-    UVMapperType[UVMapperType["Cylindrical"] = 3] = "Cylindrical";
-})(UVMapperType || (UVMapperType = {}));
-export function castUVMapperType(name) {
-    switch (name) {
-        case "box":
-            return UVMapperType.Box;
-        case "spherical":
-            return UVMapperType.Spherical;
-        case "planar":
-            return UVMapperType.Planar;
-        case "cylindrical":
-            return UVMapperType.Cylindrical;
-    }
-}
-export function fcastUVMapperType(name) {
-    const type = castUVMapperType(name);
-    if (type === undefined) {
-        throw new Error(`unknown UVMapperType: ${name}`);
-    }
-    return type;
-}
-export class UVMapEnv {
-    constructor(type, transforms, normal = new Point(0, 0, 0), uniform = true) {
-        this.type = type;
-        this.transforms = transforms;
-        this.normal = normal;
-        this.uniform = uniform;
-    }
-}
+import { hashCode } from "@configura/web-utilities";
+import { Point } from "../../geometry/Point.js";
+export var UVMapperType;
+(function (UVMapperType) {
+    UVMapperType[UVMapperType["Box"] = 0] = "Box";
+    UVMapperType[UVMapperType["Spherical"] = 1] = "Spherical";
+    UVMapperType[UVMapperType["Planar"] = 2] = "Planar";
+    UVMapperType[UVMapperType["Cylindrical"] = 3] = "Cylindrical";
+})(UVMapperType || (UVMapperType = {}));
+export function castUVMapperType(name) {
+    switch (name) {
+        case "box":
+            return UVMapperType.Box;
+        case "spherical":
+            return UVMapperType.Spherical;
+        case "planar":
+            return UVMapperType.Planar;
+        case "cylindrical":
+            return UVMapperType.Cylindrical;
+    }
+}
+export function fcastUVMapperType(name) {
+    const type = castUVMapperType(name);
+    if (type === undefined) {
+        throw new Error(`unknown UVMapperType: ${name}`);
+    }
+    return type;
+}
+export class UVMapEnv {
+    constructor(type, transforms, normal = new Point(0, 0, 0), uniform = true) {
+        this.type = type;
+        this.transforms = transforms;
+        this.normal = normal;
+        this.uniform = uniform;
+    }
+    get hash() {
+        if (this._hash === undefined) {
+            this._hash = hashCode(`ty${this.type}-tr${(this.transforms || [])
+                .map((t) => {
+                const { pos, mapping } = t.transform;
+                return `po${pos.toString()}-ma${mapping.toString()}`;
+            })
+                .join("-")}-no${this.normal.toString()}-un${this.uniform}`);
+        }
+        return this._hash;
+    }
+}

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

@@ -0,0 +1,42 @@
+import { Logger } from "@configura/web-utilities";
+import { UVMapEnv } from "./UVMapEnv.js";
+import { UVTransformer } from "./UVTransformer.js";
+export declare type MinMaxSize = {
+    min: number[];
+    max: number[];
+    size: number[];
+};
+export declare class UVMapper {
+    env?: UVMapEnv | undefined;
+    /**
+     * Applies linear transformations to the UV-coordinates. This is essentially rotating, scaling
+     * moving the texture before applying it.
+     */
+    static applyUvTransform(uv: [number, number], t: UVTransformer): [number, number];
+    static calculateLimits(bounds: MinMaxSize, refBounds: MinMaxSize | undefined): {
+        refMin: number[];
+        refSize: number[];
+        textureFixMin: number[];
+        textureFixMax: number[];
+    };
+    static calculateTextureFixLimits(bounds: MinMaxSize, refBounds: MinMaxSize): {
+        min: number[];
+        max: number[];
+    };
+    constructor(env?: UVMapEnv | undefined);
+    /**
+     * Do not use this method if you have prebaked coordinates in the CmSym file generated by CET.
+     * It is safer to use the existing ones since CET has already modified the geometry of the
+     * mesh by splitting vertices etc.
+     */
+    createUVCoordinates(logger: Logger, positions: Float32Array, bounds: MinMaxSize, normals: Float32Array): Float32Array;
+    /**
+     * @param positions Stretched positions
+     * @param normals Used both for stretched and non-stretched. We cheat a bit by always using the same normals
+     * @param refPositions Non-stretched positions
+     * @param refUvs Non-stretched UV coordinates
+     * @returns
+     */
+    createUVCoordinatesForStretched(logger: Logger, positions: Float32Array, bounds: MinMaxSize, normals: Float32Array, refPositions: Float32Array, refBounds: MinMaxSize, refUvs: Float32Array): Float32Array;
+}
+//# sourceMappingURL=UVMapper.d.ts.map

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

@@ -0,0 +1,94 @@
+import { UVMapperType } from "./UVMapEnv.js";
+import { createUVBoxCoordinates, createUVBoxCoordinatesForStretched } from "./UVMapperBox.js";
+import { createUVCylinderCoordinates, createUVCylinderCoordinatesForStretched, } from "./UVMapperCylinder.js";
+import { createUVPlaneCoordinates, createUVPlaneCoordinatesForStretched } from "./UVMapperPlane.js";
+const xyz = [0, 1, 2];
+export class UVMapper {
+    constructor(env) {
+        this.env = env;
+    }
+    /**
+     * Applies linear transformations to the UV-coordinates. This is essentially rotating, scaling
+     * moving the texture before applying it.
+     */
+    static applyUvTransform(uv, t) {
+        const { mapping, pos } = t.transform;
+        const [u, v] = uv;
+        const { x, y } = pos;
+        let uNew = u;
+        let vNew = v;
+        const { c0, c1 } = mapping;
+        uNew = c0.x * u + c1.x * v;
+        vNew = c0.y * u + c1.y * v;
+        uNew += x;
+        vNew += y;
+        return [uNew, vNew];
+    }
+    static calculateLimits(bounds, refBounds) {
+        const { min: refMin, size: refSize } = refBounds || bounds;
+        const { min: textureFixMin, max: textureFixMax } = refBounds === undefined
+            ? { min: [0, 0, 0], max: [0, 0, 0] }
+            : UVMapper.calculateTextureFixLimits(bounds, refBounds);
+        return {
+            refMin,
+            refSize,
+            textureFixMin,
+            textureFixMax,
+        };
+    }
+    static calculateTextureFixLimits(bounds, refBounds) {
+        return {
+            min: xyz.map((axis) => (refBounds.min[axis] - bounds.min[axis]) / refBounds.size[axis]),
+            max: xyz.map((axis) => (refBounds.max[axis] - bounds.max[axis]) / refBounds.size[axis]),
+        };
+    }
+    /**
+     * Do not use this method if you have prebaked coordinates in the CmSym file generated by CET.
+     * It is safer to use the existing ones since CET has already modified the geometry of the
+     * mesh by splitting vertices etc.
+     */
+    createUVCoordinates(logger, positions, bounds, normals) {
+        const env = this.env;
+        if (env === undefined) {
+            throw new Error("No UV mapping env");
+        }
+        switch (env.type) {
+            case UVMapperType.Box:
+                return createUVBoxCoordinates(env, positions, bounds, normals);
+            case UVMapperType.Planar:
+                return createUVPlaneCoordinates(env, positions);
+            case UVMapperType.Cylindrical:
+                return createUVCylinderCoordinates(env, positions, bounds, normals);
+            case UVMapperType.Spherical:
+                throw logger.errorAsObject(`Unsupported UV-mapper: ${env.type} (Spherical)`);
+            default:
+                throw logger.errorAsObject("Unknown UV-mapper: " + env.type);
+        }
+    }
+    /**
+     * @param positions Stretched positions
+     * @param normals Used both for stretched and non-stretched. We cheat a bit by always using the same normals
+     * @param refPositions Non-stretched positions
+     * @param refUvs Non-stretched UV coordinates
+     * @returns
+     */
+    createUVCoordinatesForStretched(logger, positions, bounds, normals, refPositions, refBounds, refUvs) {
+        const env = this.env;
+        if (env === undefined) {
+            throw new Error("No mapping env");
+        }
+        switch (env.type) {
+            case UVMapperType.Box:
+                return createUVBoxCoordinatesForStretched(env, positions, bounds, normals, refPositions, refBounds, refUvs);
+            case UVMapperType.Planar:
+                return createUVPlaneCoordinatesForStretched(env, positions, refPositions);
+            case UVMapperType.Cylindrical:
+                return createUVCylinderCoordinatesForStretched(env, positions, bounds, normals, refPositions, refBounds, refUvs);
+            case UVMapperType.Spherical:
+                logger.warn("Spherical mapping is not implemented for stretch. Original UV-coordinates will be used.");
+                return refUvs;
+            default:
+                throw logger.errorAsObject("Unknown UV-mapper");
+        }
+    }
+}

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

@@ -0,0 +1,5 @@
+import { UVMapEnv } from "./UVMapEnv.js";
+import { MinMaxSize } from "./UVMapper.js";
+export declare function createUVBoxCoordinates(env: UVMapEnv | undefined, positions: Float32Array, bounds: MinMaxSize, normals: Float32Array): Float32Array;
+export declare function createUVBoxCoordinatesForStretched(env: UVMapEnv | undefined, positions: Float32Array, bounds: MinMaxSize, normals: Float32Array, refPositions: Float32Array, refBounds: MinMaxSize, refUvs: Float32Array): Float32Array;
+//# sourceMappingURL=UVMapperBox.d.ts.map

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

@@ -0,0 +1,181 @@
+import { UVMapper } from "./UVMapper.js";
+const XYZ = [0, 1, 2];
+const X = 0, Y = 1, Z = 2;
+const toSide = (axis, negAxis) => axis * 2 + (negAxis ? 1 : 0);
+const toAxisAndIsNeg = (side) => [Math.trunc(side / 2), side % 2 === 1];
+/**
+ * This simulates how CET maps xyz-coordinates to uv-coordinates. On certain axis the mapping is
+ * flipped, this is handled here.
+ */
+function uvFromXyz(axis, negAxis, xyz) {
+    let u = axis === X ? xyz[1] : xyz[0];
+    let v = axis === Z ? xyz[1] : xyz[2];
+    if ((axis === X && negAxis) || (axis === Y && !negAxis)) {
+        u = 1 - u;
+    }
+    if (axis === Z && negAxis) {
+        v = 1 - v;
+    }
+    return [u, v];
+}
+/**
+ * The recommended method for calculating what side vertices belong to. It uses already calculated
+ * UVs to and as such is useful when doing stretch. If you do not do stretch you don't need to use
+ * this mapper at all. Just use the existing UVs.
+ */
+function calculateSideMapFromRefUvs(transforms, normals, refPositions, refBounds, refUvs) {
+    const vertexCount = refPositions.length / 3;
+    const { min: refMin, size: refSize } = refBounds;
+    const sideMap = new Uint8Array(vertexCount);
+    for (let i = 0; i < vertexCount; i++) {
+        const xyzOffset = i * 3;
+        const uvOffset = i * 2;
+        // Texture is applied as if the image texture was stretched to fit each side of the "cube"
+        const refNormalized = XYZ.map((axis) => (refPositions[xyzOffset + axis] - refMin[axis]) / refSize[axis]);
+        const refU = refUvs[uvOffset];
+        const refV = refUvs[uvOffset + 1];
+        // We aim at finding what side of the cube this vertex shall be textured from.
+        // We do this by in turn testing what UV-values we would get for non-stretched
+        // data and selecting the one which is the closest.
+        let diffOnLatestCandidate = Number.POSITIVE_INFINITY;
+        let normalComponentAbsOnLatestCandidate = 0;
+        let selectedSide;
+        for (let axis = 0; axis < 3; axis++) {
+            const normalComponent = normals[xyzOffset + axis];
+            const normalComponentAbs = Math.abs(normalComponent);
+            const negAxis = normalComponent < 0;
+            let [u, v] = uvFromXyz(axis, negAxis, refNormalized);
+            if (transforms !== undefined) {
+                [u, v] = UVMapper.applyUvTransform([u, v], transforms[axis]);
+            }
+            // How far off are we from the reference UV-coordinates?
+            const diffOnCandidate = Math.abs(refU - u) + Math.abs(refV - v);
+            // Here we need a lite extra care. For highly regular shapes, such as a cube it is very
+            // likely we will end up in a situation where the "pick best UV-match" approach does
+            // not work. You can imagine this as the same "color" touching the same corner from
+            // more than one side. In this case we also need to take the normals into account.
+            //
+            // For highly irregular shapes it is more unlikely that the texture coordinates will be
+            // identical, and if they are the high polygon count on such a model is likely to mask
+            // the error.
+            //
+            // The factors below are a bit arbitrarily chosen. They might need to be tweaked.
+            if (diffOnLatestCandidate - diffOnCandidate > 0.01 ||
+                normalComponentAbs - normalComponentAbsOnLatestCandidate > 0.9) {
+                selectedSide = toSide(axis, negAxis);
+                diffOnLatestCandidate = diffOnCandidate;
+                normalComponentAbsOnLatestCandidate = normalComponentAbs;
+            }
+        }
+        if (selectedSide === undefined) {
+            throw new Error("Unexpected error when calculating UV side mapping");
+        }
+        sideMap[i] = selectedSide;
+    }
+    return sideMap;
+}
+/**
+ * Fallback method of calculating what side a vertex belongs to in cases where you have no refUvs.
+ * It will give bad results in the boundary areas where mapping from different sides meet.
+ *
+ * WARNING: Only use it if you have no refUvs.
+ */
+function calculateSideMapFromNormals(normals) {
+    const vertexCount = normals.length / 3;
+    const sideMap = new Uint8Array(vertexCount);
+    for (let i = 0; i < vertexCount; i++) {
+        const xyzOffset = i * 3;
+        const normalX = normals[xyzOffset];
+        const normalY = normals[xyzOffset + 1];
+        const normalZ = normals[xyzOffset + 2];
+        if (Math.abs(normalY) < Math.abs(normalX) && Math.abs(normalZ) < Math.abs(normalX)) {
+            sideMap[i] = toSide(0, normalX < 0);
+            continue;
+        }
+        if (Math.abs(normalZ) < Math.abs(normalY)) {
+            sideMap[i] = toSide(1, normalY < 0);
+            continue;
+        }
+        sideMap[i] = toSide(2, normalZ < 0);
+    }
+    return sideMap;
+}
+export function createUVBoxCoordinates(env, positions, bounds, normals) {
+    if (normals.length !== positions.length) {
+        throw new Error("Normals are wrong count");
+    }
+    return createUV(env, positions, bounds, undefined, calculateSideMapFromNormals(normals));
+}
+export function createUVBoxCoordinatesForStretched(env, positions, bounds, normals, refPositions, refBounds, refUvs) {
+    const transforms = env === null || env === void 0 ? void 0 : env.transforms;
+    const xyzCount = positions.length;
+    const vertexCount = xyzCount / 3;
+    const uvCount = vertexCount * 2;
+    if (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}.`);
+    }
+    if (refUvs.length !== uvCount) {
+        throw new Error(`UV count differs: ${uvCount} vs ${refUvs.length}.`);
+    }
+    return createUV(env, positions, bounds, refBounds, calculateSideMapFromRefUvs(transforms, normals, refPositions, refBounds, refUvs));
+}
+function createUV(env, positions, bounds, refBounds, sideMap) {
+    const transforms = env === null || env === void 0 ? void 0 : env.transforms;
+    const xyzCount = positions.length;
+    const vertexCount = xyzCount / 3;
+    const uvCount = vertexCount * 2;
+    const { refMin, refSize, textureFixMin, textureFixMax } = UVMapper.calculateLimits(bounds, refBounds);
+    // This is what this entire method aims at populating
+    const newUvs = new Float32Array(uvCount);
+    for (let i = 0; i < vertexCount; i++) {
+        const xyzOffset = i * 3;
+        const uvOffset = i * 2;
+        // We normalize using the ref-sizes as we want the texture to tile. Normalizing to the
+        // stretched positions would make it just stretch (and defeat the entire purpose)
+        const normalized = XYZ.map((axis) => (positions[xyzOffset + axis] - refMin[axis]) / refSize[axis]);
+        const [axis, isNegAxis] = toAxisAndIsNeg(sideMap[i]);
+        let [u, v] = uvFromXyz(axis, isNegAxis, normalized);
+        // CET uses different texture origins for different sides of the cube, which makes it look
+        // like the texture "moves with" the stretch direction on some sides and stays in place on
+        // some sides.
+        //
+        // The code below emulates the CET behavior even though it can be argued that it is neither
+        // expected nor "correct".
+        if (axis === 0) {
+            if (isNegAxis) {
+                u -= textureFixMax[1];
+            }
+            else {
+                u += textureFixMin[1];
+            }
+            v += textureFixMin[2];
+        }
+        else if (axis === 1) {
+            if (isNegAxis) {
+                u += textureFixMin[0];
+            }
+            else {
+                u -= textureFixMax[0];
+            }
+            v += textureFixMin[2];
+        }
+        else {
+            u += textureFixMin[0];
+            if (isNegAxis) {
+                v -= textureFixMax[1];
+            }
+            else {
+                v += textureFixMin[1];
+            }
+        }
+        if (transforms !== undefined) {
+            [u, v] = UVMapper.applyUvTransform([u, v], transforms[axis]);
+        }
+        newUvs[uvOffset] = u;
+        newUvs[uvOffset + 1] = v;
+    }
+    return newUvs;
+}

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

@@ -0,0 +1,10 @@
+import { UVMapEnv } from "./UVMapEnv.js";
+import { MinMaxSize } 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 declare function createUVCylinderCoordinates(env: UVMapEnv | undefined, positions: Float32Array, bounds: MinMaxSize, normals: Float32Array): Float32Array;
+export declare function createUVCylinderCoordinatesForStretched(env: UVMapEnv | undefined, positions: Float32Array, bounds: MinMaxSize, normals: Float32Array, refPositions: Float32Array, refBounds: MinMaxSize, refUvs: Float32Array): Float32Array;
+//# sourceMappingURL=UVMapperCylinder.d.ts.map

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