@onerjs/core 8.53.5 → 8.53.6

package/Materials/Node/Blocks/Dual/lightBlock.pure.js

@@ -1,5 +1,5 @@
 /** This file must only contain pure code and pure imports */
-import { __decorate } from "../../../../tslib.es6.js";
+import { __esDecorate, __runInitializers } from "../../../../tslib.es6.js";
 import { NodeMaterialBlock } from "../../nodeMaterialBlock.js";
 import { NodeMaterialBlockTargets } from "../../Enums/nodeMaterialBlockTargets.js";
 import { NodeMaterialBlockConnectionPointTypes } from "../../Enums/nodeMaterialBlockConnectionPointTypes.js";
@@ -12,444 +12,457 @@ import { RegisterClass } from "../../../../Misc/typeStore.js";
 /**
  * Block used to add light in the fragment shader
  */
-export class LightBlock extends NodeMaterialBlock {
-    static _OnGenerateOnlyFragmentCodeChanged(block, _propertyName) {
-        const that = block;
-        if (that.worldPosition.isConnected) {
-            that.generateOnlyFragmentCode = !that.generateOnlyFragmentCode;
-            Logger.Error("The worldPosition input must not be connected to be able to switch!");
-            return false;
-        }
-        that._setTarget();
-        return true;
-    }
-    _setTarget() {
-        this._setInitialTarget(this.generateOnlyFragmentCode ? NodeMaterialBlockTargets.Fragment : NodeMaterialBlockTargets.VertexAndFragment);
-        this.getInputByName("worldPosition").target = this.generateOnlyFragmentCode ? NodeMaterialBlockTargets.Fragment : NodeMaterialBlockTargets.Vertex;
-    }
-    /**
-     * Create a new LightBlock
-     * @param name defines the block name
-     */
-    constructor(name) {
-        super(name, NodeMaterialBlockTargets.VertexAndFragment);
-        this._lightId = 0;
-        /** Indicates that no code should be generated in the vertex shader. Can be useful in some specific circumstances (like when doing ray marching for eg) */
-        this.generateOnlyFragmentCode = false;
-        this._isUnique = true;
-        this.registerInput("worldPosition", NodeMaterialBlockConnectionPointTypes.Vector4, false, NodeMaterialBlockTargets.Vertex);
-        this.registerInput("worldNormal", NodeMaterialBlockConnectionPointTypes.Vector4, false, NodeMaterialBlockTargets.Fragment);
-        this.registerInput("cameraPosition", NodeMaterialBlockConnectionPointTypes.Vector3, false, NodeMaterialBlockTargets.Fragment);
-        this.registerInput("glossiness", NodeMaterialBlockConnectionPointTypes.Float, true, NodeMaterialBlockTargets.Fragment);
-        this.registerInput("glossPower", NodeMaterialBlockConnectionPointTypes.Float, true, NodeMaterialBlockTargets.Fragment);
-        this.registerInput("diffuseColor", NodeMaterialBlockConnectionPointTypes.Color3, true, NodeMaterialBlockTargets.Fragment);
-        this.registerInput("specularColor", NodeMaterialBlockConnectionPointTypes.Color3, true, NodeMaterialBlockTargets.Fragment);
-        this.registerInput("view", NodeMaterialBlockConnectionPointTypes.Matrix, true);
-        this.registerOutput("diffuseOutput", NodeMaterialBlockConnectionPointTypes.Color3, NodeMaterialBlockTargets.Fragment);
-        this.registerOutput("specularOutput", NodeMaterialBlockConnectionPointTypes.Color3, NodeMaterialBlockTargets.Fragment);
-        this.registerOutput("shadow", NodeMaterialBlockConnectionPointTypes.Float, NodeMaterialBlockTargets.Fragment);
-    }
-    /**
-     * Gets the current class name
-     * @returns the class name
-     */
-    getClassName() {
-        return "LightBlock";
-    }
-    /**
-     * Gets the world position input component
-     */
-    get worldPosition() {
-        return this._inputs[0];
-    }
-    /**
-     * Gets the world normal input component
-     */
-    get worldNormal() {
-        return this._inputs[1];
-    }
-    /**
-     * Gets the camera (or eye) position component
-     */
-    get cameraPosition() {
-        return this._inputs[2];
-    }
-    /**
-     * Gets the glossiness component
-     */
-    get glossiness() {
-        return this._inputs[3];
-    }
-    /**
-     * Gets the glossiness power component
-     */
-    get glossPower() {
-        return this._inputs[4];
-    }
-    /**
-     * Gets the diffuse color component
-     */
-    get diffuseColor() {
-        return this._inputs[5];
-    }
-    /**
-     * Gets the specular color component
-     */
-    get specularColor() {
-        return this._inputs[6];
-    }
-    /**
-     * Gets the view matrix component
-     */
-    get view() {
-        return this._inputs[7];
-    }
-    /**
-     * Gets the diffuse output component
-     */
-    get diffuseOutput() {
-        return this._outputs[0];
-    }
-    /**
-     * Gets the specular output component
-     */
-    get specularOutput() {
-        return this._outputs[1];
-    }
-    /**
-     * Gets the shadow output component
-     */
-    get shadow() {
-        return this._outputs[2];
-    }
-    /**
-     * Initialize the block
-     * @param state - the build state
-     */
-    initialize(state) {
-        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        this._initShaderSourceAsync(state.shaderLanguage);
-        state._excludeVariableName("vViewDepth");
-    }
-    async _initShaderSourceAsync(shaderLanguage) {
-        this._codeIsReady = false;
-        if (shaderLanguage === 1 /* ShaderLanguage.WGSL */) {
-            await Promise.all([
-                import("../../../../ShadersWGSL/ShadersInclude/lightFragment.js"),
-                import("../../../../ShadersWGSL/ShadersInclude/lightUboDeclaration.js"),
-                import("../../../../ShadersWGSL/ShadersInclude/lightVxUboDeclaration.js"),
-                import("../../../../ShadersWGSL/ShadersInclude/helperFunctions.js"),
-                import("../../../../ShadersWGSL/ShadersInclude/lightsFragmentFunctions.js"),
-                import("../../../../ShadersWGSL/ShadersInclude/shadowsFragmentFunctions.js"),
-                import("../../../../ShadersWGSL/ShadersInclude/shadowsVertex.js"),
-            ]);
-        }
-        else {
-            await Promise.all([
-                import("../../../../Shaders/ShadersInclude/lightFragmentDeclaration.js"),
-                import("../../../../Shaders/ShadersInclude/lightFragment.js"),
-                import("../../../../Shaders/ShadersInclude/lightUboDeclaration.js"),
-                import("../../../../Shaders/ShadersInclude/lightVxUboDeclaration.js"),
-                import("../../../../Shaders/ShadersInclude/lightVxFragmentDeclaration.js"),
-                import("../../../../Shaders/ShadersInclude/helperFunctions.js"),
-                import("../../../../Shaders/ShadersInclude/lightsFragmentFunctions.js"),
-                import("../../../../Shaders/ShadersInclude/shadowsFragmentFunctions.js"),
-                import("../../../../Shaders/ShadersInclude/shadowsVertex.js"),
-            ]);
-        }
-        this._codeIsReady = true;
-        this.onCodeIsReadyObservable.notifyObservers(this);
-    }
-    /**
-     * Auto configure the block based on the material
-     * @param material - the node material
-     * @param additionalFilteringInfo - optional filtering info
-     */
-    autoConfigure(material, additionalFilteringInfo = () => true) {
-        if (!this.cameraPosition.isConnected) {
-            let cameraPositionInput = material.getInputBlockByPredicate((b) => b.systemValue === NodeMaterialSystemValues.CameraPosition && additionalFilteringInfo(b));
-            if (!cameraPositionInput) {
-                cameraPositionInput = new InputBlock("cameraPosition");
-                cameraPositionInput.setAsSystemValue(NodeMaterialSystemValues.CameraPosition);
+let LightBlock = (() => {
+    var _a;
+    let _classSuper = NodeMaterialBlock;
+    let _generateOnlyFragmentCode_decorators;
+    let _generateOnlyFragmentCode_initializers = [];
+    let _generateOnlyFragmentCode_extraInitializers = [];
+    return _a = class LightBlock extends _classSuper {
+            static _OnGenerateOnlyFragmentCodeChanged(block, _propertyName) {
+                const that = block;
+                if (that.worldPosition.isConnected) {
+                    that.generateOnlyFragmentCode = !that.generateOnlyFragmentCode;
+                    Logger.Error("The worldPosition input must not be connected to be able to switch!");
+                    return false;
+                }
+                that._setTarget();
+                return true;
             }
-            cameraPositionInput.output.connectTo(this.cameraPosition);
-        }
-    }
-    /**
-     * Prepare the list of defines
-     * @param defines - the material defines
-     * @param nodeMaterial - the node material
-     * @param mesh - the mesh to prepare for
-     */
-    prepareDefines(defines, nodeMaterial, mesh) {
-        if (!mesh || !defines._areLightsDirty) {
-            return;
-        }
-        const scene = mesh.getScene();
-        if (!this.light) {
-            PrepareDefinesForLights(scene, mesh, defines, true, nodeMaterial.maxSimultaneousLights);
-        }
-        else {
-            const state = {
-                needNormals: false,
-                needRebuild: false,
-                lightmapMode: false,
-                shadowEnabled: false,
-                specularEnabled: false,
-            };
-            PrepareDefinesForLight(scene, mesh, this.light, this._lightId, defines, true, state);
-            if (state.needRebuild) {
-                defines.rebuild();
+            _setTarget() {
+                this._setInitialTarget(this.generateOnlyFragmentCode ? NodeMaterialBlockTargets.Fragment : NodeMaterialBlockTargets.VertexAndFragment);
+                this.getInputByName("worldPosition").target = this.generateOnlyFragmentCode ? NodeMaterialBlockTargets.Fragment : NodeMaterialBlockTargets.Vertex;
             }
-        }
-    }
-    /**
-     * Checks if the block is ready
-     * @param mesh - the mesh to check
-     * @param nodeMaterial - the node material
-     * @param defines - the list of defines
-     * @returns true if ready
-     */
-    isReady(mesh, nodeMaterial, defines) {
-        if (this.light && !this.light.areLightTexturesReady()) {
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Update the uniforms and samples
-     * @param state - the build state
-     * @param nodeMaterial - the node material
-     * @param defines - the material defines
-     * @param uniformBuffers - the uniform buffers
-     */
-    updateUniformsAndSamples(state, nodeMaterial, defines, uniformBuffers) {
-        state.samplers.push("areaLightsLTC1Sampler");
-        state.samplers.push("areaLightsLTC2Sampler");
-        for (let lightIndex = 0; lightIndex < nodeMaterial.maxSimultaneousLights; lightIndex++) {
-            if (!defines["LIGHT" + lightIndex]) {
-                break;
+            /**
+             * Create a new LightBlock
+             * @param name defines the block name
+             */
+            constructor(name) {
+                super(name, NodeMaterialBlockTargets.VertexAndFragment);
+                this._lightId = 0;
+                /** Indicates that no code should be generated in the vertex shader. Can be useful in some specific circumstances (like when doing ray marching for eg) */
+                this.generateOnlyFragmentCode = __runInitializers(this, _generateOnlyFragmentCode_initializers, false);
+                __runInitializers(this, _generateOnlyFragmentCode_extraInitializers);
+                this._isUnique = true;
+                this.registerInput("worldPosition", NodeMaterialBlockConnectionPointTypes.Vector4, false, NodeMaterialBlockTargets.Vertex);
+                this.registerInput("worldNormal", NodeMaterialBlockConnectionPointTypes.Vector4, false, NodeMaterialBlockTargets.Fragment);
+                this.registerInput("cameraPosition", NodeMaterialBlockConnectionPointTypes.Vector3, false, NodeMaterialBlockTargets.Fragment);
+                this.registerInput("glossiness", NodeMaterialBlockConnectionPointTypes.Float, true, NodeMaterialBlockTargets.Fragment);
+                this.registerInput("glossPower", NodeMaterialBlockConnectionPointTypes.Float, true, NodeMaterialBlockTargets.Fragment);
+                this.registerInput("diffuseColor", NodeMaterialBlockConnectionPointTypes.Color3, true, NodeMaterialBlockTargets.Fragment);
+                this.registerInput("specularColor", NodeMaterialBlockConnectionPointTypes.Color3, true, NodeMaterialBlockTargets.Fragment);
+                this.registerInput("view", NodeMaterialBlockConnectionPointTypes.Matrix, true);
+                this.registerOutput("diffuseOutput", NodeMaterialBlockConnectionPointTypes.Color3, NodeMaterialBlockTargets.Fragment);
+                this.registerOutput("specularOutput", NodeMaterialBlockConnectionPointTypes.Color3, NodeMaterialBlockTargets.Fragment);
+                this.registerOutput("shadow", NodeMaterialBlockConnectionPointTypes.Float, NodeMaterialBlockTargets.Fragment);
             }
-            const onlyUpdateBuffersList = state.uniforms.indexOf("vLightData" + lightIndex) >= 0;
-            PrepareUniformsAndSamplersForLight(lightIndex, state.uniforms, state.samplers, defines["PROJECTEDLIGHTTEXTURE" + lightIndex], uniformBuffers, onlyUpdateBuffersList, defines["IESLIGHTTEXTURE" + lightIndex], defines["CLUSTLIGHT" + lightIndex], defines["RECTAREALIGHTEMISSIONTEXTURE" + lightIndex], state.shaderLanguage === 1 /* ShaderLanguage.WGSL */);
-        }
-    }
-    /**
-     * Bind data to effect
-     * @param effect - the effect to bind to
-     * @param nodeMaterial - the node material
-     * @param mesh - the mesh to bind for
-     */
-    bind(effect, nodeMaterial, mesh) {
-        if (!mesh) {
-            return;
-        }
-        const scene = mesh.getScene();
-        if (!this.light) {
-            BindLights(scene, mesh, effect, true, nodeMaterial.maxSimultaneousLights);
-        }
-        else {
-            BindLight(this.light, this._lightId, scene, effect, true);
-        }
-    }
-    _injectVertexCode(state) {
-        const worldPos = this.worldPosition;
-        const comments = `//${this.name}`;
-        const scene = state.sharedData.nodeMaterial.getScene();
-        // Declaration
-        if (!this.light) {
-            // Emit for all lights
-            state._emitFunctionFromInclude(state.supportUniformBuffers ? "lightVxUboDeclaration" : "lightVxFragmentDeclaration", comments, {
-                repeatKey: "maxSimultaneousLights",
-            });
-            this._lightId = 0;
-            state.sharedData.dynamicUniformBlocks.push(this);
-        }
-        else {
-            this._lightId = (state.counters["lightCounter"] !== undefined ? state.counters["lightCounter"] : -1) + 1;
-            state.counters["lightCounter"] = this._lightId;
-            state._emitFunctionFromInclude(state.supportUniformBuffers ? "lightVxUboDeclaration" : "lightVxFragmentDeclaration", comments, {
-                replaceStrings: [{ search: /{X}/g, replace: this._lightId.toString() }],
-            }, this._lightId.toString());
-        }
-        // Inject code in vertex
-        const worldPosVaryingName = "v_" + worldPos.associatedVariableName;
-        if (state._emitVaryingFromString(worldPosVaryingName, NodeMaterialBlockConnectionPointTypes.Vector4)) {
-            state.compilationString += (state.shaderLanguage === 1 /* ShaderLanguage.WGSL */ ? "vertexOutputs." : "") + `${worldPosVaryingName} = ${worldPos.associatedVariableName};\n`;
-        }
-        if (this.light) {
-            state.compilationString += state._emitCodeFromInclude("shadowsVertex", comments, {
-                replaceStrings: [
-                    { search: /{X}/g, replace: this._lightId.toString() },
-                    { search: /worldPos/g, replace: worldPos.associatedVariableName },
-                ],
-            });
-        }
-        else {
-            state.compilationString += `${state._declareLocalVar("worldPos", NodeMaterialBlockConnectionPointTypes.Vector4)} = ${worldPos.associatedVariableName};\n`;
-            if (this.view.isConnected) {
-                state.compilationString += `${state._declareLocalVar("view", NodeMaterialBlockConnectionPointTypes.Matrix)} = ${this.view.associatedVariableName};\n`;
-                state._emitVaryingFromString("vViewDepth", NodeMaterialBlockConnectionPointTypes.Float);
-                state.compilationString +=
-                    (state.shaderLanguage === 1 /* ShaderLanguage.WGSL */ ? "vertexOutputs." : "") +
-                        `vViewDepth = ${scene.useRightHandedSystem ? "-" : ""}(${this.view.associatedVariableName} * ${worldPos.associatedVariableName}).z;\n`;
+            /**
+             * Gets the current class name
+             * @returns the class name
+             */
+            getClassName() {
+                return "LightBlock";
             }
-            state.compilationString += state._emitCodeFromInclude("shadowsVertex", comments, {
-                repeatKey: "maxSimultaneousLights",
-            });
-        }
-    }
-    _injectUBODeclaration(state) {
-        const comments = `//${this.name}`;
-        if (!this.light) {
-            // Emit for all lights
-            state._emitFunctionFromInclude(state.supportUniformBuffers ? "lightUboDeclaration" : "lightFragmentDeclaration", comments, {
-                repeatKey: "maxSimultaneousLights",
-                substitutionVars: this.generateOnlyFragmentCode ? "varying," : undefined,
-            });
-        }
-        else {
-            state._emitFunctionFromInclude(state.supportUniformBuffers ? "lightUboDeclaration" : "lightFragmentDeclaration", comments, {
-                replaceStrings: [{ search: /{X}/g, replace: this._lightId.toString() }],
-            }, this._lightId.toString());
-        }
-    }
-    _buildBlock(state) {
-        super._buildBlock(state);
-        const isWGSL = state.shaderLanguage === 1 /* ShaderLanguage.WGSL */;
-        const addF = isWGSL ? "f" : "";
-        const comments = `//${this.name}`;
-        if (state.target !== NodeMaterialBlockTargets.Fragment) {
-            // Vertex
-            this._injectVertexCode(state); // won't be executed if this.generateOnlyFragmentCode is true
-            return;
-        }
-        if (this.generateOnlyFragmentCode) {
-            state.sharedData.dynamicUniformBlocks.push(this);
-        }
-        // Fragment
-        const accessor = isWGSL ? "fragmentInputs." : "";
-        state.sharedData.forcedBindableBlocks.push(this);
-        state.sharedData.blocksWithDefines.push(this);
-        if (this.light) {
-            state.sharedData.blockingBlocks.push(this);
-        }
-        const worldPos = this.worldPosition;
-        let worldPosVariableName = worldPos.associatedVariableName;
-        if (this.generateOnlyFragmentCode) {
-            worldPosVariableName = state._getFreeVariableName("globalWorldPos");
-            state._emitFunction("light_globalworldpos", `${state._declareLocalVar(worldPosVariableName, NodeMaterialBlockConnectionPointTypes.Vector3, false, true)};\n`, comments);
-            state.compilationString += `${worldPosVariableName} = ${worldPos.associatedVariableName}.xyz;\n`;
-            state.compilationString += state._emitCodeFromInclude("shadowsVertex", comments, {
-                repeatKey: "maxSimultaneousLights",
-                substitutionVars: `worldPos,${worldPos.associatedVariableName}`,
-            });
-        }
-        else {
-            worldPosVariableName = accessor + "v_" + worldPosVariableName + ".xyz";
-        }
-        state._emitFunctionFromInclude("helperFunctions", comments);
-        let replaceString = { search: /vPositionW/g, replace: worldPosVariableName };
-        if (isWGSL) {
-            replaceString = { search: /fragmentInputs\.vPositionW/g, replace: worldPosVariableName };
-        }
-        state._emitFunctionFromInclude("lightsFragmentFunctions", comments, {
-            replaceStrings: [replaceString],
-        });
-        state._emitFunctionFromInclude("shadowsFragmentFunctions", comments, {
-            replaceStrings: [replaceString],
-        });
-        this._injectUBODeclaration(state);
-        // Code
-        if (this._lightId === 0) {
-            if (state._registerTempVariable("viewDirectionW")) {
-                state.compilationString += `${state._declareLocalVar("viewDirectionW", NodeMaterialBlockConnectionPointTypes.Vector3)} = normalize(${this.cameraPosition.associatedVariableName} - ${worldPosVariableName});\n`;
+            /**
+             * Gets the world position input component
+             */
+            get worldPosition() {
+                return this._inputs[0];
+            }
+            /**
+             * Gets the world normal input component
+             */
+            get worldNormal() {
+                return this._inputs[1];
+            }
+            /**
+             * Gets the camera (or eye) position component
+             */
+            get cameraPosition() {
+                return this._inputs[2];
+            }
+            /**
+             * Gets the glossiness component
+             */
+            get glossiness() {
+                return this._inputs[3];
+            }
+            /**
+             * Gets the glossiness power component
+             */
+            get glossPower() {
+                return this._inputs[4];
+            }
+            /**
+             * Gets the diffuse color component
+             */
+            get diffuseColor() {
+                return this._inputs[5];
+            }
+            /**
+             * Gets the specular color component
+             */
+            get specularColor() {
+                return this._inputs[6];
+            }
+            /**
+             * Gets the view matrix component
+             */
+            get view() {
+                return this._inputs[7];
+            }
+            /**
+             * Gets the diffuse output component
+             */
+            get diffuseOutput() {
+                return this._outputs[0];
+            }
+            /**
+             * Gets the specular output component
+             */
+            get specularOutput() {
+                return this._outputs[1];
+            }
+            /**
+             * Gets the shadow output component
+             */
+            get shadow() {
+                return this._outputs[2];
+            }
+            /**
+             * Initialize the block
+             * @param state - the build state
+             */
+            initialize(state) {
+                // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                this._initShaderSourceAsync(state.shaderLanguage);
+                state._excludeVariableName("vViewDepth");
+            }
+            async _initShaderSourceAsync(shaderLanguage) {
+                this._codeIsReady = false;
+                if (shaderLanguage === 1 /* ShaderLanguage.WGSL */) {
+                    await Promise.all([
+                        import("../../../../ShadersWGSL/ShadersInclude/lightFragment.js"),
+                        import("../../../../ShadersWGSL/ShadersInclude/lightUboDeclaration.js"),
+                        import("../../../../ShadersWGSL/ShadersInclude/lightVxUboDeclaration.js"),
+                        import("../../../../ShadersWGSL/ShadersInclude/helperFunctions.js"),
+                        import("../../../../ShadersWGSL/ShadersInclude/lightsFragmentFunctions.js"),
+                        import("../../../../ShadersWGSL/ShadersInclude/shadowsFragmentFunctions.js"),
+                        import("../../../../ShadersWGSL/ShadersInclude/shadowsVertex.js"),
+                    ]);
+                }
+                else {
+                    await Promise.all([
+                        import("../../../../Shaders/ShadersInclude/lightFragmentDeclaration.js"),
+                        import("../../../../Shaders/ShadersInclude/lightFragment.js"),
+                        import("../../../../Shaders/ShadersInclude/lightUboDeclaration.js"),
+                        import("../../../../Shaders/ShadersInclude/lightVxUboDeclaration.js"),
+                        import("../../../../Shaders/ShadersInclude/lightVxFragmentDeclaration.js"),
+                        import("../../../../Shaders/ShadersInclude/helperFunctions.js"),
+                        import("../../../../Shaders/ShadersInclude/lightsFragmentFunctions.js"),
+                        import("../../../../Shaders/ShadersInclude/shadowsFragmentFunctions.js"),
+                        import("../../../../Shaders/ShadersInclude/shadowsVertex.js"),
+                    ]);
+                }
+                this._codeIsReady = true;
+                this.onCodeIsReadyObservable.notifyObservers(this);
+            }
+            /**
+             * Auto configure the block based on the material
+             * @param material - the node material
+             * @param additionalFilteringInfo - optional filtering info
+             */
+            autoConfigure(material, additionalFilteringInfo = () => true) {
+                if (!this.cameraPosition.isConnected) {
+                    let cameraPositionInput = material.getInputBlockByPredicate((b) => b.systemValue === NodeMaterialSystemValues.CameraPosition && additionalFilteringInfo(b));
+                    if (!cameraPositionInput) {
+                        cameraPositionInput = new InputBlock("cameraPosition");
+                        cameraPositionInput.setAsSystemValue(NodeMaterialSystemValues.CameraPosition);
+                    }
+                    cameraPositionInput.output.connectTo(this.cameraPosition);
+                }
+            }
+            /**
+             * Prepare the list of defines
+             * @param defines - the material defines
+             * @param nodeMaterial - the node material
+             * @param mesh - the mesh to prepare for
+             */
+            prepareDefines(defines, nodeMaterial, mesh) {
+                if (!mesh || !defines._areLightsDirty) {
+                    return;
+                }
+                const scene = mesh.getScene();
+                if (!this.light) {
+                    PrepareDefinesForLights(scene, mesh, defines, true, nodeMaterial.maxSimultaneousLights);
+                }
+                else {
+                    const state = {
+                        needNormals: false,
+                        needRebuild: false,
+                        lightmapMode: false,
+                        shadowEnabled: false,
+                        specularEnabled: false,
+                    };
+                    PrepareDefinesForLight(scene, mesh, this.light, this._lightId, defines, true, state);
+                    if (state.needRebuild) {
+                        defines.rebuild();
+                    }
+                }
             }
-            if (this.generateOnlyFragmentCode && this.view.isConnected) {
-                state.compilationString += `${state._declareLocalVar("vViewDepth", NodeMaterialBlockConnectionPointTypes.Float)} = (${this.view.associatedVariableName} * ${worldPos.associatedVariableName}).z;\n`;
+            /**
+             * Checks if the block is ready
+             * @param mesh - the mesh to check
+             * @param nodeMaterial - the node material
+             * @param defines - the list of defines
+             * @returns true if ready
+             */
+            isReady(mesh, nodeMaterial, defines) {
+                if (this.light && !this.light.areLightTexturesReady()) {
+                    return false;
+                }
+                return true;
             }
-            state.compilationString += isWGSL ? `var info: lightingInfo;\n` : `lightingInfo info;\n`;
-            state.compilationString += `${state._declareLocalVar("shadow", NodeMaterialBlockConnectionPointTypes.Float)} = 1.;\n`;
-            state.compilationString += `${state._declareLocalVar("aggShadow", NodeMaterialBlockConnectionPointTypes.Float)} = 0.;\n`;
-            state.compilationString += `${state._declareLocalVar("numLights", NodeMaterialBlockConnectionPointTypes.Float)} = 0.;\n`;
-            state.compilationString += `${state._declareLocalVar("glossiness", NodeMaterialBlockConnectionPointTypes.Float)} = ${this.glossiness.isConnected ? this.glossiness.associatedVariableName : "1.0"} * ${this.glossPower.isConnected ? this.glossPower.associatedVariableName : "1024.0"};\n`;
-            state.compilationString += `${state._declareLocalVar("diffuseBase", NodeMaterialBlockConnectionPointTypes.Vector3)} = vec3${addF}(0., 0., 0.);\n`;
-            state.compilationString += `${state._declareLocalVar("specularBase", NodeMaterialBlockConnectionPointTypes.Vector3)}  = vec3${addF}(0., 0., 0.);\n`;
-            state.compilationString += `${state._declareLocalVar("normalW", NodeMaterialBlockConnectionPointTypes.Vector3)} = ${this.worldNormal.associatedVariableName}.xyz;\n`;
-        }
-        if (this.light) {
-            let replaceString = [{ search: /vPositionW/g, replace: worldPosVariableName + ".xyz" }];
-            if (isWGSL) {
-                replaceString = [
-                    { search: /fragmentInputs\.vPositionW/g, replace: worldPosVariableName + ".xyz" },
-                    { search: /uniforms\.vReflectivityColor/g, replace: "vReflectivityColor" },
-                ];
+            /**
+             * Update the uniforms and samples
+             * @param state - the build state
+             * @param nodeMaterial - the node material
+             * @param defines - the material defines
+             * @param uniformBuffers - the uniform buffers
+             */
+            updateUniformsAndSamples(state, nodeMaterial, defines, uniformBuffers) {
+                state.samplers.push("areaLightsLTC1Sampler");
+                state.samplers.push("areaLightsLTC2Sampler");
+                for (let lightIndex = 0; lightIndex < nodeMaterial.maxSimultaneousLights; lightIndex++) {
+                    if (!defines["LIGHT" + lightIndex]) {
+                        break;
+                    }
+                    const onlyUpdateBuffersList = state.uniforms.indexOf("vLightData" + lightIndex) >= 0;
+                    PrepareUniformsAndSamplersForLight(lightIndex, state.uniforms, state.samplers, defines["PROJECTEDLIGHTTEXTURE" + lightIndex], uniformBuffers, onlyUpdateBuffersList, defines["IESLIGHTTEXTURE" + lightIndex], defines["CLUSTLIGHT" + lightIndex], defines["RECTAREALIGHTEMISSIONTEXTURE" + lightIndex], state.shaderLanguage === 1 /* ShaderLanguage.WGSL */);
+                }
+            }
+            /**
+             * Bind data to effect
+             * @param effect - the effect to bind to
+             * @param nodeMaterial - the node material
+             * @param mesh - the mesh to bind for
+             */
+            bind(effect, nodeMaterial, mesh) {
+                if (!mesh) {
+                    return;
+                }
+                const scene = mesh.getScene();
+                if (!this.light) {
+                    BindLights(scene, mesh, effect, true, nodeMaterial.maxSimultaneousLights);
+                }
+                else {
+                    BindLight(this.light, this._lightId, scene, effect, true);
+                }
             }
-            state.compilationString += state._emitCodeFromInclude("lightFragment", comments, {
-                replaceStrings: [{ search: /{X}/g, replace: this._lightId.toString() }, ...replaceString],
-            });
-        }
-        else {
-            let substitutionVars = `vPositionW,${worldPosVariableName}.xyz`;
-            if (isWGSL) {
-                substitutionVars = `fragmentInputs.vPositionW,${worldPosVariableName}.xyz`;
+            _injectVertexCode(state) {
+                const worldPos = this.worldPosition;
+                const comments = `//${this.name}`;
+                const scene = state.sharedData.nodeMaterial.getScene();
+                // Declaration
+                if (!this.light) {
+                    // Emit for all lights
+                    state._emitFunctionFromInclude(state.supportUniformBuffers ? "lightVxUboDeclaration" : "lightVxFragmentDeclaration", comments, {
+                        repeatKey: "maxSimultaneousLights",
+                    });
+                    this._lightId = 0;
+                    state.sharedData.dynamicUniformBlocks.push(this);
+                }
+                else {
+                    this._lightId = (state.counters["lightCounter"] !== undefined ? state.counters["lightCounter"] : -1) + 1;
+                    state.counters["lightCounter"] = this._lightId;
+                    state._emitFunctionFromInclude(state.supportUniformBuffers ? "lightVxUboDeclaration" : "lightVxFragmentDeclaration", comments, {
+                        replaceStrings: [{ search: /{X}/g, replace: this._lightId.toString() }],
+                    }, this._lightId.toString());
+                }
+                // Inject code in vertex
+                const worldPosVaryingName = "v_" + worldPos.associatedVariableName;
+                if (state._emitVaryingFromString(worldPosVaryingName, NodeMaterialBlockConnectionPointTypes.Vector4)) {
+                    state.compilationString += (state.shaderLanguage === 1 /* ShaderLanguage.WGSL */ ? "vertexOutputs." : "") + `${worldPosVaryingName} = ${worldPos.associatedVariableName};\n`;
+                }
+                if (this.light) {
+                    state.compilationString += state._emitCodeFromInclude("shadowsVertex", comments, {
+                        replaceStrings: [
+                            { search: /{X}/g, replace: this._lightId.toString() },
+                            { search: /worldPos/g, replace: worldPos.associatedVariableName },
+                        ],
+                    });
+                }
+                else {
+                    state.compilationString += `${state._declareLocalVar("worldPos", NodeMaterialBlockConnectionPointTypes.Vector4)} = ${worldPos.associatedVariableName};\n`;
+                    if (this.view.isConnected) {
+                        state.compilationString += `${state._declareLocalVar("view", NodeMaterialBlockConnectionPointTypes.Matrix)} = ${this.view.associatedVariableName};\n`;
+                        state._emitVaryingFromString("vViewDepth", NodeMaterialBlockConnectionPointTypes.Float);
+                        state.compilationString +=
+                            (state.shaderLanguage === 1 /* ShaderLanguage.WGSL */ ? "vertexOutputs." : "") +
+                                `vViewDepth = ${scene.useRightHandedSystem ? "-" : ""}(${this.view.associatedVariableName} * ${worldPos.associatedVariableName}).z;\n`;
+                    }
+                    state.compilationString += state._emitCodeFromInclude("shadowsVertex", comments, {
+                        repeatKey: "maxSimultaneousLights",
+                    });
+                }
+            }
+            _injectUBODeclaration(state) {
+                const comments = `//${this.name}`;
+                if (!this.light) {
+                    // Emit for all lights
+                    state._emitFunctionFromInclude(state.supportUniformBuffers ? "lightUboDeclaration" : "lightFragmentDeclaration", comments, {
+                        repeatKey: "maxSimultaneousLights",
+                        substitutionVars: this.generateOnlyFragmentCode ? "varying," : undefined,
+                    });
+                }
+                else {
+                    state._emitFunctionFromInclude(state.supportUniformBuffers ? "lightUboDeclaration" : "lightFragmentDeclaration", comments, {
+                        replaceStrings: [{ search: /{X}/g, replace: this._lightId.toString() }],
+                    }, this._lightId.toString());
+                }
+            }
+            _buildBlock(state) {
+                super._buildBlock(state);
+                const isWGSL = state.shaderLanguage === 1 /* ShaderLanguage.WGSL */;
+                const addF = isWGSL ? "f" : "";
+                const comments = `//${this.name}`;
+                if (state.target !== NodeMaterialBlockTargets.Fragment) {
+                    // Vertex
+                    this._injectVertexCode(state); // won't be executed if this.generateOnlyFragmentCode is true
+                    return;
+                }
                 if (this.generateOnlyFragmentCode) {
-                    substitutionVars += `,fragmentInputs.vViewDepth,vViewDepth`;
+                    state.sharedData.dynamicUniformBlocks.push(this);
                 }
+                // Fragment
+                const accessor = isWGSL ? "fragmentInputs." : "";
+                state.sharedData.forcedBindableBlocks.push(this);
+                state.sharedData.blocksWithDefines.push(this);
+                if (this.light) {
+                    state.sharedData.blockingBlocks.push(this);
+                }
+                const worldPos = this.worldPosition;
+                let worldPosVariableName = worldPos.associatedVariableName;
+                if (this.generateOnlyFragmentCode) {
+                    worldPosVariableName = state._getFreeVariableName("globalWorldPos");
+                    state._emitFunction("light_globalworldpos", `${state._declareLocalVar(worldPosVariableName, NodeMaterialBlockConnectionPointTypes.Vector3, false, true)};\n`, comments);
+                    state.compilationString += `${worldPosVariableName} = ${worldPos.associatedVariableName}.xyz;\n`;
+                    state.compilationString += state._emitCodeFromInclude("shadowsVertex", comments, {
+                        repeatKey: "maxSimultaneousLights",
+                        substitutionVars: `worldPos,${worldPos.associatedVariableName}`,
+                    });
+                }
+                else {
+                    worldPosVariableName = accessor + "v_" + worldPosVariableName + ".xyz";
+                }
+                state._emitFunctionFromInclude("helperFunctions", comments);
+                let replaceString = { search: /vPositionW/g, replace: worldPosVariableName };
+                if (isWGSL) {
+                    replaceString = { search: /fragmentInputs\.vPositionW/g, replace: worldPosVariableName };
+                }
+                state._emitFunctionFromInclude("lightsFragmentFunctions", comments, {
+                    replaceStrings: [replaceString],
+                });
+                state._emitFunctionFromInclude("shadowsFragmentFunctions", comments, {
+                    replaceStrings: [replaceString],
+                });
+                this._injectUBODeclaration(state);
+                // Code
+                if (this._lightId === 0) {
+                    if (state._registerTempVariable("viewDirectionW")) {
+                        state.compilationString += `${state._declareLocalVar("viewDirectionW", NodeMaterialBlockConnectionPointTypes.Vector3)} = normalize(${this.cameraPosition.associatedVariableName} - ${worldPosVariableName});\n`;
+                    }
+                    if (this.generateOnlyFragmentCode && this.view.isConnected) {
+                        state.compilationString += `${state._declareLocalVar("vViewDepth", NodeMaterialBlockConnectionPointTypes.Float)} = (${this.view.associatedVariableName} * ${worldPos.associatedVariableName}).z;\n`;
+                    }
+                    state.compilationString += isWGSL ? `var info: lightingInfo;\n` : `lightingInfo info;\n`;
+                    state.compilationString += `${state._declareLocalVar("shadow", NodeMaterialBlockConnectionPointTypes.Float)} = 1.;\n`;
+                    state.compilationString += `${state._declareLocalVar("aggShadow", NodeMaterialBlockConnectionPointTypes.Float)} = 0.;\n`;
+                    state.compilationString += `${state._declareLocalVar("numLights", NodeMaterialBlockConnectionPointTypes.Float)} = 0.;\n`;
+                    state.compilationString += `${state._declareLocalVar("glossiness", NodeMaterialBlockConnectionPointTypes.Float)} = ${this.glossiness.isConnected ? this.glossiness.associatedVariableName : "1.0"} * ${this.glossPower.isConnected ? this.glossPower.associatedVariableName : "1024.0"};\n`;
+                    state.compilationString += `${state._declareLocalVar("diffuseBase", NodeMaterialBlockConnectionPointTypes.Vector3)} = vec3${addF}(0., 0., 0.);\n`;
+                    state.compilationString += `${state._declareLocalVar("specularBase", NodeMaterialBlockConnectionPointTypes.Vector3)}  = vec3${addF}(0., 0., 0.);\n`;
+                    state.compilationString += `${state._declareLocalVar("normalW", NodeMaterialBlockConnectionPointTypes.Vector3)} = ${this.worldNormal.associatedVariableName}.xyz;\n`;
+                }
+                if (this.light) {
+                    let replaceString = [{ search: /vPositionW/g, replace: worldPosVariableName + ".xyz" }];
+                    if (isWGSL) {
+                        replaceString = [
+                            { search: /fragmentInputs\.vPositionW/g, replace: worldPosVariableName + ".xyz" },
+                            { search: /uniforms\.vReflectivityColor/g, replace: "vReflectivityColor" },
+                        ];
+                    }
+                    state.compilationString += state._emitCodeFromInclude("lightFragment", comments, {
+                        replaceStrings: [{ search: /{X}/g, replace: this._lightId.toString() }, ...replaceString],
+                    });
+                }
+                else {
+                    let substitutionVars = `vPositionW,${worldPosVariableName}.xyz`;
+                    if (isWGSL) {
+                        substitutionVars = `fragmentInputs.vPositionW,${worldPosVariableName}.xyz`;
+                        if (this.generateOnlyFragmentCode) {
+                            substitutionVars += `,fragmentInputs.vViewDepth,vViewDepth`;
+                        }
+                    }
+                    state.compilationString += state._emitCodeFromInclude("lightFragment", comments, {
+                        repeatKey: "maxSimultaneousLights",
+                        substitutionVars: substitutionVars,
+                    });
+                }
+                if (this._lightId === 0) {
+                    state.compilationString += `aggShadow = aggShadow / numLights;\n`;
+                }
+                const diffuseOutput = this.diffuseOutput;
+                const specularOutput = this.specularOutput;
+                state.compilationString +=
+                    state._declareOutput(diffuseOutput) + ` = diffuseBase${this.diffuseColor.isConnected ? " * " + this.diffuseColor.associatedVariableName : ""};\n`;
+                if (specularOutput.hasEndpoints) {
+                    state.compilationString +=
+                        state._declareOutput(specularOutput) + ` = specularBase${this.specularColor.isConnected ? " * " + this.specularColor.associatedVariableName : ""};\n`;
+                }
+                if (this.shadow.hasEndpoints) {
+                    state.compilationString += state._declareOutput(this.shadow) + ` = aggShadow;\n`;
+                }
+                return this;
             }
-            state.compilationString += state._emitCodeFromInclude("lightFragment", comments, {
-                repeatKey: "maxSimultaneousLights",
-                substitutionVars: substitutionVars,
-            });
-        }
-        if (this._lightId === 0) {
-            state.compilationString += `aggShadow = aggShadow / numLights;\n`;
-        }
-        const diffuseOutput = this.diffuseOutput;
-        const specularOutput = this.specularOutput;
-        state.compilationString +=
-            state._declareOutput(diffuseOutput) + ` = diffuseBase${this.diffuseColor.isConnected ? " * " + this.diffuseColor.associatedVariableName : ""};\n`;
-        if (specularOutput.hasEndpoints) {
-            state.compilationString +=
-                state._declareOutput(specularOutput) + ` = specularBase${this.specularColor.isConnected ? " * " + this.specularColor.associatedVariableName : ""};\n`;
-        }
-        if (this.shadow.hasEndpoints) {
-            state.compilationString += state._declareOutput(this.shadow) + ` = aggShadow;\n`;
-        }
-        return this;
-    }
-    /**
-     * Serializes the block
-     * @returns the serialized object
-     */
-    serialize() {
-        const serializationObject = super.serialize();
-        serializationObject.generateOnlyFragmentCode = this.generateOnlyFragmentCode;
-        if (this.light) {
-            serializationObject.lightId = this.light.id;
-        }
-        return serializationObject;
-    }
-    /**
-     * Deserializes the block
-     * @param serializationObject - the serialization object
-     * @param scene - the scene
-     * @param rootUrl - the root url
-     */
-    _deserialize(serializationObject, scene, rootUrl) {
-        super._deserialize(serializationObject, scene, rootUrl);
-        if (serializationObject.lightId) {
-            this.light = scene.getLightById(serializationObject.lightId);
-        }
-        this.generateOnlyFragmentCode = serializationObject.generateOnlyFragmentCode;
-        this._setTarget();
-    }
-}
-__decorate([
-    editableInPropertyPage("Generate only fragment code", 0 /* PropertyTypeForEdition.Boolean */, "ADVANCED", {
-        notifiers: { rebuild: true, update: true, onValidation: LightBlock._OnGenerateOnlyFragmentCodeChanged },
-    })
-], LightBlock.prototype, "generateOnlyFragmentCode", void 0);
+            /**
+             * Serializes the block
+             * @returns the serialized object
+             */
+            serialize() {
+                const serializationObject = super.serialize();
+                serializationObject.generateOnlyFragmentCode = this.generateOnlyFragmentCode;
+                if (this.light) {
+                    serializationObject.lightId = this.light.id;
+                }
+                return serializationObject;
+            }
+            /**
+             * Deserializes the block
+             * @param serializationObject - the serialization object
+             * @param scene - the scene
+             * @param rootUrl - the root url
+             */
+            _deserialize(serializationObject, scene, rootUrl) {
+                super._deserialize(serializationObject, scene, rootUrl);
+                if (serializationObject.lightId) {
+                    this.light = scene.getLightById(serializationObject.lightId);
+                }
+                this.generateOnlyFragmentCode = serializationObject.generateOnlyFragmentCode;
+                this._setTarget();
+            }
+        },
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _generateOnlyFragmentCode_decorators = [editableInPropertyPage("Generate only fragment code", 0 /* PropertyTypeForEdition.Boolean */, "ADVANCED", {
+                    notifiers: { rebuild: true, update: true, onValidation: (block, prop) => LightBlock._OnGenerateOnlyFragmentCodeChanged(block, prop) },
+                })];
+            __esDecorate(null, null, _generateOnlyFragmentCode_decorators, { kind: "field", name: "generateOnlyFragmentCode", static: false, private: false, access: { has: obj => "generateOnlyFragmentCode" in obj, get: obj => obj.generateOnlyFragmentCode, set: (obj, value) => { obj.generateOnlyFragmentCode = value; } }, metadata: _metadata }, _generateOnlyFragmentCode_initializers, _generateOnlyFragmentCode_extraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+export { LightBlock };
 let _Registered = false;
 /**
  * Register side effects for lightBlock.