@babylonjs/materials 9.15.0 → 9.16.1

package/fur/furMaterial.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 { serializeAsVector3, serializeAsTexture, serialize, expandToProperty, serializeAsColor3 } from "@babylonjs/core/Misc/decorators.js";
 import { SerializationHelper } from "@babylonjs/core/Misc/decorators.serialization.js";
 import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
@@ -48,476 +48,545 @@ class FurMaterialDefines extends MaterialDefines {
         this.rebuild();
     }
 }
-export class FurMaterial extends PushMaterial {
-    /**
-     * Instantiates a Fur 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.furLength = 1;
-        this.furAngle = 0;
-        this.furColor = new Color3(0.44, 0.21, 0.02);
-        this.furOffset = 0.0;
-        this.furSpacing = 12;
-        this.furGravity = new Vector3(0, 0, 0);
-        this.furSpeed = 100;
-        this.furDensity = 20;
-        this.furOcclusion = 0.0;
-        this._disableLighting = false;
-        this._maxSimultaneousLights = 4;
-        this.highLevelFur = true;
-        this._furTime = 0;
-        this._shadersLoaded = false;
-    }
-    get furTime() {
-        return this._furTime;
-    }
-    set furTime(furTime) {
-        this._furTime = furTime;
-    }
-    needAlphaBlending() {
-        return this.alpha < 1.0;
-    }
-    needAlphaTesting() {
-        return false;
-    }
-    getAlphaTestTexture() {
-        return null;
-    }
-    updateFur() {
-        for (let i = 1; i < this._meshes.length; i++) {
-            const offsetFur = this._meshes[i].material;
-            offsetFur.furLength = this.furLength;
-            offsetFur.furAngle = this.furAngle;
-            offsetFur.furGravity = this.furGravity;
-            offsetFur.furSpacing = this.furSpacing;
-            offsetFur.furSpeed = this.furSpeed;
-            offsetFur.furColor = this.furColor;
-            offsetFur.diffuseTexture = this.diffuseTexture;
-            offsetFur.furTexture = this.furTexture;
-            offsetFur.highLevelFur = this.highLevelFur;
-            offsetFur.furTime = this.furTime;
-            offsetFur.furDensity = this.furDensity;
-        }
-    }
-    // Methods
-    isReadyForSubMesh(mesh, subMesh, useInstances) {
-        const drawWrapper = subMesh._drawWrapper;
-        if (this.isFrozen) {
-            if (drawWrapper.effect && drawWrapper._wasPreviouslyReady && drawWrapper._wasPreviouslyUsingInstances === useInstances) {
-                return true;
+let FurMaterial = (() => {
+    var _a, _FurMaterial_diffuseTexture_accessor_storage, _FurMaterial_heightTexture_accessor_storage, _FurMaterial_disableLighting_accessor_storage, _FurMaterial_maxSimultaneousLights_accessor_storage;
+    let _classSuper = PushMaterial;
+    let _instanceExtraInitializers = [];
+    let __diffuseTexture_decorators;
+    let __diffuseTexture_initializers = [];
+    let __diffuseTexture_extraInitializers = [];
+    let _diffuseTexture_decorators;
+    let _diffuseTexture_initializers = [];
+    let _diffuseTexture_extraInitializers = [];
+    let __heightTexture_decorators;
+    let __heightTexture_initializers = [];
+    let __heightTexture_extraInitializers = [];
+    let _heightTexture_decorators;
+    let _heightTexture_initializers = [];
+    let _heightTexture_extraInitializers = [];
+    let _diffuseColor_decorators;
+    let _diffuseColor_initializers = [];
+    let _diffuseColor_extraInitializers = [];
+    let _furLength_decorators;
+    let _furLength_initializers = [];
+    let _furLength_extraInitializers = [];
+    let _furAngle_decorators;
+    let _furAngle_initializers = [];
+    let _furAngle_extraInitializers = [];
+    let _furColor_decorators;
+    let _furColor_initializers = [];
+    let _furColor_extraInitializers = [];
+    let _furOffset_decorators;
+    let _furOffset_initializers = [];
+    let _furOffset_extraInitializers = [];
+    let _furSpacing_decorators;
+    let _furSpacing_initializers = [];
+    let _furSpacing_extraInitializers = [];
+    let _furGravity_decorators;
+    let _furGravity_initializers = [];
+    let _furGravity_extraInitializers = [];
+    let _furSpeed_decorators;
+    let _furSpeed_initializers = [];
+    let _furSpeed_extraInitializers = [];
+    let _furDensity_decorators;
+    let _furDensity_initializers = [];
+    let _furDensity_extraInitializers = [];
+    let _furOcclusion_decorators;
+    let _furOcclusion_initializers = [];
+    let _furOcclusion_extraInitializers = [];
+    let __disableLighting_decorators;
+    let __disableLighting_initializers = [];
+    let __disableLighting_extraInitializers = [];
+    let _disableLighting_decorators;
+    let _disableLighting_initializers = [];
+    let _disableLighting_extraInitializers = [];
+    let __maxSimultaneousLights_decorators;
+    let __maxSimultaneousLights_initializers = [];
+    let __maxSimultaneousLights_extraInitializers = [];
+    let _maxSimultaneousLights_decorators;
+    let _maxSimultaneousLights_initializers = [];
+    let _maxSimultaneousLights_extraInitializers = [];
+    let _highLevelFur_decorators;
+    let _highLevelFur_initializers = [];
+    let _highLevelFur_extraInitializers = [];
+    let _get_furTime_decorators;
+    return _a = class FurMaterial extends _classSuper {
+            get diffuseTexture() { return __classPrivateFieldGet(this, _FurMaterial_diffuseTexture_accessor_storage, "f"); }
+            set diffuseTexture(value) { __classPrivateFieldSet(this, _FurMaterial_diffuseTexture_accessor_storage, value, "f"); }
+            get heightTexture() { return __classPrivateFieldGet(this, _FurMaterial_heightTexture_accessor_storage, "f"); }
+            set heightTexture(value) { __classPrivateFieldSet(this, _FurMaterial_heightTexture_accessor_storage, value, "f"); }
+            get disableLighting() { return __classPrivateFieldGet(this, _FurMaterial_disableLighting_accessor_storage, "f"); }
+            set disableLighting(value) { __classPrivateFieldSet(this, _FurMaterial_disableLighting_accessor_storage, value, "f"); }
+            get maxSimultaneousLights() { return __classPrivateFieldGet(this, _FurMaterial_maxSimultaneousLights_accessor_storage, "f"); }
+            set maxSimultaneousLights(value) { __classPrivateFieldSet(this, _FurMaterial_maxSimultaneousLights_accessor_storage, value, "f"); }
+            /**
+             * Instantiates a Fur 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, _instanceExtraInitializers), __runInitializers(this, __diffuseTexture_initializers, void 0));
+                _FurMaterial_diffuseTexture_accessor_storage.set(this, (__runInitializers(this, __diffuseTexture_extraInitializers), __runInitializers(this, _diffuseTexture_initializers, void 0)));
+                this._heightTexture = (__runInitializers(this, _diffuseTexture_extraInitializers), __runInitializers(this, __heightTexture_initializers, void 0));
+                _FurMaterial_heightTexture_accessor_storage.set(this, (__runInitializers(this, __heightTexture_extraInitializers), __runInitializers(this, _heightTexture_initializers, void 0)));
+                this.diffuseColor = (__runInitializers(this, _heightTexture_extraInitializers), __runInitializers(this, _diffuseColor_initializers, new Color3(1, 1, 1)));
+                this.furLength = (__runInitializers(this, _diffuseColor_extraInitializers), __runInitializers(this, _furLength_initializers, 1));
+                this.furAngle = (__runInitializers(this, _furLength_extraInitializers), __runInitializers(this, _furAngle_initializers, 0));
+                this.furColor = (__runInitializers(this, _furAngle_extraInitializers), __runInitializers(this, _furColor_initializers, new Color3(0.44, 0.21, 0.02)));
+                this.furOffset = (__runInitializers(this, _furColor_extraInitializers), __runInitializers(this, _furOffset_initializers, 0.0));
+                this.furSpacing = (__runInitializers(this, _furOffset_extraInitializers), __runInitializers(this, _furSpacing_initializers, 12));
+                this.furGravity = (__runInitializers(this, _furSpacing_extraInitializers), __runInitializers(this, _furGravity_initializers, new Vector3(0, 0, 0)));
+                this.furSpeed = (__runInitializers(this, _furGravity_extraInitializers), __runInitializers(this, _furSpeed_initializers, 100));
+                this.furDensity = (__runInitializers(this, _furSpeed_extraInitializers), __runInitializers(this, _furDensity_initializers, 20));
+                this.furOcclusion = (__runInitializers(this, _furDensity_extraInitializers), __runInitializers(this, _furOcclusion_initializers, 0.0));
+                this.furTexture = __runInitializers(this, _furOcclusion_extraInitializers);
+                this._disableLighting = __runInitializers(this, __disableLighting_initializers, false);
+                _FurMaterial_disableLighting_accessor_storage.set(this, (__runInitializers(this, __disableLighting_extraInitializers), __runInitializers(this, _disableLighting_initializers, void 0)));
+                this._maxSimultaneousLights = (__runInitializers(this, _disableLighting_extraInitializers), __runInitializers(this, __maxSimultaneousLights_initializers, 4));
+                _FurMaterial_maxSimultaneousLights_accessor_storage.set(this, (__runInitializers(this, __maxSimultaneousLights_extraInitializers), __runInitializers(this, _maxSimultaneousLights_initializers, void 0)));
+                this.highLevelFur = (__runInitializers(this, _maxSimultaneousLights_extraInitializers), __runInitializers(this, _highLevelFur_initializers, true));
+                this._meshes = __runInitializers(this, _highLevelFur_extraInitializers);
+                this._furTime = 0;
+                this._shadersLoaded = false;
+            }
+            get furTime() {
+                return this._furTime;
+            }
+            set furTime(furTime) {
+                this._furTime = furTime;
             }
-        }
-        if (!subMesh.materialDefines) {
-            subMesh.materialDefines = new FurMaterialDefines();
-        }
-        const defines = subMesh.materialDefines;
-        const scene = this.getScene();
-        if (this._isReadyForSubMesh(subMesh)) {
-            return true;
-        }
-        const engine = scene.getEngine();
-        // Textures
-        if (defines._areTexturesDirty) {
-            if (scene.texturesEnabled) {
-                if (this.diffuseTexture && MaterialFlags.DiffuseTextureEnabled) {
-                    if (!this.diffuseTexture.isReady()) {
-                        return false;
+            needAlphaBlending() {
+                return this.alpha < 1.0;
+            }
+            needAlphaTesting() {
+                return false;
+            }
+            getAlphaTestTexture() {
+                return null;
+            }
+            updateFur() {
+                for (let i = 1; i < this._meshes.length; i++) {
+                    const offsetFur = this._meshes[i].material;
+                    offsetFur.furLength = this.furLength;
+                    offsetFur.furAngle = this.furAngle;
+                    offsetFur.furGravity = this.furGravity;
+                    offsetFur.furSpacing = this.furSpacing;
+                    offsetFur.furSpeed = this.furSpeed;
+                    offsetFur.furColor = this.furColor;
+                    offsetFur.diffuseTexture = this.diffuseTexture;
+                    offsetFur.furTexture = this.furTexture;
+                    offsetFur.highLevelFur = this.highLevelFur;
+                    offsetFur.furTime = this.furTime;
+                    offsetFur.furDensity = this.furDensity;
+                }
+            }
+            // Methods
+            isReadyForSubMesh(mesh, subMesh, useInstances) {
+                const drawWrapper = subMesh._drawWrapper;
+                if (this.isFrozen) {
+                    if (drawWrapper.effect && drawWrapper._wasPreviouslyReady && drawWrapper._wasPreviouslyUsingInstances === useInstances) {
+                        return true;
                     }
-                    else {
-                        defines._needUVs = true;
-                        defines.DIFFUSE = true;
+                }
+                if (!subMesh.materialDefines) {
+                    subMesh.materialDefines = new FurMaterialDefines();
+                }
+                const defines = subMesh.materialDefines;
+                const scene = this.getScene();
+                if (this._isReadyForSubMesh(subMesh)) {
+                    return true;
+                }
+                const engine = scene.getEngine();
+                // Textures
+                if (defines._areTexturesDirty) {
+                    if (scene.texturesEnabled) {
+                        if (this.diffuseTexture && MaterialFlags.DiffuseTextureEnabled) {
+                            if (!this.diffuseTexture.isReady()) {
+                                return false;
+                            }
+                            else {
+                                defines._needUVs = true;
+                                defines.DIFFUSE = true;
+                            }
+                        }
+                        if (this.heightTexture && engine.getCaps().maxVertexTextureImageUnits) {
+                            if (!this.heightTexture.isReady()) {
+                                return false;
+                            }
+                            else {
+                                defines._needUVs = true;
+                                defines.HEIGHTMAP = true;
+                            }
+                        }
                     }
                 }
-                if (this.heightTexture && engine.getCaps().maxVertexTextureImageUnits) {
-                    if (!this.heightTexture.isReady()) {
-                        return false;
+                // High level
+                if (this.highLevelFur !== defines.HIGHLEVEL) {
+                    defines.HIGHLEVEL = true;
+                    defines.markAsUnprocessed();
+                }
+                // Misc.
+                PrepareDefinesForMisc(mesh, scene, this._useLogarithmicDepth, this.pointsCloud, this.fogEnabled, this.needAlphaTestingForMesh(mesh), defines, undefined, undefined, undefined, this._isVertexOutputInvariant);
+                // Lights
+                defines._needNormals = PrepareDefinesForLights(scene, mesh, defines, false, this._maxSimultaneousLights, this._disableLighting);
+                // Values that need to be evaluated on every frame
+                PrepareDefinesForFrameBoundValues(scene, engine, this, defines, useInstances ? true : false);
+                // Attribs
+                PrepareDefinesForAttributes(mesh, defines, true, true);
+                // Get correct effect
+                if (defines.isDirty) {
+                    defines.markAsProcessed();
+                    scene.resetCachedMaterial();
+                    // Fallbacks
+                    const fallbacks = new EffectFallbacks();
+                    if (defines.FOG) {
+                        fallbacks.addFallback(1, "FOG");
+                    }
+                    HandleFallbacksForShadows(defines, fallbacks, this.maxSimultaneousLights);
+                    if (defines.NUM_BONE_INFLUENCERS > 0) {
+                        fallbacks.addCPUSkinningFallback(0, mesh);
+                    }
+                    defines.IMAGEPROCESSINGPOSTPROCESS = scene.imageProcessingConfiguration.applyByPostProcess;
+                    //Attributes
+                    const attribs = [VertexBuffer.PositionKind];
+                    if (defines.NORMAL) {
+                        attribs.push(VertexBuffer.NormalKind);
+                    }
+                    if (defines.UV1) {
+                        attribs.push(VertexBuffer.UVKind);
                     }
-                    else {
-                        defines._needUVs = true;
-                        defines.HEIGHTMAP = true;
+                    if (defines.UV2) {
+                        attribs.push(VertexBuffer.UV2Kind);
                     }
+                    if (defines.VERTEXCOLOR) {
+                        attribs.push(VertexBuffer.ColorKind);
+                    }
+                    PrepareAttributesForBones(attribs, mesh, defines, fallbacks);
+                    PrepareAttributesForInstances(attribs, defines);
+                    // Legacy browser patch
+                    const shaderName = "fur";
+                    const join = defines.toString();
+                    const uniforms = [
+                        "world",
+                        "view",
+                        "viewProjection",
+                        "vEyePosition",
+                        "vLightsType",
+                        "vDiffuseColor",
+                        "vFogInfos",
+                        "vFogColor",
+                        "pointSize",
+                        "vDiffuseInfos",
+                        "mBones",
+                        "diffuseMatrix",
+                        "logarithmicDepthConstant",
+                        "furLength",
+                        "furAngle",
+                        "furColor",
+                        "furOffset",
+                        "furGravity",
+                        "furTime",
+                        "furSpacing",
+                        "furDensity",
+                        "furOcclusion",
+                    ];
+                    AddClipPlaneUniforms(uniforms);
+                    const samplers = ["diffuseSampler", "heightTexture", "furTexture", "areaLightsLTC1Sampler", "areaLightsLTC2Sampler"];
+                    const uniformBuffers = [];
+                    PrepareUniformsAndSamplersList({
+                        uniformsNames: uniforms,
+                        uniformBuffersNames: uniformBuffers,
+                        samplers: samplers,
+                        defines: defines,
+                        maxSimultaneousLights: this.maxSimultaneousLights,
+                        shaderLanguage: this._shaderLanguage,
+                    });
+                    subMesh.setEffect(scene.getEngine().createEffect(shaderName, {
+                        attributes: attribs,
+                        uniformsNames: uniforms,
+                        uniformBuffersNames: uniformBuffers,
+                        samplers: samplers,
+                        defines: join,
+                        fallbacks: fallbacks,
+                        onCompiled: this.onCompiled,
+                        onError: this.onError,
+                        indexParameters: { maxSimultaneousLights: this.maxSimultaneousLights },
+                        shaderLanguage: this._shaderLanguage,
+                        extraInitializationsAsync: this._shadersLoaded
+                            ? undefined
+                            : async () => {
+                                if (this.shaderLanguage === 1 /* ShaderLanguage.WGSL */) {
+                                    await Promise.all([import("./wgsl/fur.vertex.js"), import("./wgsl/fur.fragment.js")]);
+                                }
+                                else {
+                                    await Promise.all([import("./fur.vertex.js"), import("./fur.fragment.js")]);
+                                }
+                                this._shadersLoaded = true;
+                            },
+                    }, engine), defines, this._materialContext);
                 }
+                // Check if Area Lights have LTC texture.
+                if (defines["AREALIGHTUSED"]) {
+                    for (let index = 0; index < mesh.lightSources.length; index++) {
+                        if (!mesh.lightSources[index]._isReady()) {
+                            return false;
+                        }
+                    }
+                }
+                if (!subMesh.effect || !subMesh.effect.isReady()) {
+                    return false;
+                }
+                defines._renderId = scene.getRenderId();
+                drawWrapper._wasPreviouslyReady = true;
+                drawWrapper._wasPreviouslyUsingInstances = !!useInstances;
+                return true;
             }
-        }
-        // High level
-        if (this.highLevelFur !== defines.HIGHLEVEL) {
-            defines.HIGHLEVEL = true;
-            defines.markAsUnprocessed();
-        }
-        // Misc.
-        PrepareDefinesForMisc(mesh, scene, this._useLogarithmicDepth, this.pointsCloud, this.fogEnabled, this.needAlphaTestingForMesh(mesh), defines, undefined, undefined, undefined, this._isVertexOutputInvariant);
-        // Lights
-        defines._needNormals = PrepareDefinesForLights(scene, mesh, defines, false, this._maxSimultaneousLights, this._disableLighting);
-        // Values that need to be evaluated on every frame
-        PrepareDefinesForFrameBoundValues(scene, engine, this, defines, useInstances ? true : false);
-        // Attribs
-        PrepareDefinesForAttributes(mesh, defines, true, true);
-        // Get correct effect
-        if (defines.isDirty) {
-            defines.markAsProcessed();
-            scene.resetCachedMaterial();
-            // Fallbacks
-            const fallbacks = new EffectFallbacks();
-            if (defines.FOG) {
-                fallbacks.addFallback(1, "FOG");
-            }
-            HandleFallbacksForShadows(defines, fallbacks, this.maxSimultaneousLights);
-            if (defines.NUM_BONE_INFLUENCERS > 0) {
-                fallbacks.addCPUSkinningFallback(0, mesh);
-            }
-            defines.IMAGEPROCESSINGPOSTPROCESS = scene.imageProcessingConfiguration.applyByPostProcess;
-            //Attributes
-            const attribs = [VertexBuffer.PositionKind];
-            if (defines.NORMAL) {
-                attribs.push(VertexBuffer.NormalKind);
+            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());
+                    }
+                    if (this._heightTexture) {
+                        this._activeEffect.setTexture("heightTexture", this._heightTexture);
+                    }
+                    // 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.diffuseColor, this.alpha * mesh.visibility);
+                if (scene.lightsEnabled && !this.disableLighting) {
+                    BindLights(scene, mesh, this._activeEffect, defines, this.maxSimultaneousLights);
+                }
+                // View
+                if (scene.fogEnabled && mesh.applyFog && scene.fogMode !== Scene.FOGMODE_NONE) {
+                    this._activeEffect.setMatrix("view", scene.getViewMatrix());
+                }
+                // Fog
+                BindFogParameters(scene, mesh, this._activeEffect);
+                this._activeEffect.setFloat("furLength", this.furLength);
+                this._activeEffect.setFloat("furAngle", this.furAngle);
+                this._activeEffect.setColor4("furColor", this.furColor, 1.0);
+                if (this.highLevelFur) {
+                    this._activeEffect.setVector3("furGravity", this.furGravity);
+                    this._activeEffect.setFloat("furOffset", this.furOffset);
+                    this._activeEffect.setFloat("furSpacing", this.furSpacing);
+                    this._activeEffect.setFloat("furDensity", this.furDensity);
+                    this._activeEffect.setFloat("furOcclusion", this.furOcclusion);
+                    this._furTime += this.getScene().getEngine().getDeltaTime() / this.furSpeed;
+                    this._activeEffect.setFloat("furTime", this._furTime);
+                    this._activeEffect.setTexture("furTexture", this.furTexture);
+                }
+                this._afterBind(mesh, this._activeEffect, subMesh);
             }
-            if (defines.UV1) {
-                attribs.push(VertexBuffer.UVKind);
+            getAnimatables() {
+                const results = [];
+                if (this.diffuseTexture && this.diffuseTexture.animations && this.diffuseTexture.animations.length > 0) {
+                    results.push(this.diffuseTexture);
+                }
+                if (this.heightTexture && this.heightTexture.animations && this.heightTexture.animations.length > 0) {
+                    results.push(this.heightTexture);
+                }
+                return results;
             }
-            if (defines.UV2) {
-                attribs.push(VertexBuffer.UV2Kind);
+            getActiveTextures() {
+                const activeTextures = super.getActiveTextures();
+                if (this._diffuseTexture) {
+                    activeTextures.push(this._diffuseTexture);
+                }
+                if (this._heightTexture) {
+                    activeTextures.push(this._heightTexture);
+                }
+                return activeTextures;
             }
-            if (defines.VERTEXCOLOR) {
-                attribs.push(VertexBuffer.ColorKind);
+            hasTexture(texture) {
+                if (super.hasTexture(texture)) {
+                    return true;
+                }
+                if (this.diffuseTexture === texture) {
+                    return true;
+                }
+                if (this._heightTexture === texture) {
+                    return true;
+                }
+                return false;
             }
-            PrepareAttributesForBones(attribs, mesh, defines, fallbacks);
-            PrepareAttributesForInstances(attribs, defines);
-            // Legacy browser patch
-            const shaderName = "fur";
-            const join = defines.toString();
-            const uniforms = [
-                "world",
-                "view",
-                "viewProjection",
-                "vEyePosition",
-                "vLightsType",
-                "vDiffuseColor",
-                "vFogInfos",
-                "vFogColor",
-                "pointSize",
-                "vDiffuseInfos",
-                "mBones",
-                "diffuseMatrix",
-                "logarithmicDepthConstant",
-                "furLength",
-                "furAngle",
-                "furColor",
-                "furOffset",
-                "furGravity",
-                "furTime",
-                "furSpacing",
-                "furDensity",
-                "furOcclusion",
-            ];
-            AddClipPlaneUniforms(uniforms);
-            const samplers = ["diffuseSampler", "heightTexture", "furTexture", "areaLightsLTC1Sampler", "areaLightsLTC2Sampler"];
-            const uniformBuffers = [];
-            PrepareUniformsAndSamplersList({
-                uniformsNames: uniforms,
-                uniformBuffersNames: uniformBuffers,
-                samplers: samplers,
-                defines: defines,
-                maxSimultaneousLights: this.maxSimultaneousLights,
-                shaderLanguage: this._shaderLanguage,
-            });
-            subMesh.setEffect(scene.getEngine().createEffect(shaderName, {
-                attributes: attribs,
-                uniformsNames: uniforms,
-                uniformBuffersNames: uniformBuffers,
-                samplers: samplers,
-                defines: join,
-                fallbacks: fallbacks,
-                onCompiled: this.onCompiled,
-                onError: this.onError,
-                indexParameters: { maxSimultaneousLights: this.maxSimultaneousLights },
-                shaderLanguage: this._shaderLanguage,
-                extraInitializationsAsync: this._shadersLoaded
-                    ? undefined
-                    : async () => {
-                        if (this.shaderLanguage === 1 /* ShaderLanguage.WGSL */) {
-                            await Promise.all([import("./wgsl/fur.vertex.js"), import("./wgsl/fur.fragment.js")]);
-                        }
-                        else {
-                            await Promise.all([import("./fur.vertex.js"), import("./fur.fragment.js")]);
+            dispose(forceDisposeEffect) {
+                if (this.diffuseTexture) {
+                    this.diffuseTexture.dispose();
+                }
+                if (this._meshes) {
+                    for (let i = 1; i < this._meshes.length; i++) {
+                        const mat = this._meshes[i].material;
+                        if (mat) {
+                            mat.dispose(forceDisposeEffect);
                         }
-                        this._shadersLoaded = true;
-                    },
-            }, engine), defines, this._materialContext);
-        }
-        // Check if Area Lights have LTC texture.
-        if (defines["AREALIGHTUSED"]) {
-            for (let index = 0; index < mesh.lightSources.length; index++) {
-                if (!mesh.lightSources[index]._isReady()) {
-                    return false;
+                        this._meshes[i].dispose();
+                    }
                 }
+                super.dispose(forceDisposeEffect);
             }
-        }
-        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());
+            clone(name) {
+                return SerializationHelper.Clone(() => new _a(name, this.getScene()), this);
             }
-            if (this._heightTexture) {
-                this._activeEffect.setTexture("heightTexture", this._heightTexture);
+            serialize() {
+                const serializationObject = super.serialize();
+                serializationObject.customType = "BABYLON.FurMaterial";
+                if (this._meshes) {
+                    serializationObject.sourceMeshName = this._meshes[0].name;
+                    serializationObject.quality = this._meshes.length;
+                }
+                return serializationObject;
             }
-            // Clip plane
-            BindClipPlane(this._activeEffect, this, scene);
-            // Point size
-            if (this.pointsCloud) {
-                this._activeEffect.setFloat("pointSize", this.pointSize);
+            getClassName() {
+                return "FurMaterial";
             }
-            // Log. depth
-            if (this._useLogarithmicDepth) {
-                BindLogDepth(defines, effect, scene);
+            // Statics
+            static Parse(source, scene, rootUrl) {
+                const material = SerializationHelper.Parse(() => new _a(source.name, scene), source, scene, rootUrl);
+                if (source.sourceMeshName && material.highLevelFur) {
+                    scene.executeWhenReady(() => {
+                        const sourceMesh = scene.getMeshByName(source.sourceMeshName);
+                        if (sourceMesh) {
+                            const furTexture = _a.GenerateTexture("Fur Texture", scene);
+                            material.furTexture = furTexture;
+                            _a.FurifyMesh(sourceMesh, source.quality);
+                        }
+                    });
+                }
+                return material;
             }
-            scene.bindEyePosition(effect);
-        }
-        this._activeEffect.setColor4("vDiffuseColor", this.diffuseColor, this.alpha * mesh.visibility);
-        if (scene.lightsEnabled && !this.disableLighting) {
-            BindLights(scene, mesh, this._activeEffect, defines, this.maxSimultaneousLights);
-        }
-        // View
-        if (scene.fogEnabled && mesh.applyFog && scene.fogMode !== Scene.FOGMODE_NONE) {
-            this._activeEffect.setMatrix("view", scene.getViewMatrix());
-        }
-        // Fog
-        BindFogParameters(scene, mesh, this._activeEffect);
-        this._activeEffect.setFloat("furLength", this.furLength);
-        this._activeEffect.setFloat("furAngle", this.furAngle);
-        this._activeEffect.setColor4("furColor", this.furColor, 1.0);
-        if (this.highLevelFur) {
-            this._activeEffect.setVector3("furGravity", this.furGravity);
-            this._activeEffect.setFloat("furOffset", this.furOffset);
-            this._activeEffect.setFloat("furSpacing", this.furSpacing);
-            this._activeEffect.setFloat("furDensity", this.furDensity);
-            this._activeEffect.setFloat("furOcclusion", this.furOcclusion);
-            this._furTime += this.getScene().getEngine().getDeltaTime() / this.furSpeed;
-            this._activeEffect.setFloat("furTime", this._furTime);
-            this._activeEffect.setTexture("furTexture", this.furTexture);
-        }
-        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.heightTexture && this.heightTexture.animations && this.heightTexture.animations.length > 0) {
-            results.push(this.heightTexture);
-        }
-        return results;
-    }
-    getActiveTextures() {
-        const activeTextures = super.getActiveTextures();
-        if (this._diffuseTexture) {
-            activeTextures.push(this._diffuseTexture);
-        }
-        if (this._heightTexture) {
-            activeTextures.push(this._heightTexture);
-        }
-        return activeTextures;
-    }
-    hasTexture(texture) {
-        if (super.hasTexture(texture)) {
-            return true;
-        }
-        if (this.diffuseTexture === texture) {
-            return true;
-        }
-        if (this._heightTexture === texture) {
-            return true;
-        }
-        return false;
-    }
-    dispose(forceDisposeEffect) {
-        if (this.diffuseTexture) {
-            this.diffuseTexture.dispose();
-        }
-        if (this._meshes) {
-            for (let i = 1; i < this._meshes.length; i++) {
-                const mat = this._meshes[i].material;
-                if (mat) {
-                    mat.dispose(forceDisposeEffect);
+            static GenerateTexture(name, scene) {
+                // Generate fur textures
+                const texture = new DynamicTexture("FurTexture " + name, 256, scene, true);
+                const context = texture.getContext();
+                for (let i = 0; i < 20000; ++i) {
+                    context.fillStyle = "rgba(255, " + Math.floor(Math.random() * 255) + ", " + Math.floor(Math.random() * 255) + ", 1)";
+                    context.fillRect(Math.random() * texture.getSize().width, Math.random() * texture.getSize().height, 2, 2);
                 }
-                this._meshes[i].dispose();
+                texture.update(false);
+                texture.wrapU = Texture.WRAP_ADDRESSMODE;
+                texture.wrapV = Texture.WRAP_ADDRESSMODE;
+                return texture;
             }
-        }
-        super.dispose(forceDisposeEffect);
-    }
-    clone(name) {
-        return SerializationHelper.Clone(() => new FurMaterial(name, this.getScene()), this);
-    }
-    serialize() {
-        const serializationObject = super.serialize();
-        serializationObject.customType = "BABYLON.FurMaterial";
-        if (this._meshes) {
-            serializationObject.sourceMeshName = this._meshes[0].name;
-            serializationObject.quality = this._meshes.length;
-        }
-        return serializationObject;
-    }
-    getClassName() {
-        return "FurMaterial";
-    }
-    // Statics
-    static Parse(source, scene, rootUrl) {
-        const material = SerializationHelper.Parse(() => new FurMaterial(source.name, scene), source, scene, rootUrl);
-        if (source.sourceMeshName && material.highLevelFur) {
-            scene.executeWhenReady(() => {
-                const sourceMesh = scene.getMeshByName(source.sourceMeshName);
-                if (sourceMesh) {
-                    const furTexture = FurMaterial.GenerateTexture("Fur Texture", scene);
-                    material.furTexture = furTexture;
-                    FurMaterial.FurifyMesh(sourceMesh, source.quality);
+            // Creates and returns an array of meshes used as shells for the Fur Material
+            // that can be disposed later in your code
+            // The quality is in interval [0, 100]
+            static FurifyMesh(sourceMesh, quality) {
+                const meshes = [sourceMesh];
+                const mat = sourceMesh.material;
+                let i;
+                if (!(mat instanceof _a)) {
+                    // eslint-disable-next-line no-throw-literal
+                    throw "The material of the source mesh must be a Fur Material";
                 }
-            });
-        }
-        return material;
-    }
-    static GenerateTexture(name, scene) {
-        // Generate fur textures
-        const texture = new DynamicTexture("FurTexture " + name, 256, scene, true);
-        const context = texture.getContext();
-        for (let i = 0; i < 20000; ++i) {
-            context.fillStyle = "rgba(255, " + Math.floor(Math.random() * 255) + ", " + Math.floor(Math.random() * 255) + ", 1)";
-            context.fillRect(Math.random() * texture.getSize().width, Math.random() * texture.getSize().height, 2, 2);
-        }
-        texture.update(false);
-        texture.wrapU = Texture.WRAP_ADDRESSMODE;
-        texture.wrapV = Texture.WRAP_ADDRESSMODE;
-        return texture;
-    }
-    // Creates and returns an array of meshes used as shells for the Fur Material
-    // that can be disposed later in your code
-    // The quality is in interval [0, 100]
-    static FurifyMesh(sourceMesh, quality) {
-        const meshes = [sourceMesh];
-        const mat = sourceMesh.material;
-        let i;
-        if (!(mat instanceof FurMaterial)) {
-            // eslint-disable-next-line no-throw-literal
-            throw "The material of the source mesh must be a Fur Material";
-        }
-        for (i = 1; i < quality; i++) {
-            const offsetFur = new FurMaterial(mat.name + i, sourceMesh.getScene());
-            sourceMesh.getScene().materials.pop();
-            Tags.EnableFor(offsetFur);
-            Tags.AddTagsTo(offsetFur, "furShellMaterial");
-            offsetFur.furLength = mat.furLength;
-            offsetFur.furAngle = mat.furAngle;
-            offsetFur.furGravity = mat.furGravity;
-            offsetFur.furSpacing = mat.furSpacing;
-            offsetFur.furSpeed = mat.furSpeed;
-            offsetFur.furColor = mat.furColor;
-            offsetFur.diffuseTexture = mat.diffuseTexture;
-            offsetFur.furOffset = i / quality;
-            offsetFur.furTexture = mat.furTexture;
-            offsetFur.highLevelFur = mat.highLevelFur;
-            offsetFur.furTime = mat.furTime;
-            offsetFur.furDensity = mat.furDensity;
-            const offsetMesh = sourceMesh.clone(sourceMesh.name + i);
-            offsetMesh.material = offsetFur;
-            offsetMesh.skeleton = sourceMesh.skeleton;
-            offsetMesh.position = Vector3.Zero();
-            meshes.push(offsetMesh);
-        }
-        for (i = 1; i < meshes.length; i++) {
-            meshes[i].parent = sourceMesh;
-        }
-        sourceMesh.material._meshes = meshes;
-        return meshes;
-    }
-}
-__decorate([
-    serializeAsTexture("diffuseTexture")
-], FurMaterial.prototype, "_diffuseTexture", void 0);
-__decorate([
-    expandToProperty("_markAllSubMeshesAsTexturesDirty")
-], FurMaterial.prototype, "diffuseTexture", void 0);
-__decorate([
-    serializeAsTexture("heightTexture")
-], FurMaterial.prototype, "_heightTexture", void 0);
-__decorate([
-    expandToProperty("_markAllSubMeshesAsTexturesDirty")
-], FurMaterial.prototype, "heightTexture", void 0);
-__decorate([
-    serializeAsColor3()
-], FurMaterial.prototype, "diffuseColor", void 0);
-__decorate([
-    serialize()
-], FurMaterial.prototype, "furLength", void 0);
-__decorate([
-    serialize()
-], FurMaterial.prototype, "furAngle", void 0);
-__decorate([
-    serializeAsColor3()
-], FurMaterial.prototype, "furColor", void 0);
-__decorate([
-    serialize()
-], FurMaterial.prototype, "furOffset", void 0);
-__decorate([
-    serialize()
-], FurMaterial.prototype, "furSpacing", void 0);
-__decorate([
-    serializeAsVector3()
-], FurMaterial.prototype, "furGravity", void 0);
-__decorate([
-    serialize()
-], FurMaterial.prototype, "furSpeed", void 0);
-__decorate([
-    serialize()
-], FurMaterial.prototype, "furDensity", void 0);
-__decorate([
-    serialize()
-], FurMaterial.prototype, "furOcclusion", void 0);
-__decorate([
-    serialize("disableLighting")
-], FurMaterial.prototype, "_disableLighting", void 0);
-__decorate([
-    expandToProperty("_markAllSubMeshesAsLightsDirty")
-], FurMaterial.prototype, "disableLighting", void 0);
-__decorate([
-    serialize("maxSimultaneousLights")
-], FurMaterial.prototype, "_maxSimultaneousLights", void 0);
-__decorate([
-    expandToProperty("_markAllSubMeshesAsLightsDirty")
-], FurMaterial.prototype, "maxSimultaneousLights", void 0);
-__decorate([
-    serialize()
-], FurMaterial.prototype, "highLevelFur", void 0);
-__decorate([
-    serialize()
-], FurMaterial.prototype, "furTime", null);
+                for (i = 1; i < quality; i++) {
+                    const offsetFur = new _a(mat.name + i, sourceMesh.getScene());
+                    sourceMesh.getScene().materials.pop();
+                    Tags.EnableFor(offsetFur);
+                    Tags.AddTagsTo(offsetFur, "furShellMaterial");
+                    offsetFur.furLength = mat.furLength;
+                    offsetFur.furAngle = mat.furAngle;
+                    offsetFur.furGravity = mat.furGravity;
+                    offsetFur.furSpacing = mat.furSpacing;
+                    offsetFur.furSpeed = mat.furSpeed;
+                    offsetFur.furColor = mat.furColor;
+                    offsetFur.diffuseTexture = mat.diffuseTexture;
+                    offsetFur.furOffset = i / quality;
+                    offsetFur.furTexture = mat.furTexture;
+                    offsetFur.highLevelFur = mat.highLevelFur;
+                    offsetFur.furTime = mat.furTime;
+                    offsetFur.furDensity = mat.furDensity;
+                    const offsetMesh = sourceMesh.clone(sourceMesh.name + i);
+                    offsetMesh.material = offsetFur;
+                    offsetMesh.skeleton = sourceMesh.skeleton;
+                    offsetMesh.position = Vector3.Zero();
+                    meshes.push(offsetMesh);
+                }
+                for (i = 1; i < meshes.length; i++) {
+                    meshes[i].parent = sourceMesh;
+                }
+                sourceMesh.material._meshes = meshes;
+                return meshes;
+            }
+        },
+        _FurMaterial_diffuseTexture_accessor_storage = new WeakMap(),
+        _FurMaterial_heightTexture_accessor_storage = new WeakMap(),
+        _FurMaterial_disableLighting_accessor_storage = new WeakMap(),
+        _FurMaterial_maxSimultaneousLights_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")];
+            __heightTexture_decorators = [serializeAsTexture("heightTexture")];
+            _heightTexture_decorators = [expandToProperty("_markAllSubMeshesAsTexturesDirty")];
+            _diffuseColor_decorators = [serializeAsColor3()];
+            _furLength_decorators = [serialize()];
+            _furAngle_decorators = [serialize()];
+            _furColor_decorators = [serializeAsColor3()];
+            _furOffset_decorators = [serialize()];
+            _furSpacing_decorators = [serialize()];
+            _furGravity_decorators = [serializeAsVector3()];
+            _furSpeed_decorators = [serialize()];
+            _furDensity_decorators = [serialize()];
+            _furOcclusion_decorators = [serialize()];
+            __disableLighting_decorators = [serialize("disableLighting")];
+            _disableLighting_decorators = [expandToProperty("_markAllSubMeshesAsLightsDirty")];
+            __maxSimultaneousLights_decorators = [serialize("maxSimultaneousLights")];
+            _maxSimultaneousLights_decorators = [expandToProperty("_markAllSubMeshesAsLightsDirty")];
+            _highLevelFur_decorators = [serialize()];
+            _get_furTime_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, _heightTexture_decorators, { kind: "accessor", name: "heightTexture", static: false, private: false, access: { has: obj => "heightTexture" in obj, get: obj => obj.heightTexture, set: (obj, value) => { obj.heightTexture = value; } }, metadata: _metadata }, _heightTexture_initializers, _heightTexture_extraInitializers);
+            __esDecorate(_a, null, _disableLighting_decorators, { kind: "accessor", name: "disableLighting", static: false, private: false, access: { has: obj => "disableLighting" in obj, get: obj => obj.disableLighting, set: (obj, value) => { obj.disableLighting = value; } }, metadata: _metadata }, _disableLighting_initializers, _disableLighting_extraInitializers);
+            __esDecorate(_a, null, _maxSimultaneousLights_decorators, { kind: "accessor", name: "maxSimultaneousLights", static: false, private: false, access: { has: obj => "maxSimultaneousLights" in obj, get: obj => obj.maxSimultaneousLights, set: (obj, value) => { obj.maxSimultaneousLights = value; } }, metadata: _metadata }, _maxSimultaneousLights_initializers, _maxSimultaneousLights_extraInitializers);
+            __esDecorate(_a, null, _get_furTime_decorators, { kind: "getter", name: "furTime", static: false, private: false, access: { has: obj => "furTime" in obj, get: obj => obj.furTime }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __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, __heightTexture_decorators, { kind: "field", name: "_heightTexture", static: false, private: false, access: { has: obj => "_heightTexture" in obj, get: obj => obj._heightTexture, set: (obj, value) => { obj._heightTexture = value; } }, metadata: _metadata }, __heightTexture_initializers, __heightTexture_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, _furLength_decorators, { kind: "field", name: "furLength", static: false, private: false, access: { has: obj => "furLength" in obj, get: obj => obj.furLength, set: (obj, value) => { obj.furLength = value; } }, metadata: _metadata }, _furLength_initializers, _furLength_extraInitializers);
+            __esDecorate(null, null, _furAngle_decorators, { kind: "field", name: "furAngle", static: false, private: false, access: { has: obj => "furAngle" in obj, get: obj => obj.furAngle, set: (obj, value) => { obj.furAngle = value; } }, metadata: _metadata }, _furAngle_initializers, _furAngle_extraInitializers);
+            __esDecorate(null, null, _furColor_decorators, { kind: "field", name: "furColor", static: false, private: false, access: { has: obj => "furColor" in obj, get: obj => obj.furColor, set: (obj, value) => { obj.furColor = value; } }, metadata: _metadata }, _furColor_initializers, _furColor_extraInitializers);
+            __esDecorate(null, null, _furOffset_decorators, { kind: "field", name: "furOffset", static: false, private: false, access: { has: obj => "furOffset" in obj, get: obj => obj.furOffset, set: (obj, value) => { obj.furOffset = value; } }, metadata: _metadata }, _furOffset_initializers, _furOffset_extraInitializers);
+            __esDecorate(null, null, _furSpacing_decorators, { kind: "field", name: "furSpacing", static: false, private: false, access: { has: obj => "furSpacing" in obj, get: obj => obj.furSpacing, set: (obj, value) => { obj.furSpacing = value; } }, metadata: _metadata }, _furSpacing_initializers, _furSpacing_extraInitializers);
+            __esDecorate(null, null, _furGravity_decorators, { kind: "field", name: "furGravity", static: false, private: false, access: { has: obj => "furGravity" in obj, get: obj => obj.furGravity, set: (obj, value) => { obj.furGravity = value; } }, metadata: _metadata }, _furGravity_initializers, _furGravity_extraInitializers);
+            __esDecorate(null, null, _furSpeed_decorators, { kind: "field", name: "furSpeed", static: false, private: false, access: { has: obj => "furSpeed" in obj, get: obj => obj.furSpeed, set: (obj, value) => { obj.furSpeed = value; } }, metadata: _metadata }, _furSpeed_initializers, _furSpeed_extraInitializers);
+            __esDecorate(null, null, _furDensity_decorators, { kind: "field", name: "furDensity", static: false, private: false, access: { has: obj => "furDensity" in obj, get: obj => obj.furDensity, set: (obj, value) => { obj.furDensity = value; } }, metadata: _metadata }, _furDensity_initializers, _furDensity_extraInitializers);
+            __esDecorate(null, null, _furOcclusion_decorators, { kind: "field", name: "furOcclusion", static: false, private: false, access: { has: obj => "furOcclusion" in obj, get: obj => obj.furOcclusion, set: (obj, value) => { obj.furOcclusion = value; } }, metadata: _metadata }, _furOcclusion_initializers, _furOcclusion_extraInitializers);
+            __esDecorate(null, null, __disableLighting_decorators, { kind: "field", name: "_disableLighting", static: false, private: false, access: { has: obj => "_disableLighting" in obj, get: obj => obj._disableLighting, set: (obj, value) => { obj._disableLighting = value; } }, metadata: _metadata }, __disableLighting_initializers, __disableLighting_extraInitializers);
+            __esDecorate(null, null, __maxSimultaneousLights_decorators, { kind: "field", name: "_maxSimultaneousLights", static: false, private: false, access: { has: obj => "_maxSimultaneousLights" in obj, get: obj => obj._maxSimultaneousLights, set: (obj, value) => { obj._maxSimultaneousLights = value; } }, metadata: _metadata }, __maxSimultaneousLights_initializers, __maxSimultaneousLights_extraInitializers);
+            __esDecorate(null, null, _highLevelFur_decorators, { kind: "field", name: "highLevelFur", static: false, private: false, access: { has: obj => "highLevelFur" in obj, get: obj => obj.highLevelFur, set: (obj, value) => { obj.highLevelFur = value; } }, metadata: _metadata }, _highLevelFur_initializers, _highLevelFur_extraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+export { FurMaterial };
 RegisterClass("BABYLON.FurMaterial", FurMaterial);
 //# sourceMappingURL=furMaterial.js.map