@babylonjs/materials 9.15.0 → 9.16.1

package/fire/fireMaterial.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 { serializeAsTexture, serialize, expandToProperty, serializeAsColor3 } from "@babylonjs/core/Misc/decorators.js";
 import { SerializationHelper } from "@babylonjs/core/Misc/decorators.serialization.js";
 import { Color3 } from "@babylonjs/core/Maths/math.color.js";
@@ -40,320 +40,361 @@ class FireMaterialDefines extends MaterialDefines {
         this.rebuild();
     }
 }
-export class FireMaterial extends PushMaterial {
-    /**
-     * Instantiates a Fire Material in the given scene
-     * @param name The friendly name of the material
-     * @param scene The scene to add the material to
-     * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
-     */
-    constructor(name, scene, forceGLSL = false) {
-        super(name, scene, undefined, forceGLSL);
-        this.diffuseColor = new Color3(1, 1, 1);
-        this.speed = 1.0;
-        this._scaledDiffuse = new Color3();
-        this._lastTime = 0;
-        this._shadersLoaded = false;
-    }
-    needAlphaBlending() {
-        return false;
-    }
-    needAlphaTesting() {
-        return true;
-    }
-    getAlphaTestTexture() {
-        return null;
-    }
-    // Methods
-    isReadyForSubMesh(mesh, subMesh, useInstances) {
-        const drawWrapper = subMesh._drawWrapper;
-        if (this.isFrozen) {
-            if (drawWrapper._wasPreviouslyReady && drawWrapper._wasPreviouslyUsingInstances === useInstances) {
+let FireMaterial = (() => {
+    var _a, _FireMaterial_diffuseTexture_accessor_storage, _FireMaterial_distortionTexture_accessor_storage, _FireMaterial_opacityTexture_accessor_storage;
+    let _classSuper = PushMaterial;
+    let __diffuseTexture_decorators;
+    let __diffuseTexture_initializers = [];
+    let __diffuseTexture_extraInitializers = [];
+    let _diffuseTexture_decorators;
+    let _diffuseTexture_initializers = [];
+    let _diffuseTexture_extraInitializers = [];
+    let __distortionTexture_decorators;
+    let __distortionTexture_initializers = [];
+    let __distortionTexture_extraInitializers = [];
+    let _distortionTexture_decorators;
+    let _distortionTexture_initializers = [];
+    let _distortionTexture_extraInitializers = [];
+    let __opacityTexture_decorators;
+    let __opacityTexture_initializers = [];
+    let __opacityTexture_extraInitializers = [];
+    let _opacityTexture_decorators;
+    let _opacityTexture_initializers = [];
+    let _opacityTexture_extraInitializers = [];
+    let _diffuseColor_decorators;
+    let _diffuseColor_initializers = [];
+    let _diffuseColor_extraInitializers = [];
+    let _speed_decorators;
+    let _speed_initializers = [];
+    let _speed_extraInitializers = [];
+    return _a = class FireMaterial extends _classSuper {
+            get diffuseTexture() { return __classPrivateFieldGet(this, _FireMaterial_diffuseTexture_accessor_storage, "f"); }
+            set diffuseTexture(value) { __classPrivateFieldSet(this, _FireMaterial_diffuseTexture_accessor_storage, value, "f"); }
+            get distortionTexture() { return __classPrivateFieldGet(this, _FireMaterial_distortionTexture_accessor_storage, "f"); }
+            set distortionTexture(value) { __classPrivateFieldSet(this, _FireMaterial_distortionTexture_accessor_storage, value, "f"); }
+            get opacityTexture() { return __classPrivateFieldGet(this, _FireMaterial_opacityTexture_accessor_storage, "f"); }
+            set opacityTexture(value) { __classPrivateFieldSet(this, _FireMaterial_opacityTexture_accessor_storage, value, "f"); }
+            /**
+             * Instantiates a Fire Material in the given scene
+             * @param name The friendly name of the material
+             * @param scene The scene to add the material to
+             * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+             */
+            constructor(name, scene, forceGLSL = false) {
+                super(name, scene, undefined, forceGLSL);
+                this._diffuseTexture = __runInitializers(this, __diffuseTexture_initializers, void 0);
+                _FireMaterial_diffuseTexture_accessor_storage.set(this, (__runInitializers(this, __diffuseTexture_extraInitializers), __runInitializers(this, _diffuseTexture_initializers, void 0)));
+                this._distortionTexture = (__runInitializers(this, _diffuseTexture_extraInitializers), __runInitializers(this, __distortionTexture_initializers, void 0));
+                _FireMaterial_distortionTexture_accessor_storage.set(this, (__runInitializers(this, __distortionTexture_extraInitializers), __runInitializers(this, _distortionTexture_initializers, void 0)));
+                this._opacityTexture = (__runInitializers(this, _distortionTexture_extraInitializers), __runInitializers(this, __opacityTexture_initializers, void 0));
+                _FireMaterial_opacityTexture_accessor_storage.set(this, (__runInitializers(this, __opacityTexture_extraInitializers), __runInitializers(this, _opacityTexture_initializers, void 0)));
+                this.diffuseColor = (__runInitializers(this, _opacityTexture_extraInitializers), __runInitializers(this, _diffuseColor_initializers, new Color3(1, 1, 1)));
+                this.speed = (__runInitializers(this, _diffuseColor_extraInitializers), __runInitializers(this, _speed_initializers, 1.0));
+                this._scaledDiffuse = (__runInitializers(this, _speed_extraInitializers), new Color3());
+                this._lastTime = 0;
+                this._shadersLoaded = false;
+            }
+            needAlphaBlending() {
+                return false;
+            }
+            needAlphaTesting() {
                 return true;
             }
-        }
-        if (!subMesh.materialDefines) {
-            subMesh.materialDefines = new FireMaterialDefines();
-        }
-        const defines = subMesh.materialDefines;
-        const scene = this.getScene();
-        if (this._isReadyForSubMesh(subMesh)) {
-            return true;
-        }
-        const engine = scene.getEngine();
-        // Textures
-        if (defines._areTexturesDirty) {
-            defines._needUVs = false;
-            if (this._diffuseTexture && MaterialFlags.DiffuseTextureEnabled) {
-                if (!this._diffuseTexture.isReady()) {
+            getAlphaTestTexture() {
+                return null;
+            }
+            // Methods
+            isReadyForSubMesh(mesh, subMesh, useInstances) {
+                const drawWrapper = subMesh._drawWrapper;
+                if (this.isFrozen) {
+                    if (drawWrapper._wasPreviouslyReady && drawWrapper._wasPreviouslyUsingInstances === useInstances) {
+                        return true;
+                    }
+                }
+                if (!subMesh.materialDefines) {
+                    subMesh.materialDefines = new FireMaterialDefines();
+                }
+                const defines = subMesh.materialDefines;
+                const scene = this.getScene();
+                if (this._isReadyForSubMesh(subMesh)) {
+                    return true;
+                }
+                const engine = scene.getEngine();
+                // Textures
+                if (defines._areTexturesDirty) {
+                    defines._needUVs = false;
+                    if (this._diffuseTexture && MaterialFlags.DiffuseTextureEnabled) {
+                        if (!this._diffuseTexture.isReady()) {
+                            return false;
+                        }
+                        else {
+                            defines._needUVs = true;
+                            defines.DIFFUSE = true;
+                        }
+                    }
+                }
+                defines.ALPHATEST = this._opacityTexture ? true : false;
+                // Misc.
+                if (defines._areMiscDirty) {
+                    defines.POINTSIZE = this.pointsCloud || scene.forcePointsCloud;
+                    defines.FOG = scene.fogEnabled && mesh.applyFog && scene.fogMode !== Scene.FOGMODE_NONE && this.fogEnabled;
+                    defines.LOGARITHMICDEPTH = this._useLogarithmicDepth;
+                }
+                // Values that need to be evaluated on every frame
+                PrepareDefinesForFrameBoundValues(scene, engine, this, defines, useInstances ? true : false);
+                // Attribs
+                PrepareDefinesForAttributes(mesh, defines, false, true);
+                // Get correct effect
+                if (defines.isDirty) {
+                    defines.markAsProcessed();
+                    scene.resetCachedMaterial();
+                    // Fallbacks
+                    const fallbacks = new EffectFallbacks();
+                    if (defines.FOG) {
+                        fallbacks.addFallback(1, "FOG");
+                    }
+                    if (defines.NUM_BONE_INFLUENCERS > 0) {
+                        fallbacks.addCPUSkinningFallback(0, mesh);
+                    }
+                    defines.IMAGEPROCESSINGPOSTPROCESS = scene.imageProcessingConfiguration.applyByPostProcess;
+                    //Attributes
+                    const attribs = [VertexBuffer.PositionKind];
+                    if (defines.UV1) {
+                        attribs.push(VertexBuffer.UVKind);
+                    }
+                    if (defines.VERTEXCOLOR) {
+                        attribs.push(VertexBuffer.ColorKind);
+                    }
+                    PrepareAttributesForBones(attribs, mesh, defines, fallbacks);
+                    PrepareAttributesForInstances(attribs, defines);
+                    // Legacy browser patch
+                    const shaderName = "fire";
+                    const uniforms = [
+                        "world",
+                        "view",
+                        "viewProjection",
+                        "vEyePosition",
+                        "vFogInfos",
+                        "vFogColor",
+                        "pointSize",
+                        "vDiffuseInfos",
+                        "mBones",
+                        "diffuseMatrix",
+                        "logarithmicDepthConstant",
+                        // Fire
+                        "time",
+                        "speed",
+                    ];
+                    AddClipPlaneUniforms(uniforms);
+                    const join = defines.toString();
+                    subMesh.setEffect(scene.getEngine().createEffect(shaderName, {
+                        attributes: attribs,
+                        uniformsNames: uniforms,
+                        uniformBuffersNames: [],
+                        samplers: [
+                            "diffuseSampler",
+                            // Fire
+                            "distortionSampler",
+                            "opacitySampler",
+                        ],
+                        defines: join,
+                        fallbacks: fallbacks,
+                        onCompiled: this.onCompiled,
+                        onError: this.onError,
+                        indexParameters: null,
+                        maxSimultaneousLights: 4,
+                        transformFeedbackVaryings: null,
+                        shaderLanguage: this._shaderLanguage,
+                        extraInitializationsAsync: this._shadersLoaded
+                            ? undefined
+                            : async () => {
+                                if (this.shaderLanguage === 1 /* ShaderLanguage.WGSL */) {
+                                    await Promise.all([import("./wgsl/fire.vertex.js"), import("./wgsl/fire.fragment.js")]);
+                                }
+                                else {
+                                    await Promise.all([import("./fire.vertex.js"), import("./fire.fragment.js")]);
+                                }
+                                this._shadersLoaded = true;
+                            },
+                    }, engine), defines, this._materialContext);
+                }
+                if (!subMesh.effect || !subMesh.effect.isReady()) {
                     return false;
                 }
-                else {
-                    defines._needUVs = true;
-                    defines.DIFFUSE = true;
+                defines._renderId = scene.getRenderId();
+                drawWrapper._wasPreviouslyReady = true;
+                drawWrapper._wasPreviouslyUsingInstances = !!useInstances;
+                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());
+                // Bones
+                BindBonesParameters(mesh, this._activeEffect);
+                if (this._mustRebind(scene, effect, subMesh)) {
+                    // Textures
+                    if (this._diffuseTexture && MaterialFlags.DiffuseTextureEnabled) {
+                        this._activeEffect.setTexture("diffuseSampler", this._diffuseTexture);
+                        this._activeEffect.setFloat2("vDiffuseInfos", this._diffuseTexture.coordinatesIndex, this._diffuseTexture.level);
+                        this._activeEffect.setMatrix("diffuseMatrix", this._diffuseTexture.getTextureMatrix());
+                        this._activeEffect.setTexture("distortionSampler", this._distortionTexture);
+                        this._activeEffect.setTexture("opacitySampler", this._opacityTexture);
+                    }
+                    // Clip plane
+                    BindClipPlane(this._activeEffect, this, scene);
+                    // Point size
+                    if (this.pointsCloud) {
+                        this._activeEffect.setFloat("pointSize", this.pointSize);
+                    }
+                    // Log. depth
+                    if (this._useLogarithmicDepth) {
+                        BindLogDepth(defines, effect, scene);
+                    }
+                    scene.bindEyePosition(effect);
+                }
+                this._activeEffect.setColor4("vDiffuseColor", this._scaledDiffuse, this.alpha * mesh.visibility);
+                // View
+                if (scene.fogEnabled && mesh.applyFog && scene.fogMode !== Scene.FOGMODE_NONE) {
+                    this._activeEffect.setMatrix("view", scene.getViewMatrix());
                 }
+                // Fog
+                BindFogParameters(scene, mesh, this._activeEffect);
+                // Time
+                this._lastTime += scene.getEngine().getDeltaTime();
+                this._activeEffect.setFloat("time", this._lastTime);
+                // Speed
+                this._activeEffect.setFloat("speed", this.speed);
+                this._afterBind(mesh, this._activeEffect, subMesh);
             }
-        }
-        defines.ALPHATEST = this._opacityTexture ? true : false;
-        // Misc.
-        if (defines._areMiscDirty) {
-            defines.POINTSIZE = this.pointsCloud || scene.forcePointsCloud;
-            defines.FOG = scene.fogEnabled && mesh.applyFog && scene.fogMode !== Scene.FOGMODE_NONE && this.fogEnabled;
-            defines.LOGARITHMICDEPTH = this._useLogarithmicDepth;
-        }
-        // Values that need to be evaluated on every frame
-        PrepareDefinesForFrameBoundValues(scene, engine, this, defines, useInstances ? true : false);
-        // Attribs
-        PrepareDefinesForAttributes(mesh, defines, false, true);
-        // Get correct effect
-        if (defines.isDirty) {
-            defines.markAsProcessed();
-            scene.resetCachedMaterial();
-            // Fallbacks
-            const fallbacks = new EffectFallbacks();
-            if (defines.FOG) {
-                fallbacks.addFallback(1, "FOG");
+            getAnimatables() {
+                const results = [];
+                if (this._diffuseTexture && this._diffuseTexture.animations && this._diffuseTexture.animations.length > 0) {
+                    results.push(this._diffuseTexture);
+                }
+                if (this._distortionTexture && this._distortionTexture.animations && this._distortionTexture.animations.length > 0) {
+                    results.push(this._distortionTexture);
+                }
+                if (this._opacityTexture && this._opacityTexture.animations && this._opacityTexture.animations.length > 0) {
+                    results.push(this._opacityTexture);
+                }
+                return results;
+            }
+            getActiveTextures() {
+                const activeTextures = super.getActiveTextures();
+                if (this._diffuseTexture) {
+                    activeTextures.push(this._diffuseTexture);
+                }
+                if (this._distortionTexture) {
+                    activeTextures.push(this._distortionTexture);
+                }
+                if (this._opacityTexture) {
+                    activeTextures.push(this._opacityTexture);
+                }
+                return activeTextures;
             }
-            if (defines.NUM_BONE_INFLUENCERS > 0) {
-                fallbacks.addCPUSkinningFallback(0, mesh);
+            hasTexture(texture) {
+                if (super.hasTexture(texture)) {
+                    return true;
+                }
+                if (this._diffuseTexture === texture) {
+                    return true;
+                }
+                if (this._distortionTexture === texture) {
+                    return true;
+                }
+                if (this._opacityTexture === texture) {
+                    return true;
+                }
+                return false;
             }
-            defines.IMAGEPROCESSINGPOSTPROCESS = scene.imageProcessingConfiguration.applyByPostProcess;
-            //Attributes
-            const attribs = [VertexBuffer.PositionKind];
-            if (defines.UV1) {
-                attribs.push(VertexBuffer.UVKind);
+            getClassName() {
+                return "FireMaterial";
             }
-            if (defines.VERTEXCOLOR) {
-                attribs.push(VertexBuffer.ColorKind);
+            dispose(forceDisposeEffect) {
+                if (this._diffuseTexture) {
+                    this._diffuseTexture.dispose();
+                }
+                if (this._distortionTexture) {
+                    this._distortionTexture.dispose();
+                }
+                super.dispose(forceDisposeEffect);
             }
-            PrepareAttributesForBones(attribs, mesh, defines, fallbacks);
-            PrepareAttributesForInstances(attribs, defines);
-            // Legacy browser patch
-            const shaderName = "fire";
-            const uniforms = [
-                "world",
-                "view",
-                "viewProjection",
-                "vEyePosition",
-                "vFogInfos",
-                "vFogColor",
-                "pointSize",
-                "vDiffuseInfos",
-                "mBones",
-                "diffuseMatrix",
-                "logarithmicDepthConstant",
-                // Fire
-                "time",
-                "speed",
-            ];
-            AddClipPlaneUniforms(uniforms);
-            const join = defines.toString();
-            subMesh.setEffect(scene.getEngine().createEffect(shaderName, {
-                attributes: attribs,
-                uniformsNames: uniforms,
-                uniformBuffersNames: [],
-                samplers: [
-                    "diffuseSampler",
-                    // Fire
-                    "distortionSampler",
-                    "opacitySampler",
-                ],
-                defines: join,
-                fallbacks: fallbacks,
-                onCompiled: this.onCompiled,
-                onError: this.onError,
-                indexParameters: null,
-                maxSimultaneousLights: 4,
-                transformFeedbackVaryings: null,
-                shaderLanguage: this._shaderLanguage,
-                extraInitializationsAsync: this._shadersLoaded
-                    ? undefined
-                    : async () => {
-                        if (this.shaderLanguage === 1 /* ShaderLanguage.WGSL */) {
-                            await Promise.all([import("./wgsl/fire.vertex.js"), import("./wgsl/fire.fragment.js")]);
-                        }
-                        else {
-                            await Promise.all([import("./fire.vertex.js"), import("./fire.fragment.js")]);
-                        }
-                        this._shadersLoaded = true;
-                    },
-            }, engine), defines, this._materialContext);
-        }
-        if (!subMesh.effect || !subMesh.effect.isReady()) {
-            return false;
-        }
-        defines._renderId = scene.getRenderId();
-        drawWrapper._wasPreviouslyReady = true;
-        drawWrapper._wasPreviouslyUsingInstances = !!useInstances;
-        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());
-        // Bones
-        BindBonesParameters(mesh, this._activeEffect);
-        if (this._mustRebind(scene, effect, subMesh)) {
-            // Textures
-            if (this._diffuseTexture && MaterialFlags.DiffuseTextureEnabled) {
-                this._activeEffect.setTexture("diffuseSampler", this._diffuseTexture);
-                this._activeEffect.setFloat2("vDiffuseInfos", this._diffuseTexture.coordinatesIndex, this._diffuseTexture.level);
-                this._activeEffect.setMatrix("diffuseMatrix", this._diffuseTexture.getTextureMatrix());
-                this._activeEffect.setTexture("distortionSampler", this._distortionTexture);
-                this._activeEffect.setTexture("opacitySampler", this._opacityTexture);
+            clone(name) {
+                return SerializationHelper.Clone(() => new _a(name, this.getScene()), this);
             }
-            // Clip plane
-            BindClipPlane(this._activeEffect, this, scene);
-            // Point size
-            if (this.pointsCloud) {
-                this._activeEffect.setFloat("pointSize", this.pointSize);
+            serialize() {
+                const serializationObject = super.serialize();
+                serializationObject.customType = "BABYLON.FireMaterial";
+                serializationObject.diffuseColor = this.diffuseColor.asArray();
+                serializationObject.speed = this.speed;
+                if (this._diffuseTexture) {
+                    serializationObject._diffuseTexture = this._diffuseTexture.serialize();
+                }
+                if (this._distortionTexture) {
+                    serializationObject._distortionTexture = this._distortionTexture.serialize();
+                }
+                if (this._opacityTexture) {
+                    serializationObject._opacityTexture = this._opacityTexture.serialize();
+                }
+                return serializationObject;
             }
-            // Log. depth
-            if (this._useLogarithmicDepth) {
-                BindLogDepth(defines, effect, scene);
+            static Parse(source, scene, rootUrl) {
+                const material = new _a(source.name, scene);
+                material.diffuseColor = Color3.FromArray(source.diffuseColor);
+                material.speed = source.speed;
+                material.alpha = source.alpha;
+                material.id = source.id;
+                Tags.AddTagsTo(material, source.tags);
+                material.backFaceCulling = source.backFaceCulling;
+                material.wireframe = source.wireframe;
+                if (source._diffuseTexture) {
+                    material._diffuseTexture = Texture.Parse(source._diffuseTexture, scene, rootUrl);
+                }
+                if (source._distortionTexture) {
+                    material._distortionTexture = Texture.Parse(source._distortionTexture, scene, rootUrl);
+                }
+                if (source._opacityTexture) {
+                    material._opacityTexture = Texture.Parse(source._opacityTexture, scene, rootUrl);
+                }
+                return material;
             }
-            scene.bindEyePosition(effect);
-        }
-        this._activeEffect.setColor4("vDiffuseColor", this._scaledDiffuse, this.alpha * mesh.visibility);
-        // View
-        if (scene.fogEnabled && mesh.applyFog && scene.fogMode !== Scene.FOGMODE_NONE) {
-            this._activeEffect.setMatrix("view", scene.getViewMatrix());
-        }
-        // Fog
-        BindFogParameters(scene, mesh, this._activeEffect);
-        // Time
-        this._lastTime += scene.getEngine().getDeltaTime();
-        this._activeEffect.setFloat("time", this._lastTime);
-        // Speed
-        this._activeEffect.setFloat("speed", this.speed);
-        this._afterBind(mesh, this._activeEffect, subMesh);
-    }
-    getAnimatables() {
-        const results = [];
-        if (this._diffuseTexture && this._diffuseTexture.animations && this._diffuseTexture.animations.length > 0) {
-            results.push(this._diffuseTexture);
-        }
-        if (this._distortionTexture && this._distortionTexture.animations && this._distortionTexture.animations.length > 0) {
-            results.push(this._distortionTexture);
-        }
-        if (this._opacityTexture && this._opacityTexture.animations && this._opacityTexture.animations.length > 0) {
-            results.push(this._opacityTexture);
-        }
-        return results;
-    }
-    getActiveTextures() {
-        const activeTextures = super.getActiveTextures();
-        if (this._diffuseTexture) {
-            activeTextures.push(this._diffuseTexture);
-        }
-        if (this._distortionTexture) {
-            activeTextures.push(this._distortionTexture);
-        }
-        if (this._opacityTexture) {
-            activeTextures.push(this._opacityTexture);
-        }
-        return activeTextures;
-    }
-    hasTexture(texture) {
-        if (super.hasTexture(texture)) {
-            return true;
-        }
-        if (this._diffuseTexture === texture) {
-            return true;
-        }
-        if (this._distortionTexture === texture) {
-            return true;
-        }
-        if (this._opacityTexture === texture) {
-            return true;
-        }
-        return false;
-    }
-    getClassName() {
-        return "FireMaterial";
-    }
-    dispose(forceDisposeEffect) {
-        if (this._diffuseTexture) {
-            this._diffuseTexture.dispose();
-        }
-        if (this._distortionTexture) {
-            this._distortionTexture.dispose();
-        }
-        super.dispose(forceDisposeEffect);
-    }
-    clone(name) {
-        return SerializationHelper.Clone(() => new FireMaterial(name, this.getScene()), this);
-    }
-    serialize() {
-        const serializationObject = super.serialize();
-        serializationObject.customType = "BABYLON.FireMaterial";
-        serializationObject.diffuseColor = this.diffuseColor.asArray();
-        serializationObject.speed = this.speed;
-        if (this._diffuseTexture) {
-            serializationObject._diffuseTexture = this._diffuseTexture.serialize();
-        }
-        if (this._distortionTexture) {
-            serializationObject._distortionTexture = this._distortionTexture.serialize();
-        }
-        if (this._opacityTexture) {
-            serializationObject._opacityTexture = this._opacityTexture.serialize();
-        }
-        return serializationObject;
-    }
-    static Parse(source, scene, rootUrl) {
-        const material = new FireMaterial(source.name, scene);
-        material.diffuseColor = Color3.FromArray(source.diffuseColor);
-        material.speed = source.speed;
-        material.alpha = source.alpha;
-        material.id = source.id;
-        Tags.AddTagsTo(material, source.tags);
-        material.backFaceCulling = source.backFaceCulling;
-        material.wireframe = source.wireframe;
-        if (source._diffuseTexture) {
-            material._diffuseTexture = Texture.Parse(source._diffuseTexture, scene, rootUrl);
-        }
-        if (source._distortionTexture) {
-            material._distortionTexture = Texture.Parse(source._distortionTexture, scene, rootUrl);
-        }
-        if (source._opacityTexture) {
-            material._opacityTexture = Texture.Parse(source._opacityTexture, scene, rootUrl);
-        }
-        return material;
-    }
-}
-__decorate([
-    serializeAsTexture("diffuseTexture")
-], FireMaterial.prototype, "_diffuseTexture", void 0);
-__decorate([
-    expandToProperty("_markAllSubMeshesAsTexturesDirty")
-], FireMaterial.prototype, "diffuseTexture", void 0);
-__decorate([
-    serializeAsTexture("distortionTexture")
-], FireMaterial.prototype, "_distortionTexture", void 0);
-__decorate([
-    expandToProperty("_markAllSubMeshesAsTexturesDirty")
-], FireMaterial.prototype, "distortionTexture", void 0);
-__decorate([
-    serializeAsTexture("opacityTexture")
-], FireMaterial.prototype, "_opacityTexture", void 0);
-__decorate([
-    expandToProperty("_markAllSubMeshesAsTexturesDirty")
-], FireMaterial.prototype, "opacityTexture", void 0);
-__decorate([
-    serializeAsColor3("diffuse")
-], FireMaterial.prototype, "diffuseColor", void 0);
-__decorate([
-    serialize()
-], FireMaterial.prototype, "speed", void 0);
+        },
+        _FireMaterial_diffuseTexture_accessor_storage = new WeakMap(),
+        _FireMaterial_distortionTexture_accessor_storage = new WeakMap(),
+        _FireMaterial_opacityTexture_accessor_storage = new WeakMap(),
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __diffuseTexture_decorators = [serializeAsTexture("diffuseTexture")];
+            _diffuseTexture_decorators = [expandToProperty("_markAllSubMeshesAsTexturesDirty")];
+            __distortionTexture_decorators = [serializeAsTexture("distortionTexture")];
+            _distortionTexture_decorators = [expandToProperty("_markAllSubMeshesAsTexturesDirty")];
+            __opacityTexture_decorators = [serializeAsTexture("opacityTexture")];
+            _opacityTexture_decorators = [expandToProperty("_markAllSubMeshesAsTexturesDirty")];
+            _diffuseColor_decorators = [serializeAsColor3("diffuse")];
+            _speed_decorators = [serialize()];
+            __esDecorate(_a, null, _diffuseTexture_decorators, { kind: "accessor", name: "diffuseTexture", static: false, private: false, access: { has: obj => "diffuseTexture" in obj, get: obj => obj.diffuseTexture, set: (obj, value) => { obj.diffuseTexture = value; } }, metadata: _metadata }, _diffuseTexture_initializers, _diffuseTexture_extraInitializers);
+            __esDecorate(_a, null, _distortionTexture_decorators, { kind: "accessor", name: "distortionTexture", static: false, private: false, access: { has: obj => "distortionTexture" in obj, get: obj => obj.distortionTexture, set: (obj, value) => { obj.distortionTexture = value; } }, metadata: _metadata }, _distortionTexture_initializers, _distortionTexture_extraInitializers);
+            __esDecorate(_a, null, _opacityTexture_decorators, { kind: "accessor", name: "opacityTexture", static: false, private: false, access: { has: obj => "opacityTexture" in obj, get: obj => obj.opacityTexture, set: (obj, value) => { obj.opacityTexture = value; } }, metadata: _metadata }, _opacityTexture_initializers, _opacityTexture_extraInitializers);
+            __esDecorate(null, null, __diffuseTexture_decorators, { kind: "field", name: "_diffuseTexture", static: false, private: false, access: { has: obj => "_diffuseTexture" in obj, get: obj => obj._diffuseTexture, set: (obj, value) => { obj._diffuseTexture = value; } }, metadata: _metadata }, __diffuseTexture_initializers, __diffuseTexture_extraInitializers);
+            __esDecorate(null, null, __distortionTexture_decorators, { kind: "field", name: "_distortionTexture", static: false, private: false, access: { has: obj => "_distortionTexture" in obj, get: obj => obj._distortionTexture, set: (obj, value) => { obj._distortionTexture = value; } }, metadata: _metadata }, __distortionTexture_initializers, __distortionTexture_extraInitializers);
+            __esDecorate(null, null, __opacityTexture_decorators, { kind: "field", name: "_opacityTexture", static: false, private: false, access: { has: obj => "_opacityTexture" in obj, get: obj => obj._opacityTexture, set: (obj, value) => { obj._opacityTexture = value; } }, metadata: _metadata }, __opacityTexture_initializers, __opacityTexture_extraInitializers);
+            __esDecorate(null, null, _diffuseColor_decorators, { kind: "field", name: "diffuseColor", static: false, private: false, access: { has: obj => "diffuseColor" in obj, get: obj => obj.diffuseColor, set: (obj, value) => { obj.diffuseColor = value; } }, metadata: _metadata }, _diffuseColor_initializers, _diffuseColor_extraInitializers);
+            __esDecorate(null, null, _speed_decorators, { kind: "field", name: "speed", static: false, private: false, access: { has: obj => "speed" in obj, get: obj => obj.speed, set: (obj, value) => { obj.speed = value; } }, metadata: _metadata }, _speed_initializers, _speed_extraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+export { FireMaterial };
 RegisterClass("BABYLON.FireMaterial", FireMaterial);
 //# sourceMappingURL=fireMaterial.js.map