@fps-games/editor 0.2.0-beta.4 → 0.2.1-beta.2

package/node_modules/@babylonjs/loaders/glTF/1.0/glTFLoaderUtils.js

@@ -0,0 +1,254 @@
+import { EParameterType, ETextureWrapMode, ETextureFilterType, EComponentType } from "./glTFLoaderInterfaces.js";
+import { Vector2, Vector3, Vector4, Matrix } from "@babylonjs/core/Maths/math.vector.js";
+import { Color4 } from "@babylonjs/core/Maths/math.color.js";
+import { Effect } from "@babylonjs/core/Materials/effect.js";
+import { ShaderMaterial } from "@babylonjs/core/Materials/shaderMaterial.js";
+import { Texture } from "@babylonjs/core/Materials/Textures/texture.js";
+/**
+ * Utils functions for GLTF
+ * @internal
+ * @deprecated
+ */
+export class GLTFUtils {
+    /**
+     * Sets the given "parameter" matrix
+     * @param scene the Scene object
+     * @param source the source node where to pick the matrix
+     * @param parameter the GLTF technique parameter
+     * @param uniformName the name of the shader's uniform
+     * @param shaderMaterial the shader material
+     */
+    static SetMatrix(scene, source, parameter, uniformName, shaderMaterial) {
+        let mat = null;
+        if (parameter.semantic === "MODEL") {
+            mat = source.getWorldMatrix();
+        }
+        else if (parameter.semantic === "PROJECTION") {
+            mat = scene.getProjectionMatrix();
+        }
+        else if (parameter.semantic === "VIEW") {
+            mat = scene.getViewMatrix();
+        }
+        else if (parameter.semantic === "MODELVIEWINVERSETRANSPOSE") {
+            mat = Matrix.Transpose(source.getWorldMatrix().multiply(scene.getViewMatrix()).invert());
+        }
+        else if (parameter.semantic === "MODELVIEW") {
+            mat = source.getWorldMatrix().multiply(scene.getViewMatrix());
+        }
+        else if (parameter.semantic === "MODELVIEWPROJECTION") {
+            mat = source.getWorldMatrix().multiply(scene.getTransformMatrix());
+        }
+        else if (parameter.semantic === "MODELINVERSE") {
+            mat = source.getWorldMatrix().invert();
+        }
+        else if (parameter.semantic === "VIEWINVERSE") {
+            mat = scene.getViewMatrix().invert();
+        }
+        else if (parameter.semantic === "PROJECTIONINVERSE") {
+            mat = scene.getProjectionMatrix().invert();
+        }
+        else if (parameter.semantic === "MODELVIEWINVERSE") {
+            mat = source.getWorldMatrix().multiply(scene.getViewMatrix()).invert();
+        }
+        else if (parameter.semantic === "MODELVIEWPROJECTIONINVERSE") {
+            mat = source.getWorldMatrix().multiply(scene.getTransformMatrix()).invert();
+        }
+        else if (parameter.semantic === "MODELINVERSETRANSPOSE") {
+            mat = Matrix.Transpose(source.getWorldMatrix().invert());
+        }
+        if (mat) {
+            switch (parameter.type) {
+                case EParameterType.FLOAT_MAT2:
+                    shaderMaterial.setMatrix2x2(uniformName, Matrix.GetAsMatrix2x2(mat));
+                    break;
+                case EParameterType.FLOAT_MAT3:
+                    shaderMaterial.setMatrix3x3(uniformName, Matrix.GetAsMatrix3x3(mat));
+                    break;
+                case EParameterType.FLOAT_MAT4:
+                    shaderMaterial.setMatrix(uniformName, mat);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    /**
+     * Sets the given "parameter" matrix
+     * @param shaderMaterial the shader material
+     * @param uniform the name of the shader's uniform
+     * @param value the value of the uniform
+     * @param type the uniform's type (EParameterType FLOAT, VEC2, VEC3 or VEC4)
+     * @returns true if set, else false
+     */
+    static SetUniform(shaderMaterial, uniform, value, type) {
+        switch (type) {
+            case EParameterType.FLOAT:
+                shaderMaterial.setFloat(uniform, value);
+                return true;
+            case EParameterType.FLOAT_VEC2:
+                shaderMaterial.setVector2(uniform, Vector2.FromArray(value));
+                return true;
+            case EParameterType.FLOAT_VEC3:
+                shaderMaterial.setVector3(uniform, Vector3.FromArray(value));
+                return true;
+            case EParameterType.FLOAT_VEC4:
+                shaderMaterial.setVector4(uniform, Vector4.FromArray(value));
+                return true;
+            default:
+                return false;
+        }
+    }
+    /**
+     * Returns the wrap mode of the texture
+     * @param mode the mode value
+     * @returns the wrap mode (TEXTURE_WRAP_ADDRESSMODE, MIRROR_ADDRESSMODE or CLAMP_ADDRESSMODE)
+     */
+    static GetWrapMode(mode) {
+        switch (mode) {
+            case ETextureWrapMode.CLAMP_TO_EDGE:
+                return Texture.CLAMP_ADDRESSMODE;
+            case ETextureWrapMode.MIRRORED_REPEAT:
+                return Texture.MIRROR_ADDRESSMODE;
+            case ETextureWrapMode.REPEAT:
+                return Texture.WRAP_ADDRESSMODE;
+            default:
+                return Texture.WRAP_ADDRESSMODE;
+        }
+    }
+    /**
+     * Returns the byte stride giving an accessor
+     * @param accessor the GLTF accessor objet
+     * @returns the byte stride
+     */
+    static GetByteStrideFromType(accessor) {
+        // Needs this function since "byteStride" isn't requiered in glTF format
+        const type = accessor.type;
+        switch (type) {
+            case "VEC2":
+                return 2;
+            case "VEC3":
+                return 3;
+            case "VEC4":
+                return 4;
+            case "MAT2":
+                return 4;
+            case "MAT3":
+                return 9;
+            case "MAT4":
+                return 16;
+            default:
+                return 1;
+        }
+    }
+    /**
+     * Returns the texture filter mode giving a mode value
+     * @param mode the filter mode value
+     * @returns the filter mode (TODO - needs to be a type?)
+     */
+    static GetTextureFilterMode(mode) {
+        switch (mode) {
+            case ETextureFilterType.LINEAR:
+            case ETextureFilterType.LINEAR_MIPMAP_NEAREST:
+            case ETextureFilterType.LINEAR_MIPMAP_LINEAR:
+                return Texture.TRILINEAR_SAMPLINGMODE;
+            case ETextureFilterType.NEAREST:
+            case ETextureFilterType.NEAREST_MIPMAP_NEAREST:
+                return Texture.NEAREST_SAMPLINGMODE;
+            default:
+                return Texture.BILINEAR_SAMPLINGMODE;
+        }
+    }
+    static GetBufferFromBufferView(gltfRuntime, bufferView, byteOffset, byteLength, componentType) {
+        byteOffset = bufferView.byteOffset + byteOffset;
+        const loadedBufferView = gltfRuntime.loadedBufferViews[bufferView.buffer];
+        if (byteOffset + byteLength > loadedBufferView.byteLength) {
+            throw new Error("Buffer access is out of range");
+        }
+        const buffer = loadedBufferView.buffer;
+        byteOffset += loadedBufferView.byteOffset;
+        switch (componentType) {
+            case EComponentType.BYTE:
+                return new Int8Array(buffer, byteOffset, byteLength);
+            case EComponentType.UNSIGNED_BYTE:
+                return new Uint8Array(buffer, byteOffset, byteLength);
+            case EComponentType.SHORT:
+                return new Int16Array(buffer, byteOffset, byteLength);
+            case EComponentType.UNSIGNED_SHORT:
+                return new Uint16Array(buffer, byteOffset, byteLength);
+            default:
+                return new Float32Array(buffer, byteOffset, byteLength);
+        }
+    }
+    /**
+     * Returns a buffer from its accessor
+     * @param gltfRuntime the GLTF runtime
+     * @param accessor the GLTF accessor
+     * @returns an array buffer view
+     */
+    static GetBufferFromAccessor(gltfRuntime, accessor) {
+        const bufferView = gltfRuntime.bufferViews[accessor.bufferView];
+        const byteLength = accessor.count * GLTFUtils.GetByteStrideFromType(accessor);
+        return GLTFUtils.GetBufferFromBufferView(gltfRuntime, bufferView, accessor.byteOffset, byteLength, accessor.componentType);
+    }
+    /**
+     * Decodes a buffer view into a string
+     * @param view the buffer view
+     * @returns a string
+     */
+    static DecodeBufferToText(view) {
+        let result = "";
+        const length = view.byteLength;
+        for (let i = 0; i < length; ++i) {
+            result += String.fromCharCode(view[i]);
+        }
+        return result;
+    }
+    /**
+     * Returns the default material of gltf. Related to
+     * https://github.com/KhronosGroup/glTF/tree/master/specification/1.0#appendix-a-default-material
+     * @param scene the Babylon.js scene
+     * @returns the default Babylon material
+     */
+    static GetDefaultMaterial(scene) {
+        if (!GLTFUtils._DefaultMaterial) {
+            Effect.ShadersStore["GLTFDefaultMaterialVertexShader"] = [
+                "precision highp float;",
+                "",
+                "uniform mat4 worldView;",
+                "uniform mat4 projection;",
+                "",
+                "attribute vec3 position;",
+                "",
+                "void main(void)",
+                "{",
+                "    gl_Position = projection * worldView * vec4(position, 1.0);",
+                "}",
+            ].join("\n");
+            Effect.ShadersStore["GLTFDefaultMaterialPixelShader"] = [
+                "precision highp float;",
+                "",
+                "uniform vec4 u_emission;",
+                "",
+                "void main(void)",
+                "{",
+                "    gl_FragColor = u_emission;",
+                "}",
+            ].join("\n");
+            const shaderPath = {
+                vertex: "GLTFDefaultMaterial",
+                fragment: "GLTFDefaultMaterial",
+            };
+            const options = {
+                attributes: ["position"],
+                uniforms: ["worldView", "projection", "u_emission"],
+                samplers: new Array(),
+                needAlphaBlending: false,
+            };
+            GLTFUtils._DefaultMaterial = new ShaderMaterial("GLTFDefaultMaterial", scene, shaderPath, options);
+            GLTFUtils._DefaultMaterial.setColor4("u_emission", new Color4(0.5, 0.5, 0.5, 1.0));
+        }
+        return GLTFUtils._DefaultMaterial;
+    }
+}
+// The GLTF default material
+GLTFUtils._DefaultMaterial = null;

package/node_modules/@babylonjs/loaders/glTF/1.0/glTFMaterialsCommonExtension.d.ts

@@ -0,0 +1,13 @@
+import { GLTFLoaderExtension } from "./glTFLoader.js";
+import type { IGLTFRuntime } from "./glTFLoaderInterfaces.js";
+import { Material } from "@babylonjs/core/Materials/material.js";
+/**
+ * @internal
+ * @deprecated
+ */
+export declare class GLTFMaterialsCommonExtension extends GLTFLoaderExtension {
+    constructor();
+    loadRuntimeExtensionsAsync(gltfRuntime: IGLTFRuntime): boolean;
+    loadMaterialAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (material: Material) => void, onError: (message: string) => void): boolean;
+    private _loadTexture;
+}

package/node_modules/@babylonjs/loaders/glTF/1.0/glTFMaterialsCommonExtension.js

@@ -0,0 +1,130 @@
+import { GLTFLoaderExtension, GLTFLoaderBase, GLTFLoader } from "./glTFLoader.js";
+import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";
+import { Tools } from "@babylonjs/core/Misc/tools.js";
+import { Material } from "@babylonjs/core/Materials/material.js";
+import { StandardMaterial } from "@babylonjs/core/Materials/standardMaterial.js";
+import { HemisphericLight } from "@babylonjs/core/Lights/hemisphericLight.js";
+import { DirectionalLight } from "@babylonjs/core/Lights/directionalLight.js";
+import { PointLight } from "@babylonjs/core/Lights/pointLight.js";
+import { SpotLight } from "@babylonjs/core/Lights/spotLight.js";
+/**
+ * @internal
+ * @deprecated
+ */
+export class GLTFMaterialsCommonExtension extends GLTFLoaderExtension {
+    constructor() {
+        super("KHR_materials_common");
+    }
+    // eslint-disable-next-line no-restricted-syntax
+    loadRuntimeExtensionsAsync(gltfRuntime) {
+        if (!gltfRuntime.extensions) {
+            return false;
+        }
+        const extension = gltfRuntime.extensions[this.name];
+        if (!extension) {
+            return false;
+        }
+        // Create lights
+        const lights = extension.lights;
+        if (lights) {
+            for (const thing in lights) {
+                const light = lights[thing];
+                switch (light.type) {
+                    case "ambient": {
+                        const ambientLight = new HemisphericLight(light.name, new Vector3(0, 1, 0), gltfRuntime.scene);
+                        const ambient = light.ambient;
+                        if (ambient) {
+                            ambientLight.diffuse = Color3.FromArray(ambient.color || [1, 1, 1]);
+                        }
+                        break;
+                    }
+                    case "point": {
+                        const pointLight = new PointLight(light.name, new Vector3(10, 10, 10), gltfRuntime.scene);
+                        const point = light.point;
+                        if (point) {
+                            pointLight.diffuse = Color3.FromArray(point.color || [1, 1, 1]);
+                        }
+                        break;
+                    }
+                    case "directional": {
+                        const dirLight = new DirectionalLight(light.name, new Vector3(0, -1, 0), gltfRuntime.scene);
+                        const directional = light.directional;
+                        if (directional) {
+                            dirLight.diffuse = Color3.FromArray(directional.color || [1, 1, 1]);
+                        }
+                        break;
+                    }
+                    case "spot": {
+                        const spot = light.spot;
+                        if (spot) {
+                            const spotLight = new SpotLight(light.name, new Vector3(0, 10, 0), new Vector3(0, -1, 0), spot.fallOffAngle || Math.PI, spot.fallOffExponent || 0.0, gltfRuntime.scene);
+                            spotLight.diffuse = Color3.FromArray(spot.color || [1, 1, 1]);
+                        }
+                        break;
+                    }
+                    default:
+                        Tools.Warn('GLTF Material Common extension: light type "' + light.type + "” not supported");
+                        break;
+                }
+            }
+        }
+        return false;
+    }
+    // eslint-disable-next-line no-restricted-syntax
+    loadMaterialAsync(gltfRuntime, id, onSuccess, onError) {
+        const material = gltfRuntime.materials[id];
+        if (!material || !material.extensions) {
+            return false;
+        }
+        const extension = material.extensions[this.name];
+        if (!extension) {
+            return false;
+        }
+        const standardMaterial = new StandardMaterial(id, gltfRuntime.scene);
+        standardMaterial.sideOrientation = Material.CounterClockWiseSideOrientation;
+        if (extension.technique === "CONSTANT") {
+            standardMaterial.disableLighting = true;
+        }
+        standardMaterial.backFaceCulling = extension.doubleSided === undefined ? false : !extension.doubleSided;
+        standardMaterial.alpha = extension.values.transparency === undefined ? 1.0 : extension.values.transparency;
+        standardMaterial.specularPower = extension.values.shininess === undefined ? 0.0 : extension.values.shininess;
+        // Ambient
+        if (typeof extension.values.ambient === "string") {
+            this._loadTexture(gltfRuntime, extension.values.ambient, standardMaterial, "ambientTexture", onError);
+        }
+        else {
+            standardMaterial.ambientColor = Color3.FromArray(extension.values.ambient || [0, 0, 0]);
+        }
+        // Diffuse
+        if (typeof extension.values.diffuse === "string") {
+            this._loadTexture(gltfRuntime, extension.values.diffuse, standardMaterial, "diffuseTexture", onError);
+        }
+        else {
+            standardMaterial.diffuseColor = Color3.FromArray(extension.values.diffuse || [0, 0, 0]);
+        }
+        // Emission
+        if (typeof extension.values.emission === "string") {
+            this._loadTexture(gltfRuntime, extension.values.emission, standardMaterial, "emissiveTexture", onError);
+        }
+        else {
+            standardMaterial.emissiveColor = Color3.FromArray(extension.values.emission || [0, 0, 0]);
+        }
+        // Specular
+        if (typeof extension.values.specular === "string") {
+            this._loadTexture(gltfRuntime, extension.values.specular, standardMaterial, "specularTexture", onError);
+        }
+        else {
+            standardMaterial.specularColor = Color3.FromArray(extension.values.specular || [0, 0, 0]);
+        }
+        return true;
+    }
+    _loadTexture(gltfRuntime, id, material, propertyPath, onError) {
+        // Create buffer from texture url
+        GLTFLoaderBase.LoadTextureBufferAsync(gltfRuntime, id, (buffer) => {
+            // Create texture from buffer
+            GLTFLoaderBase.CreateTextureAsync(gltfRuntime, id, buffer, (texture) => (material[propertyPath] = texture));
+        }, onError);
+    }
+}
+GLTFLoader.RegisterExtension(new GLTFMaterialsCommonExtension());

package/node_modules/@babylonjs/loaders/glTF/1.0/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./glTFBinaryExtension.js";
+export * from "./glTFLoader.js";
+export * from "./glTFLoaderInterfaces.js";
+export * from "./glTFLoaderUtils.js";
+export * from "./glTFMaterialsCommonExtension.js";

package/node_modules/@babylonjs/loaders/glTF/1.0/index.js

@@ -0,0 +1,5 @@
+export * from "./glTFBinaryExtension.js";
+export * from "./glTFLoader.js";
+export * from "./glTFLoaderInterfaces.js";
+export * from "./glTFLoaderUtils.js";
+export * from "./glTFMaterialsCommonExtension.js";

package/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/EXT_lights_area.d.ts

@@ -0,0 +1,41 @@
+import type { Nullable } from "@babylonjs/core/types.js";
+import type { TransformNode } from "@babylonjs/core/Meshes/transformNode.js";
+import type { INode } from "../glTFLoaderInterfaces.js";
+import type { IGLTFLoaderExtension } from "../glTFLoaderExtension.js";
+import { GLTFLoader } from "../glTFLoader.js";
+declare module "../../glTFFileLoader.js" {
+    interface GLTFLoaderExtensionOptions {
+        /**
+         * Defines options for the EXT_lights_area extension.
+         */
+        ["EXT_lights_area"]: {};
+    }
+}
+/**
+ * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Vendor/EXT_lights_area/README.md)
+ */
+export declare class EXT_lights_area implements IGLTFLoaderExtension {
+    /**
+     * The name of this extension.
+     */
+    readonly name = "EXT_lights_area";
+    /**
+     * Defines whether this extension is enabled.
+     */
+    enabled: boolean;
+    /** hidden */
+    private _loader;
+    private _lights?;
+    /**
+     * @internal
+     */
+    constructor(loader: GLTFLoader);
+    /** @internal */
+    dispose(): void;
+    /** @internal */
+    onLoading(): void;
+    /**
+     * @internal
+     */
+    loadNodeAsync(context: string, node: INode, assign: (babylonTransformNode: TransformNode) => void): Nullable<Promise<TransformNode>>;
+}

package/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/EXT_lights_area.js

@@ -0,0 +1,93 @@
+import { Vector3, Quaternion } from "@babylonjs/core/Maths/math.vector.js";
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";
+import { Light } from "@babylonjs/core/Lights/light.js";
+import { RectAreaLight } from "@babylonjs/core/Lights/rectAreaLight.js";
+import { TransformNode as BabylonTransformNode } from "@babylonjs/core/Meshes/transformNode.js";
+import { GLTFLoader, ArrayItem } from "../glTFLoader.js";
+import { registerGLTFExtension, unregisterGLTFExtension } from "../glTFLoaderExtensionRegistry.js";
+const NAME = "EXT_lights_area";
+/**
+ * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Vendor/EXT_lights_area/README.md)
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export class EXT_lights_area {
+    /**
+     * @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
+     */
+    // eslint-disable-next-line no-restricted-syntax
+    loadNodeAsync(context, node, assign) {
+        return GLTFLoader.LoadExtensionAsync(context, node, this.name, async (extensionContext, extension) => {
+            this._loader._allMaterialsDirtyRequired = true;
+            return await 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;
+                const size = light.size !== undefined ? light.size : 1.0;
+                switch (light.type) {
+                    case "rect" /* EXTLightsArea_LightType.RECT */: {
+                        const width = light.rect?.aspect !== undefined ? light.rect.aspect * size : size;
+                        const height = size;
+                        const babylonRectAreaLight = new RectAreaLight(name, Vector3.Zero(), width, height, this._loader.babylonScene);
+                        babylonLight = babylonRectAreaLight;
+                        break;
+                    }
+                    case "disk" /* EXTLightsArea_LightType.DISK */: {
+                        // For disk lights, we'll use a rectangle light with the same area to approximate the disk light
+                        // In the future, this could be extended to support actual disk area lights
+                        const newSize = Math.sqrt(size * size * 0.25 * Math.PI); // Area of the disk
+                        const babylonRectAreaLight = new RectAreaLight(name, Vector3.Zero(), newSize, newSize, this._loader.babylonScene);
+                        babylonLight = babylonRectAreaLight;
+                        break;
+                    }
+                    default: {
+                        this._loader.babylonScene._blockEntityCollection = false;
+                        throw new Error(`${extensionContext}: Invalid area 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;
+                // glTF EXT_lights_area specifies lights face down -Z, but Babylon.js area lights face down +Z
+                // Create a parent transform node with 180-degree rotation around Y axis to flip the direction
+                const lightParentNode = new BabylonTransformNode(`${name}_orientation`, this._loader.babylonScene);
+                lightParentNode.rotationQuaternion = Quaternion.RotationAxis(Vector3.Up(), Math.PI);
+                lightParentNode.parent = babylonMesh;
+                babylonLight.parent = lightParentNode;
+                this._loader._babylonLights.push(babylonLight);
+                GLTFLoader.AddPointerMetadata(babylonLight, extensionContext);
+                assign(babylonMesh);
+            });
+        });
+    }
+}
+unregisterGLTFExtension(NAME);
+registerGLTFExtension(NAME, true, (loader) => new EXT_lights_area(loader));

package/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/EXT_lights_ies.d.ts

@@ -0,0 +1,41 @@
+import type { Nullable } from "@babylonjs/core/types.js";
+import type { TransformNode } from "@babylonjs/core/Meshes/transformNode.js";
+import type { INode } from "../glTFLoaderInterfaces.js";
+import type { IGLTFLoaderExtension } from "../glTFLoaderExtension.js";
+import { GLTFLoader } from "../glTFLoader.js";
+declare module "../../glTFFileLoader.js" {
+    interface GLTFLoaderExtensionOptions {
+        /**
+         * Defines options for the EXT_lights_ies extension.
+         */
+        ["EXT_lights_ies"]: {};
+    }
+}
+/**
+ * [Specification](https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Vendor/EXT_lights_ies)
+ */
+export declare class EXT_lights_ies implements IGLTFLoaderExtension {
+    /**
+     * The name of this extension.
+     */
+    readonly name = "EXT_lights_ies";
+    /**
+     * Defines whether this extension is enabled.
+     */
+    enabled: boolean;
+    /** hidden */
+    private _loader;
+    private _lights?;
+    /**
+     * @internal
+     */
+    constructor(loader: GLTFLoader);
+    /** @internal */
+    dispose(): void;
+    /** @internal */
+    onLoading(): void;
+    /**
+     * @internal
+     */
+    loadNodeAsync(context: string, node: INode, assign: (babylonTransformNode: TransformNode) => void): Nullable<Promise<TransformNode>>;
+}

package/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/EXT_lights_ies.js

@@ -0,0 +1,83 @@
+import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";
+import { SpotLight } from "@babylonjs/core/Lights/spotLight.js";
+import { Light } from "@babylonjs/core/Lights/light.js";
+import { GLTFLoader, ArrayItem } from "../glTFLoader.js";
+import { registerGLTFExtension, unregisterGLTFExtension } from "../glTFLoaderExtensionRegistry.js";
+import { Texture } from "@babylonjs/core/Materials/Textures/texture.js";
+const NAME = "EXT_lights_ies";
+/**
+ * [Specification](https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Vendor/EXT_lights_ies)
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export class EXT_lights_ies {
+    /**
+     * @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
+     */
+    // eslint-disable-next-line no-restricted-syntax
+    // eslint-disable-next-line no-restricted-syntax
+    loadNodeAsync(context, node, assign) {
+        return GLTFLoader.LoadExtensionAsync(context, node, this.name, async (extensionContext, extension) => {
+            this._loader._allMaterialsDirtyRequired = true;
+            let babylonSpotLight;
+            let light;
+            const transformNode = await this._loader.loadNodeAsync(context, node, (babylonMesh) => {
+                light = ArrayItem.Get(extensionContext, this._lights, extension.light);
+                const name = light.name || babylonMesh.name;
+                this._loader.babylonScene._blockEntityCollection = !!this._loader._assetContainer;
+                babylonSpotLight = new SpotLight(name, Vector3.Zero(), Vector3.Backward(), 0, 1, this._loader.babylonScene);
+                babylonSpotLight.angle = Math.PI / 2;
+                babylonSpotLight.innerAngle = 0;
+                babylonSpotLight._parentContainer = this._loader._assetContainer;
+                this._loader.babylonScene._blockEntityCollection = false;
+                light._babylonLight = babylonSpotLight;
+                babylonSpotLight.falloffType = Light.FALLOFF_GLTF;
+                babylonSpotLight.diffuse = extension.color ? Color3.FromArray(extension.color) : Color3.White();
+                babylonSpotLight.intensity = extension.multiplier || 1;
+                babylonSpotLight.range = Number.MAX_VALUE;
+                babylonSpotLight.parent = babylonMesh;
+                this._loader._babylonLights.push(babylonSpotLight);
+                GLTFLoader.AddPointerMetadata(babylonSpotLight, extensionContext);
+                assign(babylonMesh);
+            });
+            // Load the profile
+            let bufferData;
+            if (light.uri) {
+                bufferData = await this._loader.loadUriAsync(context, light, light.uri);
+            }
+            else {
+                const bufferView = ArrayItem.Get(`${context}/bufferView`, this._loader.gltf.bufferViews, light.bufferView);
+                bufferData = await this._loader.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView);
+            }
+            babylonSpotLight.iesProfileTexture = new Texture(name + "_iesProfile", this._loader.babylonScene, true, false, undefined, null, null, bufferData, true, undefined, undefined, undefined, undefined, ".ies");
+            return transformNode;
+        });
+    }
+}
+unregisterGLTFExtension(NAME);
+registerGLTFExtension(NAME, true, (loader) => new EXT_lights_ies(loader));