@babylonjs/gui 9.14.0 → 9.16.0

package/3D/materials/fluent/fluentMaterial.pure.js

@@ -1,4 +1,4 @@
-import { __decorate } from "@babylonjs/core/tslib.es6.js";
+import { __classPrivateFieldGet, __classPrivateFieldSet, __esDecorate, __runInitializers } from "@babylonjs/core/tslib.es6.js";
 import { serializeAsColor4, serializeAsVector3, serializeAsTexture, serialize, expandToProperty, serializeAsColor3 } from "@babylonjs/core/Misc/decorators.js";
 import { SerializationHelper } from "@babylonjs/core/Misc/decorators.serialization.js";
 import { Vector3, TmpVectors } from "@babylonjs/core/Maths/math.vector.pure.js";
@@ -22,286 +22,338 @@ export class FluentMaterialDefines extends MaterialDefines {
 /**
  * Class used to render controls with fluent design
  */
-export class FluentMaterial extends PushMaterial {
-    /**
-     * Creates a new Fluent material
-     * @param name defines the name of the material
-     * @param scene defines the hosting scene
-     */
-    constructor(name, scene) {
-        super(name, scene);
-        this._shadersLoaded = false;
-        /**
-         * Gets or sets inner glow intensity. A value of 0 means no glow (default is 0.5)
-         */
-        this.innerGlowColorIntensity = 0.5;
-        /**
-         * Gets or sets the inner glow color (white by default)
-         */
-        this.innerGlowColor = new Color3(1.0, 1.0, 1.0);
-        /**
-         * Gets or sets the albedo color (Default is Color3(0.3, 0.35, 0.4))
-         */
-        this.albedoColor = new Color3(0.3, 0.35, 0.4);
-        /**
-         * Gets or sets a boolean indicating if borders must be rendered (default is false)
-         */
-        this.renderBorders = false;
-        /**
-         * Gets or sets border width (default is 0.5)
-         */
-        this.borderWidth = 0.5;
-        /**
-         * Gets or sets a value indicating the smoothing value applied to border edges (0.02 by default)
-         */
-        this.edgeSmoothingValue = 0.02;
-        /**
-         * Gets or sets the minimum value that can be applied to border width (default is 0.1)
-         */
-        this.borderMinValue = 0.1;
-        /**
-         * Gets or sets a boolean indicating if hover light must be rendered (default is false)
-         */
-        this.renderHoverLight = false;
-        /**
-         * Gets or sets the radius used to render the hover light (default is 0.01)
-         */
-        this.hoverRadius = 0.01;
-        /**
-         * Gets or sets the color used to render the hover light (default is Color4(0.3, 0.3, 0.3, 1.0))
-         */
-        this.hoverColor = new Color4(0.3, 0.3, 0.3, 1.0);
-        /**
-         * Gets or sets the hover light position in world space (default is Vector3.Zero())
-         */
-        this.hoverPosition = Vector3.Zero();
-    }
-    needAlphaBlending() {
-        return this.alpha !== 1.0;
-    }
-    needAlphaTesting() {
-        return false;
-    }
-    getAlphaTestTexture() {
-        return null;
-    }
-    isReadyForSubMesh(mesh, subMesh) {
-        const drawWrapper = subMesh._drawWrapper;
-        if (this.isFrozen) {
-            if (drawWrapper.effect && drawWrapper._wasPreviouslyReady) {
-                return true;
+let FluentMaterial = (() => {
+    var _a, _FluentMaterial_innerGlowColorIntensity_accessor_storage, _FluentMaterial_renderBorders_accessor_storage, _FluentMaterial_renderHoverLight_accessor_storage, _FluentMaterial_albedoTexture_accessor_storage;
+    let _classSuper = PushMaterial;
+    let _innerGlowColorIntensity_decorators;
+    let _innerGlowColorIntensity_initializers = [];
+    let _innerGlowColorIntensity_extraInitializers = [];
+    let _innerGlowColor_decorators;
+    let _innerGlowColor_initializers = [];
+    let _innerGlowColor_extraInitializers = [];
+    let _albedoColor_decorators;
+    let _albedoColor_initializers = [];
+    let _albedoColor_extraInitializers = [];
+    let _renderBorders_decorators;
+    let _renderBorders_initializers = [];
+    let _renderBorders_extraInitializers = [];
+    let _borderWidth_decorators;
+    let _borderWidth_initializers = [];
+    let _borderWidth_extraInitializers = [];
+    let _edgeSmoothingValue_decorators;
+    let _edgeSmoothingValue_initializers = [];
+    let _edgeSmoothingValue_extraInitializers = [];
+    let _borderMinValue_decorators;
+    let _borderMinValue_initializers = [];
+    let _borderMinValue_extraInitializers = [];
+    let _renderHoverLight_decorators;
+    let _renderHoverLight_initializers = [];
+    let _renderHoverLight_extraInitializers = [];
+    let _hoverRadius_decorators;
+    let _hoverRadius_initializers = [];
+    let _hoverRadius_extraInitializers = [];
+    let _hoverColor_decorators;
+    let _hoverColor_initializers = [];
+    let _hoverColor_extraInitializers = [];
+    let _hoverPosition_decorators;
+    let _hoverPosition_initializers = [];
+    let _hoverPosition_extraInitializers = [];
+    let __albedoTexture_decorators;
+    let __albedoTexture_initializers = [];
+    let __albedoTexture_extraInitializers = [];
+    let _albedoTexture_decorators;
+    let _albedoTexture_initializers = [];
+    let _albedoTexture_extraInitializers = [];
+    return _a = class FluentMaterial extends _classSuper {
+            /**
+             * Gets or sets inner glow intensity. A value of 0 means no glow (default is 0.5)
+             */
+            get innerGlowColorIntensity() { return __classPrivateFieldGet(this, _FluentMaterial_innerGlowColorIntensity_accessor_storage, "f"); }
+            set innerGlowColorIntensity(value) { __classPrivateFieldSet(this, _FluentMaterial_innerGlowColorIntensity_accessor_storage, value, "f"); }
+            /**
+             * Gets or sets a boolean indicating if borders must be rendered (default is false)
+             */
+            get renderBorders() { return __classPrivateFieldGet(this, _FluentMaterial_renderBorders_accessor_storage, "f"); }
+            set renderBorders(value) { __classPrivateFieldSet(this, _FluentMaterial_renderBorders_accessor_storage, value, "f"); }
+            /**
+             * Gets or sets a boolean indicating if hover light must be rendered (default is false)
+             */
+            get renderHoverLight() { return __classPrivateFieldGet(this, _FluentMaterial_renderHoverLight_accessor_storage, "f"); }
+            set renderHoverLight(value) { __classPrivateFieldSet(this, _FluentMaterial_renderHoverLight_accessor_storage, value, "f"); }
+            /** Gets or sets the texture to use for albedo color */
+            get albedoTexture() { return __classPrivateFieldGet(this, _FluentMaterial_albedoTexture_accessor_storage, "f"); }
+            set albedoTexture(value) { __classPrivateFieldSet(this, _FluentMaterial_albedoTexture_accessor_storage, value, "f"); }
+            /**
+             * Creates a new Fluent material
+             * @param name defines the name of the material
+             * @param scene defines the hosting scene
+             */
+            constructor(name, scene) {
+                super(name, scene);
+                this._shadersLoaded = false;
+                _FluentMaterial_innerGlowColorIntensity_accessor_storage.set(this, __runInitializers(this, _innerGlowColorIntensity_initializers, 0.5));
+                /**
+                 * Gets or sets the inner glow color (white by default)
+                 */
+                this.innerGlowColor = (__runInitializers(this, _innerGlowColorIntensity_extraInitializers), __runInitializers(this, _innerGlowColor_initializers, new Color3(1.0, 1.0, 1.0)));
+                /**
+                 * Gets or sets the albedo color (Default is Color3(0.3, 0.35, 0.4))
+                 */
+                this.albedoColor = (__runInitializers(this, _innerGlowColor_extraInitializers), __runInitializers(this, _albedoColor_initializers, new Color3(0.3, 0.35, 0.4)));
+                _FluentMaterial_renderBorders_accessor_storage.set(this, (__runInitializers(this, _albedoColor_extraInitializers), __runInitializers(this, _renderBorders_initializers, false)));
+                /**
+                 * Gets or sets border width (default is 0.5)
+                 */
+                this.borderWidth = (__runInitializers(this, _renderBorders_extraInitializers), __runInitializers(this, _borderWidth_initializers, 0.5));
+                /**
+                 * Gets or sets a value indicating the smoothing value applied to border edges (0.02 by default)
+                 */
+                this.edgeSmoothingValue = (__runInitializers(this, _borderWidth_extraInitializers), __runInitializers(this, _edgeSmoothingValue_initializers, 0.02));
+                /**
+                 * Gets or sets the minimum value that can be applied to border width (default is 0.1)
+                 */
+                this.borderMinValue = (__runInitializers(this, _edgeSmoothingValue_extraInitializers), __runInitializers(this, _borderMinValue_initializers, 0.1));
+                _FluentMaterial_renderHoverLight_accessor_storage.set(this, (__runInitializers(this, _borderMinValue_extraInitializers), __runInitializers(this, _renderHoverLight_initializers, false)));
+                /**
+                 * Gets or sets the radius used to render the hover light (default is 0.01)
+                 */
+                this.hoverRadius = (__runInitializers(this, _renderHoverLight_extraInitializers), __runInitializers(this, _hoverRadius_initializers, 0.01));
+                /**
+                 * Gets or sets the color used to render the hover light (default is Color4(0.3, 0.3, 0.3, 1.0))
+                 */
+                this.hoverColor = (__runInitializers(this, _hoverRadius_extraInitializers), __runInitializers(this, _hoverColor_initializers, new Color4(0.3, 0.3, 0.3, 1.0)));
+                /**
+                 * Gets or sets the hover light position in world space (default is Vector3.Zero())
+                 */
+                this.hoverPosition = (__runInitializers(this, _hoverColor_extraInitializers), __runInitializers(this, _hoverPosition_initializers, Vector3.Zero()));
+                this._albedoTexture = (__runInitializers(this, _hoverPosition_extraInitializers), __runInitializers(this, __albedoTexture_initializers, void 0));
+                _FluentMaterial_albedoTexture_accessor_storage.set(this, (__runInitializers(this, __albedoTexture_extraInitializers), __runInitializers(this, _albedoTexture_initializers, void 0)));
+                __runInitializers(this, _albedoTexture_extraInitializers);
             }
-        }
-        if (!subMesh.materialDefines) {
-            subMesh.materialDefines = new FluentMaterialDefines();
-        }
-        const scene = this.getScene();
-        const defines = subMesh.materialDefines;
-        if (!this.checkReadyOnEveryCall && subMesh.effect) {
-            if (defines._renderId === scene.getRenderId()) {
-                return true;
+            needAlphaBlending() {
+                return this.alpha !== 1.0;
+            }
+            needAlphaTesting() {
+                return false;
             }
-        }
-        if (defines._areTexturesDirty) {
-            defines.INNERGLOW = this.innerGlowColorIntensity > 0;
-            defines.BORDER = this.renderBorders;
-            defines.HOVERLIGHT = this.renderHoverLight;
-            if (this._albedoTexture) {
-                if (!this._albedoTexture.isReadyOrNotBlocking()) {
+            getAlphaTestTexture() {
+                return null;
+            }
+            isReadyForSubMesh(mesh, subMesh) {
+                const drawWrapper = subMesh._drawWrapper;
+                if (this.isFrozen) {
+                    if (drawWrapper.effect && drawWrapper._wasPreviouslyReady) {
+                        return true;
+                    }
+                }
+                if (!subMesh.materialDefines) {
+                    subMesh.materialDefines = new FluentMaterialDefines();
+                }
+                const scene = this.getScene();
+                const defines = subMesh.materialDefines;
+                if (!this.checkReadyOnEveryCall && subMesh.effect) {
+                    if (defines._renderId === scene.getRenderId()) {
+                        return true;
+                    }
+                }
+                if (defines._areTexturesDirty) {
+                    defines.INNERGLOW = this.innerGlowColorIntensity > 0;
+                    defines.BORDER = this.renderBorders;
+                    defines.HOVERLIGHT = this.renderHoverLight;
+                    if (this._albedoTexture) {
+                        if (!this._albedoTexture.isReadyOrNotBlocking()) {
+                            return false;
+                        }
+                        else {
+                            defines.TEXTURE = true;
+                        }
+                    }
+                    else {
+                        defines.TEXTURE = false;
+                    }
+                }
+                const engine = scene.getEngine();
+                // Get correct effect
+                if (defines.isDirty) {
+                    defines.markAsProcessed();
+                    scene.resetCachedMaterial();
+                    //Attributes
+                    const attribs = [VertexBuffer.PositionKind];
+                    attribs.push(VertexBuffer.NormalKind);
+                    attribs.push(VertexBuffer.UVKind);
+                    const shaderName = "fluent";
+                    const uniforms = [
+                        "world",
+                        "viewProjection",
+                        "innerGlowColor",
+                        "albedoColor",
+                        "borderWidth",
+                        "edgeSmoothingValue",
+                        "scaleFactor",
+                        "borderMinValue",
+                        "hoverColor",
+                        "hoverPosition",
+                        "hoverRadius",
+                        "textureMatrix",
+                    ];
+                    const samplers = ["albedoSampler"];
+                    const uniformBuffers = [];
+                    PrepareUniformsAndSamplersList({
+                        uniformsNames: uniforms,
+                        uniformBuffersNames: uniformBuffers,
+                        samplers: samplers,
+                        defines: defines,
+                        maxSimultaneousLights: 4,
+                        shaderLanguage: this._shaderLanguage,
+                    });
+                    const join = defines.toString();
+                    subMesh.setEffect(scene.getEngine().createEffect(shaderName, {
+                        attributes: attribs,
+                        uniformsNames: uniforms,
+                        uniformBuffersNames: uniformBuffers,
+                        samplers: samplers,
+                        defines: join,
+                        fallbacks: null,
+                        onCompiled: this.onCompiled,
+                        onError: this.onError,
+                        indexParameters: { maxSimultaneousLights: 4 },
+                        shaderLanguage: this._shaderLanguage,
+                        extraInitializationsAsync: this._shadersLoaded
+                            ? undefined
+                            : async () => {
+                                if (this.shaderLanguage === 1 /* ShaderLanguage.WGSL */) {
+                                    await Promise.all([import("./wgsl/fluent.vertex.js"), import("./wgsl/fluent.fragment.js")]);
+                                }
+                                else {
+                                    await Promise.all([import("./shaders/fluent.vertex.js"), import("./shaders/fluent.fragment.js")]);
+                                }
+                                this._shadersLoaded = true;
+                            },
+                    }, engine), defines, this._materialContext);
+                }
+                if (!subMesh.effect || !subMesh.effect.isReady()) {
                     return false;
                 }
-                else {
-                    defines.TEXTURE = true;
+                defines._renderId = scene.getRenderId();
+                drawWrapper._wasPreviouslyReady = true;
+                return true;
+            }
+            bindForSubMesh(world, mesh, subMesh) {
+                const scene = this.getScene();
+                const defines = subMesh.materialDefines;
+                if (!defines) {
+                    return;
                 }
+                const effect = subMesh.effect;
+                if (!effect) {
+                    return;
+                }
+                this._activeEffect = effect;
+                // Matrices
+                this.bindOnlyWorldMatrix(world);
+                this._activeEffect.setMatrix("viewProjection", scene.getTransformMatrix());
+                if (this._mustRebind(scene, effect, subMesh)) {
+                    this._activeEffect.setColor4("albedoColor", this.albedoColor, this.alpha);
+                    if (defines.INNERGLOW) {
+                        this._activeEffect.setColor4("innerGlowColor", this.innerGlowColor, this.innerGlowColorIntensity);
+                    }
+                    if (defines.BORDER) {
+                        this._activeEffect.setFloat("borderWidth", this.borderWidth);
+                        this._activeEffect.setFloat("edgeSmoothingValue", this.edgeSmoothingValue);
+                        this._activeEffect.setFloat("borderMinValue", this.borderMinValue);
+                        mesh.getBoundingInfo().boundingBox.extendSize.multiplyToRef(mesh.scaling, TmpVectors.Vector3[0]);
+                        this._activeEffect.setVector3("scaleFactor", TmpVectors.Vector3[0]);
+                    }
+                    if (defines.HOVERLIGHT) {
+                        this._activeEffect.setDirectColor4("hoverColor", this.hoverColor);
+                        this._activeEffect.setFloat("hoverRadius", this.hoverRadius);
+                        this._activeEffect.setVector3("hoverPosition", this.hoverPosition);
+                    }
+                    if (defines.TEXTURE && this._albedoTexture) {
+                        this._activeEffect.setTexture("albedoSampler", this._albedoTexture);
+                        const matrix = this._albedoTexture.getTextureMatrix();
+                        this._activeEffect.setMatrix("textureMatrix", matrix);
+                    }
+                }
+                this._afterBind(mesh, this._activeEffect, subMesh);
             }
-            else {
-                defines.TEXTURE = false;
+            getActiveTextures() {
+                const activeTextures = super.getActiveTextures();
+                return activeTextures;
             }
-        }
-        const engine = scene.getEngine();
-        // Get correct effect
-        if (defines.isDirty) {
-            defines.markAsProcessed();
-            scene.resetCachedMaterial();
-            //Attributes
-            const attribs = [VertexBuffer.PositionKind];
-            attribs.push(VertexBuffer.NormalKind);
-            attribs.push(VertexBuffer.UVKind);
-            const shaderName = "fluent";
-            const uniforms = [
-                "world",
-                "viewProjection",
-                "innerGlowColor",
-                "albedoColor",
-                "borderWidth",
-                "edgeSmoothingValue",
-                "scaleFactor",
-                "borderMinValue",
-                "hoverColor",
-                "hoverPosition",
-                "hoverRadius",
-                "textureMatrix",
-            ];
-            const samplers = ["albedoSampler"];
-            const uniformBuffers = [];
-            PrepareUniformsAndSamplersList({
-                uniformsNames: uniforms,
-                uniformBuffersNames: uniformBuffers,
-                samplers: samplers,
-                defines: defines,
-                maxSimultaneousLights: 4,
-                shaderLanguage: this._shaderLanguage,
-            });
-            const join = defines.toString();
-            subMesh.setEffect(scene.getEngine().createEffect(shaderName, {
-                attributes: attribs,
-                uniformsNames: uniforms,
-                uniformBuffersNames: uniformBuffers,
-                samplers: samplers,
-                defines: join,
-                fallbacks: null,
-                onCompiled: this.onCompiled,
-                onError: this.onError,
-                indexParameters: { maxSimultaneousLights: 4 },
-                shaderLanguage: this._shaderLanguage,
-                extraInitializationsAsync: this._shadersLoaded
-                    ? undefined
-                    : async () => {
-                        if (this.shaderLanguage === 1 /* ShaderLanguage.WGSL */) {
-                            await Promise.all([import("./wgsl/fluent.vertex.js"), import("./wgsl/fluent.fragment.js")]);
-                        }
-                        this._shadersLoaded = true;
-                    },
-            }, engine), defines, this._materialContext);
-        }
-        if (!subMesh.effect || !subMesh.effect.isReady()) {
-            return false;
-        }
-        defines._renderId = scene.getRenderId();
-        drawWrapper._wasPreviouslyReady = true;
-        return true;
-    }
-    bindForSubMesh(world, mesh, subMesh) {
-        const scene = this.getScene();
-        const defines = subMesh.materialDefines;
-        if (!defines) {
-            return;
-        }
-        const effect = subMesh.effect;
-        if (!effect) {
-            return;
-        }
-        this._activeEffect = effect;
-        // Matrices
-        this.bindOnlyWorldMatrix(world);
-        this._activeEffect.setMatrix("viewProjection", scene.getTransformMatrix());
-        if (this._mustRebind(scene, effect, subMesh)) {
-            this._activeEffect.setColor4("albedoColor", this.albedoColor, this.alpha);
-            if (defines.INNERGLOW) {
-                this._activeEffect.setColor4("innerGlowColor", this.innerGlowColor, this.innerGlowColorIntensity);
+            hasTexture(texture) {
+                if (super.hasTexture(texture)) {
+                    return true;
+                }
+                return false;
             }
-            if (defines.BORDER) {
-                this._activeEffect.setFloat("borderWidth", this.borderWidth);
-                this._activeEffect.setFloat("edgeSmoothingValue", this.edgeSmoothingValue);
-                this._activeEffect.setFloat("borderMinValue", this.borderMinValue);
-                mesh.getBoundingInfo().boundingBox.extendSize.multiplyToRef(mesh.scaling, TmpVectors.Vector3[0]);
-                this._activeEffect.setVector3("scaleFactor", TmpVectors.Vector3[0]);
+            /**
+             * Disposes the material.
+             * @param forceDisposeEffect specifies if effects should be forcefully disposed
+             */
+            dispose(forceDisposeEffect) {
+                super.dispose(forceDisposeEffect);
             }
-            if (defines.HOVERLIGHT) {
-                this._activeEffect.setDirectColor4("hoverColor", this.hoverColor);
-                this._activeEffect.setFloat("hoverRadius", this.hoverRadius);
-                this._activeEffect.setVector3("hoverPosition", this.hoverPosition);
+            clone(name) {
+                return SerializationHelper.Clone(() => new _a(name, this.getScene()), this);
             }
-            if (defines.TEXTURE && this._albedoTexture) {
-                this._activeEffect.setTexture("albedoSampler", this._albedoTexture);
-                const matrix = this._albedoTexture.getTextureMatrix();
-                this._activeEffect.setMatrix("textureMatrix", matrix);
+            serialize() {
+                const serializationObject = super.serialize();
+                serializationObject.customType = "BABYLON.GUI.FluentMaterial";
+                return serializationObject;
             }
-        }
-        this._afterBind(mesh, this._activeEffect, subMesh);
-    }
-    getActiveTextures() {
-        const activeTextures = super.getActiveTextures();
-        return activeTextures;
-    }
-    hasTexture(texture) {
-        if (super.hasTexture(texture)) {
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Disposes the material.
-     * @param forceDisposeEffect specifies if effects should be forcefully disposed
-     */
-    dispose(forceDisposeEffect) {
-        super.dispose(forceDisposeEffect);
-    }
-    clone(name) {
-        return SerializationHelper.Clone(() => new FluentMaterial(name, this.getScene()), this);
-    }
-    serialize() {
-        const serializationObject = super.serialize();
-        serializationObject.customType = "BABYLON.GUI.FluentMaterial";
-        return serializationObject;
-    }
-    getClassName() {
-        return "FluentMaterial";
-    }
-    // Statics
-    /**
-     * Creates a fluent material from parsed material data.
-     * @param source defines the JSON representation of the material
-     * @param scene defines the hosting scene
-     * @param rootUrl defines the root URL to use to load textures and relative dependencies
-     * @returns a new fluent material
-     */
-    static Parse(source, scene, rootUrl) {
-        return SerializationHelper.Parse(() => new FluentMaterial(source.name, scene), source, scene, rootUrl);
-    }
-}
-__decorate([
-    serialize(),
-    expandToProperty("_markAllSubMeshesAsTexturesDirty")
-], FluentMaterial.prototype, "innerGlowColorIntensity", void 0);
-__decorate([
-    serializeAsColor3()
-], FluentMaterial.prototype, "innerGlowColor", void 0);
-__decorate([
-    serializeAsColor3()
-], FluentMaterial.prototype, "albedoColor", void 0);
-__decorate([
-    serialize(),
-    expandToProperty("_markAllSubMeshesAsTexturesDirty")
-], FluentMaterial.prototype, "renderBorders", void 0);
-__decorate([
-    serialize()
-], FluentMaterial.prototype, "borderWidth", void 0);
-__decorate([
-    serialize()
-], FluentMaterial.prototype, "edgeSmoothingValue", void 0);
-__decorate([
-    serialize()
-], FluentMaterial.prototype, "borderMinValue", void 0);
-__decorate([
-    serialize(),
-    expandToProperty("_markAllSubMeshesAsTexturesDirty")
-], FluentMaterial.prototype, "renderHoverLight", void 0);
-__decorate([
-    serialize()
-], FluentMaterial.prototype, "hoverRadius", void 0);
-__decorate([
-    serializeAsColor4()
-], FluentMaterial.prototype, "hoverColor", void 0);
-__decorate([
-    serializeAsVector3()
-], FluentMaterial.prototype, "hoverPosition", void 0);
-__decorate([
-    serializeAsTexture("albedoTexture")
-], FluentMaterial.prototype, "_albedoTexture", void 0);
-__decorate([
-    expandToProperty("_markAllSubMeshesAsTexturesAndMiscDirty")
-], FluentMaterial.prototype, "albedoTexture", void 0);
+            getClassName() {
+                return "FluentMaterial";
+            }
+            // Statics
+            /**
+             * Creates a fluent material from parsed material data.
+             * @param source defines the JSON representation of the material
+             * @param scene defines the hosting scene
+             * @param rootUrl defines the root URL to use to load textures and relative dependencies
+             * @returns a new fluent material
+             */
+            static Parse(source, scene, rootUrl) {
+                return SerializationHelper.Parse(() => new _a(source.name, scene), source, scene, rootUrl);
+            }
+        },
+        _FluentMaterial_innerGlowColorIntensity_accessor_storage = new WeakMap(),
+        _FluentMaterial_renderBorders_accessor_storage = new WeakMap(),
+        _FluentMaterial_renderHoverLight_accessor_storage = new WeakMap(),
+        _FluentMaterial_albedoTexture_accessor_storage = new WeakMap(),
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _innerGlowColorIntensity_decorators = [serialize(), expandToProperty("_markAllSubMeshesAsTexturesDirty")];
+            _innerGlowColor_decorators = [serializeAsColor3()];
+            _albedoColor_decorators = [serializeAsColor3()];
+            _renderBorders_decorators = [serialize(), expandToProperty("_markAllSubMeshesAsTexturesDirty")];
+            _borderWidth_decorators = [serialize()];
+            _edgeSmoothingValue_decorators = [serialize()];
+            _borderMinValue_decorators = [serialize()];
+            _renderHoverLight_decorators = [serialize(), expandToProperty("_markAllSubMeshesAsTexturesDirty")];
+            _hoverRadius_decorators = [serialize()];
+            _hoverColor_decorators = [serializeAsColor4()];
+            _hoverPosition_decorators = [serializeAsVector3()];
+            __albedoTexture_decorators = [serializeAsTexture("albedoTexture")];
+            _albedoTexture_decorators = [expandToProperty("_markAllSubMeshesAsTexturesAndMiscDirty")];
+            __esDecorate(_a, null, _innerGlowColorIntensity_decorators, { kind: "accessor", name: "innerGlowColorIntensity", static: false, private: false, access: { has: obj => "innerGlowColorIntensity" in obj, get: obj => obj.innerGlowColorIntensity, set: (obj, value) => { obj.innerGlowColorIntensity = value; } }, metadata: _metadata }, _innerGlowColorIntensity_initializers, _innerGlowColorIntensity_extraInitializers);
+            __esDecorate(_a, null, _renderBorders_decorators, { kind: "accessor", name: "renderBorders", static: false, private: false, access: { has: obj => "renderBorders" in obj, get: obj => obj.renderBorders, set: (obj, value) => { obj.renderBorders = value; } }, metadata: _metadata }, _renderBorders_initializers, _renderBorders_extraInitializers);
+            __esDecorate(_a, null, _renderHoverLight_decorators, { kind: "accessor", name: "renderHoverLight", static: false, private: false, access: { has: obj => "renderHoverLight" in obj, get: obj => obj.renderHoverLight, set: (obj, value) => { obj.renderHoverLight = value; } }, metadata: _metadata }, _renderHoverLight_initializers, _renderHoverLight_extraInitializers);
+            __esDecorate(_a, null, _albedoTexture_decorators, { kind: "accessor", name: "albedoTexture", static: false, private: false, access: { has: obj => "albedoTexture" in obj, get: obj => obj.albedoTexture, set: (obj, value) => { obj.albedoTexture = value; } }, metadata: _metadata }, _albedoTexture_initializers, _albedoTexture_extraInitializers);
+            __esDecorate(null, null, _innerGlowColor_decorators, { kind: "field", name: "innerGlowColor", static: false, private: false, access: { has: obj => "innerGlowColor" in obj, get: obj => obj.innerGlowColor, set: (obj, value) => { obj.innerGlowColor = value; } }, metadata: _metadata }, _innerGlowColor_initializers, _innerGlowColor_extraInitializers);
+            __esDecorate(null, null, _albedoColor_decorators, { kind: "field", name: "albedoColor", static: false, private: false, access: { has: obj => "albedoColor" in obj, get: obj => obj.albedoColor, set: (obj, value) => { obj.albedoColor = value; } }, metadata: _metadata }, _albedoColor_initializers, _albedoColor_extraInitializers);
+            __esDecorate(null, null, _borderWidth_decorators, { kind: "field", name: "borderWidth", static: false, private: false, access: { has: obj => "borderWidth" in obj, get: obj => obj.borderWidth, set: (obj, value) => { obj.borderWidth = value; } }, metadata: _metadata }, _borderWidth_initializers, _borderWidth_extraInitializers);
+            __esDecorate(null, null, _edgeSmoothingValue_decorators, { kind: "field", name: "edgeSmoothingValue", static: false, private: false, access: { has: obj => "edgeSmoothingValue" in obj, get: obj => obj.edgeSmoothingValue, set: (obj, value) => { obj.edgeSmoothingValue = value; } }, metadata: _metadata }, _edgeSmoothingValue_initializers, _edgeSmoothingValue_extraInitializers);
+            __esDecorate(null, null, _borderMinValue_decorators, { kind: "field", name: "borderMinValue", static: false, private: false, access: { has: obj => "borderMinValue" in obj, get: obj => obj.borderMinValue, set: (obj, value) => { obj.borderMinValue = value; } }, metadata: _metadata }, _borderMinValue_initializers, _borderMinValue_extraInitializers);
+            __esDecorate(null, null, _hoverRadius_decorators, { kind: "field", name: "hoverRadius", static: false, private: false, access: { has: obj => "hoverRadius" in obj, get: obj => obj.hoverRadius, set: (obj, value) => { obj.hoverRadius = value; } }, metadata: _metadata }, _hoverRadius_initializers, _hoverRadius_extraInitializers);
+            __esDecorate(null, null, _hoverColor_decorators, { kind: "field", name: "hoverColor", static: false, private: false, access: { has: obj => "hoverColor" in obj, get: obj => obj.hoverColor, set: (obj, value) => { obj.hoverColor = value; } }, metadata: _metadata }, _hoverColor_initializers, _hoverColor_extraInitializers);
+            __esDecorate(null, null, _hoverPosition_decorators, { kind: "field", name: "hoverPosition", static: false, private: false, access: { has: obj => "hoverPosition" in obj, get: obj => obj.hoverPosition, set: (obj, value) => { obj.hoverPosition = value; } }, metadata: _metadata }, _hoverPosition_initializers, _hoverPosition_extraInitializers);
+            __esDecorate(null, null, __albedoTexture_decorators, { kind: "field", name: "_albedoTexture", static: false, private: false, access: { has: obj => "_albedoTexture" in obj, get: obj => obj._albedoTexture, set: (obj, value) => { obj._albedoTexture = value; } }, metadata: _metadata }, __albedoTexture_initializers, __albedoTexture_extraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+export { FluentMaterial };
 let _Registered = false;
 /**
  * Registers the FluentMaterial class with the type store for serialization support.