@configura/babylon-view 2.1.0 → 2.2.0-alpha.1

package/dist/material/DummyMaterialCreator.d.ts

@@ -1,5 +1,5 @@
-import { Scene } from "@babylonjs/core/scene.js";
-import { CfgMaterial } from "./CfgMaterial.js";
-export declare type DummyMaterialCreator = (scene: Scene, maxSimultaneousLights: number, color?: number) => CfgMaterial;
-export declare function defaultDummyMaterialCreator(scene: Scene, maxSimultaneousLights: number, color?: number): CfgMaterial;
+import { Scene } from "@babylonjs/core/scene.js";
+import { CfgMaterial } from "./CfgMaterial.js";
+export declare type DummyMaterialCreator = (scene: Scene, maxSimultaneousLights: number, color?: number) => CfgMaterial;
+export declare function defaultDummyMaterialCreator(scene: Scene, maxSimultaneousLights: number, color?: number): CfgMaterial;
 //# sourceMappingURL=DummyMaterialCreator.d.ts.map

package/dist/material/DummyMaterialCreator.js

@@ -1,15 +1,15 @@
-import { PBRMaterial } from "@babylonjs/core/Materials/PBR/pbrMaterial.js";
-import { toColor3 } from "../utilities/utilitiesColor.js";
-import { CfgMaterial, makeMaterialDoubleSided } from "./CfgMaterial.js";
-export function defaultDummyMaterialCreator(scene, maxSimultaneousLights, color) {
-    const material = new PBRMaterial("Dummy Material", scene);
-    material.albedoColor = toColor3(color === undefined ? 0xb5b5b5 : color).toLinearSpace();
-    material.roughness = 1;
-    // For a rather nice x-ray version during loading, enable the settings below
-    // material.alpha = 0.2;
-    // material.transparencyMode = PBRMaterial.PBRMATERIAL_ALPHABLEND;
-    // material.disableDepthWrite = true;
-    // material.separateCullingPass = true;
-    makeMaterialDoubleSided(material, true); // Double sided improved mesh compatibility
-    return new CfgMaterial(material, maxSimultaneousLights);
-}
+import { PBRMaterial } from "@babylonjs/core/Materials/PBR/pbrMaterial.js";
+import { toColor3 } from "../utilities/utilitiesColor.js";
+import { CfgMaterial, makeMaterialDoubleSided } from "./CfgMaterial.js";
+export function defaultDummyMaterialCreator(scene, maxSimultaneousLights, color) {
+    const material = new PBRMaterial("Dummy Material", scene);
+    material.albedoColor = toColor3(color === undefined ? 0xb5b5b5 : color).toLinearSpace();
+    material.roughness = 1;
+    // For a rather nice x-ray version during loading, enable the settings below
+    // material.alpha = 0.2;
+    // material.transparencyMode = PBRMaterial.PBRMATERIAL_ALPHABLEND;
+    // material.disableDepthWrite = true;
+    // material.separateCullingPass = true;
+    makeMaterialDoubleSided(material, true); // Double sided improved mesh compatibility
+    return new CfgMaterial(material, maxSimultaneousLights);
+}

package/dist/material/material.d.ts

@@ -1,19 +1,19 @@
-import { CfgMtrlSourceWithMetaData } from "@configura/web-api";
-import { GMaterial3D } from "@configura/web-core/dist/cm/core3D/GMaterial3D.js";
-import { MultiGMaterial3D } from "@configura/web-core/dist/cm/core3D/MultiGMaterial3D.js";
-import { LogObservable } from "@configura/web-utilities";
-import { RenderEnv } from "../view/RenderEnv.js";
-import { CfgMaterial } from "./CfgMaterial.js";
-export declare type MaterialMetaData = {
-    sourcePath: string[];
-    logger: LogObservable;
-    multiGMaterial?: MultiGMaterial3D;
-    gMaterial?: GMaterial3D;
-};
-export declare type MaterialWithMetaData = {
-    material: CfgMaterial | undefined;
-    meta: MaterialMetaData;
-};
-export declare function mtrlSourceToCfgMaterial(meta: MaterialMetaData, mtrlSourceWithMetaData: CfgMtrlSourceWithMetaData, renderEnvironment: RenderEnv): Promise<CfgMaterial | undefined>;
-export declare function gMaterialToCfgMaterial(meta: MaterialMetaData, renderEnvironment: RenderEnv, gMaterial: GMaterial3D): Promise<CfgMaterial | undefined>;
+import { CfgMtrlSourceWithMetaData } from "@configura/web-api";
+import { GMaterial3D } from "@configura/web-core/dist/cm/core3D/GMaterial3D.js";
+import { MultiGMaterial3D } from "@configura/web-core/dist/cm/core3D/MultiGMaterial3D.js";
+import { LogObservable } from "@configura/web-utilities";
+import { RenderEnv } from "../view/RenderEnv.js";
+import { CfgMaterial } from "./CfgMaterial.js";
+export declare type MaterialMetaData = {
+    sourcePath: string[];
+    logger: LogObservable;
+    multiGMaterial?: MultiGMaterial3D;
+    gMaterial?: GMaterial3D;
+};
+export declare type MaterialWithMetaData = {
+    material: CfgMaterial | undefined;
+    meta: MaterialMetaData;
+};
+export declare function mtrlSourceToCfgMaterial(meta: MaterialMetaData, mtrlSourceWithMetaData: CfgMtrlSourceWithMetaData, renderEnvironment: RenderEnv): Promise<CfgMaterial | undefined>;
+export declare function gMaterialToCfgMaterial(meta: MaterialMetaData, renderEnvironment: RenderEnv, gMaterial: GMaterial3D): Promise<CfgMaterial | undefined>;
 //# sourceMappingURL=material.d.ts.map

package/dist/material/material.js

@@ -1,128 +1,128 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { CfgMtrlSourceBuffer, CfgMtrlSourceUrl, } from "@configura/web-api";
-import { loadMaterialFromUrl, makeMaterialFromBuffer, } from "@configura/web-core/dist/cm/format/cmsym/components/SymGMaterial.js";
-import { getFileExtension, LogObservable } from "@configura/web-utilities";
-import { CfgMaterial } from "./CfgMaterial.js";
-import { getTextures, loadTextureFromURL } from "./texture.js";
-function copyMetaData(source, target) {
-    const { logger: sourceLogger, sourcePath: sourceSourcePath, multiGMaterial: sourceMultiGMaterial, gMaterial: sourceGMaterial, } = source;
-    const { logger: targetLogger, sourcePath: targetSourcePath } = target;
-    sourceLogger.accumulated.forEach((p) => targetLogger.addPrebaked(p));
-    targetSourcePath.push(...sourceSourcePath);
-    if (sourceMultiGMaterial !== undefined) {
-        target.multiGMaterial = sourceMultiGMaterial;
-    }
-    if (sourceGMaterial !== undefined) {
-        target.gMaterial = sourceGMaterial;
-    }
-}
-export function mtrlSourceToCfgMaterial(meta, mtrlSourceWithMetaData, renderEnvironment) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const mtrlSource = mtrlSourceWithMetaData.mtrl;
-        meta.sourcePath.push("mtrlSourceToCfgMaterial");
-        if (mtrlSource instanceof CfgMtrlSourceBuffer) {
-            return bufferToCfgMaterial(renderEnvironment, meta, mtrlSource);
-        }
-        if (mtrlSource instanceof CfgMtrlSourceUrl) {
-            return mtrlSourceUrlToCachedCfgMaterial(meta, renderEnvironment, mtrlSource);
-        }
-        throw meta.logger.errorAsObject("Unsupported mtrlSource");
-    });
-}
-function mtrlSourceUrlToCachedCfgMaterial(meta, renderEnvironment, mtrl) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const url = mtrl.url;
-        meta.sourcePath.push("mtrlSourceUrlToCachedCfgMaterial");
-        const materialWithMetaData = yield renderEnvironment.materialCache.get(url, () => __awaiter(this, void 0, void 0, function* () {
-            const innerMeta = {
-                logger: new LogObservable(),
-                sourcePath: [],
-            };
-            const result = {
-                material: undefined,
-                meta: innerMeta,
-            };
-            innerMeta.sourcePath.push("cache_url");
-            if (!url.startsWith("http")) {
-                innerMeta.logger.warn("BAD MTRL URL: ", url);
-                return result;
-            }
-            if (getFileExtension(url) !== "gm") {
-                const texture = yield loadTextureFromURL(url, renderEnvironment);
-                innerMeta.sourcePath.push("image");
-                result.material = CfgMaterial.makeFromTexture(renderEnvironment, texture, innerMeta.sourcePath);
-                return result;
-            }
-            const multiGMaterial = yield loadMaterialFromUrl(innerMeta.logger, url, renderEnvironment.dexManager);
-            innerMeta.sourcePath.push("gm");
-            result.material = yield multiGToCfgMaterial(innerMeta, renderEnvironment, multiGMaterial);
-            return result;
-        }));
-        copyMetaData(materialWithMetaData.meta, meta);
-        return materialWithMetaData.material;
-    });
-}
-function bufferToCfgMaterial(renderEnvironment, meta, mtrl) {
-    return __awaiter(this, void 0, void 0, function* () {
-        meta.sourcePath.push("bufferToCfgMaterial");
-        const fileName = mtrl.fileName;
-        const buffer = mtrl.buffer;
-        const fileExtension = getFileExtension(fileName);
-        if (fileExtension !== "gm") {
-            if (fileExtension !== "jpg" && fileExtension !== "jpeg" && fileExtension !== "png") {
-                throw meta.logger.errorAsObject("Unsupported file type");
-            }
-            meta.sourcePath.push("image");
-            const texture = yield loadTextureFromURL(`data:image/${fileExtension};base64,${btoa(String.fromCharCode(...new Uint8Array(buffer)))}`, renderEnvironment);
-            return CfgMaterial.makeFromTexture(renderEnvironment, texture, meta.sourcePath);
-        }
-        const multiGMaterial = makeMaterialFromBuffer(meta.logger, mtrl.buffer, renderEnvironment.dexManager);
-        meta.sourcePath.push("gm");
-        return multiGToCfgMaterial(meta, renderEnvironment, multiGMaterial);
-    });
-}
-export function gMaterialToCfgMaterial(meta, renderEnvironment, gMaterial) {
-    return __awaiter(this, void 0, void 0, function* () {
-        meta.sourcePath.push("gMaterialToCfgMaterial");
-        const withMetaData = yield renderEnvironment.materialCache.get(gMaterial, () => __awaiter(this, void 0, void 0, function* () {
-            const innerMeta = {
-                logger: new LogObservable(),
-                sourcePath: [],
-            };
-            innerMeta.sourcePath.push("cache_gMaterial");
-            innerMeta.gMaterial = gMaterial;
-            const textures = yield getTextures(innerMeta.logger, renderEnvironment, gMaterial);
-            const material = CfgMaterial.makeFromGm(renderEnvironment, innerMeta, gMaterial, textures);
-            return {
-                material: material,
-                meta: innerMeta,
-            };
-        }));
-        copyMetaData(withMetaData.meta, meta);
-        return withMetaData.material;
-    });
-}
-function multiGToCfgMaterial(meta, renderEnvironment, multiGMaterial) {
-    return __awaiter(this, void 0, void 0, function* () {
-        meta.sourcePath.push("multiGToCfgMaterial");
-        if (multiGMaterial instanceof Error) {
-            meta.logger.error("error while loading materials", multiGMaterial.message);
-            meta.logger.warn(multiGMaterial);
-            return;
-        }
-        meta.multiGMaterial = multiGMaterial;
-        const gMaterial = multiGMaterial.renderMaterial();
-        if (gMaterial === undefined) {
-            return;
-        }
-        return gMaterialToCfgMaterial(meta, renderEnvironment, gMaterial);
-    });
-}
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { CfgMtrlSourceBuffer, CfgMtrlSourceUrl, } from "@configura/web-api";
+import { loadMaterialFromUrl, makeMaterialFromBuffer, } from "@configura/web-core/dist/cm/format/cmsym/components/SymGMaterial.js";
+import { getFileExtension, LogObservable } from "@configura/web-utilities";
+import { CfgMaterial } from "./CfgMaterial.js";
+import { getTextures, loadTextureFromURL } from "./texture.js";
+function copyMetaData(source, target) {
+    const { logger: sourceLogger, sourcePath: sourceSourcePath, multiGMaterial: sourceMultiGMaterial, gMaterial: sourceGMaterial, } = source;
+    const { logger: targetLogger, sourcePath: targetSourcePath } = target;
+    sourceLogger.accumulated.forEach((p) => targetLogger.addPrebaked(p));
+    targetSourcePath.push(...sourceSourcePath);
+    if (sourceMultiGMaterial !== undefined) {
+        target.multiGMaterial = sourceMultiGMaterial;
+    }
+    if (sourceGMaterial !== undefined) {
+        target.gMaterial = sourceGMaterial;
+    }
+}
+export function mtrlSourceToCfgMaterial(meta, mtrlSourceWithMetaData, renderEnvironment) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const mtrlSource = mtrlSourceWithMetaData.mtrl;
+        meta.sourcePath.push("mtrlSourceToCfgMaterial");
+        if (mtrlSource instanceof CfgMtrlSourceBuffer) {
+            return bufferToCfgMaterial(renderEnvironment, meta, mtrlSource);
+        }
+        if (mtrlSource instanceof CfgMtrlSourceUrl) {
+            return mtrlSourceUrlToCachedCfgMaterial(meta, renderEnvironment, mtrlSource);
+        }
+        throw meta.logger.errorAsObject("Unsupported mtrlSource");
+    });
+}
+function mtrlSourceUrlToCachedCfgMaterial(meta, renderEnvironment, mtrl) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const url = mtrl.url;
+        meta.sourcePath.push("mtrlSourceUrlToCachedCfgMaterial");
+        const materialWithMetaData = yield renderEnvironment.materialCache.get(url, () => __awaiter(this, void 0, void 0, function* () {
+            const innerMeta = {
+                logger: new LogObservable(),
+                sourcePath: [],
+            };
+            const result = {
+                material: undefined,
+                meta: innerMeta,
+            };
+            innerMeta.sourcePath.push("cache_url");
+            if (!url.startsWith("http")) {
+                innerMeta.logger.warn("BAD MTRL URL: ", url);
+                return result;
+            }
+            if (getFileExtension(url) !== "gm") {
+                const texture = yield loadTextureFromURL(url, renderEnvironment);
+                innerMeta.sourcePath.push("image");
+                result.material = CfgMaterial.makeFromTexture(renderEnvironment, texture, innerMeta.sourcePath);
+                return result;
+            }
+            const multiGMaterial = yield loadMaterialFromUrl(innerMeta.logger, url, renderEnvironment.dexManager);
+            innerMeta.sourcePath.push("gm");
+            result.material = yield multiGToCfgMaterial(innerMeta, renderEnvironment, multiGMaterial);
+            return result;
+        }));
+        copyMetaData(materialWithMetaData.meta, meta);
+        return materialWithMetaData.material;
+    });
+}
+function bufferToCfgMaterial(renderEnvironment, meta, mtrl) {
+    return __awaiter(this, void 0, void 0, function* () {
+        meta.sourcePath.push("bufferToCfgMaterial");
+        const fileName = mtrl.fileName;
+        const buffer = mtrl.buffer;
+        const fileExtension = getFileExtension(fileName);
+        if (fileExtension !== "gm") {
+            if (fileExtension !== "jpg" && fileExtension !== "jpeg" && fileExtension !== "png") {
+                throw meta.logger.errorAsObject("Unsupported file type");
+            }
+            meta.sourcePath.push("image");
+            const texture = yield loadTextureFromURL(`data:image/${fileExtension};base64,${btoa(String.fromCharCode(...new Uint8Array(buffer)))}`, renderEnvironment);
+            return CfgMaterial.makeFromTexture(renderEnvironment, texture, meta.sourcePath);
+        }
+        const multiGMaterial = makeMaterialFromBuffer(meta.logger, mtrl.buffer, renderEnvironment.dexManager);
+        meta.sourcePath.push("gm");
+        return multiGToCfgMaterial(meta, renderEnvironment, multiGMaterial);
+    });
+}
+export function gMaterialToCfgMaterial(meta, renderEnvironment, gMaterial) {
+    return __awaiter(this, void 0, void 0, function* () {
+        meta.sourcePath.push("gMaterialToCfgMaterial");
+        const withMetaData = yield renderEnvironment.materialCache.get(gMaterial, () => __awaiter(this, void 0, void 0, function* () {
+            const innerMeta = {
+                logger: new LogObservable(),
+                sourcePath: [],
+            };
+            innerMeta.sourcePath.push("cache_gMaterial");
+            innerMeta.gMaterial = gMaterial;
+            const textures = yield getTextures(innerMeta.logger, renderEnvironment, gMaterial);
+            const material = CfgMaterial.makeFromGm(renderEnvironment, innerMeta, gMaterial, textures);
+            return {
+                material: material,
+                meta: innerMeta,
+            };
+        }));
+        copyMetaData(withMetaData.meta, meta);
+        return withMetaData.material;
+    });
+}
+function multiGToCfgMaterial(meta, renderEnvironment, multiGMaterial) {
+    return __awaiter(this, void 0, void 0, function* () {
+        meta.sourcePath.push("multiGToCfgMaterial");
+        if (multiGMaterial instanceof Error) {
+            meta.logger.error("error while loading materials", multiGMaterial.message);
+            meta.logger.warn(multiGMaterial);
+            return;
+        }
+        meta.multiGMaterial = multiGMaterial;
+        const gMaterial = multiGMaterial.renderMaterial();
+        if (gMaterial === undefined) {
+            return;
+        }
+        return gMaterialToCfgMaterial(meta, renderEnvironment, gMaterial);
+    });
+}

package/dist/material/texture.d.ts

@@ -1,15 +1,15 @@
-import { Texture } from "@babylonjs/core/Materials/Textures/texture.js";
-import { GMaterial3D, GMaterial3DTexture } from "@configura/web-core/dist/cm/core3D/GMaterial3D.js";
-import { Logger, LogObservable } from "@configura/web-utilities";
-import { RenderEnv } from "../view/RenderEnv.js";
-export declare type TextureImageWithMetaData = {
-    image: HTMLImageElement | undefined;
-    logger: LogObservable;
-};
-export declare function loadTextureFromURL(url: string, renderEnvironment: RenderEnv): Promise<Texture>;
-export interface GMAndTexture {
-    gm: GMaterial3DTexture;
-    tx?: Texture;
-}
-export declare function getTextures(logger: Logger, renderEnvironment: RenderEnv, gm: GMaterial3D): Promise<GMAndTexture[]>;
+import { Texture } from "@babylonjs/core/Materials/Textures/texture.js";
+import { GMaterial3D, GMaterial3DTexture } from "@configura/web-core/dist/cm/core3D/GMaterial3D.js";
+import { Logger, LogObservable } from "@configura/web-utilities";
+import { RenderEnv } from "../view/RenderEnv.js";
+export declare type TextureImageWithMetaData = {
+    image: HTMLImageElement | undefined;
+    logger: LogObservable;
+};
+export declare function loadTextureFromURL(url: string, renderEnvironment: RenderEnv): Promise<Texture>;
+export interface GMAndTexture {
+    gm: GMaterial3DTexture;
+    tx?: Texture;
+}
+export declare function getTextures(logger: Logger, renderEnvironment: RenderEnv, gm: GMaterial3D): Promise<GMAndTexture[]>;
 //# sourceMappingURL=texture.d.ts.map