@babylonjs/materials 9.15.0 → 9.16.1

package/sky/skyMaterial.js

@@ -1,4 +1,4 @@
-import { __decorate } from "@babylonjs/core/tslib.es6.js";
+import { __esDecorate, __runInitializers } from "@babylonjs/core/tslib.es6.js";
 import { serializeAsVector3, serialize } from "@babylonjs/core/Misc/decorators.js";
 import { SerializationHelper } from "@babylonjs/core/Misc/decorators.serialization.js";
 import { Vector3, Quaternion, TmpVectors } from "@babylonjs/core/Maths/math.vector.js";
@@ -35,354 +35,390 @@ class SkyMaterialDefines extends MaterialDefines {
  * This is the sky material which allows to create dynamic and texture free effects for skyboxes.
  * @see https://doc.babylonjs.com/toolsAndResources/assetLibraries/materialsLibrary/skyMat
  */
-export class SkyMaterial extends PushMaterial {
-    /**
-     * Instantiates a new sky material.
-     * This material allows to create dynamic and texture free
-     * effects for skyboxes by taking care of the atmosphere state.
-     * @see https://doc.babylonjs.com/toolsAndResources/assetLibraries/materialsLibrary/skyMat
-     * @param name Define the name of the material in the scene
-     * @param scene Define the scene the material belong 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);
-        /**
-         * Defines the overall luminance of sky in interval ]0, 1[.
-         */
-        this.luminance = 1.0;
-        /**
-         * Defines the amount (scattering) of haze as opposed to molecules in atmosphere.
-         */
-        this.turbidity = 10.0;
-        /**
-         * Defines the sky appearance (light intensity).
-         */
-        this.rayleigh = 2.0;
-        /**
-         * Defines the mieCoefficient in interval [0, 0.1] which affects the property .mieDirectionalG.
-         */
-        this.mieCoefficient = 0.005;
-        /**
-         * Defines the amount of haze particles following the Mie scattering theory.
-         */
-        this.mieDirectionalG = 0.8;
-        /**
-         * Defines the distance of the sun according to the active scene camera.
-         */
-        this.distance = 500;
-        /**
-         * Defines the sun inclination, in interval [-0.5, 0.5]. When the inclination is not 0, the sun is said
-         * "inclined".
-         */
-        this.inclination = 0.49;
-        /**
-         * Defines the solar azimuth in interval [0, 1]. The azimuth is the angle in the horizontal plan between
-         * an object direction and a reference direction.
-         */
-        this.azimuth = 0.25;
-        /**
-         * Defines the sun position in the sky on (x,y,z). If the property .useSunPosition is set to false, then
-         * the property is overridden by the inclination and the azimuth and can be read at any moment.
-         */
-        this.sunPosition = new Vector3(0, 100, 0);
-        /**
-         * Defines if the sun position should be computed (inclination and azimuth) according to the given
-         * .sunPosition property.
-         */
-        this.useSunPosition = false;
-        /**
-         * Defines an offset vector used to get a horizon offset.
-         * @example skyMaterial.cameraOffset.y = camera.globalPosition.y // Set horizon relative to 0 on the Y axis
-         */
-        this.cameraOffset = Vector3.Zero();
-        /**
-         * Defines the vector the skyMaterial should consider as up. (default is Vector3(0, 1, 0) as returned by Vector3.Up())
-         */
-        this.up = Vector3.Up();
-        /**
-         * Defines if sky should be dithered.
-         */
-        this.dithering = false;
-        // Private members
-        this._cameraPosition = Vector3.Zero();
-        this._skyOrientation = new Quaternion();
-        this._shadersLoaded = false;
-    }
-    /**
-     * Specifies if the material will require alpha blending
-     * @returns a boolean specifying if alpha blending is needed
-     */
-    needAlphaBlending() {
-        return this.alpha < 1.0;
-    }
-    /**
-     * Specifies if this material should be rendered in alpha test mode
-     * @returns false as the sky material doesn't need alpha testing.
-     */
-    needAlphaTesting() {
-        return false;
-    }
-    /**
-     * Get the texture used for alpha test purpose.
-     * @returns null as the sky material has no texture.
-     */
-    getAlphaTestTexture() {
-        return null;
-    }
-    /**
-     * Get if the submesh is ready to be used and all its information available.
-     * Child classes can use it to update shaders
-     * @param mesh defines the mesh to check
-     * @param subMesh defines which submesh to check
-     * @returns a boolean indicating that the submesh is ready or not
-     */
-    isReadyForSubMesh(mesh, subMesh) {
-        const drawWrapper = subMesh._drawWrapper;
-        if (this.isFrozen) {
-            if (drawWrapper.effect && drawWrapper._wasPreviouslyReady) {
+let SkyMaterial = (() => {
+    var _a;
+    let _classSuper = PushMaterial;
+    let _luminance_decorators;
+    let _luminance_initializers = [];
+    let _luminance_extraInitializers = [];
+    let _turbidity_decorators;
+    let _turbidity_initializers = [];
+    let _turbidity_extraInitializers = [];
+    let _rayleigh_decorators;
+    let _rayleigh_initializers = [];
+    let _rayleigh_extraInitializers = [];
+    let _mieCoefficient_decorators;
+    let _mieCoefficient_initializers = [];
+    let _mieCoefficient_extraInitializers = [];
+    let _mieDirectionalG_decorators;
+    let _mieDirectionalG_initializers = [];
+    let _mieDirectionalG_extraInitializers = [];
+    let _distance_decorators;
+    let _distance_initializers = [];
+    let _distance_extraInitializers = [];
+    let _inclination_decorators;
+    let _inclination_initializers = [];
+    let _inclination_extraInitializers = [];
+    let _azimuth_decorators;
+    let _azimuth_initializers = [];
+    let _azimuth_extraInitializers = [];
+    let _sunPosition_decorators;
+    let _sunPosition_initializers = [];
+    let _sunPosition_extraInitializers = [];
+    let _useSunPosition_decorators;
+    let _useSunPosition_initializers = [];
+    let _useSunPosition_extraInitializers = [];
+    let _cameraOffset_decorators;
+    let _cameraOffset_initializers = [];
+    let _cameraOffset_extraInitializers = [];
+    let _up_decorators;
+    let _up_initializers = [];
+    let _up_extraInitializers = [];
+    let _dithering_decorators;
+    let _dithering_initializers = [];
+    let _dithering_extraInitializers = [];
+    return _a = class SkyMaterial extends _classSuper {
+            /**
+             * Instantiates a new sky material.
+             * This material allows to create dynamic and texture free
+             * effects for skyboxes by taking care of the atmosphere state.
+             * @see https://doc.babylonjs.com/toolsAndResources/assetLibraries/materialsLibrary/skyMat
+             * @param name Define the name of the material in the scene
+             * @param scene Define the scene the material belong 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);
+                /**
+                 * Defines the overall luminance of sky in interval ]0, 1[.
+                 */
+                this.luminance = __runInitializers(this, _luminance_initializers, 1.0);
+                /**
+                 * Defines the amount (scattering) of haze as opposed to molecules in atmosphere.
+                 */
+                this.turbidity = (__runInitializers(this, _luminance_extraInitializers), __runInitializers(this, _turbidity_initializers, 10.0));
+                /**
+                 * Defines the sky appearance (light intensity).
+                 */
+                this.rayleigh = (__runInitializers(this, _turbidity_extraInitializers), __runInitializers(this, _rayleigh_initializers, 2.0));
+                /**
+                 * Defines the mieCoefficient in interval [0, 0.1] which affects the property .mieDirectionalG.
+                 */
+                this.mieCoefficient = (__runInitializers(this, _rayleigh_extraInitializers), __runInitializers(this, _mieCoefficient_initializers, 0.005));
+                /**
+                 * Defines the amount of haze particles following the Mie scattering theory.
+                 */
+                this.mieDirectionalG = (__runInitializers(this, _mieCoefficient_extraInitializers), __runInitializers(this, _mieDirectionalG_initializers, 0.8));
+                /**
+                 * Defines the distance of the sun according to the active scene camera.
+                 */
+                this.distance = (__runInitializers(this, _mieDirectionalG_extraInitializers), __runInitializers(this, _distance_initializers, 500));
+                /**
+                 * Defines the sun inclination, in interval [-0.5, 0.5]. When the inclination is not 0, the sun is said
+                 * "inclined".
+                 */
+                this.inclination = (__runInitializers(this, _distance_extraInitializers), __runInitializers(this, _inclination_initializers, 0.49));
+                /**
+                 * Defines the solar azimuth in interval [0, 1]. The azimuth is the angle in the horizontal plan between
+                 * an object direction and a reference direction.
+                 */
+                this.azimuth = (__runInitializers(this, _inclination_extraInitializers), __runInitializers(this, _azimuth_initializers, 0.25));
+                /**
+                 * Defines the sun position in the sky on (x,y,z). If the property .useSunPosition is set to false, then
+                 * the property is overridden by the inclination and the azimuth and can be read at any moment.
+                 */
+                this.sunPosition = (__runInitializers(this, _azimuth_extraInitializers), __runInitializers(this, _sunPosition_initializers, new Vector3(0, 100, 0)));
+                /**
+                 * Defines if the sun position should be computed (inclination and azimuth) according to the given
+                 * .sunPosition property.
+                 */
+                this.useSunPosition = (__runInitializers(this, _sunPosition_extraInitializers), __runInitializers(this, _useSunPosition_initializers, false));
+                /**
+                 * Defines an offset vector used to get a horizon offset.
+                 * @example skyMaterial.cameraOffset.y = camera.globalPosition.y // Set horizon relative to 0 on the Y axis
+                 */
+                this.cameraOffset = (__runInitializers(this, _useSunPosition_extraInitializers), __runInitializers(this, _cameraOffset_initializers, Vector3.Zero()));
+                /**
+                 * Defines the vector the skyMaterial should consider as up. (default is Vector3(0, 1, 0) as returned by Vector3.Up())
+                 */
+                this.up = (__runInitializers(this, _cameraOffset_extraInitializers), __runInitializers(this, _up_initializers, Vector3.Up()));
+                /**
+                 * Defines if sky should be dithered.
+                 */
+                this.dithering = (__runInitializers(this, _up_extraInitializers), __runInitializers(this, _dithering_initializers, false));
+                // Private members
+                this._cameraPosition = (__runInitializers(this, _dithering_extraInitializers), Vector3.Zero());
+                this._skyOrientation = new Quaternion();
+                this._shadersLoaded = false;
+            }
+            /**
+             * Specifies if the material will require alpha blending
+             * @returns a boolean specifying if alpha blending is needed
+             */
+            needAlphaBlending() {
+                return this.alpha < 1.0;
+            }
+            /**
+             * Specifies if this material should be rendered in alpha test mode
+             * @returns false as the sky material doesn't need alpha testing.
+             */
+            needAlphaTesting() {
+                return false;
+            }
+            /**
+             * Get the texture used for alpha test purpose.
+             * @returns null as the sky material has no texture.
+             */
+            getAlphaTestTexture() {
+                return null;
+            }
+            /**
+             * Get if the submesh is ready to be used and all its information available.
+             * Child classes can use it to update shaders
+             * @param mesh defines the mesh to check
+             * @param subMesh defines which submesh to check
+             * @returns a boolean indicating that the submesh is ready or not
+             */
+            isReadyForSubMesh(mesh, subMesh) {
+                const drawWrapper = subMesh._drawWrapper;
+                if (this.isFrozen) {
+                    if (drawWrapper.effect && drawWrapper._wasPreviouslyReady) {
+                        return true;
+                    }
+                }
+                if (!subMesh.materialDefines) {
+                    subMesh.materialDefines = new SkyMaterialDefines();
+                }
+                const defines = subMesh.materialDefines;
+                const scene = this.getScene();
+                if (this._isReadyForSubMesh(subMesh)) {
+                    return true;
+                }
+                PrepareDefinesForMisc(mesh, scene, this._useLogarithmicDepth, this.pointsCloud, this.fogEnabled, false, defines, undefined, undefined, undefined, this._isVertexOutputInvariant);
+                // Attribs
+                PrepareDefinesForAttributes(mesh, defines, true, false);
+                if (defines.IMAGEPROCESSINGPOSTPROCESS !== scene.imageProcessingConfiguration.applyByPostProcess) {
+                    defines.markAsMiscDirty();
+                }
+                if (defines.DITHER !== this.dithering) {
+                    defines.markAsMiscDirty();
+                }
+                // Get correct effect
+                if (defines.isDirty) {
+                    defines.markAsProcessed();
+                    scene.resetCachedMaterial();
+                    // Fallbacks
+                    const fallbacks = new EffectFallbacks();
+                    if (defines.FOG) {
+                        fallbacks.addFallback(1, "FOG");
+                    }
+                    defines.IMAGEPROCESSINGPOSTPROCESS = scene.imageProcessingConfiguration.applyByPostProcess;
+                    defines.DITHER = this.dithering;
+                    //Attributes
+                    const attribs = [VertexBuffer.PositionKind];
+                    if (defines.VERTEXCOLOR) {
+                        attribs.push(VertexBuffer.ColorKind);
+                    }
+                    const shaderName = "sky";
+                    const uniforms = [
+                        "world",
+                        "viewProjection",
+                        "view",
+                        "vFogInfos",
+                        "vFogColor",
+                        "logarithmicDepthConstant",
+                        "pointSize",
+                        "luminance",
+                        "turbidity",
+                        "rayleigh",
+                        "mieCoefficient",
+                        "mieDirectionalG",
+                        "sunPosition",
+                        "cameraPosition",
+                        "cameraOffset",
+                        "up",
+                    ];
+                    AddClipPlaneUniforms(uniforms);
+                    const join = defines.toString();
+                    subMesh.setEffect(scene.getEngine().createEffect(shaderName, {
+                        attributes: attribs,
+                        uniformsNames: uniforms,
+                        uniformBuffersNames: [],
+                        samplers: [],
+                        defines: join,
+                        fallbacks: fallbacks,
+                        onCompiled: this.onCompiled,
+                        onError: this.onError,
+                        shaderLanguage: this._shaderLanguage,
+                        extraInitializationsAsync: this._shadersLoaded
+                            ? undefined
+                            : async () => {
+                                if (this.shaderLanguage === 1 /* ShaderLanguage.WGSL */) {
+                                    await Promise.all([import("./wgsl/sky.vertex.js"), import("./wgsl/sky.fragment.js")]);
+                                }
+                                else {
+                                    await Promise.all([import("./sky.vertex.js"), import("./sky.fragment.js")]);
+                                }
+                                this._shadersLoaded = true;
+                            },
+                    }, scene.getEngine()), defines, this._materialContext);
+                }
+                if (!subMesh.effect || !subMesh.effect.isReady()) {
+                    return false;
+                }
+                defines._renderId = scene.getRenderId();
+                drawWrapper._wasPreviouslyReady = true;
                 return true;
             }
-        }
-        if (!subMesh.materialDefines) {
-            subMesh.materialDefines = new SkyMaterialDefines();
-        }
-        const defines = subMesh.materialDefines;
-        const scene = this.getScene();
-        if (this._isReadyForSubMesh(subMesh)) {
-            return true;
-        }
-        PrepareDefinesForMisc(mesh, scene, this._useLogarithmicDepth, this.pointsCloud, this.fogEnabled, false, defines, undefined, undefined, undefined, this._isVertexOutputInvariant);
-        // Attribs
-        PrepareDefinesForAttributes(mesh, defines, true, false);
-        if (defines.IMAGEPROCESSINGPOSTPROCESS !== scene.imageProcessingConfiguration.applyByPostProcess) {
-            defines.markAsMiscDirty();
-        }
-        if (defines.DITHER !== this.dithering) {
-            defines.markAsMiscDirty();
-        }
-        // Get correct effect
-        if (defines.isDirty) {
-            defines.markAsProcessed();
-            scene.resetCachedMaterial();
-            // Fallbacks
-            const fallbacks = new EffectFallbacks();
-            if (defines.FOG) {
-                fallbacks.addFallback(1, "FOG");
+            /**
+             * Binds the submesh to this material by preparing the effect and shader to draw
+             * @param world defines the world transformation matrix
+             * @param mesh defines the mesh containing the submesh
+             * @param subMesh defines the submesh to bind the material to
+             */
+            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)) {
+                    BindClipPlane(effect, this, scene);
+                    // Point size
+                    if (this.pointsCloud) {
+                        this._activeEffect.setFloat("pointSize", this.pointSize);
+                    }
+                    // Log. depth
+                    if (this._useLogarithmicDepth) {
+                        BindLogDepth(defines, effect, scene);
+                    }
+                }
+                // View
+                if (scene.fogEnabled && mesh.applyFog && scene.fogMode !== Scene.FOGMODE_NONE) {
+                    this._activeEffect.setMatrix("view", scene.getViewMatrix());
+                }
+                // Fog
+                BindFogParameters(scene, mesh, this._activeEffect);
+                // Sky
+                const camera = scene.activeCamera;
+                if (camera) {
+                    const cameraWorldMatrix = camera.getWorldMatrix();
+                    this._cameraPosition.x = cameraWorldMatrix.m[12];
+                    this._cameraPosition.y = cameraWorldMatrix.m[13];
+                    this._cameraPosition.z = cameraWorldMatrix.m[14];
+                    this._activeEffect.setVector3("cameraPosition", TmpVectors.Vector3[0].copyFrom(this._cameraPosition).subtractInPlace(scene.floatingOriginOffset));
+                }
+                this._activeEffect.setVector3("cameraOffset", this.cameraOffset);
+                this._activeEffect.setVector3("up", this.up);
+                if (this.luminance > 0) {
+                    this._activeEffect.setFloat("luminance", this.luminance);
+                }
+                this._activeEffect.setFloat("turbidity", this.turbidity);
+                this._activeEffect.setFloat("rayleigh", this.rayleigh);
+                this._activeEffect.setFloat("mieCoefficient", this.mieCoefficient);
+                this._activeEffect.setFloat("mieDirectionalG", this.mieDirectionalG);
+                if (!this.useSunPosition) {
+                    const theta = Math.PI * (this.inclination - 0.5);
+                    const phi = 2 * Math.PI * (this.azimuth - 0.5);
+                    this.sunPosition.x = this.distance * Math.cos(phi) * Math.cos(theta);
+                    this.sunPosition.y = this.distance * Math.sin(-theta);
+                    this.sunPosition.z = this.distance * Math.sin(phi) * Math.cos(theta);
+                    Quaternion.FromUnitVectorsToRef(Vector3.UpReadOnly, this.up, this._skyOrientation);
+                    this.sunPosition.rotateByQuaternionToRef(this._skyOrientation, this.sunPosition);
+                }
+                this._activeEffect.setVector3("sunPosition", this.sunPosition);
+                this._afterBind(mesh, this._activeEffect, subMesh);
             }
-            defines.IMAGEPROCESSINGPOSTPROCESS = scene.imageProcessingConfiguration.applyByPostProcess;
-            defines.DITHER = this.dithering;
-            //Attributes
-            const attribs = [VertexBuffer.PositionKind];
-            if (defines.VERTEXCOLOR) {
-                attribs.push(VertexBuffer.ColorKind);
+            /**
+             * Get the list of animatables in the material.
+             * @returns the list of animatables object used in the material
+             */
+            getAnimatables() {
+                return [];
             }
-            const shaderName = "sky";
-            const uniforms = [
-                "world",
-                "viewProjection",
-                "view",
-                "vFogInfos",
-                "vFogColor",
-                "logarithmicDepthConstant",
-                "pointSize",
-                "luminance",
-                "turbidity",
-                "rayleigh",
-                "mieCoefficient",
-                "mieDirectionalG",
-                "sunPosition",
-                "cameraPosition",
-                "cameraOffset",
-                "up",
-            ];
-            AddClipPlaneUniforms(uniforms);
-            const join = defines.toString();
-            subMesh.setEffect(scene.getEngine().createEffect(shaderName, {
-                attributes: attribs,
-                uniformsNames: uniforms,
-                uniformBuffersNames: [],
-                samplers: [],
-                defines: join,
-                fallbacks: fallbacks,
-                onCompiled: this.onCompiled,
-                onError: this.onError,
-                shaderLanguage: this._shaderLanguage,
-                extraInitializationsAsync: this._shadersLoaded
-                    ? undefined
-                    : async () => {
-                        if (this.shaderLanguage === 1 /* ShaderLanguage.WGSL */) {
-                            await Promise.all([import("./wgsl/sky.vertex.js"), import("./wgsl/sky.fragment.js")]);
-                        }
-                        else {
-                            await Promise.all([import("./sky.vertex.js"), import("./sky.fragment.js")]);
-                        }
-                        this._shadersLoaded = true;
-                    },
-            }, scene.getEngine()), defines, this._materialContext);
-        }
-        if (!subMesh.effect || !subMesh.effect.isReady()) {
-            return false;
-        }
-        defines._renderId = scene.getRenderId();
-        drawWrapper._wasPreviouslyReady = true;
-        return true;
-    }
-    /**
-     * Binds the submesh to this material by preparing the effect and shader to draw
-     * @param world defines the world transformation matrix
-     * @param mesh defines the mesh containing the submesh
-     * @param subMesh defines the submesh to bind the material to
-     */
-    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)) {
-            BindClipPlane(effect, this, scene);
-            // Point size
-            if (this.pointsCloud) {
-                this._activeEffect.setFloat("pointSize", this.pointSize);
+            /**
+             * Disposes the material
+             * @param forceDisposeEffect specifies if effects should be forcefully disposed
+             */
+            dispose(forceDisposeEffect) {
+                super.dispose(forceDisposeEffect);
             }
-            // Log. depth
-            if (this._useLogarithmicDepth) {
-                BindLogDepth(defines, effect, scene);
+            /**
+             * Makes a duplicate of the material, and gives it a new name
+             * @param name defines the new name for the duplicated material
+             * @returns the cloned material
+             */
+            clone(name) {
+                return SerializationHelper.Clone(() => new _a(name, this.getScene()), this);
             }
-        }
-        // View
-        if (scene.fogEnabled && mesh.applyFog && scene.fogMode !== Scene.FOGMODE_NONE) {
-            this._activeEffect.setMatrix("view", scene.getViewMatrix());
-        }
-        // Fog
-        BindFogParameters(scene, mesh, this._activeEffect);
-        // Sky
-        const camera = scene.activeCamera;
-        if (camera) {
-            const cameraWorldMatrix = camera.getWorldMatrix();
-            this._cameraPosition.x = cameraWorldMatrix.m[12];
-            this._cameraPosition.y = cameraWorldMatrix.m[13];
-            this._cameraPosition.z = cameraWorldMatrix.m[14];
-            this._activeEffect.setVector3("cameraPosition", TmpVectors.Vector3[0].copyFrom(this._cameraPosition).subtractInPlace(scene.floatingOriginOffset));
-        }
-        this._activeEffect.setVector3("cameraOffset", this.cameraOffset);
-        this._activeEffect.setVector3("up", this.up);
-        if (this.luminance > 0) {
-            this._activeEffect.setFloat("luminance", this.luminance);
-        }
-        this._activeEffect.setFloat("turbidity", this.turbidity);
-        this._activeEffect.setFloat("rayleigh", this.rayleigh);
-        this._activeEffect.setFloat("mieCoefficient", this.mieCoefficient);
-        this._activeEffect.setFloat("mieDirectionalG", this.mieDirectionalG);
-        if (!this.useSunPosition) {
-            const theta = Math.PI * (this.inclination - 0.5);
-            const phi = 2 * Math.PI * (this.azimuth - 0.5);
-            this.sunPosition.x = this.distance * Math.cos(phi) * Math.cos(theta);
-            this.sunPosition.y = this.distance * Math.sin(-theta);
-            this.sunPosition.z = this.distance * Math.sin(phi) * Math.cos(theta);
-            Quaternion.FromUnitVectorsToRef(Vector3.UpReadOnly, this.up, this._skyOrientation);
-            this.sunPosition.rotateByQuaternionToRef(this._skyOrientation, this.sunPosition);
-        }
-        this._activeEffect.setVector3("sunPosition", this.sunPosition);
-        this._afterBind(mesh, this._activeEffect, subMesh);
-    }
-    /**
-     * Get the list of animatables in the material.
-     * @returns the list of animatables object used in the material
-     */
-    getAnimatables() {
-        return [];
-    }
-    /**
-     * Disposes the material
-     * @param forceDisposeEffect specifies if effects should be forcefully disposed
-     */
-    dispose(forceDisposeEffect) {
-        super.dispose(forceDisposeEffect);
-    }
-    /**
-     * Makes a duplicate of the material, and gives it a new name
-     * @param name defines the new name for the duplicated material
-     * @returns the cloned material
-     */
-    clone(name) {
-        return SerializationHelper.Clone(() => new SkyMaterial(name, this.getScene()), this);
-    }
-    /**
-     * Serializes this material in a JSON representation
-     * @returns the serialized material object
-     */
-    serialize() {
-        const serializationObject = super.serialize();
-        serializationObject.customType = "BABYLON.SkyMaterial";
-        return serializationObject;
-    }
-    /**
-     * Gets the current class name of the material e.g. "SkyMaterial"
-     * Mainly use in serialization.
-     * @returns the class name
-     */
-    getClassName() {
-        return "SkyMaterial";
-    }
-    /**
-     * Creates a sky 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 sky material
-     */
-    static Parse(source, scene, rootUrl) {
-        return SerializationHelper.Parse(() => new SkyMaterial(source.name, scene), source, scene, rootUrl);
-    }
-}
-__decorate([
-    serialize()
-], SkyMaterial.prototype, "luminance", void 0);
-__decorate([
-    serialize()
-], SkyMaterial.prototype, "turbidity", void 0);
-__decorate([
-    serialize()
-], SkyMaterial.prototype, "rayleigh", void 0);
-__decorate([
-    serialize()
-], SkyMaterial.prototype, "mieCoefficient", void 0);
-__decorate([
-    serialize()
-], SkyMaterial.prototype, "mieDirectionalG", void 0);
-__decorate([
-    serialize()
-], SkyMaterial.prototype, "distance", void 0);
-__decorate([
-    serialize()
-], SkyMaterial.prototype, "inclination", void 0);
-__decorate([
-    serialize()
-], SkyMaterial.prototype, "azimuth", void 0);
-__decorate([
-    serializeAsVector3()
-], SkyMaterial.prototype, "sunPosition", void 0);
-__decorate([
-    serialize()
-], SkyMaterial.prototype, "useSunPosition", void 0);
-__decorate([
-    serializeAsVector3()
-], SkyMaterial.prototype, "cameraOffset", void 0);
-__decorate([
-    serializeAsVector3()
-], SkyMaterial.prototype, "up", void 0);
-__decorate([
-    serialize()
-], SkyMaterial.prototype, "dithering", void 0);
+            /**
+             * Serializes this material in a JSON representation
+             * @returns the serialized material object
+             */
+            serialize() {
+                const serializationObject = super.serialize();
+                serializationObject.customType = "BABYLON.SkyMaterial";
+                return serializationObject;
+            }
+            /**
+             * Gets the current class name of the material e.g. "SkyMaterial"
+             * Mainly use in serialization.
+             * @returns the class name
+             */
+            getClassName() {
+                return "SkyMaterial";
+            }
+            /**
+             * Creates a sky 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 sky material
+             */
+            static Parse(source, scene, rootUrl) {
+                return SerializationHelper.Parse(() => new _a(source.name, scene), source, scene, rootUrl);
+            }
+        },
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _luminance_decorators = [serialize()];
+            _turbidity_decorators = [serialize()];
+            _rayleigh_decorators = [serialize()];
+            _mieCoefficient_decorators = [serialize()];
+            _mieDirectionalG_decorators = [serialize()];
+            _distance_decorators = [serialize()];
+            _inclination_decorators = [serialize()];
+            _azimuth_decorators = [serialize()];
+            _sunPosition_decorators = [serializeAsVector3()];
+            _useSunPosition_decorators = [serialize()];
+            _cameraOffset_decorators = [serializeAsVector3()];
+            _up_decorators = [serializeAsVector3()];
+            _dithering_decorators = [serialize()];
+            __esDecorate(null, null, _luminance_decorators, { kind: "field", name: "luminance", static: false, private: false, access: { has: obj => "luminance" in obj, get: obj => obj.luminance, set: (obj, value) => { obj.luminance = value; } }, metadata: _metadata }, _luminance_initializers, _luminance_extraInitializers);
+            __esDecorate(null, null, _turbidity_decorators, { kind: "field", name: "turbidity", static: false, private: false, access: { has: obj => "turbidity" in obj, get: obj => obj.turbidity, set: (obj, value) => { obj.turbidity = value; } }, metadata: _metadata }, _turbidity_initializers, _turbidity_extraInitializers);
+            __esDecorate(null, null, _rayleigh_decorators, { kind: "field", name: "rayleigh", static: false, private: false, access: { has: obj => "rayleigh" in obj, get: obj => obj.rayleigh, set: (obj, value) => { obj.rayleigh = value; } }, metadata: _metadata }, _rayleigh_initializers, _rayleigh_extraInitializers);
+            __esDecorate(null, null, _mieCoefficient_decorators, { kind: "field", name: "mieCoefficient", static: false, private: false, access: { has: obj => "mieCoefficient" in obj, get: obj => obj.mieCoefficient, set: (obj, value) => { obj.mieCoefficient = value; } }, metadata: _metadata }, _mieCoefficient_initializers, _mieCoefficient_extraInitializers);
+            __esDecorate(null, null, _mieDirectionalG_decorators, { kind: "field", name: "mieDirectionalG", static: false, private: false, access: { has: obj => "mieDirectionalG" in obj, get: obj => obj.mieDirectionalG, set: (obj, value) => { obj.mieDirectionalG = value; } }, metadata: _metadata }, _mieDirectionalG_initializers, _mieDirectionalG_extraInitializers);
+            __esDecorate(null, null, _distance_decorators, { kind: "field", name: "distance", static: false, private: false, access: { has: obj => "distance" in obj, get: obj => obj.distance, set: (obj, value) => { obj.distance = value; } }, metadata: _metadata }, _distance_initializers, _distance_extraInitializers);
+            __esDecorate(null, null, _inclination_decorators, { kind: "field", name: "inclination", static: false, private: false, access: { has: obj => "inclination" in obj, get: obj => obj.inclination, set: (obj, value) => { obj.inclination = value; } }, metadata: _metadata }, _inclination_initializers, _inclination_extraInitializers);
+            __esDecorate(null, null, _azimuth_decorators, { kind: "field", name: "azimuth", static: false, private: false, access: { has: obj => "azimuth" in obj, get: obj => obj.azimuth, set: (obj, value) => { obj.azimuth = value; } }, metadata: _metadata }, _azimuth_initializers, _azimuth_extraInitializers);
+            __esDecorate(null, null, _sunPosition_decorators, { kind: "field", name: "sunPosition", static: false, private: false, access: { has: obj => "sunPosition" in obj, get: obj => obj.sunPosition, set: (obj, value) => { obj.sunPosition = value; } }, metadata: _metadata }, _sunPosition_initializers, _sunPosition_extraInitializers);
+            __esDecorate(null, null, _useSunPosition_decorators, { kind: "field", name: "useSunPosition", static: false, private: false, access: { has: obj => "useSunPosition" in obj, get: obj => obj.useSunPosition, set: (obj, value) => { obj.useSunPosition = value; } }, metadata: _metadata }, _useSunPosition_initializers, _useSunPosition_extraInitializers);
+            __esDecorate(null, null, _cameraOffset_decorators, { kind: "field", name: "cameraOffset", static: false, private: false, access: { has: obj => "cameraOffset" in obj, get: obj => obj.cameraOffset, set: (obj, value) => { obj.cameraOffset = value; } }, metadata: _metadata }, _cameraOffset_initializers, _cameraOffset_extraInitializers);
+            __esDecorate(null, null, _up_decorators, { kind: "field", name: "up", static: false, private: false, access: { has: obj => "up" in obj, get: obj => obj.up, set: (obj, value) => { obj.up = value; } }, metadata: _metadata }, _up_initializers, _up_extraInitializers);
+            __esDecorate(null, null, _dithering_decorators, { kind: "field", name: "dithering", static: false, private: false, access: { has: obj => "dithering" in obj, get: obj => obj.dithering, set: (obj, value) => { obj.dithering = value; } }, metadata: _metadata }, _dithering_initializers, _dithering_extraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+export { SkyMaterial };
 RegisterClass("BABYLON.SkyMaterial", SkyMaterial);
 //# sourceMappingURL=skyMaterial.js.map