@shapediver/viewer.data-engine.material-engine - npm Package Compare versions

Comparing version 3.2.1 to 3.2.2

dist/MaterialEngine.d.ts

@@ -0,5 +1,5 @@
+import { IMaterialContentDataV1, IMaterialContentDataV2, IMaterialContentDataV3, ITexture } from '@shapediver/viewer.data-engine.shared-types';
 import { ITreeNode } from '@shapediver/viewer.shared.node-tree';
-import { IMaterialAbstractData, IMaterialAbstractDataProperties, MapData, MaterialStandardData } from '@shapediver/viewer.shared.types';
 import { ShapeDiverResponseOutputContent } from '@shapediver/sdk.geometry-api-sdk-v2';
-import { IMaterialContentDataV1, IMaterialContentDataV2, IMaterialContentDataV3, ITexture } from '@shapediver/viewer.data-engine.shared-types';
+import { IMapDataPropertiesDefinition, IMaterialAbstractData, IMaterialAbstractDataProperties, IMaterialAbstractDataPropertiesDefinition, MapData, MaterialStandardData } from '@shapediver/viewer.shared.types';
 export declare class MaterialEngine {
@@ -18,2 +18,3 @@ private readonly _converter;
     createMaterialData(materialProperties: IMaterialAbstractDataProperties): IMaterialAbstractData;
+    createMaterialDataFromDefinition(definition: IMaterialAbstractDataPropertiesDefinition): Promise<IMaterialAbstractData>;
     /**
@@ -26,4 +27,11 @@ * Load the material content into a scene graph node.
     loadContent(content: ShapeDiverResponseOutputContent): Promise<ITreeNode>;
-    loadMap(url: string, id?: string): Promise<MapData | null>;
-    loadMapWithProperties(texture: ITexture): Promise<MapData | null>;
+    loadMap(url: string, id?: string): Promise<MapData>;
+    /**
+     * Load a map from a definition.
+     *
+     * @param definition
+     * @returns
+     */
+    loadMapFromDefinition(definition?: IMapDataPropertiesDefinition): Promise<MapData | undefined>;
+    loadMapWithProperties(texture: ITexture): Promise<MapData>;
     loadMaterialDefinitionV1(data: IMaterialContentDataV1, presetData?: IMaterialContentDataV3): IMaterialContentDataV3;
@@ -30,0 +38,0 @@ loadMaterialDefinitionV2(data: IMaterialContentDataV2, presetData?: IMaterialContentDataV3): IMaterialContentDataV3;

dist/MaterialEngine.js

@@ -13,8 +13,8 @@ "use strict";
 exports.MaterialEngine = void 0;
+const viewer_shared_services_1 = require("@shapediver/viewer.shared.services");
+const viewer_shared_node_tree_1 = require("@shapediver/viewer.shared.node-tree");
+const materialDatabase_1 = require("./materialDatabase");
+const gl_matrix_1 = require("gl-matrix");
 /* eslint-disable no-prototype-builtins */
-const viewer_shared_node_tree_1 = require("@shapediver/viewer.shared.node-tree");
-const viewer_shared_services_1 = require("@shapediver/viewer.shared.services");
 const viewer_shared_types_1 = require("@shapediver/viewer.shared.types");
-const gl_matrix_1 = require("gl-matrix");
-const materialDatabase_1 = require("./materialDatabase");
 class MaterialEngine {
@@ -26,11 +26,11 @@ constructor() {
         this._logger = viewer_shared_services_1.Logger.instance;
-        // #endregion Private Methods (3)
+        // #endregion Private Methods (4)
     }
     // #endregion Properties (4)
-    // #region Public Static Accessors (1)
+    // #region Public Static Getters And Setters (1)
     static get instance() {
         return this._instance || (this._instance = new this());
     }
-    // #endregion Public Static Accessors (1)
-    // #region Public Methods (9)
+    // #endregion Public Static Getters And Setters (1)
+    // #region Public Methods (12)
     /**
@@ -55,2 +55,216 @@ * Create a material data based on the material properties
     }
+    createMaterialDataFromDefinition(definition) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const materialType = definition.type || viewer_shared_types_1.MATERIAL_TYPE.STANDARD;
+            const promises = [];
+            const abstractProperties = {};
+            abstractProperties.alphaCutoff = definition.alphaCutoff;
+            promises.push(this.loadMapFromDefinition(definition.alphaMap).then(map => {
+                if (map)
+                    abstractProperties.alphaMap = map;
+                return map;
+            }));
+            abstractProperties.alphaMode = definition.alphaMode;
+            promises.push(this.loadMapFromDefinition(definition.aoMap).then(map => {
+                if (map)
+                    abstractProperties.aoMap = map;
+                return map;
+            }));
+            abstractProperties.aoMapIntensity = definition.aoMapIntensity;
+            promises.push(this.loadMapFromDefinition(definition.bumpMap).then(map => {
+                if (map)
+                    abstractProperties.bumpMap = map;
+                return map;
+            }));
+            abstractProperties.bumpScale = definition.bumpScale;
+            abstractProperties.color = definition.color ? this._converter.toColorArray(definition.color) : undefined;
+            abstractProperties.depthTest = definition.depthTest;
+            abstractProperties.depthWrite = definition.depthWrite;
+            promises.push(this.loadMapFromDefinition(definition.emissiveMap).then(map => {
+                if (map)
+                    abstractProperties.emissiveMap = map;
+                return map;
+            }));
+            abstractProperties.emissiveness = definition.emissiveness ? this._converter.toColorArray(definition.emissiveness) : undefined;
+            promises.push(this.loadMapFromDefinition(definition.map).then(map => {
+                if (map)
+                    abstractProperties.map = map;
+                return map;
+            }));
+            abstractProperties.name = definition.name;
+            promises.push(this.loadMapFromDefinition(definition.normalMap).then(map => {
+                if (map)
+                    abstractProperties.normalMap = map;
+                return map;
+            }));
+            abstractProperties.normalScale = definition.normalScale;
+            abstractProperties.opacity = definition.opacity;
+            abstractProperties.shading = definition.shading;
+            abstractProperties.side = definition.side;
+            abstractProperties.transparent = definition.transparent;
+            abstractProperties.type = materialType;
+            switch (materialType) {
+                case viewer_shared_types_1.MATERIAL_TYPE.SPECULAR_GLOSSINESS:
+                    {
+                        const specularGlossinessProperties = abstractProperties;
+                        const specularGlossinessDefinition = definition;
+                        specularGlossinessProperties.envMap = specularGlossinessDefinition.envMap;
+                        specularGlossinessProperties.glossiness = specularGlossinessDefinition.glossiness;
+                        specularGlossinessProperties.specular = specularGlossinessDefinition.specular;
+                        if (specularGlossinessDefinition.specularGlossinessMap) {
+                            promises.push(this.loadMapFromDefinition(specularGlossinessDefinition.specularGlossinessMap).then(map => {
+                                if (map)
+                                    specularGlossinessProperties.specularGlossinessMap = map;
+                                return map;
+                            }));
+                        }
+                        else {
+                            promises.push(this.loadMapFromDefinition(specularGlossinessDefinition.specularMap).then(map => {
+                                if (map)
+                                    specularGlossinessProperties.specularMap = map;
+                                return map;
+                            }));
+                            promises.push(this.loadMapFromDefinition(specularGlossinessDefinition.glossinessMap).then(map => {
+                                if (map)
+                                    specularGlossinessProperties.glossinessMap = map;
+                                return map;
+                            }));
+                        }
+                        yield Promise.all(promises);
+                        return new viewer_shared_types_1.MaterialSpecularGlossinessData(specularGlossinessProperties);
+                    }
+                case viewer_shared_types_1.MATERIAL_TYPE.UNLIT:
+                    {
+                        const unlitProperties = abstractProperties;
+                        const unlitDefinition = definition;
+                        unlitProperties.envMap = unlitDefinition.envMap;
+                        yield Promise.all(promises);
+                        return new viewer_shared_types_1.MaterialUnlitData(unlitProperties);
+                    }
+                case viewer_shared_types_1.MATERIAL_TYPE.GEM:
+                    {
+                        const gemProperties = abstractProperties;
+                        const gemDefinition = definition;
+                        gemProperties.brightness = gemDefinition.brightness;
+                        gemProperties.center = gemDefinition.center;
+                        gemProperties.colorTransferBegin = gemDefinition.colorTransferBegin;
+                        gemProperties.colorTransferEnd = gemDefinition.colorTransferEnd;
+                        gemProperties.contrast = gemDefinition.contrast;
+                        gemProperties.dispersion = gemDefinition.dispersion;
+                        gemProperties.envMap = gemDefinition.envMap;
+                        gemProperties.gamma = gemDefinition.gamma;
+                        promises.push(this.loadMapFromDefinition(gemDefinition.impurityMap).then(map => {
+                            if (map)
+                                gemProperties.impurityMap = map;
+                            return map;
+                        }));
+                        gemProperties.impurityScale = gemDefinition.impurityScale;
+                        gemProperties.radius = gemDefinition.radius;
+                        gemProperties.refractionIndex = gemDefinition.refractionIndex;
+                        promises.push(this.loadMapFromDefinition(gemDefinition.sphericalNormalMap).then(map => {
+                            if (map)
+                                gemProperties.sphericalNormalMap = map;
+                            return map;
+                        }));
+                        gemProperties.tracingDepth = gemDefinition.tracingDepth;
+                        gemProperties.tracingOpacity = gemDefinition.tracingOpacity;
+                        yield Promise.all(promises);
+                        return new viewer_shared_types_1.MaterialGemData(gemProperties);
+                    }
+                default:
+                    {
+                        const standardProperties = abstractProperties;
+                        const standardDefinition = definition;
+                        standardProperties.attenuationColor = standardDefinition.attenuationColor;
+                        standardProperties.attenuationDistance = standardDefinition.attenuationDistance;
+                        standardProperties.clearcoat = standardDefinition.clearcoat;
+                        promises.push(this.loadMapFromDefinition(standardDefinition.clearcoatMap).then(map => {
+                            if (map)
+                                standardProperties.clearcoatMap = map;
+                            return map;
+                        }));
+                        promises.push(this.loadMapFromDefinition(standardDefinition.clearcoatNormalMap).then(map => {
+                            if (map)
+                                standardProperties.clearcoatNormalMap = map;
+                            return map;
+                        }));
+                        standardProperties.clearcoatRoughness = standardDefinition.clearcoatRoughness;
+                        promises.push(this.loadMapFromDefinition(standardDefinition.clearcoatRoughnessMap).then(map => {
+                            if (map)
+                                standardProperties.clearcoatRoughnessMap = map;
+                            return map;
+                        }));
+                        standardProperties.displacementBias = standardDefinition.displacementBias;
+                        promises.push(this.loadMapFromDefinition(standardDefinition.displacementMap).then(map => {
+                            if (map)
+                                standardProperties.displacementMap = map;
+                            return map;
+                        }));
+                        standardProperties.displacementScale = standardDefinition.displacementScale;
+                        standardProperties.envMap = standardDefinition.envMap;
+                        standardProperties.ior = standardDefinition.ior;
+                        standardProperties.metalness = standardDefinition.metalness;
+                        if (standardDefinition.metalnessRoughnessMap) {
+                            promises.push(this.loadMapFromDefinition(standardDefinition.metalnessMap).then(map => {
+                                if (map)
+                                    standardProperties.metalnessMap = map;
+                                return map;
+                            }));
+                        }
+                        else {
+                            promises.push(this.loadMapFromDefinition(standardDefinition.metalnessMap).then(map => {
+                                if (map)
+                                    standardProperties.metalnessMap = map;
+                                return map;
+                            }));
+                            promises.push(this.loadMapFromDefinition(standardDefinition.roughnessMap).then(map => {
+                                if (map)
+                                    standardProperties.roughnessMap = map;
+                                return map;
+                            }));
+                        }
+                        standardProperties.roughness = standardDefinition.roughness;
+                        standardProperties.sheen = standardDefinition.sheen;
+                        standardProperties.sheenColor = standardDefinition.sheenColor;
+                        promises.push(this.loadMapFromDefinition(standardDefinition.sheenColorMap).then(map => {
+                            if (map)
+                                standardProperties.sheenColorMap = map;
+                            return map;
+                        }));
+                        standardProperties.sheenRoughness = standardDefinition.sheenRoughness;
+                        promises.push(this.loadMapFromDefinition(standardDefinition.sheenRoughnessMap).then(map => {
+                            if (map)
+                                standardProperties.sheenRoughnessMap = map;
+                            return map;
+                        }));
+                        standardProperties.specularColor = standardDefinition.specularColor;
+                        promises.push(this.loadMapFromDefinition(standardDefinition.specularColorMap).then(map => {
+                            if (map)
+                                standardProperties.specularColorMap = map;
+                            return map;
+                        }));
+                        standardProperties.specularIntensity = standardDefinition.specularIntensity;
+                        promises.push(this.loadMapFromDefinition(standardDefinition.specularIntensityMap).then(map => {
+                            if (map)
+                                standardProperties.specularIntensityMap = map;
+                            return map;
+                        }));
+                        standardProperties.thickness = standardDefinition.thickness;
+                        promises.push(this.loadMapFromDefinition(standardDefinition.thicknessMap).then(map => {
+                            if (map)
+                                standardProperties.thicknessMap = map;
+                            return map;
+                        }));
+                        standardProperties.transmission = standardDefinition.transmission;
+                        promises.push(this.loadMapFromDefinition(standardDefinition.transmissionMap).then(map => {
+                            if (map)
+                                standardProperties.transmissionMap = map;
+                            return map;
+                        }));
+                        yield Promise.all(promises);
+                        return new viewer_shared_types_1.MaterialStandardData(standardProperties);
+                    }
+            }
+        });
+    }
     /**
@@ -118,2 +332,32 @@ * Load the material content into a scene graph node.
     }
+    /**
+     * Load a map from a definition.
+     *
+     * @param definition
+     * @returns
+     */
+    loadMapFromDefinition(definition) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!definition)
+                return undefined;
+            if (definition.image) {
+                if (typeof definition.image === 'string') {
+                    return this.loadMapWithProperties({
+                        href: definition.image,
+                        wrapS: definition.wrapS,
+                        wrapT: definition.wrapT,
+                        center: definition.center,
+                        color: definition.color ? this._converter.toColorArray(definition.color) : undefined,
+                        offset: definition.offset,
+                        repeat: definition.repeat,
+                        rotation: definition.rotation
+                    });
+                }
+                else {
+                    return new viewer_shared_types_1.MapData(definition.image);
+                }
+            }
+            return;
+        });
+    }
     loadMapWithProperties(texture) {
@@ -324,4 +568,4 @@ return __awaiter(this, void 0, void 0, function* () {
     }
-    // #endregion Public Methods (9)
-    // #region Private Methods (3)
+    // #endregion Public Methods (12)
+    // #region Private Methods (4)
     assignGeneralDefinition(id, generalDefinition, specificDefinition, definition) {
@@ -328,0 +572,0 @@ if (generalDefinition.transparencytexture && !specificDefinition.transparencytexture)

package.json

 {
   "name": "@shapediver/viewer.data-engine.material-engine",
-  "version": "3.2.1",
+  "version": "3.2.2",
   "description": "",
@@ -43,10 +43,10 @@ "keywords": [],
     "@shapediver/sdk.geometry-api-sdk-v2": "1.10.0",
-    "@shapediver/viewer.data-engine.shared-types": "3.2.1",
-    "@shapediver/viewer.shared.node-tree": "3.2.1",
-    "@shapediver/viewer.shared.services": "3.2.1",
-    "@shapediver/viewer.shared.types": "3.2.1",
+    "@shapediver/viewer.data-engine.shared-types": "3.2.2",
+    "@shapediver/viewer.shared.node-tree": "3.2.2",
+    "@shapediver/viewer.shared.services": "3.2.2",
+    "@shapediver/viewer.shared.types": "3.2.2",
     "axios": "^1.2.6",
     "gl-matrix": "3.3.0"
   },
-  "gitHead": "00f87aa21c3616bbabf0d06a93f94491324825c5"
+  "gitHead": "53949d3be352baa3951ac2e48385472ee7b3b222"
 }

src/MaterialEngine.ts

@@ -0,7 +1,33 @@
+import {
+    Converter,
+    HttpClient,
+    Logger,
+    ShapeDiverViewerDataProcessingError
+} from '@shapediver/viewer.shared.services';
+import {
+    IMaterialContentData,
+    IMaterialContentDataV1,
+    IMaterialContentDataV2,
+    IMaterialContentDataV3,
+    IPresetMaterialDefinition,
+    ITexture
+} from '@shapediver/viewer.data-engine.shared-types';
+import { ITreeNode, TreeNode } from '@shapediver/viewer.shared.node-tree';
+import { materialDatabase } from './materialDatabase';
+import { ShapeDiverResponseOutputContent } from '@shapediver/sdk.geometry-api-sdk-v2';
+import { vec2, vec4 } from 'gl-matrix';
 /* eslint-disable no-prototype-builtins */
-import { ITreeNode, TreeNode } from '@shapediver/viewer.shared.node-tree';
-import { Converter, HttpClient, Logger, ShapeDiverViewerDataProcessingError } from '@shapediver/viewer.shared.services';
 import {
+    IMapDataPropertiesDefinition,
     IMaterialAbstractData,
     IMaterialAbstractDataProperties,
+    IMaterialAbstractDataPropertiesDefinition,
+    IMaterialGemDataProperties,
+    IMaterialGemDataPropertiesDefinition,
+    IMaterialSpecularGlossinessDataProperties,
+    IMaterialSpecularGlossinessDataPropertiesDefinition,
+    IMaterialStandardDataProperties,
+    IMaterialStandardDataPropertiesDefinition,
+    IMaterialUnlitDataProperties,
+    IMaterialUnlitDataPropertiesDefinition,
     MapData,
@@ -17,8 +43,3 @@ MATERIAL_SIDE,
 } from '@shapediver/viewer.shared.types';
-import { vec2, vec4 } from 'gl-matrix';
 
-import { materialDatabase } from './materialDatabase';
-import { ShapeDiverResponseOutputContent } from '@shapediver/sdk.geometry-api-sdk-v2';
-import { IMaterialContentData, IMaterialContentDataV1, IMaterialContentDataV2, IMaterialContentDataV3, IPresetMaterialDefinition, ITexture } from '@shapediver/viewer.data-engine.shared-types';
-
 export class MaterialEngine {
@@ -35,3 +56,3 @@ // #region Properties (4)
 
-    // #region Public Static Accessors (1)
+    // #region Public Static Getters And Setters (1)
 
@@ -42,5 +63,5 @@ public static get instance() {
 
-    // #endregion Public Static Accessors (1)
+    // #endregion Public Static Getters And Setters (1)
 
-    // #region Public Methods (9)
+    // #region Public Methods (12)
 
@@ -54,3 +75,3 @@ /**
     public createMaterialData(materialProperties: IMaterialAbstractDataProperties): IMaterialAbstractData {
-        const materialType = materialProperties.type  || MATERIAL_TYPE.STANDARD;
+        const materialType = materialProperties.type || MATERIAL_TYPE.STANDARD;
         switch (materialType) {
@@ -68,2 +89,200 @@ case MATERIAL_TYPE.SPECULAR_GLOSSINESS:
 
+    public async createMaterialDataFromDefinition(definition: IMaterialAbstractDataPropertiesDefinition): Promise<IMaterialAbstractData> {
+        const materialType = definition.type || MATERIAL_TYPE.STANDARD;
+
+        const promises: Promise<MapData | undefined>[] = [];
+
+        const abstractProperties: IMaterialAbstractDataProperties = {};
+
+        abstractProperties.alphaCutoff = definition.alphaCutoff;
+        promises.push(this.loadMapFromDefinition(definition.alphaMap).then(map => {
+            if (map) abstractProperties.alphaMap = map;
+            return map;
+        }));
+        abstractProperties.alphaMode = definition.alphaMode;
+        promises.push(this.loadMapFromDefinition(definition.aoMap).then(map => {
+            if (map) abstractProperties.aoMap = map;
+            return map;
+        }));
+        abstractProperties.aoMapIntensity = definition.aoMapIntensity;
+        promises.push(this.loadMapFromDefinition(definition.bumpMap).then(map => {
+            if (map) abstractProperties.bumpMap = map;
+            return map;
+        }));
+        abstractProperties.bumpScale = definition.bumpScale;
+        abstractProperties.color = definition.color ? this._converter.toColorArray(definition.color) : undefined;
+        abstractProperties.depthTest = definition.depthTest;
+        abstractProperties.depthWrite = definition.depthWrite;
+        promises.push(this.loadMapFromDefinition(definition.emissiveMap).then(map => {
+            if (map) abstractProperties.emissiveMap = map;
+            return map;
+        }));
+        abstractProperties.emissiveness = definition.emissiveness ? this._converter.toColorArray(definition.emissiveness) : undefined;
+        promises.push(this.loadMapFromDefinition(definition.map).then(map => {
+            if (map) abstractProperties.map = map;
+            return map;
+        }));
+        abstractProperties.name = definition.name;
+        promises.push(this.loadMapFromDefinition(definition.normalMap).then(map => {
+            if (map) abstractProperties.normalMap = map;
+            return map;
+        }));
+        abstractProperties.normalScale = definition.normalScale;
+        abstractProperties.opacity = definition.opacity;
+        abstractProperties.shading = definition.shading;
+        abstractProperties.side = definition.side;
+        abstractProperties.transparent = definition.transparent;
+        abstractProperties.type = materialType;
+
+        switch (materialType) {
+            case MATERIAL_TYPE.SPECULAR_GLOSSINESS:
+                {
+                    const specularGlossinessProperties: IMaterialSpecularGlossinessDataProperties = abstractProperties;
+                    const specularGlossinessDefinition: IMaterialSpecularGlossinessDataPropertiesDefinition = definition as IMaterialSpecularGlossinessDataPropertiesDefinition;
+
+                    specularGlossinessProperties.envMap = specularGlossinessDefinition.envMap;
+                    specularGlossinessProperties.glossiness = specularGlossinessDefinition.glossiness;
+                    specularGlossinessProperties.specular = specularGlossinessDefinition.specular;
+
+                    if (specularGlossinessDefinition.specularGlossinessMap) {
+                        promises.push(this.loadMapFromDefinition(specularGlossinessDefinition.specularGlossinessMap).then(map => {
+                            if (map) specularGlossinessProperties.specularGlossinessMap = map;
+                            return map;
+                        }));
+                    } else {
+                        promises.push(this.loadMapFromDefinition(specularGlossinessDefinition.specularMap).then(map => {
+                            if (map) specularGlossinessProperties.specularMap = map;
+                            return map;
+                        }));
+                        promises.push(this.loadMapFromDefinition(specularGlossinessDefinition.glossinessMap).then(map => {
+                            if (map) specularGlossinessProperties.glossinessMap = map;
+                            return map;
+                        }));
+                    }
+
+                    await Promise.all(promises);
+                    return new MaterialSpecularGlossinessData(specularGlossinessProperties);
+                }
+            case MATERIAL_TYPE.UNLIT:
+                {
+                    const unlitProperties: IMaterialUnlitDataProperties = abstractProperties;
+                    const unlitDefinition: IMaterialUnlitDataPropertiesDefinition = definition;
+                    unlitProperties.envMap = unlitDefinition.envMap;
+                    await Promise.all(promises);
+                    return new MaterialUnlitData(unlitProperties);
+                }
+            case MATERIAL_TYPE.GEM:
+                {
+                    const gemProperties: IMaterialGemDataProperties = abstractProperties;
+                    const gemDefinition: IMaterialGemDataPropertiesDefinition = definition;
+
+                    gemProperties.brightness = gemDefinition.brightness;
+                    gemProperties.center = gemDefinition.center;
+                    gemProperties.colorTransferBegin = gemDefinition.colorTransferBegin;
+                    gemProperties.colorTransferEnd = gemDefinition.colorTransferEnd;
+                    gemProperties.contrast = gemDefinition.contrast;
+                    gemProperties.dispersion = gemDefinition.dispersion;
+                    gemProperties.envMap = gemDefinition.envMap;
+                    gemProperties.gamma = gemDefinition.gamma;
+                    promises.push(this.loadMapFromDefinition(gemDefinition.impurityMap).then(map => {
+                        if (map) gemProperties.impurityMap = map;
+                        return map;
+                    }));
+                    gemProperties.impurityScale = gemDefinition.impurityScale;
+                    gemProperties.radius = gemDefinition.radius;
+                    gemProperties.refractionIndex = gemDefinition.refractionIndex;
+                    promises.push(this.loadMapFromDefinition(gemDefinition.sphericalNormalMap).then(map => {
+                        if (map) gemProperties.sphericalNormalMap = map;
+                        return map;
+                    }));
+                    gemProperties.tracingDepth = gemDefinition.tracingDepth;
+                    gemProperties.tracingOpacity = gemDefinition.tracingOpacity;
+
+                    await Promise.all(promises);
+                    return new MaterialGemData(gemProperties);
+                }
+            default:
+                {
+                    const standardProperties: IMaterialStandardDataProperties = abstractProperties;
+                    const standardDefinition: IMaterialStandardDataPropertiesDefinition = definition;
+
+                    standardProperties.attenuationColor = standardDefinition.attenuationColor;
+                    standardProperties.attenuationDistance = standardDefinition.attenuationDistance;
+                    standardProperties.clearcoat = standardDefinition.clearcoat;
+                    promises.push(this.loadMapFromDefinition(standardDefinition.clearcoatMap).then(map => {
+                        if (map) standardProperties.clearcoatMap = map;
+                        return map;
+                    }));
+                    promises.push(this.loadMapFromDefinition(standardDefinition.clearcoatNormalMap).then(map => {
+                        if (map) standardProperties.clearcoatNormalMap = map;
+                        return map;
+                    }));
+                    standardProperties.clearcoatRoughness = standardDefinition.clearcoatRoughness;
+                    promises.push(this.loadMapFromDefinition(standardDefinition.clearcoatRoughnessMap).then(map => {
+                        if (map) standardProperties.clearcoatRoughnessMap = map;
+                        return map;
+                    }));
+                    standardProperties.displacementBias = standardDefinition.displacementBias;
+                    promises.push(this.loadMapFromDefinition(standardDefinition.displacementMap).then(map => {
+                        if (map) standardProperties.displacementMap = map;
+                        return map;
+                    }));
+                    standardProperties.displacementScale = standardDefinition.displacementScale;
+                    standardProperties.envMap = standardDefinition.envMap;
+                    standardProperties.ior = standardDefinition.ior;
+                    standardProperties.metalness = standardDefinition.metalness;
+                    if (standardDefinition.metalnessRoughnessMap) {
+                        promises.push(this.loadMapFromDefinition(standardDefinition.metalnessMap).then(map => {
+                            if (map) standardProperties.metalnessMap = map;
+                            return map;
+                        }));
+                    } else {
+                        promises.push(this.loadMapFromDefinition(standardDefinition.metalnessMap).then(map => {
+                            if (map) standardProperties.metalnessMap = map;
+                            return map;
+                        }));
+                        promises.push(this.loadMapFromDefinition(standardDefinition.roughnessMap).then(map => {
+                            if (map) standardProperties.roughnessMap = map;
+                            return map;
+                        }));
+                    }
+                    standardProperties.roughness = standardDefinition.roughness;
+                    standardProperties.sheen = standardDefinition.sheen;
+                    standardProperties.sheenColor = standardDefinition.sheenColor;
+                    promises.push(this.loadMapFromDefinition(standardDefinition.sheenColorMap).then(map => {
+                        if (map) standardProperties.sheenColorMap = map;
+                        return map;
+                    }));
+                    standardProperties.sheenRoughness = standardDefinition.sheenRoughness;
+                    promises.push(this.loadMapFromDefinition(standardDefinition.sheenRoughnessMap).then(map => {
+                        if (map) standardProperties.sheenRoughnessMap = map;
+                        return map;
+                    }));
+                    standardProperties.specularColor = standardDefinition.specularColor;
+                    promises.push(this.loadMapFromDefinition(standardDefinition.specularColorMap).then(map => {
+                        if (map) standardProperties.specularColorMap = map;
+                        return map;
+                    }));
+                    standardProperties.specularIntensity = standardDefinition.specularIntensity;
+                    promises.push(this.loadMapFromDefinition(standardDefinition.specularIntensityMap).then(map => {
+                        if (map) standardProperties.specularIntensityMap = map;
+                        return map;
+                    }));
+                    standardProperties.thickness = standardDefinition.thickness;
+                    promises.push(this.loadMapFromDefinition(standardDefinition.thicknessMap).then(map => {
+                        if (map) standardProperties.thicknessMap = map;
+                        return map;
+                    }));
+                    standardProperties.transmission = standardDefinition.transmission;
+                    promises.push(this.loadMapFromDefinition(standardDefinition.transmissionMap).then(map => {
+                        if (map) standardProperties.transmissionMap = map;
+                        return map;
+                    }));
+
+                    await Promise.all(promises);
+                    return new MaterialStandardData(standardProperties);
+                }
+        }
+    }
+
     /**
@@ -111,3 +330,3 @@ * Load the material content into a scene graph node.
 
-    public async loadMap(url: string, id?: string): Promise<MapData | null> {
+    public async loadMap(url: string, id?: string): Promise<MapData> {
         let response;
@@ -119,4 +338,4 @@ if (!id) {
         }
-        
-        if(typeof window !== 'undefined') {
+
+        if (typeof window !== 'undefined') {
             const image = await Converter.instance.responseToImage(response);
@@ -129,3 +348,31 @@ return new MapData(image, { blob: response.data.blob });
 
-    public async loadMapWithProperties(texture: ITexture): Promise<MapData | null> {
+    /**
+     * Load a map from a definition.
+     * 
+     * @param definition 
+     * @returns 
+     */
+    public async loadMapFromDefinition(definition?: IMapDataPropertiesDefinition): Promise<MapData | undefined> {
+        if (!definition) return undefined;
+
+        if (definition.image) {
+            if (typeof definition.image === 'string') {
+                return this.loadMapWithProperties({
+                    href: definition.image,
+                    wrapS: definition.wrapS,
+                    wrapT: definition.wrapT,
+                    center: definition.center as number[] | undefined,
+                    color: definition.color ? this._converter.toColorArray(definition.color) : undefined,
+                    offset: definition.offset as number[] | undefined,
+                    repeat: definition.repeat as number[] | undefined,
+                    rotation: definition.rotation
+                });
+            } else {
+                return new MapData(definition.image);
+            }
+        }
+        return;
+    }
+
+    public async loadMapWithProperties(texture: ITexture): Promise<MapData> {
         const response = await this._httpClient.loadTexture(texture.href!);
@@ -140,3 +387,3 @@
 
-        if(typeof window !== 'undefined') {
+        if (typeof window !== 'undefined') {
             const image = await Converter.instance.responseToImage(response);
@@ -393,5 +640,5 @@ return new MapData(image, { blob: response.data.blob, wrapS, wrapT, minFilter: TEXTURE_FILTERING.LINEAR_MIPMAP_LINEAR, magFilter: TEXTURE_FILTERING.LINEAR, center, color, offset, repeat, rotation: texture.rotation || 0 });
 
-    // #endregion Public Methods (9)
+    // #endregion Public Methods (12)
 
-    // #region Private Methods (3)
+    // #region Private Methods (4)
 
@@ -539,3 +786,3 @@ private assignGeneralDefinition(id: { class: string, specific: string }, generalDefinition: IPresetMaterialDefinition, specificDefinition: IPresetMaterialDefinition, definition: IMaterialContentDataV3) {
 
-    // #endregion Private Methods (3)
+    // #endregion Private Methods (4)
 }

No alert changes

Improved metrics

Total package byte prevSize

127547

increased by41.87%

Lines of code

1776

increased by37.67%

Dependency changes

• + Added@shapediver/viewer.data-engine.shared-types@3.2.2(transitive)

• + Added@shapediver/viewer.shared.build-data@3.2.2(transitive)

• + Added@shapediver/viewer.shared.math@3.2.2(transitive)

• + Added@shapediver/viewer.shared.node-tree@3.2.2(transitive)

• + Added@shapediver/viewer.shared.services@3.2.2(transitive)

• + Added@shapediver/viewer.shared.types@3.2.2(transitive)

• - Removed@shapediver/viewer.data-engine.shared-types@3.2.1(transitive)

• - Removed@shapediver/viewer.shared.build-data@3.2.1(transitive)

• - Removed@shapediver/viewer.shared.math@3.2.1(transitive)

• - Removed@shapediver/viewer.shared.node-tree@3.2.1(transitive)

• - Removed@shapediver/viewer.shared.services@3.2.1(transitive)

• - Removed@shapediver/viewer.shared.types@3.2.1(transitive)

• Updated@shapediver/viewer.data-engine.shared-types@3.2.2

• Updated@shapediver/viewer.shared.node-tree@3.2.2

• Updated@shapediver/viewer.shared.services@3.2.2

• Updated@shapediver/viewer.shared.types@3.2.2