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

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/uvmapper/UVMapEnv.d.ts

@@ -1,20 +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);
-    private _hash;
-    get hash(): number;
-}
+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/uvmapper/UVMapEnv.js

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

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

@@ -1,94 +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");
-        }
-    }
-}
+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

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