@babylonjs/viewer 7.35.1 → 7.35.2-alpha

package/dist/chunks/KHR_lights_punctual-CIEvgNk7.esm.js

@@ -0,0 +1,1253 @@
+import { ak as __decorate, aU as serializeAsVector3, ao as serialize, aV as Light, a2 as Matrix, u as Vector3, aW as Axis, a4 as TmpVectors, aX as Node, R as RegisterClass, s as Texture, al as serializeAsTexture, q as Color3, aN as unregisterGLTFExtension, aO as registerGLTFExtension } from './index-CVMH5-nD.esm.js';
+import { A as ArrayItem, G as GLTFLoader } from './glTFLoader-DDABr3tc.esm.js';
+import './rawTexture-B4sxPzau.esm.js';
+import './assetContainer-DO29qm5j.esm.js';
+import './glTFLoaderAnimation-Ce1T-HK4.esm.js';
+
+/**
+ * Base implementation IShadowLight
+ * It groups all the common behaviour in order to reduce duplication and better follow the DRY pattern.
+ */
+class ShadowLight extends Light {
+    constructor() {
+        super(...arguments);
+        this._needProjectionMatrixCompute = true;
+        this._viewMatrix = Matrix.Identity();
+        this._projectionMatrix = Matrix.Identity();
+    }
+    _setPosition(value) {
+        this._position = value;
+    }
+    /**
+     * Sets the position the shadow will be casted from. Also use as the light position for both
+     * point and spot lights.
+     */
+    get position() {
+        return this._position;
+    }
+    /**
+     * Sets the position the shadow will be casted from. Also use as the light position for both
+     * point and spot lights.
+     */
+    set position(value) {
+        this._setPosition(value);
+    }
+    _setDirection(value) {
+        this._direction = value;
+    }
+    /**
+     * In 2d mode (needCube being false), gets the direction used to cast the shadow.
+     * Also use as the light direction on spot and directional lights.
+     */
+    get direction() {
+        return this._direction;
+    }
+    /**
+     * In 2d mode (needCube being false), sets the direction used to cast the shadow.
+     * Also use as the light direction on spot and directional lights.
+     */
+    set direction(value) {
+        this._setDirection(value);
+    }
+    /**
+     * Gets the shadow projection clipping minimum z value.
+     */
+    get shadowMinZ() {
+        return this._shadowMinZ;
+    }
+    /**
+     * Sets the shadow projection clipping minimum z value.
+     */
+    set shadowMinZ(value) {
+        this._shadowMinZ = value;
+        this.forceProjectionMatrixCompute();
+    }
+    /**
+     * Sets the shadow projection clipping maximum z value.
+     */
+    get shadowMaxZ() {
+        return this._shadowMaxZ;
+    }
+    /**
+     * Gets the shadow projection clipping maximum z value.
+     */
+    set shadowMaxZ(value) {
+        this._shadowMaxZ = value;
+        this.forceProjectionMatrixCompute();
+    }
+    /**
+     * Computes the transformed information (transformedPosition and transformedDirection in World space) of the current light
+     * @returns true if the information has been computed, false if it does not need to (no parenting)
+     */
+    computeTransformedInformation() {
+        if (this.parent && this.parent.getWorldMatrix) {
+            if (!this.transformedPosition) {
+                this.transformedPosition = Vector3.Zero();
+            }
+            Vector3.TransformCoordinatesToRef(this.position, this.parent.getWorldMatrix(), this.transformedPosition);
+            // In case the direction is present.
+            if (this.direction) {
+                if (!this.transformedDirection) {
+                    this.transformedDirection = Vector3.Zero();
+                }
+                Vector3.TransformNormalToRef(this.direction, this.parent.getWorldMatrix(), this.transformedDirection);
+            }
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Return the depth scale used for the shadow map.
+     * @returns the depth scale.
+     */
+    getDepthScale() {
+        return 50.0;
+    }
+    /**
+     * Get the direction to use to render the shadow map. In case of cube texture, the face index can be passed.
+     * @param faceIndex The index of the face we are computed the direction to generate shadow
+     * @returns The set direction in 2d mode otherwise the direction to the cubemap face if needCube() is true
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getShadowDirection(faceIndex) {
+        return this.transformedDirection ? this.transformedDirection : this.direction;
+    }
+    /**
+     * If computeTransformedInformation has been called, returns the ShadowLight absolute position in the world. Otherwise, returns the local position.
+     * @returns the position vector in world space
+     */
+    getAbsolutePosition() {
+        return this.transformedPosition ? this.transformedPosition : this.position;
+    }
+    /**
+     * Sets the ShadowLight direction toward the passed target.
+     * @param target The point to target in local space
+     * @returns the updated ShadowLight direction
+     */
+    setDirectionToTarget(target) {
+        this.direction = Vector3.Normalize(target.subtract(this.position));
+        return this.direction;
+    }
+    /**
+     * Returns the light rotation in euler definition.
+     * @returns the x y z rotation in local space.
+     */
+    getRotation() {
+        this.direction.normalize();
+        const xaxis = Vector3.Cross(this.direction, Axis.Y);
+        const yaxis = Vector3.Cross(xaxis, this.direction);
+        return Vector3.RotationFromAxis(xaxis, yaxis, this.direction);
+    }
+    /**
+     * Returns whether or not the shadow generation require a cube texture or a 2d texture.
+     * @returns true if a cube texture needs to be use
+     */
+    needCube() {
+        return false;
+    }
+    /**
+     * Detects if the projection matrix requires to be recomputed this frame.
+     * @returns true if it requires to be recomputed otherwise, false.
+     */
+    needProjectionMatrixCompute() {
+        return this._needProjectionMatrixCompute;
+    }
+    /**
+     * Forces the shadow generator to recompute the projection matrix even if position and direction did not changed.
+     */
+    forceProjectionMatrixCompute() {
+        this._needProjectionMatrixCompute = true;
+    }
+    /** @internal */
+    _initCache() {
+        super._initCache();
+        this._cache.position = Vector3.Zero();
+    }
+    /** @internal */
+    _isSynchronized() {
+        if (!this._cache.position.equals(this.position)) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Computes the world matrix of the node
+     * @param force defines if the cache version should be invalidated forcing the world matrix to be created from scratch
+     * @returns the world matrix
+     */
+    computeWorldMatrix(force) {
+        if (!force && this.isSynchronized()) {
+            this._currentRenderId = this.getScene().getRenderId();
+            return this._worldMatrix;
+        }
+        this._updateCache();
+        this._cache.position.copyFrom(this.position);
+        if (!this._worldMatrix) {
+            this._worldMatrix = Matrix.Identity();
+        }
+        Matrix.TranslationToRef(this.position.x, this.position.y, this.position.z, this._worldMatrix);
+        if (this.parent && this.parent.getWorldMatrix) {
+            this._worldMatrix.multiplyToRef(this.parent.getWorldMatrix(), this._worldMatrix);
+            this._markSyncedWithParent();
+        }
+        // Cache the determinant
+        this._worldMatrixDeterminantIsDirty = true;
+        return this._worldMatrix;
+    }
+    /**
+     * Gets the minZ used for shadow according to both the scene and the light.
+     * @param activeCamera The camera we are returning the min for
+     * @returns the depth min z
+     */
+    getDepthMinZ(activeCamera) {
+        return this.shadowMinZ !== undefined ? this.shadowMinZ : activeCamera.minZ;
+    }
+    /**
+     * Gets the maxZ used for shadow according to both the scene and the light.
+     * @param activeCamera The camera we are returning the max for
+     * @returns the depth max z
+     */
+    getDepthMaxZ(activeCamera) {
+        return this.shadowMaxZ !== undefined ? this.shadowMaxZ : activeCamera.maxZ;
+    }
+    /**
+     * Sets the shadow projection matrix in parameter to the generated projection matrix.
+     * @param matrix The matrix to updated with the projection information
+     * @param viewMatrix The transform matrix of the light
+     * @param renderList The list of mesh to render in the map
+     * @returns The current light
+     */
+    setShadowProjectionMatrix(matrix, viewMatrix, renderList) {
+        if (this.customProjectionMatrixBuilder) {
+            this.customProjectionMatrixBuilder(viewMatrix, renderList, matrix);
+        }
+        else {
+            this._setDefaultShadowProjectionMatrix(matrix, viewMatrix, renderList);
+        }
+        return this;
+    }
+    /** @internal */
+    _syncParentEnabledState() {
+        super._syncParentEnabledState();
+        if (!this.parent || !this.parent.getWorldMatrix) {
+            this.transformedPosition = null;
+            this.transformedDirection = null;
+        }
+    }
+    /**
+     * Returns the view matrix.
+     * @param faceIndex The index of the face for which we want to extract the view matrix. Only used for point light types.
+     * @returns The view matrix. Can be null, if a view matrix cannot be defined for the type of light considered (as for a hemispherical light, for example).
+     */
+    getViewMatrix(faceIndex) {
+        const lightDirection = TmpVectors.Vector3[0];
+        let lightPosition = this.position;
+        if (this.computeTransformedInformation()) {
+            lightPosition = this.transformedPosition;
+        }
+        Vector3.NormalizeToRef(this.getShadowDirection(faceIndex), lightDirection);
+        if (Math.abs(Vector3.Dot(lightDirection, Vector3.Up())) === 1.0) {
+            lightDirection.z = 0.0000000000001; // Required to avoid perfectly perpendicular light
+        }
+        const lightTarget = TmpVectors.Vector3[1];
+        lightPosition.addToRef(lightDirection, lightTarget);
+        Matrix.LookAtLHToRef(lightPosition, lightTarget, Vector3.Up(), this._viewMatrix);
+        return this._viewMatrix;
+    }
+    /**
+     * Returns the projection matrix.
+     * Note that viewMatrix and renderList are optional and are only used by lights that calculate the projection matrix from a list of meshes (e.g. directional lights with automatic extents calculation).
+     * @param viewMatrix The view transform matrix of the light (optional).
+     * @param renderList The list of meshes to take into account when calculating the projection matrix (optional).
+     * @returns The projection matrix. Can be null, if a projection matrix cannot be defined for the type of light considered (as for a hemispherical light, for example).
+     */
+    getProjectionMatrix(viewMatrix, renderList) {
+        this.setShadowProjectionMatrix(this._projectionMatrix, viewMatrix ?? this._viewMatrix, renderList ?? []);
+        return this._projectionMatrix;
+    }
+}
+__decorate([
+    serializeAsVector3()
+], ShadowLight.prototype, "position", null);
+__decorate([
+    serializeAsVector3()
+], ShadowLight.prototype, "direction", null);
+__decorate([
+    serialize()
+], ShadowLight.prototype, "shadowMinZ", null);
+__decorate([
+    serialize()
+], ShadowLight.prototype, "shadowMaxZ", null);
+
+Node.AddNodeConstructor("Light_Type_1", (name, scene) => {
+    return () => new DirectionalLight(name, Vector3.Zero(), scene);
+});
+/**
+ * A directional light is defined by a direction (what a surprise!).
+ * The light is emitted from everywhere in the specified direction, and has an infinite range.
+ * An example of a directional light is when a distance planet is lit by the apparently parallel lines of light from its sun. Light in a downward direction will light the top of an object.
+ * Documentation: https://doc.babylonjs.com/features/featuresDeepDive/lights/lights_introduction
+ */
+class DirectionalLight extends ShadowLight {
+    /**
+     * Fix frustum size for the shadow generation. This is disabled if the value is 0.
+     */
+    get shadowFrustumSize() {
+        return this._shadowFrustumSize;
+    }
+    /**
+     * Specifies a fix frustum size for the shadow generation.
+     */
+    set shadowFrustumSize(value) {
+        this._shadowFrustumSize = value;
+        this.forceProjectionMatrixCompute();
+    }
+    /**
+     * Gets the shadow projection scale against the optimal computed one.
+     * 0.1 by default which means that the projection window is increase by 10% from the optimal size.
+     * This does not impact in fixed frustum size (shadowFrustumSize being set)
+     */
+    get shadowOrthoScale() {
+        return this._shadowOrthoScale;
+    }
+    /**
+     * Sets the shadow projection scale against the optimal computed one.
+     * 0.1 by default which means that the projection window is increase by 10% from the optimal size.
+     * This does not impact in fixed frustum size (shadowFrustumSize being set)
+     */
+    set shadowOrthoScale(value) {
+        this._shadowOrthoScale = value;
+        this.forceProjectionMatrixCompute();
+    }
+    /**
+     * Gets or sets the orthoLeft property used to build the light frustum
+     */
+    get orthoLeft() {
+        return this._orthoLeft;
+    }
+    set orthoLeft(left) {
+        this._orthoLeft = left;
+    }
+    /**
+     * Gets or sets the orthoRight property used to build the light frustum
+     */
+    get orthoRight() {
+        return this._orthoRight;
+    }
+    set orthoRight(right) {
+        this._orthoRight = right;
+    }
+    /**
+     * Gets or sets the orthoTop property used to build the light frustum
+     */
+    get orthoTop() {
+        return this._orthoTop;
+    }
+    set orthoTop(top) {
+        this._orthoTop = top;
+    }
+    /**
+     * Gets or sets the orthoBottom property used to build the light frustum
+     */
+    get orthoBottom() {
+        return this._orthoBottom;
+    }
+    set orthoBottom(bottom) {
+        this._orthoBottom = bottom;
+    }
+    /**
+     * Creates a DirectionalLight object in the scene, oriented towards the passed direction (Vector3).
+     * The directional light is emitted from everywhere in the given direction.
+     * It can cast shadows.
+     * Documentation : https://doc.babylonjs.com/features/featuresDeepDive/lights/lights_introduction
+     * @param name The friendly name of the light
+     * @param direction The direction of the light
+     * @param scene The scene the light belongs to
+     */
+    constructor(name, direction, scene) {
+        super(name, scene);
+        this._shadowFrustumSize = 0;
+        this._shadowOrthoScale = 0.1;
+        /**
+         * Automatically compute the projection matrix to best fit (including all the casters)
+         * on each frame.
+         */
+        this.autoUpdateExtends = true;
+        /**
+         * Automatically compute the shadowMinZ and shadowMaxZ for the projection matrix to best fit (including all the casters)
+         * on each frame. autoUpdateExtends must be set to true for this to work
+         */
+        this.autoCalcShadowZBounds = false;
+        // Cache
+        this._orthoLeft = Number.MAX_VALUE;
+        this._orthoRight = Number.MIN_VALUE;
+        this._orthoTop = Number.MIN_VALUE;
+        this._orthoBottom = Number.MAX_VALUE;
+        this.position = direction.scale(-1.0);
+        this.direction = direction;
+    }
+    /**
+     * Returns the string "DirectionalLight".
+     * @returns The class name
+     */
+    getClassName() {
+        return "DirectionalLight";
+    }
+    /**
+     * Returns the integer 1.
+     * @returns The light Type id as a constant defines in Light.LIGHTTYPEID_x
+     */
+    getTypeID() {
+        return Light.LIGHTTYPEID_DIRECTIONALLIGHT;
+    }
+    /**
+     * Sets the passed matrix "matrix" as projection matrix for the shadows cast by the light according to the passed view matrix.
+     * Returns the DirectionalLight Shadow projection matrix.
+     * @param matrix
+     * @param viewMatrix
+     * @param renderList
+     */
+    _setDefaultShadowProjectionMatrix(matrix, viewMatrix, renderList) {
+        if (this.shadowFrustumSize > 0) {
+            this._setDefaultFixedFrustumShadowProjectionMatrix(matrix);
+        }
+        else {
+            this._setDefaultAutoExtendShadowProjectionMatrix(matrix, viewMatrix, renderList);
+        }
+    }
+    /**
+     * Sets the passed matrix "matrix" as fixed frustum projection matrix for the shadows cast by the light according to the passed view matrix.
+     * Returns the DirectionalLight Shadow projection matrix.
+     * @param matrix
+     */
+    _setDefaultFixedFrustumShadowProjectionMatrix(matrix) {
+        const activeCamera = this.getScene().activeCamera;
+        if (!activeCamera) {
+            return;
+        }
+        Matrix.OrthoLHToRef(this.shadowFrustumSize, this.shadowFrustumSize, this.shadowMinZ !== undefined ? this.shadowMinZ : activeCamera.minZ, this.shadowMaxZ !== undefined ? this.shadowMaxZ : activeCamera.maxZ, matrix, this.getScene().getEngine().isNDCHalfZRange);
+    }
+    /**
+     * Sets the passed matrix "matrix" as auto extend projection matrix for the shadows cast by the light according to the passed view matrix.
+     * Returns the DirectionalLight Shadow projection matrix.
+     * @param matrix
+     * @param viewMatrix
+     * @param renderList
+     */
+    _setDefaultAutoExtendShadowProjectionMatrix(matrix, viewMatrix, renderList) {
+        const activeCamera = this.getScene().activeCamera;
+        if (!activeCamera) {
+            return;
+        }
+        // Check extends
+        if (this.autoUpdateExtends || this._orthoLeft === Number.MAX_VALUE) {
+            const tempVector3 = Vector3.Zero();
+            this._orthoLeft = Number.MAX_VALUE;
+            this._orthoRight = -Number.MAX_VALUE;
+            this._orthoTop = -Number.MAX_VALUE;
+            this._orthoBottom = Number.MAX_VALUE;
+            let shadowMinZ = Number.MAX_VALUE;
+            let shadowMaxZ = -Number.MAX_VALUE;
+            for (let meshIndex = 0; meshIndex < renderList.length; meshIndex++) {
+                const mesh = renderList[meshIndex];
+                if (!mesh) {
+                    continue;
+                }
+                const boundingInfo = mesh.getBoundingInfo();
+                const boundingBox = boundingInfo.boundingBox;
+                for (let index = 0; index < boundingBox.vectorsWorld.length; index++) {
+                    Vector3.TransformCoordinatesToRef(boundingBox.vectorsWorld[index], viewMatrix, tempVector3);
+                    if (tempVector3.x < this._orthoLeft) {
+                        this._orthoLeft = tempVector3.x;
+                    }
+                    if (tempVector3.y < this._orthoBottom) {
+                        this._orthoBottom = tempVector3.y;
+                    }
+                    if (tempVector3.x > this._orthoRight) {
+                        this._orthoRight = tempVector3.x;
+                    }
+                    if (tempVector3.y > this._orthoTop) {
+                        this._orthoTop = tempVector3.y;
+                    }
+                    if (this.autoCalcShadowZBounds) {
+                        if (tempVector3.z < shadowMinZ) {
+                            shadowMinZ = tempVector3.z;
+                        }
+                        if (tempVector3.z > shadowMaxZ) {
+                            shadowMaxZ = tempVector3.z;
+                        }
+                    }
+                }
+            }
+            if (this.autoCalcShadowZBounds) {
+                this._shadowMinZ = shadowMinZ;
+                this._shadowMaxZ = shadowMaxZ;
+            }
+        }
+        const xOffset = this._orthoRight - this._orthoLeft;
+        const yOffset = this._orthoTop - this._orthoBottom;
+        const minZ = this.shadowMinZ !== undefined ? this.shadowMinZ : activeCamera.minZ;
+        const maxZ = this.shadowMaxZ !== undefined ? this.shadowMaxZ : activeCamera.maxZ;
+        const useReverseDepthBuffer = this.getScene().getEngine().useReverseDepthBuffer;
+        Matrix.OrthoOffCenterLHToRef(this._orthoLeft - xOffset * this.shadowOrthoScale, this._orthoRight + xOffset * this.shadowOrthoScale, this._orthoBottom - yOffset * this.shadowOrthoScale, this._orthoTop + yOffset * this.shadowOrthoScale, useReverseDepthBuffer ? maxZ : minZ, useReverseDepthBuffer ? minZ : maxZ, matrix, this.getScene().getEngine().isNDCHalfZRange);
+    }
+    _buildUniformLayout() {
+        this._uniformBuffer.addUniform("vLightData", 4);
+        this._uniformBuffer.addUniform("vLightDiffuse", 4);
+        this._uniformBuffer.addUniform("vLightSpecular", 4);
+        this._uniformBuffer.addUniform("shadowsInfo", 3);
+        this._uniformBuffer.addUniform("depthValues", 2);
+        this._uniformBuffer.create();
+    }
+    /**
+     * Sets the passed Effect object with the DirectionalLight transformed position (or position if not parented) and the passed name.
+     * @param effect The effect to update
+     * @param lightIndex The index of the light in the effect to update
+     * @returns The directional light
+     */
+    transferToEffect(effect, lightIndex) {
+        if (this.computeTransformedInformation()) {
+            this._uniformBuffer.updateFloat4("vLightData", this.transformedDirection.x, this.transformedDirection.y, this.transformedDirection.z, 1, lightIndex);
+            return this;
+        }
+        this._uniformBuffer.updateFloat4("vLightData", this.direction.x, this.direction.y, this.direction.z, 1, lightIndex);
+        return this;
+    }
+    transferToNodeMaterialEffect(effect, lightDataUniformName) {
+        if (this.computeTransformedInformation()) {
+            effect.setFloat3(lightDataUniformName, this.transformedDirection.x, this.transformedDirection.y, this.transformedDirection.z);
+            return this;
+        }
+        effect.setFloat3(lightDataUniformName, this.direction.x, this.direction.y, this.direction.z);
+        return this;
+    }
+    /**
+     * Gets the minZ used for shadow according to both the scene and the light.
+     *
+     * Values are fixed on directional lights as it relies on an ortho projection hence the need to convert being
+     * -1 and 1 to 0 and 1 doing (depth + min) / (min + max) -> (depth + 1) / (1 + 1) -> (depth * 0.5) + 0.5.
+     * (when not using reverse depth buffer / NDC half Z range)
+     * @param activeCamera The camera we are returning the min for
+     * @returns the depth min z
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getDepthMinZ(activeCamera) {
+        const engine = this._scene.getEngine();
+        return !engine.useReverseDepthBuffer && engine.isNDCHalfZRange ? 0 : 1;
+    }
+    /**
+     * Gets the maxZ used for shadow according to both the scene and the light.
+     *
+     * Values are fixed on directional lights as it relies on an ortho projection hence the need to convert being
+     * -1 and 1 to 0 and 1 doing (depth + min) / (min + max) -> (depth + 1) / (1 + 1) -> (depth * 0.5) + 0.5.
+     * (when not using reverse depth buffer / NDC half Z range)
+     * @param activeCamera The camera we are returning the max for
+     * @returns the depth max z
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getDepthMaxZ(activeCamera) {
+        const engine = this._scene.getEngine();
+        return engine.useReverseDepthBuffer && engine.isNDCHalfZRange ? 0 : 1;
+    }
+    /**
+     * Prepares the list of defines specific to the light type.
+     * @param defines the list of defines
+     * @param lightIndex defines the index of the light for the effect
+     */
+    prepareLightSpecificDefines(defines, lightIndex) {
+        defines["DIRLIGHT" + lightIndex] = true;
+    }
+}
+__decorate([
+    serialize()
+], DirectionalLight.prototype, "shadowFrustumSize", null);
+__decorate([
+    serialize()
+], DirectionalLight.prototype, "shadowOrthoScale", null);
+__decorate([
+    serialize()
+], DirectionalLight.prototype, "autoUpdateExtends", void 0);
+__decorate([
+    serialize()
+], DirectionalLight.prototype, "autoCalcShadowZBounds", void 0);
+__decorate([
+    serialize("orthoLeft")
+], DirectionalLight.prototype, "_orthoLeft", void 0);
+__decorate([
+    serialize("orthoRight")
+], DirectionalLight.prototype, "_orthoRight", void 0);
+__decorate([
+    serialize("orthoTop")
+], DirectionalLight.prototype, "_orthoTop", void 0);
+__decorate([
+    serialize("orthoBottom")
+], DirectionalLight.prototype, "_orthoBottom", void 0);
+// Register Class Name
+RegisterClass("BABYLON.DirectionalLight", DirectionalLight);
+
+Node.AddNodeConstructor("Light_Type_0", (name, scene) => {
+    return () => new PointLight(name, Vector3.Zero(), scene);
+});
+/**
+ * A point light is a light defined by an unique point in world space.
+ * The light is emitted in every direction from this point.
+ * A good example of a point light is a standard light bulb.
+ * Documentation: https://doc.babylonjs.com/features/featuresDeepDive/lights/lights_introduction
+ */
+class PointLight extends ShadowLight {
+    /**
+     * Getter: In case of direction provided, the shadow will not use a cube texture but simulate a spot shadow as a fallback
+     * This specifies what angle the shadow will use to be created.
+     *
+     * It default to 90 degrees to work nicely with the cube texture generation for point lights shadow maps.
+     */
+    get shadowAngle() {
+        return this._shadowAngle;
+    }
+    /**
+     * Setter: In case of direction provided, the shadow will not use a cube texture but simulate a spot shadow as a fallback
+     * This specifies what angle the shadow will use to be created.
+     *
+     * It default to 90 degrees to work nicely with the cube texture generation for point lights shadow maps.
+     */
+    set shadowAngle(value) {
+        this._shadowAngle = value;
+        this.forceProjectionMatrixCompute();
+    }
+    /**
+     * Gets the direction if it has been set.
+     * In case of direction provided, the shadow will not use a cube texture but simulate a spot shadow as a fallback
+     */
+    get direction() {
+        return this._direction;
+    }
+    /**
+     * In case of direction provided, the shadow will not use a cube texture but simulate a spot shadow as a fallback
+     */
+    set direction(value) {
+        const previousNeedCube = this.needCube();
+        this._direction = value;
+        if (this.needCube() !== previousNeedCube && this._shadowGenerators) {
+            const iterator = this._shadowGenerators.values();
+            for (let key = iterator.next(); key.done !== true; key = iterator.next()) {
+                const shadowGenerator = key.value;
+                shadowGenerator.recreateShadowMap();
+            }
+        }
+    }
+    /**
+     * Creates a PointLight object from the passed name and position (Vector3) and adds it in the scene.
+     * A PointLight emits the light in every direction.
+     * It can cast shadows.
+     * If the scene camera is already defined and you want to set your PointLight at the camera position, just set it :
+     * ```javascript
+     * var pointLight = new PointLight("pl", camera.position, scene);
+     * ```
+     * Documentation : https://doc.babylonjs.com/features/featuresDeepDive/lights/lights_introduction
+     * @param name The light friendly name
+     * @param position The position of the point light in the scene
+     * @param scene The scene the lights belongs to
+     */
+    constructor(name, position, scene) {
+        super(name, scene);
+        this._shadowAngle = Math.PI / 2;
+        this.position = position;
+    }
+    /**
+     * Returns the string "PointLight"
+     * @returns the class name
+     */
+    getClassName() {
+        return "PointLight";
+    }
+    /**
+     * Returns the integer 0.
+     * @returns The light Type id as a constant defines in Light.LIGHTTYPEID_x
+     */
+    getTypeID() {
+        return Light.LIGHTTYPEID_POINTLIGHT;
+    }
+    /**
+     * Specifies whether or not the shadowmap should be a cube texture.
+     * @returns true if the shadowmap needs to be a cube texture.
+     */
+    needCube() {
+        return !this.direction;
+    }
+    /**
+     * Returns a new Vector3 aligned with the PointLight cube system according to the passed cube face index (integer).
+     * @param faceIndex The index of the face we are computed the direction to generate shadow
+     * @returns The set direction in 2d mode otherwise the direction to the cubemap face if needCube() is true
+     */
+    getShadowDirection(faceIndex) {
+        if (this.direction) {
+            return super.getShadowDirection(faceIndex);
+        }
+        else {
+            switch (faceIndex) {
+                case 0:
+                    return new Vector3(1.0, 0.0, 0.0);
+                case 1:
+                    return new Vector3(-1.0, 0.0, 0.0);
+                case 2:
+                    return new Vector3(0.0, -1.0, 0.0);
+                case 3:
+                    return new Vector3(0.0, 1.0, 0.0);
+                case 4:
+                    return new Vector3(0.0, 0.0, 1.0);
+                case 5:
+                    return new Vector3(0.0, 0.0, -1.0);
+            }
+        }
+        return Vector3.Zero();
+    }
+    /**
+     * Sets the passed matrix "matrix" as a left-handed perspective projection matrix with the following settings :
+     * - fov = PI / 2
+     * - aspect ratio : 1.0
+     * - z-near and far equal to the active camera minZ and maxZ.
+     * Returns the PointLight.
+     * @param matrix
+     * @param viewMatrix
+     * @param renderList
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _setDefaultShadowProjectionMatrix(matrix, viewMatrix, renderList) {
+        const activeCamera = this.getScene().activeCamera;
+        if (!activeCamera) {
+            return;
+        }
+        const minZ = this.shadowMinZ !== undefined ? this.shadowMinZ : activeCamera.minZ;
+        const maxZ = this.shadowMaxZ !== undefined ? this.shadowMaxZ : activeCamera.maxZ;
+        const useReverseDepthBuffer = this.getScene().getEngine().useReverseDepthBuffer;
+        Matrix.PerspectiveFovLHToRef(this.shadowAngle, 1.0, useReverseDepthBuffer ? maxZ : minZ, useReverseDepthBuffer ? minZ : maxZ, matrix, true, this._scene.getEngine().isNDCHalfZRange, undefined, useReverseDepthBuffer);
+    }
+    _buildUniformLayout() {
+        this._uniformBuffer.addUniform("vLightData", 4);
+        this._uniformBuffer.addUniform("vLightDiffuse", 4);
+        this._uniformBuffer.addUniform("vLightSpecular", 4);
+        this._uniformBuffer.addUniform("vLightFalloff", 4);
+        this._uniformBuffer.addUniform("shadowsInfo", 3);
+        this._uniformBuffer.addUniform("depthValues", 2);
+        this._uniformBuffer.create();
+    }
+    /**
+     * Sets the passed Effect "effect" with the PointLight transformed position (or position, if none) and passed name (string).
+     * @param effect The effect to update
+     * @param lightIndex The index of the light in the effect to update
+     * @returns The point light
+     */
+    transferToEffect(effect, lightIndex) {
+        if (this.computeTransformedInformation()) {
+            this._uniformBuffer.updateFloat4("vLightData", this.transformedPosition.x, this.transformedPosition.y, this.transformedPosition.z, 0.0, lightIndex);
+        }
+        else {
+            this._uniformBuffer.updateFloat4("vLightData", this.position.x, this.position.y, this.position.z, 0, lightIndex);
+        }
+        this._uniformBuffer.updateFloat4("vLightFalloff", this.range, this._inverseSquaredRange, 0, 0, lightIndex);
+        return this;
+    }
+    transferToNodeMaterialEffect(effect, lightDataUniformName) {
+        if (this.computeTransformedInformation()) {
+            effect.setFloat3(lightDataUniformName, this.transformedPosition.x, this.transformedPosition.y, this.transformedPosition.z);
+        }
+        else {
+            effect.setFloat3(lightDataUniformName, this.position.x, this.position.y, this.position.z);
+        }
+        return this;
+    }
+    /**
+     * Prepares the list of defines specific to the light type.
+     * @param defines the list of defines
+     * @param lightIndex defines the index of the light for the effect
+     */
+    prepareLightSpecificDefines(defines, lightIndex) {
+        defines["POINTLIGHT" + lightIndex] = true;
+    }
+}
+__decorate([
+    serialize()
+], PointLight.prototype, "shadowAngle", null);
+// Register Class Name
+RegisterClass("BABYLON.PointLight", PointLight);
+
+Node.AddNodeConstructor("Light_Type_2", (name, scene) => {
+    return () => new SpotLight(name, Vector3.Zero(), Vector3.Zero(), 0, 0, scene);
+});
+/**
+ * A spot light is defined by a position, a direction, an angle, and an exponent.
+ * These values define a cone of light starting from the position, emitting toward the direction.
+ * The angle, in radians, defines the size (field of illumination) of the spotlight's conical beam,
+ * and the exponent defines the speed of the decay of the light with distance (reach).
+ * Documentation: https://doc.babylonjs.com/features/featuresDeepDive/lights/lights_introduction
+ */
+class SpotLight extends ShadowLight {
+    /**
+     * Gets the cone angle of the spot light in Radians.
+     */
+    get angle() {
+        return this._angle;
+    }
+    /**
+     * Sets the cone angle of the spot light in Radians.
+     */
+    set angle(value) {
+        this._angle = value;
+        this._cosHalfAngle = Math.cos(value * 0.5);
+        this._projectionTextureProjectionLightDirty = true;
+        this.forceProjectionMatrixCompute();
+        this._computeAngleValues();
+    }
+    /**
+     * Only used in gltf falloff mode, this defines the angle where
+     * the directional falloff will start before cutting at angle which could be seen
+     * as outer angle.
+     */
+    get innerAngle() {
+        return this._innerAngle;
+    }
+    /**
+     * Only used in gltf falloff mode, this defines the angle where
+     * the directional falloff will start before cutting at angle which could be seen
+     * as outer angle.
+     */
+    set innerAngle(value) {
+        this._innerAngle = value;
+        this._computeAngleValues();
+    }
+    /**
+     * Allows scaling the angle of the light for shadow generation only.
+     */
+    get shadowAngleScale() {
+        return this._shadowAngleScale;
+    }
+    /**
+     * Allows scaling the angle of the light for shadow generation only.
+     */
+    set shadowAngleScale(value) {
+        this._shadowAngleScale = value;
+        this.forceProjectionMatrixCompute();
+    }
+    /**
+     * Allows reading the projection texture
+     */
+    get projectionTextureMatrix() {
+        return this._projectionTextureMatrix;
+    }
+    /**
+     * Gets the near clip of the Spotlight for texture projection.
+     */
+    get projectionTextureLightNear() {
+        return this._projectionTextureLightNear;
+    }
+    /**
+     * Sets the near clip of the Spotlight for texture projection.
+     */
+    set projectionTextureLightNear(value) {
+        this._projectionTextureLightNear = value;
+        this._projectionTextureProjectionLightDirty = true;
+    }
+    /**
+     * Gets the far clip of the Spotlight for texture projection.
+     */
+    get projectionTextureLightFar() {
+        return this._projectionTextureLightFar;
+    }
+    /**
+     * Sets the far clip of the Spotlight for texture projection.
+     */
+    set projectionTextureLightFar(value) {
+        this._projectionTextureLightFar = value;
+        this._projectionTextureProjectionLightDirty = true;
+    }
+    /**
+     * Gets the Up vector of the Spotlight for texture projection.
+     */
+    get projectionTextureUpDirection() {
+        return this._projectionTextureUpDirection;
+    }
+    /**
+     * Sets the Up vector of the Spotlight for texture projection.
+     */
+    set projectionTextureUpDirection(value) {
+        this._projectionTextureUpDirection = value;
+        this._projectionTextureProjectionLightDirty = true;
+    }
+    /**
+     * Gets the projection texture of the light.
+     */
+    get projectionTexture() {
+        return this._projectionTexture;
+    }
+    /**
+     * Sets the projection texture of the light.
+     */
+    set projectionTexture(value) {
+        if (this._projectionTexture === value) {
+            return;
+        }
+        this._projectionTexture = value;
+        this._projectionTextureDirty = true;
+        if (this._projectionTexture && !this._projectionTexture.isReady()) {
+            if (SpotLight._IsProceduralTexture(this._projectionTexture)) {
+                this._projectionTexture.getEffect().executeWhenCompiled(() => {
+                    this._markMeshesAsLightDirty();
+                });
+            }
+            else if (SpotLight._IsTexture(this._projectionTexture)) {
+                this._projectionTexture.onLoadObservable.addOnce(() => {
+                    this._markMeshesAsLightDirty();
+                });
+            }
+        }
+    }
+    static _IsProceduralTexture(texture) {
+        return texture.onGeneratedObservable !== undefined;
+    }
+    static _IsTexture(texture) {
+        return texture.onLoadObservable !== undefined;
+    }
+    /**
+     * Gets or sets the light projection matrix as used by the projection texture
+     */
+    get projectionTextureProjectionLightMatrix() {
+        return this._projectionTextureProjectionLightMatrix;
+    }
+    set projectionTextureProjectionLightMatrix(projection) {
+        this._projectionTextureProjectionLightMatrix = projection;
+        this._projectionTextureProjectionLightDirty = false;
+        this._projectionTextureDirty = true;
+    }
+    /**
+     * Creates a SpotLight object in the scene. A spot light is a simply light oriented cone.
+     * It can cast shadows.
+     * Documentation : https://doc.babylonjs.com/features/featuresDeepDive/lights/lights_introduction
+     * @param name The light friendly name
+     * @param position The position of the spot light in the scene
+     * @param direction The direction of the light in the scene
+     * @param angle The cone angle of the light in Radians
+     * @param exponent The light decay speed with the distance from the emission spot
+     * @param scene The scene the lights belongs to
+     */
+    constructor(name, position, direction, angle, exponent, scene) {
+        super(name, scene);
+        this._innerAngle = 0;
+        this._projectionTextureMatrix = Matrix.Zero();
+        this._projectionTextureLightNear = 1e-6;
+        this._projectionTextureLightFar = 1000.0;
+        this._projectionTextureUpDirection = Vector3.Up();
+        this._projectionTextureViewLightDirty = true;
+        this._projectionTextureProjectionLightDirty = true;
+        this._projectionTextureDirty = true;
+        this._projectionTextureViewTargetVector = Vector3.Zero();
+        this._projectionTextureViewLightMatrix = Matrix.Zero();
+        this._projectionTextureProjectionLightMatrix = Matrix.Zero();
+        this._projectionTextureScalingMatrix = Matrix.FromValues(0.5, 0.0, 0.0, 0.0, 0.0, 0.5, 0.0, 0.0, 0.0, 0.0, 0.5, 0.0, 0.5, 0.5, 0.5, 1.0);
+        this.position = position;
+        this.direction = direction;
+        this.angle = angle;
+        this.exponent = exponent;
+    }
+    /**
+     * Returns the string "SpotLight".
+     * @returns the class name
+     */
+    getClassName() {
+        return "SpotLight";
+    }
+    /**
+     * Returns the integer 2.
+     * @returns The light Type id as a constant defines in Light.LIGHTTYPEID_x
+     */
+    getTypeID() {
+        return Light.LIGHTTYPEID_SPOTLIGHT;
+    }
+    /**
+     * Overrides the direction setter to recompute the projection texture view light Matrix.
+     * @param value
+     */
+    _setDirection(value) {
+        super._setDirection(value);
+        this._projectionTextureViewLightDirty = true;
+    }
+    /**
+     * Overrides the position setter to recompute the projection texture view light Matrix.
+     * @param value
+     */
+    _setPosition(value) {
+        super._setPosition(value);
+        this._projectionTextureViewLightDirty = true;
+    }
+    /**
+     * Sets the passed matrix "matrix" as perspective projection matrix for the shadows and the passed view matrix with the fov equal to the SpotLight angle and and aspect ratio of 1.0.
+     * Returns the SpotLight.
+     * @param matrix
+     * @param viewMatrix
+     * @param renderList
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _setDefaultShadowProjectionMatrix(matrix, viewMatrix, renderList) {
+        const activeCamera = this.getScene().activeCamera;
+        if (!activeCamera) {
+            return;
+        }
+        this._shadowAngleScale = this._shadowAngleScale || 1;
+        const angle = this._shadowAngleScale * this._angle;
+        const minZ = this.shadowMinZ !== undefined ? this.shadowMinZ : activeCamera.minZ;
+        const maxZ = this.shadowMaxZ !== undefined ? this.shadowMaxZ : activeCamera.maxZ;
+        const useReverseDepthBuffer = this.getScene().getEngine().useReverseDepthBuffer;
+        Matrix.PerspectiveFovLHToRef(angle, 1.0, useReverseDepthBuffer ? maxZ : minZ, useReverseDepthBuffer ? minZ : maxZ, matrix, true, this._scene.getEngine().isNDCHalfZRange, undefined, useReverseDepthBuffer);
+    }
+    _computeProjectionTextureViewLightMatrix() {
+        this._projectionTextureViewLightDirty = false;
+        this._projectionTextureDirty = true;
+        this.getAbsolutePosition().addToRef(this.getShadowDirection(), this._projectionTextureViewTargetVector);
+        Matrix.LookAtLHToRef(this.getAbsolutePosition(), this._projectionTextureViewTargetVector, this._projectionTextureUpDirection, this._projectionTextureViewLightMatrix);
+    }
+    _computeProjectionTextureProjectionLightMatrix() {
+        this._projectionTextureProjectionLightDirty = false;
+        this._projectionTextureDirty = true;
+        const lightFar = this.projectionTextureLightFar;
+        const lightNear = this.projectionTextureLightNear;
+        const P = lightFar / (lightFar - lightNear);
+        const Q = -P * lightNear;
+        const S = 1.0 / Math.tan(this._angle / 2.0);
+        const A = 1.0;
+        Matrix.FromValuesToRef(S / A, 0.0, 0.0, 0.0, 0.0, S, 0.0, 0.0, 0.0, 0.0, P, 1.0, 0.0, 0.0, Q, 0.0, this._projectionTextureProjectionLightMatrix);
+    }
+    /**
+     * Main function for light texture projection matrix computing.
+     */
+    _computeProjectionTextureMatrix() {
+        this._projectionTextureDirty = false;
+        this._projectionTextureViewLightMatrix.multiplyToRef(this._projectionTextureProjectionLightMatrix, this._projectionTextureMatrix);
+        if (this._projectionTexture instanceof Texture) {
+            const u = this._projectionTexture.uScale / 2.0;
+            const v = this._projectionTexture.vScale / 2.0;
+            Matrix.FromValuesToRef(u, 0.0, 0.0, 0.0, 0.0, v, 0.0, 0.0, 0.0, 0.0, 0.5, 0.0, 0.5, 0.5, 0.5, 1.0, this._projectionTextureScalingMatrix);
+        }
+        this._projectionTextureMatrix.multiplyToRef(this._projectionTextureScalingMatrix, this._projectionTextureMatrix);
+    }
+    _buildUniformLayout() {
+        this._uniformBuffer.addUniform("vLightData", 4);
+        this._uniformBuffer.addUniform("vLightDiffuse", 4);
+        this._uniformBuffer.addUniform("vLightSpecular", 4);
+        this._uniformBuffer.addUniform("vLightDirection", 3);
+        this._uniformBuffer.addUniform("vLightFalloff", 4);
+        this._uniformBuffer.addUniform("shadowsInfo", 3);
+        this._uniformBuffer.addUniform("depthValues", 2);
+        this._uniformBuffer.create();
+    }
+    _computeAngleValues() {
+        this._lightAngleScale = 1.0 / Math.max(0.001, Math.cos(this._innerAngle * 0.5) - this._cosHalfAngle);
+        this._lightAngleOffset = -this._cosHalfAngle * this._lightAngleScale;
+    }
+    /**
+     * Sets the passed Effect "effect" with the Light textures.
+     * @param effect The effect to update
+     * @param lightIndex The index of the light in the effect to update
+     * @returns The light
+     */
+    transferTexturesToEffect(effect, lightIndex) {
+        if (this.projectionTexture && this.projectionTexture.isReady()) {
+            if (this._projectionTextureViewLightDirty) {
+                this._computeProjectionTextureViewLightMatrix();
+            }
+            if (this._projectionTextureProjectionLightDirty) {
+                this._computeProjectionTextureProjectionLightMatrix();
+            }
+            if (this._projectionTextureDirty) {
+                this._computeProjectionTextureMatrix();
+            }
+            effect.setMatrix("textureProjectionMatrix" + lightIndex, this._projectionTextureMatrix);
+            effect.setTexture("projectionLightTexture" + lightIndex, this.projectionTexture);
+        }
+        return this;
+    }
+    /**
+     * Sets the passed Effect object with the SpotLight transformed position (or position if not parented) and normalized direction.
+     * @param effect The effect to update
+     * @param lightIndex The index of the light in the effect to update
+     * @returns The spot light
+     */
+    transferToEffect(effect, lightIndex) {
+        let normalizeDirection;
+        if (this.computeTransformedInformation()) {
+            this._uniformBuffer.updateFloat4("vLightData", this.transformedPosition.x, this.transformedPosition.y, this.transformedPosition.z, this.exponent, lightIndex);
+            normalizeDirection = Vector3.Normalize(this.transformedDirection);
+        }
+        else {
+            this._uniformBuffer.updateFloat4("vLightData", this.position.x, this.position.y, this.position.z, this.exponent, lightIndex);
+            normalizeDirection = Vector3.Normalize(this.direction);
+        }
+        this._uniformBuffer.updateFloat4("vLightDirection", normalizeDirection.x, normalizeDirection.y, normalizeDirection.z, this._cosHalfAngle, lightIndex);
+        this._uniformBuffer.updateFloat4("vLightFalloff", this.range, this._inverseSquaredRange, this._lightAngleScale, this._lightAngleOffset, lightIndex);
+        return this;
+    }
+    transferToNodeMaterialEffect(effect, lightDataUniformName) {
+        let normalizeDirection;
+        if (this.computeTransformedInformation()) {
+            normalizeDirection = Vector3.Normalize(this.transformedDirection);
+        }
+        else {
+            normalizeDirection = Vector3.Normalize(this.direction);
+        }
+        if (this.getScene().useRightHandedSystem) {
+            effect.setFloat3(lightDataUniformName, -normalizeDirection.x, -normalizeDirection.y, -normalizeDirection.z);
+        }
+        else {
+            effect.setFloat3(lightDataUniformName, normalizeDirection.x, normalizeDirection.y, normalizeDirection.z);
+        }
+        return this;
+    }
+    /**
+     * Disposes the light and the associated resources.
+     */
+    dispose() {
+        super.dispose();
+        if (this._projectionTexture) {
+            this._projectionTexture.dispose();
+        }
+    }
+    /**
+     * Gets the minZ used for shadow according to both the scene and the light.
+     * @param activeCamera The camera we are returning the min for
+     * @returns the depth min z
+     */
+    getDepthMinZ(activeCamera) {
+        const engine = this._scene.getEngine();
+        const minZ = this.shadowMinZ !== undefined ? this.shadowMinZ : activeCamera.minZ;
+        return engine.useReverseDepthBuffer && engine.isNDCHalfZRange ? minZ : this._scene.getEngine().isNDCHalfZRange ? 0 : minZ;
+    }
+    /**
+     * Gets the maxZ used for shadow according to both the scene and the light.
+     * @param activeCamera The camera we are returning the max for
+     * @returns the depth max z
+     */
+    getDepthMaxZ(activeCamera) {
+        const engine = this._scene.getEngine();
+        const maxZ = this.shadowMaxZ !== undefined ? this.shadowMaxZ : activeCamera.maxZ;
+        return engine.useReverseDepthBuffer && engine.isNDCHalfZRange ? 0 : maxZ;
+    }
+    /**
+     * Prepares the list of defines specific to the light type.
+     * @param defines the list of defines
+     * @param lightIndex defines the index of the light for the effect
+     */
+    prepareLightSpecificDefines(defines, lightIndex) {
+        defines["SPOTLIGHT" + lightIndex] = true;
+        defines["PROJECTEDLIGHTTEXTURE" + lightIndex] = this.projectionTexture && this.projectionTexture.isReady() ? true : false;
+    }
+}
+__decorate([
+    serialize()
+], SpotLight.prototype, "angle", null);
+__decorate([
+    serialize()
+], SpotLight.prototype, "innerAngle", null);
+__decorate([
+    serialize()
+], SpotLight.prototype, "shadowAngleScale", null);
+__decorate([
+    serialize()
+], SpotLight.prototype, "exponent", void 0);
+__decorate([
+    serialize()
+], SpotLight.prototype, "projectionTextureLightNear", null);
+__decorate([
+    serialize()
+], SpotLight.prototype, "projectionTextureLightFar", null);
+__decorate([
+    serialize()
+], SpotLight.prototype, "projectionTextureUpDirection", null);
+__decorate([
+    serializeAsTexture("projectedLightTexture")
+], SpotLight.prototype, "_projectionTexture", void 0);
+// Register Class Name
+RegisterClass("BABYLON.SpotLight", SpotLight);
+
+const NAME = "KHR_lights_punctual";
+/**
+ * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_lights_punctual/README.md)
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+class KHR_lights {
+    /**
+     * @internal
+     */
+    constructor(loader) {
+        /**
+         * The name of this extension.
+         */
+        this.name = NAME;
+        this._loader = loader;
+        this.enabled = this._loader.isExtensionUsed(NAME);
+    }
+    /** @internal */
+    dispose() {
+        this._loader = null;
+        delete this._lights;
+    }
+    /** @internal */
+    onLoading() {
+        const extensions = this._loader.gltf.extensions;
+        if (extensions && extensions[this.name]) {
+            const extension = extensions[this.name];
+            this._lights = extension.lights;
+            ArrayItem.Assign(this._lights);
+        }
+    }
+    /**
+     * @internal
+     */
+    loadNodeAsync(context, node, assign) {
+        return GLTFLoader.LoadExtensionAsync(context, node, this.name, (extensionContext, extension) => {
+            this._loader._allMaterialsDirtyRequired = true;
+            return this._loader.loadNodeAsync(context, node, (babylonMesh) => {
+                let babylonLight;
+                const light = ArrayItem.Get(extensionContext, this._lights, extension.light);
+                const name = light.name || babylonMesh.name;
+                this._loader.babylonScene._blockEntityCollection = !!this._loader._assetContainer;
+                switch (light.type) {
+                    case "directional" /* KHRLightsPunctual_LightType.DIRECTIONAL */: {
+                        const babylonDirectionalLight = new DirectionalLight(name, Vector3.Backward(), this._loader.babylonScene);
+                        babylonDirectionalLight.position.setAll(0);
+                        babylonLight = babylonDirectionalLight;
+                        break;
+                    }
+                    case "point" /* KHRLightsPunctual_LightType.POINT */: {
+                        babylonLight = new PointLight(name, Vector3.Zero(), this._loader.babylonScene);
+                        break;
+                    }
+                    case "spot" /* KHRLightsPunctual_LightType.SPOT */: {
+                        const babylonSpotLight = new SpotLight(name, Vector3.Zero(), Vector3.Backward(), 0, 1, this._loader.babylonScene);
+                        babylonSpotLight.angle = ((light.spot && light.spot.outerConeAngle) || Math.PI / 4) * 2;
+                        babylonSpotLight.innerAngle = ((light.spot && light.spot.innerConeAngle) || 0) * 2;
+                        babylonLight = babylonSpotLight;
+                        break;
+                    }
+                    default: {
+                        this._loader.babylonScene._blockEntityCollection = false;
+                        throw new Error(`${extensionContext}: Invalid light type (${light.type})`);
+                    }
+                }
+                babylonLight._parentContainer = this._loader._assetContainer;
+                this._loader.babylonScene._blockEntityCollection = false;
+                light._babylonLight = babylonLight;
+                babylonLight.falloffType = Light.FALLOFF_GLTF;
+                babylonLight.diffuse = light.color ? Color3.FromArray(light.color) : Color3.White();
+                babylonLight.intensity = light.intensity == undefined ? 1 : light.intensity;
+                babylonLight.range = light.range == undefined ? Number.MAX_VALUE : light.range;
+                babylonLight.parent = babylonMesh;
+                this._loader._babylonLights.push(babylonLight);
+                GLTFLoader.AddPointerMetadata(babylonLight, extensionContext);
+                assign(babylonMesh);
+            });
+        });
+    }
+}
+unregisterGLTFExtension(NAME);
+registerGLTFExtension(NAME, true, (loader) => new KHR_lights(loader));
+
+export { KHR_lights };
+//# sourceMappingURL=KHR_lights_punctual-CIEvgNk7.esm.js.map