@configura/web-core 2.1.0-alpha.2 → 2.1.0-alpha.3

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

@@ -1,181 +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;
-}
+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

@@ -1,10 +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;
+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

@@ -1,96 +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;
-}
+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

@@ -1,4 +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;
+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