@itwin/core-backend 4.0.0-dev.52 → 4.0.0-dev.54

package/lib/cjs/Material.d.ts

@@ -1,132 +1,132 @@
-/** @packageDocumentation
- * @module Elements
- */
-import { Id64String } from "@itwin/core-bentley";
-import { Code, CodeScopeProps, NormalMapProps, RenderMaterialProps, RgbFactorProps, TextureMapProps } from "@itwin/core-common";
-import { DefinitionElement } from "./Element";
-import { IModelDb } from "./IModelDb";
-/** A PhysicalMaterial defines the matter that makes up physical elements.
- * @note See [[RenderMaterialElement]] for the DefinitionElement used to define rendering characteristics.
- * @public
- */
-export declare abstract class PhysicalMaterial extends DefinitionElement {
-    /** @internal */
-    static get className(): string;
-    /** Create a Code for a PhysicalMaterial given a name that is meant to be unique within the scope of the specified DefinitionModel.
-     * @param iModel  The IModelDb
-     * @param definitionModelId The Id of the DefinitionModel that will contain the PhysicalMaterial and provide the scope for its name.
-     * @param name The name (codeValue) of the PhysicalMaterial
-     */
-    static createCode(iModel: IModelDb, definitionModelId: CodeScopeProps, name: string): Code;
-    /** Create a PhysicalMaterial
-     * @param iModelDb The IModelDb
-     * @param definitionModelId The Id of the DefinitionModel that will contain the PhysicalMaterial and provide the scope for its name.
-     * @param name The name (codeValue) of the PhysicalMaterial
-     * @returns The newly constructed PhysicalMaterial
-     * @throws [[IModelError]] if there is a problem creating the PhysicalMaterial
-     */
-    static create<T extends PhysicalMaterial>(iModelDb: IModelDb, definitionModelId: CodeScopeProps, name: string): T;
-}
-/** Defines a rendering material.
- * @note See [[PhysicalMaterial]] for the DefinitionElement used to define the matter that makes up physical elements.
- * @public
- */
-export declare class RenderMaterialElement extends DefinitionElement {
-    /** @internal */
-    static get className(): string;
-    /** The name of a palette that can be used to categorize multiple materials. */
-    paletteName: string;
-    /** An optional description of the material. */
-    description?: string;
-    /** @internal */
-    constructor(props: RenderMaterialProps, iModel: IModelDb);
-    /** @internal */
-    toJSON(): RenderMaterialProps;
-    /** Create a Code for a RenderMaterial given a name that is meant to be unique within the scope of the specified DefinitionModel.
-     * @param iModel  The IModelDb
-     * @param scopeModelId The Id of the DefinitionModel that contains the RenderMaterial and provides the scope for its name.
-     * @param name The RenderMaterial name
-     */
-    static createCode(iModel: IModelDb, scopeModelId: CodeScopeProps, name: string): Code;
-    /**
-     * Create a RenderMaterial with given parameters.
-     * @param iModelDb The iModel
-     * @param definitionModelId The [[DefinitionModel]]
-     * @param materialName The name/CodeValue of the RenderMaterial
-     * @param params Parameters object which describes how to construct the RenderMaterial
-     * @returns The newly constructed RenderMaterial element.
-     * @throws [[IModelError]] if unable to create the element.
-     */
-    static create(iModelDb: IModelDb, definitionModelId: Id64String, materialName: string, params: RenderMaterialElementParams): RenderMaterialElement;
-    /**
-     * Insert a new RenderMaterial into a model.
-     * @param iModelDb Insert into this iModel
-     * @param definitionModelId Insert the new Texture into this DefinitionModel
-     * @param materialName The name/CodeValue of the RenderMaterial
-     * @param params Parameters object which describes how to construct the RenderMaterial
-     * @returns The Id of the newly inserted RenderMaterial element.
-     * @throws [[IModelError]] if unable to insert the element.
-     */
-    static insert(iModelDb: IModelDb, definitionModelId: Id64String, materialName: string, params: RenderMaterialElementParams): Id64String;
-}
-/** @public */
-export declare namespace RenderMaterialElement {
-    /** Parameters used to construct a [[RenderMaterial]].
-     * The persistent JSON representation - [RenderMaterialAssetProps]($common) - is quite verbose and unwieldy. This representation simplifies it somewhat.
-     * @see [[RenderMaterialElement.create]] and [[RenderMaterialElement.insert]] to create a [[RenderMaterial]] from parameters of this type.
-     * @deprecated in 3.6 because it is not useful to use a `class` - just use [[RenderMaterialElementParams]] directly instead.
-     */
-    class Params {
-        /** A required palette name that categorizes this RenderMaterial */
-        paletteName: string;
-        /** An optional description of this RenderMaterial */
-        description?: string;
-        /** If defined, the color to use for surface fill or diffuse illumination, overriding the surface's own color. */
-        color?: RgbFactorProps;
-        /** The color to use for specular illumination. Default: black. */
-        specularColor?: RgbFactorProps;
-        /** The specular exponent describing the surface's shininess, in the range 0 through 128.
-         * Default: 0.
-         */
-        finish?: number;
-        /** A transparency to be applied to the surface, ranging from 0 (fully opaque) to 1 (fully transparent).
-         * The surface's own transparency will be multiplied by `(1 - transmit)`. permitting the material to increase but not decrease the surface transparency.
-         * Default: 13.5.
-         */
-        transmit?: number;
-        /** The surface's diffuse reflectivity from 0.0 to 1.0. Default: 0.6. */
-        diffuse?: number;
-        /** The surface's specular reflectivity from 0.0 to 1.0. Default: 0.0. */
-        specular?: number;
-        /** Currently unused. */
-        reflect?: number;
-        /** Currently unused. */
-        reflectColor?: number[];
-        /** Specifies a texture image to map onto the surface, replacing or mixing with the surface's own color and transparency.
-         * @note With the exception of `TextureId`, the [TextureMapProps]($common) of [[patternMap]] and [[normalMap]] are expected to be identical. If a property is defined in both
-         * [[patternMap]]] and [[normalMap]], the value in [[patternMap]] takes precedence.
-         */
-        patternMap?: TextureMapProps;
-        /** Specifies a [normal map](https://en.wikipedia.org/wiki/Normal_mapping) to apply to the surface to simulate more surface detail than is present in the
-         * surface's geometry.
-         * @note With the exception of `TextureId`, the [TextureMapProps]($common) of [[patternMap]] and [[normalMap]] are expected to be identical. If a property is defined in both
-         * [[patternMap]]] and [[normalMap]], the value in [[patternMap]] takes precedence.
-         */
-        normalMap?: NormalMapProps & {
-            /** A factor by which to multiply the components of the normal vectors read from the texture.
-             * Default: 1.
-             */
-            scale?: number;
-        };
-        /** Construct a new RenderMaterial.Params object with the specified paletteName. Alter the public members on that object to specify settings. */
-        constructor(paletteName: string);
-    }
-}
-/** Parameters used to create a [[RenderMaterial]] element.
- * The persistent JSON representation - [RenderMaterialAssetProps]($common) - is quite verbose and unwieldy. This representation simplifies it somewhat.
- * @see [[RenderMaterialElement.create]] and [[RenderMaterialElement.insert]] to create a [[RenderMaterial]] from parameters of this type.
- * @public
- */
-export interface RenderMaterialElementParams extends RenderMaterialElement.Params {
-}
+/** @packageDocumentation
+ * @module Elements
+ */
+import { Id64String } from "@itwin/core-bentley";
+import { Code, CodeScopeProps, NormalMapProps, RenderMaterialProps, RgbFactorProps, TextureMapProps } from "@itwin/core-common";
+import { DefinitionElement } from "./Element";
+import { IModelDb } from "./IModelDb";
+/** A PhysicalMaterial defines the matter that makes up physical elements.
+ * @note See [[RenderMaterialElement]] for the DefinitionElement used to define rendering characteristics.
+ * @public
+ */
+export declare abstract class PhysicalMaterial extends DefinitionElement {
+    /** @internal */
+    static get className(): string;
+    /** Create a Code for a PhysicalMaterial given a name that is meant to be unique within the scope of the specified DefinitionModel.
+     * @param iModel  The IModelDb
+     * @param definitionModelId The Id of the DefinitionModel that will contain the PhysicalMaterial and provide the scope for its name.
+     * @param name The name (codeValue) of the PhysicalMaterial
+     */
+    static createCode(iModel: IModelDb, definitionModelId: CodeScopeProps, name: string): Code;
+    /** Create a PhysicalMaterial
+     * @param iModelDb The IModelDb
+     * @param definitionModelId The Id of the DefinitionModel that will contain the PhysicalMaterial and provide the scope for its name.
+     * @param name The name (codeValue) of the PhysicalMaterial
+     * @returns The newly constructed PhysicalMaterial
+     * @throws [[IModelError]] if there is a problem creating the PhysicalMaterial
+     */
+    static create<T extends PhysicalMaterial>(iModelDb: IModelDb, definitionModelId: CodeScopeProps, name: string): T;
+}
+/** Defines a rendering material.
+ * @note See [[PhysicalMaterial]] for the DefinitionElement used to define the matter that makes up physical elements.
+ * @public
+ */
+export declare class RenderMaterialElement extends DefinitionElement {
+    /** @internal */
+    static get className(): string;
+    /** The name of a palette that can be used to categorize multiple materials. */
+    paletteName: string;
+    /** An optional description of the material. */
+    description?: string;
+    /** @internal */
+    constructor(props: RenderMaterialProps, iModel: IModelDb);
+    /** @internal */
+    toJSON(): RenderMaterialProps;
+    /** Create a Code for a RenderMaterial given a name that is meant to be unique within the scope of the specified DefinitionModel.
+     * @param iModel  The IModelDb
+     * @param scopeModelId The Id of the DefinitionModel that contains the RenderMaterial and provides the scope for its name.
+     * @param name The RenderMaterial name
+     */
+    static createCode(iModel: IModelDb, scopeModelId: CodeScopeProps, name: string): Code;
+    /**
+     * Create a RenderMaterial with given parameters.
+     * @param iModelDb The iModel
+     * @param definitionModelId The [[DefinitionModel]]
+     * @param materialName The name/CodeValue of the RenderMaterial
+     * @param params Parameters object which describes how to construct the RenderMaterial
+     * @returns The newly constructed RenderMaterial element.
+     * @throws [[IModelError]] if unable to create the element.
+     */
+    static create(iModelDb: IModelDb, definitionModelId: Id64String, materialName: string, params: RenderMaterialElementParams): RenderMaterialElement;
+    /**
+     * Insert a new RenderMaterial into a model.
+     * @param iModelDb Insert into this iModel
+     * @param definitionModelId Insert the new Texture into this DefinitionModel
+     * @param materialName The name/CodeValue of the RenderMaterial
+     * @param params Parameters object which describes how to construct the RenderMaterial
+     * @returns The Id of the newly inserted RenderMaterial element.
+     * @throws [[IModelError]] if unable to insert the element.
+     */
+    static insert(iModelDb: IModelDb, definitionModelId: Id64String, materialName: string, params: RenderMaterialElementParams): Id64String;
+}
+/** @public */
+export declare namespace RenderMaterialElement {
+    /** Parameters used to construct a [[RenderMaterial]].
+     * The persistent JSON representation - [RenderMaterialAssetProps]($common) - is quite verbose and unwieldy. This representation simplifies it somewhat.
+     * @see [[RenderMaterialElement.create]] and [[RenderMaterialElement.insert]] to create a [[RenderMaterial]] from parameters of this type.
+     * @deprecated in 3.6 because it is not useful to use a `class` - just use [[RenderMaterialElementParams]] directly instead.
+     */
+    class Params {
+        /** A required palette name that categorizes this RenderMaterial */
+        paletteName: string;
+        /** An optional description of this RenderMaterial */
+        description?: string;
+        /** If defined, the color to use for surface fill or diffuse illumination, overriding the surface's own color. */
+        color?: RgbFactorProps;
+        /** The color to use for specular illumination. Default: black. */
+        specularColor?: RgbFactorProps;
+        /** The specular exponent describing the surface's shininess, in the range 0 through 128.
+         * Default: 0.
+         */
+        finish?: number;
+        /** A transparency to be applied to the surface, ranging from 0 (fully opaque) to 1 (fully transparent).
+         * The surface's own transparency will be multiplied by `(1 - transmit)`. permitting the material to increase but not decrease the surface transparency.
+         * Default: 13.5.
+         */
+        transmit?: number;
+        /** The surface's diffuse reflectivity from 0.0 to 1.0. Default: 0.6. */
+        diffuse?: number;
+        /** The surface's specular reflectivity from 0.0 to 1.0. Default: 0.0. */
+        specular?: number;
+        /** Currently unused. */
+        reflect?: number;
+        /** Currently unused. */
+        reflectColor?: number[];
+        /** Specifies a texture image to map onto the surface, replacing or mixing with the surface's own color and transparency.
+         * @note With the exception of `TextureId`, the [TextureMapProps]($common) of [[patternMap]] and [[normalMap]] are expected to be identical. If a property is defined in both
+         * [[patternMap]]] and [[normalMap]], the value in [[patternMap]] takes precedence.
+         */
+        patternMap?: TextureMapProps;
+        /** Specifies a [normal map](https://en.wikipedia.org/wiki/Normal_mapping) to apply to the surface to simulate more surface detail than is present in the
+         * surface's geometry.
+         * @note With the exception of `TextureId`, the [TextureMapProps]($common) of [[patternMap]] and [[normalMap]] are expected to be identical. If a property is defined in both
+         * [[patternMap]]] and [[normalMap]], the value in [[patternMap]] takes precedence.
+         */
+        normalMap?: NormalMapProps & {
+            /** A factor by which to multiply the components of the normal vectors read from the texture.
+             * Default: 1.
+             */
+            scale?: number;
+        };
+        /** Construct a new RenderMaterial.Params object with the specified paletteName. Alter the public members on that object to specify settings. */
+        constructor(paletteName: string);
+    }
+}
+/** Parameters used to create a [[RenderMaterial]] element.
+ * The persistent JSON representation - [RenderMaterialAssetProps]($common) - is quite verbose and unwieldy. This representation simplifies it somewhat.
+ * @see [[RenderMaterialElement.create]] and [[RenderMaterialElement.insert]] to create a [[RenderMaterial]] from parameters of this type.
+ * @public
+ */
+export interface RenderMaterialElementParams extends RenderMaterialElement.Params {
+}
 //# sourceMappingURL=Material.d.ts.map

package/lib/cjs/Material.js

@@ -1,181 +1,181 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Elements
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RenderMaterialElement = exports.PhysicalMaterial = void 0;
-const core_common_1 = require("@itwin/core-common");
-const Element_1 = require("./Element");
-/* eslint-disable @typescript-eslint/naming-convention */
-/** A PhysicalMaterial defines the matter that makes up physical elements.
- * @note See [[RenderMaterialElement]] for the DefinitionElement used to define rendering characteristics.
- * @public
- */
-class PhysicalMaterial extends Element_1.DefinitionElement {
-    /** @internal */
-    static get className() { return "PhysicalMaterial"; }
-    /** Create a Code for a PhysicalMaterial given a name that is meant to be unique within the scope of the specified DefinitionModel.
-     * @param iModel  The IModelDb
-     * @param definitionModelId The Id of the DefinitionModel that will contain the PhysicalMaterial and provide the scope for its name.
-     * @param name The name (codeValue) of the PhysicalMaterial
-     */
-    static createCode(iModel, definitionModelId, name) {
-        const codeSpec = iModel.codeSpecs.getByName(core_common_1.BisCodeSpec.physicalMaterial);
-        return new core_common_1.Code({ spec: codeSpec.id, scope: definitionModelId, value: name });
-    }
-    /** Create a PhysicalMaterial
-     * @param iModelDb The IModelDb
-     * @param definitionModelId The Id of the DefinitionModel that will contain the PhysicalMaterial and provide the scope for its name.
-     * @param name The name (codeValue) of the PhysicalMaterial
-     * @returns The newly constructed PhysicalMaterial
-     * @throws [[IModelError]] if there is a problem creating the PhysicalMaterial
-     */
-    static create(iModelDb, definitionModelId, name) {
-        const elementProps = {
-            classFullName: this.classFullName,
-            model: definitionModelId,
-            code: this.createCode(iModelDb, definitionModelId, name),
-        };
-        return iModelDb.elements.createElement(elementProps);
-    }
-}
-exports.PhysicalMaterial = PhysicalMaterial;
-/** Defines a rendering material.
- * @note See [[PhysicalMaterial]] for the DefinitionElement used to define the matter that makes up physical elements.
- * @public
- */
-class RenderMaterialElement extends Element_1.DefinitionElement {
-    /** @internal */
-    constructor(props, iModel) {
-        super(props, iModel);
-        this.paletteName = props.paletteName;
-        this.description = props.description;
-    }
-    /** @internal */
-    static get className() { return "RenderMaterial"; }
-    /** @internal */
-    toJSON() {
-        const val = super.toJSON();
-        val.paletteName = this.paletteName;
-        val.description = this.description;
-        return val;
-    }
-    /** Create a Code for a RenderMaterial given a name that is meant to be unique within the scope of the specified DefinitionModel.
-     * @param iModel  The IModelDb
-     * @param scopeModelId The Id of the DefinitionModel that contains the RenderMaterial and provides the scope for its name.
-     * @param name The RenderMaterial name
-     */
-    static createCode(iModel, scopeModelId, name) {
-        const codeSpec = iModel.codeSpecs.getByName(core_common_1.BisCodeSpec.texture);
-        return 0 === name.length ? core_common_1.Code.createEmpty() : new core_common_1.Code({ spec: codeSpec.id, scope: scopeModelId, value: name });
-    }
-    /**
-     * Create a RenderMaterial with given parameters.
-     * @param iModelDb The iModel
-     * @param definitionModelId The [[DefinitionModel]]
-     * @param materialName The name/CodeValue of the RenderMaterial
-     * @param params Parameters object which describes how to construct the RenderMaterial
-     * @returns The newly constructed RenderMaterial element.
-     * @throws [[IModelError]] if unable to create the element.
-     */
-    static create(iModelDb, definitionModelId, materialName, params) {
-        let maps;
-        const pbr_normal = params.normalMap?.scale;
-        if (params.patternMap || params.normalMap) {
-            function choose(obj, key) {
-                const pat = params.patternMap;
-                if (pat && undefined !== pat[key])
-                    obj[key] = pat[key];
-                else if (params.normalMap && undefined !== params.normalMap[key])
-                    obj[key] = params.normalMap[key];
-            }
-            const baseProps = {};
-            choose(baseProps, "pattern_angle");
-            choose(baseProps, "pattern_u_flip");
-            choose(baseProps, "pattern_flip");
-            choose(baseProps, "pattern_scale");
-            choose(baseProps, "pattern_offset");
-            choose(baseProps, "pattern_scalemode");
-            choose(baseProps, "pattern_mapping");
-            choose(baseProps, "pattern_weight");
-            maps = {};
-            if (params.patternMap)
-                maps.Pattern = { ...params.patternMap, ...baseProps };
-            if (params.normalMap) {
-                maps.Normal = {
-                    ...params.normalMap,
-                    ...baseProps,
-                };
-                delete maps.Normal.scale;
-            }
-        }
-        // const map = undefined !== params.patternMap ? { Pattern: params.patternMap } : undefined;
-        const renderMaterialProps = {
-            classFullName: this.classFullName,
-            code: this.createCode(iModelDb, definitionModelId, materialName),
-            paletteName: params.paletteName,
-            description: params.description,
-            jsonProperties: {
-                materialAssets: {
-                    renderMaterial: {
-                        HasBaseColor: params.color !== undefined,
-                        color: params.color,
-                        HasSpecularColor: params.specularColor !== undefined,
-                        specular_color: params.specularColor,
-                        HasFinish: params.finish !== undefined,
-                        finish: params.finish,
-                        HasTransmit: params.transmit !== undefined,
-                        transmit: params.transmit,
-                        HasDiffuse: params.diffuse !== undefined,
-                        diffuse: params.diffuse,
-                        HasSpecular: params.specular !== undefined,
-                        specular: params.specular,
-                        HasReflect: params.reflect !== undefined,
-                        reflect: params.reflect,
-                        HasReflectColor: params.reflectColor !== undefined,
-                        reflect_color: params.reflectColor,
-                        Map: maps,
-                        pbr_normal,
-                    },
-                },
-            },
-            model: definitionModelId,
-            isPrivate: false,
-        };
-        return new RenderMaterialElement(renderMaterialProps, iModelDb);
-    }
-    /**
-     * Insert a new RenderMaterial into a model.
-     * @param iModelDb Insert into this iModel
-     * @param definitionModelId Insert the new Texture into this DefinitionModel
-     * @param materialName The name/CodeValue of the RenderMaterial
-     * @param params Parameters object which describes how to construct the RenderMaterial
-     * @returns The Id of the newly inserted RenderMaterial element.
-     * @throws [[IModelError]] if unable to insert the element.
-     */
-    static insert(iModelDb, definitionModelId, materialName, params) {
-        const renderMaterial = this.create(iModelDb, definitionModelId, materialName, params);
-        return iModelDb.elements.insertElement(renderMaterial.toJSON());
-    }
-}
-exports.RenderMaterialElement = RenderMaterialElement;
-/** @public */
-(function (RenderMaterialElement) {
-    /** Parameters used to construct a [[RenderMaterial]].
-     * The persistent JSON representation - [RenderMaterialAssetProps]($common) - is quite verbose and unwieldy. This representation simplifies it somewhat.
-     * @see [[RenderMaterialElement.create]] and [[RenderMaterialElement.insert]] to create a [[RenderMaterial]] from parameters of this type.
-     * @deprecated in 3.6 because it is not useful to use a `class` - just use [[RenderMaterialElementParams]] directly instead.
-     */
-    class Params {
-        /** Construct a new RenderMaterial.Params object with the specified paletteName. Alter the public members on that object to specify settings. */
-        constructor(paletteName) {
-            this.paletteName = paletteName;
-        }
-    }
-    RenderMaterialElement.Params = Params;
-})(RenderMaterialElement = exports.RenderMaterialElement || (exports.RenderMaterialElement = {}));
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Elements
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenderMaterialElement = exports.PhysicalMaterial = void 0;
+const core_common_1 = require("@itwin/core-common");
+const Element_1 = require("./Element");
+/* eslint-disable @typescript-eslint/naming-convention */
+/** A PhysicalMaterial defines the matter that makes up physical elements.
+ * @note See [[RenderMaterialElement]] for the DefinitionElement used to define rendering characteristics.
+ * @public
+ */
+class PhysicalMaterial extends Element_1.DefinitionElement {
+    /** @internal */
+    static get className() { return "PhysicalMaterial"; }
+    /** Create a Code for a PhysicalMaterial given a name that is meant to be unique within the scope of the specified DefinitionModel.
+     * @param iModel  The IModelDb
+     * @param definitionModelId The Id of the DefinitionModel that will contain the PhysicalMaterial and provide the scope for its name.
+     * @param name The name (codeValue) of the PhysicalMaterial
+     */
+    static createCode(iModel, definitionModelId, name) {
+        const codeSpec = iModel.codeSpecs.getByName(core_common_1.BisCodeSpec.physicalMaterial);
+        return new core_common_1.Code({ spec: codeSpec.id, scope: definitionModelId, value: name });
+    }
+    /** Create a PhysicalMaterial
+     * @param iModelDb The IModelDb
+     * @param definitionModelId The Id of the DefinitionModel that will contain the PhysicalMaterial and provide the scope for its name.
+     * @param name The name (codeValue) of the PhysicalMaterial
+     * @returns The newly constructed PhysicalMaterial
+     * @throws [[IModelError]] if there is a problem creating the PhysicalMaterial
+     */
+    static create(iModelDb, definitionModelId, name) {
+        const elementProps = {
+            classFullName: this.classFullName,
+            model: definitionModelId,
+            code: this.createCode(iModelDb, definitionModelId, name),
+        };
+        return iModelDb.elements.createElement(elementProps);
+    }
+}
+exports.PhysicalMaterial = PhysicalMaterial;
+/** Defines a rendering material.
+ * @note See [[PhysicalMaterial]] for the DefinitionElement used to define the matter that makes up physical elements.
+ * @public
+ */
+class RenderMaterialElement extends Element_1.DefinitionElement {
+    /** @internal */
+    static get className() { return "RenderMaterial"; }
+    /** @internal */
+    constructor(props, iModel) {
+        super(props, iModel);
+        this.paletteName = props.paletteName;
+        this.description = props.description;
+    }
+    /** @internal */
+    toJSON() {
+        const val = super.toJSON();
+        val.paletteName = this.paletteName;
+        val.description = this.description;
+        return val;
+    }
+    /** Create a Code for a RenderMaterial given a name that is meant to be unique within the scope of the specified DefinitionModel.
+     * @param iModel  The IModelDb
+     * @param scopeModelId The Id of the DefinitionModel that contains the RenderMaterial and provides the scope for its name.
+     * @param name The RenderMaterial name
+     */
+    static createCode(iModel, scopeModelId, name) {
+        const codeSpec = iModel.codeSpecs.getByName(core_common_1.BisCodeSpec.texture);
+        return 0 === name.length ? core_common_1.Code.createEmpty() : new core_common_1.Code({ spec: codeSpec.id, scope: scopeModelId, value: name });
+    }
+    /**
+     * Create a RenderMaterial with given parameters.
+     * @param iModelDb The iModel
+     * @param definitionModelId The [[DefinitionModel]]
+     * @param materialName The name/CodeValue of the RenderMaterial
+     * @param params Parameters object which describes how to construct the RenderMaterial
+     * @returns The newly constructed RenderMaterial element.
+     * @throws [[IModelError]] if unable to create the element.
+     */
+    static create(iModelDb, definitionModelId, materialName, params) {
+        let maps;
+        const pbr_normal = params.normalMap?.scale;
+        if (params.patternMap || params.normalMap) {
+            function choose(obj, key) {
+                const pat = params.patternMap;
+                if (pat && undefined !== pat[key])
+                    obj[key] = pat[key];
+                else if (params.normalMap && undefined !== params.normalMap[key])
+                    obj[key] = params.normalMap[key];
+            }
+            const baseProps = {};
+            choose(baseProps, "pattern_angle");
+            choose(baseProps, "pattern_u_flip");
+            choose(baseProps, "pattern_flip");
+            choose(baseProps, "pattern_scale");
+            choose(baseProps, "pattern_offset");
+            choose(baseProps, "pattern_scalemode");
+            choose(baseProps, "pattern_mapping");
+            choose(baseProps, "pattern_weight");
+            maps = {};
+            if (params.patternMap)
+                maps.Pattern = { ...params.patternMap, ...baseProps };
+            if (params.normalMap) {
+                maps.Normal = {
+                    ...params.normalMap,
+                    ...baseProps,
+                };
+                delete maps.Normal.scale;
+            }
+        }
+        // const map = undefined !== params.patternMap ? { Pattern: params.patternMap } : undefined;
+        const renderMaterialProps = {
+            classFullName: this.classFullName,
+            code: this.createCode(iModelDb, definitionModelId, materialName),
+            paletteName: params.paletteName,
+            description: params.description,
+            jsonProperties: {
+                materialAssets: {
+                    renderMaterial: {
+                        HasBaseColor: params.color !== undefined,
+                        color: params.color,
+                        HasSpecularColor: params.specularColor !== undefined,
+                        specular_color: params.specularColor,
+                        HasFinish: params.finish !== undefined,
+                        finish: params.finish,
+                        HasTransmit: params.transmit !== undefined,
+                        transmit: params.transmit,
+                        HasDiffuse: params.diffuse !== undefined,
+                        diffuse: params.diffuse,
+                        HasSpecular: params.specular !== undefined,
+                        specular: params.specular,
+                        HasReflect: params.reflect !== undefined,
+                        reflect: params.reflect,
+                        HasReflectColor: params.reflectColor !== undefined,
+                        reflect_color: params.reflectColor,
+                        Map: maps,
+                        pbr_normal,
+                    },
+                },
+            },
+            model: definitionModelId,
+            isPrivate: false,
+        };
+        return new RenderMaterialElement(renderMaterialProps, iModelDb);
+    }
+    /**
+     * Insert a new RenderMaterial into a model.
+     * @param iModelDb Insert into this iModel
+     * @param definitionModelId Insert the new Texture into this DefinitionModel
+     * @param materialName The name/CodeValue of the RenderMaterial
+     * @param params Parameters object which describes how to construct the RenderMaterial
+     * @returns The Id of the newly inserted RenderMaterial element.
+     * @throws [[IModelError]] if unable to insert the element.
+     */
+    static insert(iModelDb, definitionModelId, materialName, params) {
+        const renderMaterial = this.create(iModelDb, definitionModelId, materialName, params);
+        return iModelDb.elements.insertElement(renderMaterial.toJSON());
+    }
+}
+exports.RenderMaterialElement = RenderMaterialElement;
+/** @public */
+(function (RenderMaterialElement) {
+    /** Parameters used to construct a [[RenderMaterial]].
+     * The persistent JSON representation - [RenderMaterialAssetProps]($common) - is quite verbose and unwieldy. This representation simplifies it somewhat.
+     * @see [[RenderMaterialElement.create]] and [[RenderMaterialElement.insert]] to create a [[RenderMaterial]] from parameters of this type.
+     * @deprecated in 3.6 because it is not useful to use a `class` - just use [[RenderMaterialElementParams]] directly instead.
+     */
+    class Params {
+        /** Construct a new RenderMaterial.Params object with the specified paletteName. Alter the public members on that object to specify settings. */
+        constructor(paletteName) {
+            this.paletteName = paletteName;
+        }
+    }
+    RenderMaterialElement.Params = Params;
+})(RenderMaterialElement = exports.RenderMaterialElement || (exports.RenderMaterialElement = {}));
 //# sourceMappingURL=Material.js.map