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

package/dist/cm/core3D/ATriMeshF.d.ts

@@ -50,7 +50,8 @@ export declare class ATriMeshF {
      */
     doubleSided: boolean;
     constructor(data: Uint8Array | undefined, lowerLeftTextureOrigin: boolean, doubleSided: boolean);
-    static createWithArrays(indices: Uint32Array, vertices: Float32Array, normals: Float32Array, uvs?: Float32Array, colors?: Float32Array, tangents?: Float32Array): ATriMeshF;
+    /** Creates and returns a new ATriMeshF with the mesh data supplied. */
+    static createWithArrays(indices: Uint32Array, vertices: Float32Array, normals?: Float32Array, uvs?: Float32Array, colors?: Float32Array, tangents?: Float32Array): ATriMeshF;
     get indices(): Uint32Array;
     get vertices(): Float32Array;
     get normals(): Float32Array;
@@ -81,6 +82,11 @@ export declare class ATriMeshF {
      * public geometry getters.
      */
     load(): void;
+    /**
+     * Calculates and sets tangent data if this ATriMeshF has normals but no gradient (constant) UV
+     * coordinates. Without this fix, shader calculations that depends on UV gradients can fail.
+     * This is only a workaround since a the tangent is not well defined without a UV gradient.
+     */
     private computeTangentsIfNeeded;
     hasNormals(): boolean;
     hasUVCoordinates(): boolean;

package/dist/cm/core3D/ATriMeshF.js

@@ -26,12 +26,14 @@ export class ATriMeshF {
         this._colors = new Float32Array(0);
         this._tangents = new Float32Array(0);
     }
-    /// Creates and returns a new ATriMeshF with the mesh data supplied.
+    /** Creates and returns a new ATriMeshF with the mesh data supplied. */
     static createWithArrays(indices, vertices, normals, uvs, colors, tangents) {
         const mesh = new ATriMeshF(undefined, false, false);
         mesh._indices = indices;
         mesh._vertices = vertices;
-        mesh._normals = normals;
+        if (normals !== undefined) {
+            mesh._normals = normals;
+        }
         if (uvs !== undefined) {
             mesh._uvs = uvs;
         }
@@ -129,9 +131,11 @@ export class ATriMeshF {
         // );
         this.computeTangentsIfNeeded();
     }
-    /// Calculates and sets tangent data if this ATriMeshF has normals but no gradient (constant)
-    /// UV coordinates. Without this fix, shader calculations that depends on UV gradients can fail.
-    /// This is only a workaround since a the tangent is not well defined without a UV gradient.
+    /**
+     * Calculates and sets tangent data if this ATriMeshF has normals but no gradient (constant) UV
+     * coordinates. Without this fix, shader calculations that depends on UV gradients can fail.
+     * This is only a workaround since a the tangent is not well defined without a UV gradient.
+     */
     computeTangentsIfNeeded() {
         if (this._uvs.length < 2 || this._normals.length < 3) {
             return;

package/dist/cm/core3D/GMaterial3D.d.ts

@@ -31,6 +31,7 @@ export declare const enum TextureType {
     pbrRefraction = "refraction",
     pbrRoughness = "roughness"
 }
+/** Common texture class used both by Classic and PBR GMaterials. */
 export declare class GMaterial3DTexture {
     readonly type: TextureType;
     constructor(type: TextureType);
@@ -39,13 +40,16 @@ export declare class GMaterial3DTexture {
     vScale: number;
     uOffset: number;
     vOffset: number;
+    /** Texture rotation in radians. */
     rot: number;
     wrapU: TextureWrap;
     wrapV: TextureWrap;
     minFilter: TextureFilter;
     magFilter: TextureFilter;
+    /** mipFilter is tristate. Also not (yet) included in the CmSym PBR specification. */
     mipFilter: TextureFilter | undefined;
 }
+/** Common settings for both Classic and PBR GMaterials. */
 export declare class GMaterial3D {
     materialKey?: string;
     doubleSided: boolean;

package/dist/cm/core3D/GMaterial3D.js

@@ -1,7 +1,7 @@
 import { DexObj } from "../format/dex/DexObj.js";
 import { DexURL } from "../format/dex/DexURL.js";
 import { DexXRef } from "../format/dex/DexXRef.js";
-/// Common texture class used both by Classic and PBR GMaterials
+/** Common texture class used both by Classic and PBR GMaterials. */
 export class GMaterial3DTexture {
     constructor(type) {
         this.type = type;
@@ -10,7 +10,7 @@ export class GMaterial3DTexture {
         this.vScale = 1;
         this.uOffset = 0;
         this.vOffset = 0;
-        /// Texture rotation in radians
+        /** Texture rotation in radians. */
         this.rot = 0;
         // Texture wrap modes
         this.wrapU = 0 /* repeat */;
@@ -18,11 +18,11 @@ export class GMaterial3DTexture {
         // Texture filtering. Default to trilinear.
         this.minFilter = 0 /* linear */;
         this.magFilter = 0 /* linear */;
-        /// mipFilter is tristate. Also not (yet) included in the CmSym PBR specification.
+        /** mipFilter is tristate. Also not (yet) included in the CmSym PBR specification. */
         this.mipFilter = 0 /* linear */;
     }
 }
-/// Common settings for both Classic and PBR GMaterials
+/** Common settings for both Classic and PBR GMaterials. */
 export class GMaterial3D {
     constructor(log, obj) {
         this.doubleSided = false;

package/dist/cm/core3D/GMaterialPBR.js

@@ -1,7 +1,7 @@
 import { ColorF } from "../basic/ColorF.js";
 import { DexObj } from "../format/dex/DexObj.js";
 import { AngleF } from "../geometry/AngleF.js";
-import { GMaterial3D, GMaterial3DTexture, imageUrlFromDex, textureWrapFromDex } from "./GMaterial3D.js";
+import { GMaterial3D, GMaterial3DTexture, imageUrlFromDex, textureWrapFromDex, } from "./GMaterial3D.js";
 // tslint:disable:max-classes-per-file
 export class GMaterialPBR extends GMaterial3D {
     constructor(log, obj) {
@@ -159,8 +159,10 @@ export class PBRRoughness {
         this.channel = channel;
     }
 }
-/// Loads and returns the specified texture. Returns undefined if the texture was not found (they
-/// are optional) or there was an problem loading the texture.
+/**
+ * Loads and returns the specified texture. Returns undefined if the texture was not found (they
+ * are optional) or there was an problem loading the texture.
+ */
 function loadTexture(log, type, dex) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j;
     const scope = type + ".texture";
@@ -201,8 +203,10 @@ function loadTexture(log, type, dex) {
     }
     return txt;
 }
-/// Loads and returns the TextureFilter specified by the name parameter.
-/// Returns undefined if the object was not found or not of the correct type.
+/**
+ * Loads and returns the TextureFilter specified by the name parameter.
+ * Returns undefined if the object was not found or not of the correct type.
+ */
 function loadTextureFilter(log, scope, dex, name) {
     const obj = dex.get(name);
     switch (obj) {
@@ -240,8 +244,10 @@ function loadChannels(log, scope, dex, name = "channels") {
     log.warn(`Channels property not valid (${scope}.${name}): ${obj}`);
     return undefined;
 }
-/// Loads and returns the number specified by the name parameter.
-/// Returns undefined if the object was not found or not of the correct type.
+/**
+ * Loads and returns the number specified by the name parameter.
+ * Returns undefined if the object was not found or not of the correct type.
+ */
 function loadNumber(log, scope, dex, name) {
     const obj = dex.get(name);
     if (obj !== undefined && typeof obj !== "number") {
@@ -250,8 +256,10 @@ function loadNumber(log, scope, dex, name) {
     }
     return obj;
 }
-/// Loads and returns the angle (in radians) specified by the name parameter.
-/// Returns undefined if the object was not found or not of the correct type.
+/**
+ * Loads and returns the angle (in radians) specified by the name parameter.
+ * Returns undefined if the object was not found or not of the correct type.
+ */
 function loadAngle(log, scope, dex, name) {
     const obj = dex.get(name);
     if (obj !== undefined && !(obj instanceof AngleF)) {
@@ -260,8 +268,10 @@ function loadAngle(log, scope, dex, name) {
     }
     return obj === null || obj === void 0 ? void 0 : obj.radians;
 }
-/// Loads and returns the ColorF specified by the name parameter.
-/// Returns <1,1,1,1> if the object was not found or not of the correct type.
+/**
+ * Loads and returns the ColorF specified by the name parameter.
+ * Returns <1,1,1,1> if the object was not found or not of the correct type.
+ */
 function loadColorF(log, scope, dex, name) {
     const obj = dex.get(name);
     if (!(obj instanceof ColorF)) {
@@ -272,8 +282,10 @@ function loadColorF(log, scope, dex, name) {
     }
     return obj;
 }
-/// Loads and returns the PBROpacityMode mode.
-/// Returns "opaque" if the object was not found or not of the correct type.
+/**
+ * Loads and returns the PBROpacityMode mode.
+ * Returns "opaque" if the object was not found or not of the correct type.
+ */
 function loadOpacityMode(log, scope, dex) {
     const obj = dex.get("mode");
     switch (obj) {

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

@@ -1,4 +1,4 @@
-import { Point } from "../geometry/Point.js";
+import { Point } from "../../geometry/Point.js";
 import { UVTransformer } from "./UVTransformer.js";
 export declare enum UVMapperType {
     Box = 0,
@@ -14,5 +14,7 @@ export declare class UVMapEnv {
     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,4 +1,5 @@
-import { Point } from "../geometry/Point.js";
+import { hashCode } from "@configura/web-utilities";
+import { Point } from "../../geometry/Point.js";
 export var UVMapperType;
 (function (UVMapperType) {
     UVMapperType[UVMapperType["Box"] = 0] = "Box";
@@ -32,4 +33,15 @@ export class UVMapEnv {
         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