@xeokit/xeokit-sdk 2.5.2-beta-5 → 2.5.2-beta-8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xeokit/xeokit-sdk",
-  "version": "2.5.2-beta-5",
+  "version": "2.5.2-beta-8",
   "description": "Web Programming Toolkit for 3D/2D BIM and AEC Graphics",
   "module": "./dist/xeokit-sdk.es.js",
   "main": "./dist/xeokit-sdk.cjs.js",

package/src/plugins/AngleMeasurementsPlugin/AngleMeasurementsMouseControl.js

@@ -218,8 +218,13 @@ export class AngleMeasurementsMouseControl extends AngleMeasurementsControl {
                 mouseHoverCanvasPos.set(canvasPos);
                 switch (this._mouseState) {
                     case MOUSE_FINDING_ORIGIN:
-                        this.markerDiv.style.marginLeft = `${canvasPos[0] - 5}px`;
-                        this.markerDiv.style.marginTop = `${canvasPos[1] - 5}px`;
+                        const canvasBoundRect = canvas.getBoundingClientRect();
+                        const scrollLeft = window.pageXOffset || document.documentElement.scrollLeft;
+                        const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
+                        const canvasLeftEdge = canvasBoundRect.left + scrollLeft;
+                        const canvasTopEdge = canvasBoundRect.top + scrollTop;
+                        this._markerDiv.style.marginLeft = `${canvasLeftEdge + canvasPos[0] - 5}px`;
+                        this._markerDiv.style.marginTop = `${canvasTopEdge + canvasPos[1] - 5}px`;
                         break;
                     case MOUSE_FINDING_CORNER:
                         if (this._currentAngleMeasurement) {

package/src/plugins/DistanceMeasurementsPlugin/DistanceMeasurementsMouseControl.js

@@ -204,8 +204,15 @@ export class DistanceMeasurementsMouseControl extends DistanceMeasurementsContro
                 pointerWorldPos.set(event.worldPos);
                 pointerCanvasPos.set(event.canvasPos);
                 if (this._mouseState === MOUSE_FIRST_CLICK_EXPECTED) {
-                    this._markerDiv.style.marginLeft = `${canvasPos[0] - 5}px`;
-                    this._markerDiv.style.marginTop = `${canvasPos[1] - 5}px`;
+                    
+                    const canvasBoundRect = canvas.getBoundingClientRect();
+                    const scrollLeft = window.pageXOffset || document.documentElement.scrollLeft;
+                    const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
+                    const canvasLeftEdge = canvasBoundRect.left + scrollLeft;
+                    const canvasTopEdge = canvasBoundRect.top + scrollTop;
+                    
+                    this._markerDiv.style.marginLeft = `${canvasLeftEdge + canvasPos[0] - 5}px`;
+                    this._markerDiv.style.marginTop = `${canvasTopEdge + canvasPos[1] - 5}px`;
                     this._markerDiv.style.background = "pink";
                     if (event.snappedToVertex || event.snappedToEdge) {
                         if (this.pointerLens) {

package/src/plugins/TreeViewPlugin/TreeViewNode.js

@@ -28,12 +28,20 @@ class TreeViewNode {
     get title() {
     }
 
+    /** Type of the corresponding {@link MetaObject}.
+     *
+     * @type {String}
+     * @abstract
+     */
+    get type() {
+    }
+
     /**
      * ID of the corresponding {@link MetaObject}.
      *
      * This is only defined if the TreeViewNode represents an object.
      *
-     * @type {Number|String}
+     * @type {String}
      * @abstract
      */
     get objectId() {
@@ -54,7 +62,6 @@ class TreeViewNode {
      * @abstract
      */
     get parent() {
-
     }
 
     /** The number of {@link Entity}s within the subtree of this TreeViewNode.
@@ -72,7 +79,6 @@ class TreeViewNode {
      * @abstract
      */
     get numVisibleEntities() {
-
     }
 
     /** Whether or not the TreeViewNode is currently checked.
@@ -81,7 +87,6 @@ class TreeViewNode {
      * @abstract
      */
     get checked() {
-
     }
 
     /** Whether or not the TreeViewNode is currently xrayed.
@@ -89,9 +94,8 @@ class TreeViewNode {
      * @type {Boolean}
      * @abstract
      */
-     get xrayed() {
-
+    get xrayed() {
     }
 }
 
-export {TreeViewNode};
+export {TreeViewNode};

package/src/viewer/scene/model/SceneModel.js

@@ -1146,8 +1146,6 @@ export class SceneModel extends Component {
         this._vboBatchingLayers = {};
         this._dtxLayers = {};
 
-        this._meshList = [];
-
         this.layerList = []; // For GL state efficiency when drawing, InstancingLayers are in first part, BatchingLayers are in second
         this._entityList = [];
 
@@ -1159,7 +1157,8 @@ export class SceneModel extends Component {
         this._meshes = {};
         this._entities = {};
 
-        this._scheduledMeshes = {}
+        this._scheduledMeshes = {};
+        this._meshesCfgsBeforeMeshCreation = {};
 
         /** @private **/
         this.renderFlags = new RenderFlags();
@@ -2690,7 +2689,7 @@ export class SceneModel extends Component {
     /**
      * Creates a new {@link SceneModelMesh} within this SceneModel.
      *
-     * * Stores the new SceneModelMesh in {@link SceneModel#meshes}.
+     * * It prepares and saves data for a SceneModelMesh {@link SceneModel#meshes} creation. SceneModelMesh will be created only once the SceneModelEntity (which references this particular SceneModelMesh) will be created.
      * * The SceneModelMesh can either define its own geometry or share it with other SceneModelMeshes. To define own geometry, provide the
      * various geometry arrays to this method. To share a geometry, provide the ID of a geometry created earlier
      * with {@link SceneModel#createGeometry}.
@@ -2725,18 +2724,18 @@ export class SceneModel extends Component {
      * @param {Number} [cfg.opacity=1] Opacity in range ````[0..1]````. Overridden by texture set ````colorTexture````.
      * @param {Number} [cfg.metallic=0] Metallic factor in range ````[0..1]````. Overridden by texture set ````metallicRoughnessTexture````.
      * @param {Number} [cfg.roughness=1] Roughness factor in range ````[0..1]````. Overridden by texture set ````metallicRoughnessTexture````.
-     * @returns {SceneModelMesh} The new mesh.
+     * @returns {Boolean} True = successfully mesh was created. False = error during creation of a mesh.
      */
     createMesh(cfg) {
 
         if (cfg.id === undefined || cfg.id === null) {
             this.error("[createMesh] SceneModel.createMesh() config missing: id");
-            return;
+            return false;
         }
 
         if (this._scheduledMeshes[cfg.id]) {
             this.error(`[createMesh] SceneModel already has a mesh with this ID: ${cfg.id}`);
-            return;
+            return false;
         }
 
         const instancing = (cfg.geometryId !== undefined);
@@ -2751,31 +2750,31 @@ export class SceneModel extends Component {
             }
             if (cfg.primitive !== "points" && cfg.primitive !== "lines" && cfg.primitive !== "triangles" && cfg.primitive !== "solid" && cfg.primitive !== "surface") {
                 this.error(`Unsupported value for 'primitive': '${primitive}'  ('geometryId' is absent) - supported values are 'points', 'lines', 'triangles', 'solid' and 'surface'.`);
-                return;
+                return false;
             }
             if (!cfg.positions && !cfg.positionsCompressed && !cfg.buckets) {
                 this.error("Param expected: 'positions',  'positionsCompressed' or `buckets`  ('geometryId' is absent)");
-                return null;
+                return false;
             }
             if (cfg.positions && (cfg.positionsDecodeMatrix || cfg.positionsDecodeBoundary)) {
                 this.error("Illegal params: 'positions' not expected with 'positionsDecodeMatrix'/'positionsDecodeBoundary' ('geometryId' is absent)");
-                return null;
+                return false;
             }
             if (cfg.positionsCompressed && !cfg.positionsDecodeMatrix && !cfg.positionsDecodeBoundary) {
                 this.error("Param expected: 'positionsCompressed' should be accompanied by 'positionsDecodeMatrix'/'positionsDecodeBoundary' ('geometryId' is absent)");
-                return null;
+                return false;
             }
             if (cfg.uvCompressed && !cfg.uvDecodeMatrix) {
                 this.error("Param expected: 'uvCompressed' should be accompanied by `uvDecodeMatrix` ('geometryId' is absent)");
-                return null;
+                return false;
             }
             if (!cfg.buckets && !cfg.indices && cfg.primitive !== "points") {
                 this.error(`Param expected: indices (required for '${cfg.primitive}' primitive type)`);
-                return null;
+                return false;
             }
             if ((cfg.matrix || cfg.position || cfg.rotation || cfg.scale) && (cfg.positionsCompressed || cfg.positionsDecodeBoundary)) {
                 this.error("Unexpected params: 'matrix', 'rotation', 'scale', 'position' not allowed with 'positionsCompressed'");
-                return null;
+                return false;
             }
 
             const useDTX = (!!this._dtxEnabled && (cfg.primitive === "triangles"
@@ -2940,7 +2939,7 @@ export class SceneModel extends Component {
                     cfg.textureSet = this._textureSets[cfg.textureSetId];
                     if (!cfg.textureSet) {
                         this.error(`[createMesh] Texture set not found: ${cfg.textureSetId} - ensure that you create it first with createTextureSet()`);
-                        return;
+                        return false;
                     }
                 }
             }
@@ -2951,13 +2950,13 @@ export class SceneModel extends Component {
 
             if (cfg.positions || cfg.positionsCompressed || cfg.indices || cfg.edgeIndices || cfg.normals || cfg.normalsCompressed || cfg.uv || cfg.uvCompressed || cfg.positionsDecodeMatrix) {
                 this.error(`Mesh geometry parameters not expected when instancing a geometry (not expected: positions, positionsCompressed, indices, edgeIndices, normals, normalsCompressed, uv, uvCompressed, positionsDecodeMatrix)`);
-                return;
+                return false;
             }
 
             cfg.geometry = this._geometries[cfg.geometryId];
             if (!cfg.geometry) {
                 this.error(`[createMesh] Geometry not found: ${cfg.geometryId} - ensure that you create it first with createGeometry()`);
-                return;
+                return false;
             }
 
             cfg.origin = cfg.origin ? math.addVec3(this._origin, cfg.origin, math.vec3()) : this._origin;
@@ -2971,7 +2970,7 @@ export class SceneModel extends Component {
 
                 if (!cfg.transform) {
                     this.error(`[createMesh] Transform not found: ${cfg.transformId} - ensure that you create it first with createTransform()`);
-                    return;
+                    return false;
                 }
 
                 cfg.aabb = cfg.geometry.aabb;
@@ -3039,7 +3038,7 @@ export class SceneModel extends Component {
                     cfg.textureSet = this._textureSets[cfg.textureSetId];
                     // if (!cfg.textureSet) {
                     //     this.error(`[createMesh] Texture set not found: ${cfg.textureSetId} - ensure that you create it first with createTextureSet()`);
-                    //     return;
+                    //     return false;
                     // }
                 }
             }
@@ -3047,7 +3046,9 @@ export class SceneModel extends Component {
 
         cfg.numPrimitives = this._getNumPrimitives(cfg);
 
-        return this._createMesh(cfg);
+        this._meshesCfgsBeforeMeshCreation[cfg.id] = cfg;
+
+        return true;
     }
 
     _createMesh(cfg) {
@@ -3079,8 +3080,6 @@ export class SceneModel extends Component {
             cfg.meshMatrix = cfg.transform.worldMatrix;
         }
         mesh.portionId = mesh.layer.createPortion(mesh, cfg);
-        this._meshes[cfg.id] = mesh;
-        this._meshList.push(mesh);
         return mesh;
     }
 
@@ -3439,10 +3438,15 @@ export class SceneModel extends Component {
         let meshes = [];
         for (let i = 0, len = cfg.meshIds.length; i < len; i++) {
             const meshId = cfg.meshIds[i];
-            const mesh = this._meshes[meshId];
-            if (!mesh) {
-                this.error(`Mesh with this ID not found: "${meshId}" - ignoring this mesh`);
-                continue;
+            let mesh = this._meshes[meshId]; // Trying to get already created mesh
+            if (!mesh) { // Checks if there is already created mesh for this meshId
+                let meshCfg = this._meshesCfgsBeforeMeshCreation[meshId]; // Trying to get already created cfg
+                if (!meshCfg) { // Checks if there is already created cfg for this meshId
+                    this.error(`Mesh with this ID not found: "${meshId}" - ignoring this mesh`); // There is no such cfg
+                    continue;
+                }
+                mesh = this._createMesh(meshCfg) // There is no such mesh yet, but there is already created cfg, so it creates this mesh
+                this._meshes[cfg.id] = mesh; // Now it will also add this mesh to dictionary of created meshes
             }
             if (mesh.parent) {
                 this.error(`Mesh with ID "${meshId}" already belongs to object with ID "${mesh.parent.id}" - ignoring this mesh`);

package/types/plugins/TreeViewPlugin/TreeViewNode.d.ts

@@ -6,7 +6,6 @@ export declare class TreeViewNode {
    * Globally unique node ID.
    *
    * @type {String}
-   * @abstract
    */
   get nodeId(): string;
 
@@ -14,7 +13,6 @@ export declare class TreeViewNode {
    * Title of the TreeViewNode.
    *
    * @type {String}
-   * @abstract
    */
   get title(): string;
 
@@ -23,51 +21,51 @@ export declare class TreeViewNode {
    *
    * This is only defined if the TreeViewNode represents an object.
    *
-   * @type {Number|String}
-   * @abstract
+   * @type {String}
+   */
+  get objectId(): string;
+
+  /**
+   * Type of the corresponding {@link MetaObject}.
+   *
+   * @type {String}
    */
-  get objectId(): string | number;
+  get type(): string;
 
   /**
    * The child TreeViewNodes.
    *
    * @type {Array}
-   * @abstract
    */
   get children(): any[];
 
   /** The parent TreeViewNode.
    *
-   * @type {TreeViewNode}
-   * @abstract
+   * @type {TreeViewNode|null}
    */
-  get parent(): TreeViewNode;
+  get parent(): TreeViewNode | null;
 
   /** The number of {@link Entity}s within the subtree of this TreeViewNode.
    *
    * @type {Number}
-   * @abstract
    */
   get numEntities(): number;
 
   /** The number of {@link Entity}s that are currently visible within the subtree of this TreeViewNode.
    *
    * @type {Number}
-   * @abstract
    */
   get numVisibleEntities(): number;
 
   /** Whether or not the TreeViewNode is currently checked.
    *
    * @type {Boolean}
-   * @abstract
    */
   get checked(): boolean;
 
   /** Whether or not the TreeViewNode is currently xrayed.
    *
    * @type {Boolean}
-   * @abstract
    */
-     get xrayed(): boolean;
+  get xrayed(): boolean;
 }

package/types/plugins/TreeViewPlugin/renderService.d.ts

@@ -72,7 +72,7 @@ export declare interface ITreeViewRenderService {
    *
    * @returns {String} The node id.
    */
-  getId(element: HTMLElement): string;
+  getId(element: HTMLElement): string | undefined;
 
   /**
    * Returns the node id from the checkbox element.
@@ -90,7 +90,7 @@ export declare interface ITreeViewRenderService {
    *
    * @returns {HTMLElement} The expand/collapse element.
    */
-  getSwitchElement(nodeId: string): HTMLElement
+  getSwitchElement(nodeId: string): HTMLElement | null;
 
   /**
    * Returns the node's checkbox state.

package/types/viewer/scene/models/SceneModel.d.ts

@@ -1,8 +1,8 @@
-import {Component} from "../Component";
-import {SceneModelEntity} from "./SceneModelEntity";
-import {EdgeMaterial, EmphasisMaterial} from "../materials";
-import {SceneModelMesh} from "./SceneModelMesh";
-import {SceneModelTextureSet} from "./SceneModelTextureSet";
+import { Component } from "../Component";
+import { SceneModelEntity } from "./SceneModelEntity";
+import { EdgeMaterial, EmphasisMaterial } from "../materials";
+import { SceneModelMesh } from "./SceneModelMesh";
+import { SceneModelTextureSet } from "./SceneModelTextureSet";
 
 /**
  * A high-performance model representation for efficient rendering and low memory usage.
@@ -168,6 +168,16 @@ export declare class SceneModel extends Component {
      */
     get aabb(): number[];
 
+
+    get numEntities(): number;
+
+    /**
+     * The number of entities in this SceneModel.
+     *
+     * @type {number}
+     */
+    get numEntities(): number;
+
     /**
      * The approximate number of triangle primitives in this SceneModel.
      *
@@ -297,7 +307,7 @@ export declare class SceneModel extends Component {
      *
      * @type {Boolean}
      */
-    set clippable(clippable: boolean) ;
+    set clippable(clippable: boolean);
 
     /**
      * Gets if this SceneModel is collidable.
@@ -395,7 +405,7 @@ export declare class SceneModel extends Component {
      *
      * @type {Boolean}
      */
-    set receivesShadow(receivesShadow: boolean) ;
+    set receivesShadow(receivesShadow: boolean);
 
     /**
      * Gets if Scalable Ambient Obscurance (SAO) will apply to this SceneModel.
@@ -587,67 +597,63 @@ export declare class SceneModel extends Component {
     }): SceneModelMesh;
 
     /**
-     * Creates a mesh within this SceneModel.
+     * Creates a new {@link SceneModelMesh} within this SceneModel.
      *
-     * A mesh can either share geometry with other meshes, or have its own unique geometry.
-     *
-     * To share a geometry with other meshes, provide the ID of a geometry created earlier
-     * with {@link SceneModel.createGeometry}.
-     *
-     * To create unique geometry for the mesh, provide geometry data arrays.
-     *
-     * Internally, SceneModel will batch all unique mesh geometries into the same arrays, which improves
-     * rendering performance.
-     *
-     * If you accompany the arrays with a  ````positionsDecodeMatrix```` , then ````createMesh()```` will assume
-     * that the ````positions```` and ````normals```` arrays are compressed. When compressed, ````positions```` will be
-     * quantized and in World-space, and ````normals```` will be oct-encoded and in World-space.
-     *
-     * If you accompany the arrays with an  ````origin````, then ````createMesh()```` will assume
-     * that the ````positions```` are in relative-to-center (RTC) coordinates, with ````origin```` being the origin of their
-     * RTC coordinate system.
-     *
-     * When providing either ````positionsDecodeMatrix```` or ````origin````, ````createMesh()```` will start a new
-     * batch each time either of those two parameters change since the last call. Therefore, to combine arrays into the
-     * minimum number of batches, it's best for performance to create your shared meshes in runs that have the same value
-     * for ````positionsDecodeMatrix```` and ````origin````.
-     *
-     * Note that ````positions````, ````normals```` and ````indices```` are all required together.
+     * * It prepares and saves data for a SceneModelMesh {@link SceneModel#meshes} creation. SceneModelMesh will be created only once the SceneModelEntity (which references this particular SceneModelMesh) will be created.
+     * * The SceneModelMesh can either define its own geometry or share it with other SceneModelMeshes. To define own geometry, provide the
+     * various geometry arrays to this method. To share a geometry, provide the ID of a geometry created earlier
+     * with {@link SceneModel#createGeometry}.
+     * * If you accompany the arrays with an  ````origin````, then ````createMesh()```` will assume
+     * that the geometry ````positions```` are in relative-to-center (RTC) coordinates, with ````origin```` being the
+     * origin of their RTC coordinate system.
      *
      * @param {object} cfg Object properties.
-     * @param {string} cfg.id Mandatory ID for the new mesh. Must not clash with any existing components within the {@link Scene}.
-     * @param {string|number} [cfg.geometryId] ID of a geometry to instance, previously created with {@link SceneModel.createGeometry:method"}}createMesh(){{/crossLink}}. Overrides all other geometry parameters given to this method.
-     * @param {string} [cfg.primitive="triangles"]  Geometry primitive type. Ignored when ````geometryId```` is given. Accepted values are 'points', 'lines' and 'triangles'.
-     * @param {number[]} [cfg.positions] Flat array of vertex positions. Ignored when ````geometryId```` is given.
-     * @param {number[]} [cfg.colors] Flat array of RGB vertex colors as float values in range ````[0..1]````. Ignored when ````geometryId```` is given, overriden by ````color```` and ````colorsCompressed````.
-     * @param {number[]} [cfg.colorsCompressed] Flat array of RGB vertex colors as unsigned short integers in range ````[0..255]````. Ignored when ````geometryId```` is given, overrides ````colors```` and is overriden by ````color````.
-     * @param {number[]} [cfg.normals] Flat array of normal vectors. Only used with 'triangles' primitives. When no normals are given, the mesh will be flat shaded using auto-generated face-aligned normals.
-     * @param {number[]} [cfg.positionsDecodeMatrix] A 4x4 matrix for decompressing ````positions````.
-     * @param {number[]} [cfg.origin] Optional geometry origin, relative to {@link SceneModel.origin}. When this is given, then ````positions```` are assumed to be relative to this.
-     * @param {number[]} [cfg.indices] Array of triangle indices. Ignored when ````geometryId```` is given.
-     * @param {number[]} [cfg.edgeIndices] Array of edge line indices. If ````geometryId```` is not given, edge line indices are
-     * automatically generated internally if not given, using the ````edgeThreshold```` given to the ````SceneModel````
-     * constructor. This parameter is ignored when ````geometryId```` is given.
-     * @param {number[]} [cfg.position=[0,0,0]] Local 3D position. of the mesh
-     * @param {number[]} [cfg.scale=[1,1,1]] Scale of the mesh.
-     * @param {number[]} [cfg.rotation=[0,0,0]] Rotation of the mesh as Euler angles given in degrees, for each of the X, Y and Z axis.
-     * @param {number[]} [cfg.matrix=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1]] Mesh modelling transform matrix. Overrides the ````position````, ````scale```` and ````rotation```` parameters.
-     * @param {number[]} [cfg.color=[1,1,1]] RGB color in range ````[0..1, 0..`, 0..1]````. Overrides ````colors```` and ````colorsCompressed````.
-     * @param {number} [cfg.opacity=1] Opacity in range ````[0..1]````.
+     * @param {String} cfg.id Mandatory ID for the new mesh. Must not clash with any existing components within the {@link Scene}.
+     * @param {String|Number} [cfg.textureSetId] ID of a {@link SceneModelTextureSet} previously created with {@link SceneModel#createTextureSet}.
+     * @param {String|Number} [cfg.transformId] ID of a {@link SceneModelTransform} to instance, previously created with {@link SceneModel#createTransform}. Overrides all other transform parameters given to this method.
+     * @param {String|Number} [cfg.geometryId] ID of a geometry to instance, previously created with {@link SceneModel#createGeometry}. Overrides all other geometry parameters given to this method.
+     * @param {String} cfg.primitive The primitive type. Accepted values are 'points', 'lines', 'triangles', 'solid' and 'surface'.
+     * @param {Number[]} [cfg.positions] Flat array of uncompressed 3D vertex positions positions. Required for all primitive types. Overridden by ````positionsCompressed````.
+     * @param {Number[]} [cfg.positionsCompressed] Flat array of quantized 3D vertex positions. Overrides ````positions````, and must be accompanied by ````positionsDecodeMatrix````.
+     * @param {Number[]} [cfg.positionsDecodeMatrix] A 4x4 matrix for decompressing ````positionsCompressed````. Must be accompanied by ````positionsCompressed````.
+     * @param {Number[]} [cfg.normals] Flat array of normal vectors. Only used with "triangles", "solid" and "surface" primitives. When no normals are given, the geometry will be flat shaded using auto-generated face-aligned normals.
+     * @param {Number[]} [cfg.normalsCompressed] Flat array of oct-encoded normal vectors. Overrides ````normals````. Only used with "triangles", "solid" and "surface" primitives. When no normals are given, the geometry will be flat shaded using auto-generated face-aligned normals.
+     * @param {Number[]} [cfg.colors] Flat array of uncompressed RGBA vertex colors, as float values in range ````[0..1]````. Ignored when ````geometryId```` is given. Overridden by ````color```` and ````colorsCompressed````.
+     * @param {Number[]} [cfg.colorsCompressed] Flat array of compressed RGBA vertex colors, as unsigned short integers in range ````[0..255]````. Ignored when ````geometryId```` is given. Overrides ````colors```` and is overridden by ````color````.
+     * @param {Number[]} [cfg.uv] Flat array of uncompressed vertex UV coordinates. Only used with "triangles", "solid" and "surface" primitives. Required for textured rendering.
+     * @param {Number[]} [cfg.uvCompressed] Flat array of compressed vertex UV coordinates. Only used with "triangles", "solid" and "surface" primitives. Overrides ````uv````. Must be accompanied by ````uvDecodeMatrix````. Only used with "triangles", "solid" and "surface" primitives. Required for textured rendering.
+     * @param {Number[]} [cfg.uvDecodeMatrix] A 3x3 matrix for decompressing ````uvCompressed````.
+     * @param {Number[]} [cfg.indices] Array of primitive connectivity indices. Not required for `points` primitives.
+     * @param {Number[]} [cfg.edgeIndices] Array of edge line indices. Used only with 'triangles', 'solid' and 'surface' primitives. Automatically generated internally if not supplied, using the optional ````edgeThreshold```` given to the ````SceneModel```` constructor.
+     * @param {Number[]} [cfg.origin] Optional geometry origin, relative to {@link SceneModel#origin}. When this is given, then ````positions```` are assumed to be relative to this.
+     * @param {Number[]} [cfg.position=[0,0,0]] Local 3D position of the mesh. Overridden by ````transformId````.
+     * @param {Number[]} [cfg.scale=[1,1,1]] Scale of the mesh.  Overridden by ````transformId````.
+     * @param {Number[]} [cfg.rotation=[0,0,0]] Rotation of the mesh as Euler angles given in degrees, for each of the X, Y and Z axis.  Overridden by ````transformId````.
+     * @param {Number[]} [cfg.matrix=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1]] Mesh modelling transform matrix. Overrides the ````position````, ````scale```` and ````rotation```` parameters. Also  overridden by ````transformId````.
+     * @param {Number[]} [cfg.color=[1,1,1]] RGB color in range ````[0..1, 0..1, 0..1]````. Overridden by texture set ````colorTexture````. Overrides ````colors```` and ````colorsCompressed````.
+     * @param {Number} [cfg.opacity=1] Opacity in range ````[0..1]````. Overridden by texture set ````colorTexture````.
+     * @param {Number} [cfg.metallic=0] Metallic factor in range ````[0..1]````. Overridden by texture set ````metallicRoughnessTexture````.
+     * @param {Number} [cfg.roughness=1] Roughness factor in range ````[0..1]````. Overridden by texture set ````metallicRoughnessTexture````.
+     * @returns {Boolean} True = successfully mesh was created. False = error during creation of a mesh.
      */
     createMesh(cfg: {
         id: string;
-        geometryId?: string | number;
-        transformId?: string | number;
         textureSetId?: string | number;
+        transformId?: string | number;
+        geometryId?: string | number;
         primitive: "lines" | "triangles" | "points";
         positions: number[];
+        positionsCompressed: number[];
+        positionsDecodeMatrix: number[];
         normals: number[];
+        normalsCompressed: number[];
         colors: number[];
         colorsCompressed: number[];
+        uv: number[];
+        uvCompressed: number[];
+        uvDecodeMatrix: number[];
         indices: number[];
         edgeIndices: number[];
-        positionsDecodeMatrix: number[];
         origin?: number[];
         position?: number[];
         scale?: number[];
@@ -655,7 +661,9 @@ export declare class SceneModel extends Component {
         matrix?: number[];
         color?: number[];
         opacity?: number;
-    }): SceneModelMesh;
+        metallic?: number;
+        roughness?: number;
+    }): boolean;
 
     /**
      * Creates an {@link SceneModelEntity} within this SceneModel, giving it one or more meshes previously created with {@link SceneModel.createMesh}.