@babylonjs/loaders 5.0.0-rc.5 → 5.0.0-rc.9

package/glTF/1.0/glTFMaterialsCommonExtension.js

@@ -1,130 +1,130 @@
-import { __extends } from "tslib";
-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";
-/** @hidden */
-var GLTFMaterialsCommonExtension = /** @class */ (function (_super) {
-    __extends(GLTFMaterialsCommonExtension, _super);
-    function GLTFMaterialsCommonExtension() {
-        return _super.call(this, "KHR_materials_common") || this;
-    }
-    GLTFMaterialsCommonExtension.prototype.loadRuntimeExtensionsAsync = function (gltfRuntime) {
-        if (!gltfRuntime.extensions) {
-            return false;
-        }
-        var extension = gltfRuntime.extensions[this.name];
-        if (!extension) {
-            return false;
-        }
-        // Create lights
-        var lights = extension.lights;
-        if (lights) {
-            for (var thing in lights) {
-                var light = lights[thing];
-                switch (light.type) {
-                    case "ambient": {
-                        var ambientLight = new HemisphericLight(light.name, new Vector3(0, 1, 0), gltfRuntime.scene);
-                        var ambient = light.ambient;
-                        if (ambient) {
-                            ambientLight.diffuse = Color3.FromArray(ambient.color || [1, 1, 1]);
-                        }
-                        break;
-                    }
-                    case "point": {
-                        var pointLight = new PointLight(light.name, new Vector3(10, 10, 10), gltfRuntime.scene);
-                        var point = light.point;
-                        if (point) {
-                            pointLight.diffuse = Color3.FromArray(point.color || [1, 1, 1]);
-                        }
-                        break;
-                    }
-                    case "directional": {
-                        var dirLight = new DirectionalLight(light.name, new Vector3(0, -1, 0), gltfRuntime.scene);
-                        var directional = light.directional;
-                        if (directional) {
-                            dirLight.diffuse = Color3.FromArray(directional.color || [1, 1, 1]);
-                        }
-                        break;
-                    }
-                    case "spot": {
-                        var spot = light.spot;
-                        if (spot) {
-                            var 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;
-    };
-    GLTFMaterialsCommonExtension.prototype.loadMaterialAsync = function (gltfRuntime, id, onSuccess, onError) {
-        var material = gltfRuntime.materials[id];
-        if (!material || !material.extensions) {
-            return false;
-        }
-        var extension = material.extensions[this.name];
-        if (!extension) {
-            return false;
-        }
-        var 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;
-    };
-    GLTFMaterialsCommonExtension.prototype._loadTexture = function (gltfRuntime, id, material, propertyPath, onError) {
-        // Create buffer from texture url
-        GLTFLoaderBase.LoadTextureBufferAsync(gltfRuntime, id, function (buffer) {
-            // Create texture from buffer
-            GLTFLoaderBase.CreateTextureAsync(gltfRuntime, id, buffer, function (texture) { return (material[propertyPath] = texture); });
-        }, onError);
-    };
-    return GLTFMaterialsCommonExtension;
-}(GLTFLoaderExtension));
-export { GLTFMaterialsCommonExtension };
-GLTFLoader.RegisterExtension(new GLTFMaterialsCommonExtension());
+import { __extends } from "tslib";
+import { GLTFLoaderExtension, GLTFLoaderBase, GLTFLoader } from "./glTFLoader";
+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";
+/** @hidden */
+var GLTFMaterialsCommonExtension = /** @class */ (function (_super) {
+    __extends(GLTFMaterialsCommonExtension, _super);
+    function GLTFMaterialsCommonExtension() {
+        return _super.call(this, "KHR_materials_common") || this;
+    }
+    GLTFMaterialsCommonExtension.prototype.loadRuntimeExtensionsAsync = function (gltfRuntime) {
+        if (!gltfRuntime.extensions) {
+            return false;
+        }
+        var extension = gltfRuntime.extensions[this.name];
+        if (!extension) {
+            return false;
+        }
+        // Create lights
+        var lights = extension.lights;
+        if (lights) {
+            for (var thing in lights) {
+                var light = lights[thing];
+                switch (light.type) {
+                    case "ambient": {
+                        var ambientLight = new HemisphericLight(light.name, new Vector3(0, 1, 0), gltfRuntime.scene);
+                        var ambient = light.ambient;
+                        if (ambient) {
+                            ambientLight.diffuse = Color3.FromArray(ambient.color || [1, 1, 1]);
+                        }
+                        break;
+                    }
+                    case "point": {
+                        var pointLight = new PointLight(light.name, new Vector3(10, 10, 10), gltfRuntime.scene);
+                        var point = light.point;
+                        if (point) {
+                            pointLight.diffuse = Color3.FromArray(point.color || [1, 1, 1]);
+                        }
+                        break;
+                    }
+                    case "directional": {
+                        var dirLight = new DirectionalLight(light.name, new Vector3(0, -1, 0), gltfRuntime.scene);
+                        var directional = light.directional;
+                        if (directional) {
+                            dirLight.diffuse = Color3.FromArray(directional.color || [1, 1, 1]);
+                        }
+                        break;
+                    }
+                    case "spot": {
+                        var spot = light.spot;
+                        if (spot) {
+                            var 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;
+    };
+    GLTFMaterialsCommonExtension.prototype.loadMaterialAsync = function (gltfRuntime, id, onSuccess, onError) {
+        var material = gltfRuntime.materials[id];
+        if (!material || !material.extensions) {
+            return false;
+        }
+        var extension = material.extensions[this.name];
+        if (!extension) {
+            return false;
+        }
+        var 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;
+    };
+    GLTFMaterialsCommonExtension.prototype._loadTexture = function (gltfRuntime, id, material, propertyPath, onError) {
+        // Create buffer from texture url
+        GLTFLoaderBase.LoadTextureBufferAsync(gltfRuntime, id, function (buffer) {
+            // Create texture from buffer
+            GLTFLoaderBase.CreateTextureAsync(gltfRuntime, id, buffer, function (texture) { return (material[propertyPath] = texture); });
+        }, onError);
+    };
+    return GLTFMaterialsCommonExtension;
+}(GLTFLoaderExtension));
+export { GLTFMaterialsCommonExtension };
+GLTFLoader.RegisterExtension(new GLTFMaterialsCommonExtension());
 //# sourceMappingURL=glTFMaterialsCommonExtension.js.map

package/glTF/1.0/index.d.ts

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

package/glTF/1.0/index.js

@@ -1,6 +1,6 @@
-export * from "./glTFBinaryExtension.js";
-export * from "./glTFLoader.js";
-export * from "./glTFLoaderInterfaces.js";
-export * from "./glTFLoaderUtils.js";
-export * from "./glTFMaterialsCommonExtension.js";
+export * from "./glTFBinaryExtension";
+export * from "./glTFLoader";
+export * from "./glTFLoaderInterfaces";
+export * from "./glTFLoaderUtils";
+export * from "./glTFMaterialsCommonExtension";
 //# sourceMappingURL=index.js.map

package/glTF/2.0/Extensions/EXT_lights_image_based.d.ts

@@ -1,43 +1,43 @@
-import { Nullable } from "@babylonjs/core/types.js";
-import { BaseTexture } from "@babylonjs/core/Materials/Textures/baseTexture.js";
-import { IScene } from "../glTFLoaderInterfaces";
-import { IGLTFLoaderExtension } from "../glTFLoaderExtension";
-import { GLTFLoader } from "../glTFLoader";
-declare module "babylonjs-gltf2interface" {
-    /** @hidden */
-    interface IEXTLightsImageBased_LightImageBased {
-        _babylonTexture?: BaseTexture;
-        _loaded?: Promise<void>;
-    }
-}
-/**
- * [Specification](https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Vendor/EXT_lights_image_based/README.md)
- */
-export declare class EXT_lights_image_based implements IGLTFLoaderExtension {
-    /**
-     * The name of this extension.
-     */
-    readonly name = "EXT_lights_image_based";
-    /**
-     * Defines whether this extension is enabled.
-     */
-    enabled: boolean;
-    private _loader;
-    private _lights?;
-    /**
-     * @param loader
-     * @hidden
-     */
-    constructor(loader: GLTFLoader);
-    /** @hidden */
-    dispose(): void;
-    /** @hidden */
-    onLoading(): void;
-    /**
-     * @param context
-     * @param scene
-     * @hidden
-     */
-    loadSceneAsync(context: string, scene: IScene): Nullable<Promise<void>>;
-    private _loadLightAsync;
-}
+import { Nullable } from "@babylonjs/core/types.js";
+import { BaseTexture } from "@babylonjs/core/Materials/Textures/baseTexture.js";
+import { IScene } from "../glTFLoaderInterfaces";
+import { IGLTFLoaderExtension } from "../glTFLoaderExtension";
+import { GLTFLoader } from "../glTFLoader";
+declare module "babylonjs-gltf2interface" {
+    /** @hidden */
+    interface IEXTLightsImageBased_LightImageBased {
+        _babylonTexture?: BaseTexture;
+        _loaded?: Promise<void>;
+    }
+}
+/**
+ * [Specification](https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Vendor/EXT_lights_image_based/README.md)
+ */
+export declare class EXT_lights_image_based implements IGLTFLoaderExtension {
+    /**
+     * The name of this extension.
+     */
+    readonly name = "EXT_lights_image_based";
+    /**
+     * Defines whether this extension is enabled.
+     */
+    enabled: boolean;
+    private _loader;
+    private _lights?;
+    /**
+     * @param loader
+     * @hidden
+     */
+    constructor(loader: GLTFLoader);
+    /** @hidden */
+    dispose(): void;
+    /** @hidden */
+    onLoading(): void;
+    /**
+     * @param context
+     * @param scene
+     * @hidden
+     */
+    loadSceneAsync(context: string, scene: IScene): Nullable<Promise<void>>;
+    private _loadLightAsync;
+}

package/glTF/2.0/Extensions/EXT_lights_image_based.js

@@ -1,118 +1,118 @@
-import { Scalar } from "@babylonjs/core/Maths/math.scalar.js";
-import { SphericalHarmonics, SphericalPolynomial } from "@babylonjs/core/Maths/sphericalPolynomial.js";
-import { Quaternion, Matrix } from "@babylonjs/core/Maths/math.vector.js";
-import { RawCubeTexture } from "@babylonjs/core/Materials/Textures/rawCubeTexture.js";
-import { GLTFLoader, ArrayItem } from "../glTFLoader.js";
-var NAME = "EXT_lights_image_based";
-/**
- * [Specification](https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Vendor/EXT_lights_image_based/README.md)
- */
-var EXT_lights_image_based = /** @class */ (function () {
-    /**
-     * @param loader
-     * @hidden
-     */
-    function EXT_lights_image_based(loader) {
-        /**
-         * The name of this extension.
-         */
-        this.name = NAME;
-        this._loader = loader;
-        this.enabled = this._loader.isExtensionUsed(NAME);
-    }
-    /** @hidden */
-    EXT_lights_image_based.prototype.dispose = function () {
-        this._loader = null;
-        delete this._lights;
-    };
-    /** @hidden */
-    EXT_lights_image_based.prototype.onLoading = function () {
-        var extensions = this._loader.gltf.extensions;
-        if (extensions && extensions[this.name]) {
-            var extension = extensions[this.name];
-            this._lights = extension.lights;
-        }
-    };
-    /**
-     * @param context
-     * @param scene
-     * @hidden
-     */
-    EXT_lights_image_based.prototype.loadSceneAsync = function (context, scene) {
-        var _this = this;
-        return GLTFLoader.LoadExtensionAsync(context, scene, this.name, function (extensionContext, extension) {
-            var promises = new Array();
-            promises.push(_this._loader.loadSceneAsync(context, scene));
-            _this._loader.logOpen("".concat(extensionContext));
-            var light = ArrayItem.Get("".concat(extensionContext, "/light"), _this._lights, extension.light);
-            promises.push(_this._loadLightAsync("/extensions/".concat(_this.name, "/lights/").concat(extension.light), light).then(function (texture) {
-                _this._loader.babylonScene.environmentTexture = texture;
-            }));
-            _this._loader.logClose();
-            return Promise.all(promises).then(function () { });
-        });
-    };
-    EXT_lights_image_based.prototype._loadLightAsync = function (context, light) {
-        var _this = this;
-        if (!light._loaded) {
-            var promises = new Array();
-            this._loader.logOpen("".concat(context));
-            var imageData_1 = new Array(light.specularImages.length);
-            var _loop_1 = function (mipmap) {
-                var faces = light.specularImages[mipmap];
-                imageData_1[mipmap] = new Array(faces.length);
-                var _loop_2 = function (face) {
-                    var specularImageContext = "".concat(context, "/specularImages/").concat(mipmap, "/").concat(face);
-                    this_1._loader.logOpen("".concat(specularImageContext));
-                    var index = faces[face];
-                    var image = ArrayItem.Get(specularImageContext, this_1._loader.gltf.images, index);
-                    promises.push(this_1._loader.loadImageAsync("/images/".concat(index), image).then(function (data) {
-                        imageData_1[mipmap][face] = data;
-                    }));
-                    this_1._loader.logClose();
-                };
-                for (var face = 0; face < faces.length; face++) {
-                    _loop_2(face);
-                }
-            };
-            var this_1 = this;
-            for (var mipmap = 0; mipmap < light.specularImages.length; mipmap++) {
-                _loop_1(mipmap);
-            }
-            this._loader.logClose();
-            light._loaded = Promise.all(promises).then(function () {
-                var babylonTexture = new RawCubeTexture(_this._loader.babylonScene, null, light.specularImageSize);
-                babylonTexture.name = light.name || "environment";
-                light._babylonTexture = babylonTexture;
-                if (light.intensity != undefined) {
-                    babylonTexture.level = light.intensity;
-                }
-                if (light.rotation) {
-                    var rotation = Quaternion.FromArray(light.rotation);
-                    // Invert the rotation so that positive rotation is counter-clockwise.
-                    if (!_this._loader.babylonScene.useRightHandedSystem) {
-                        rotation = Quaternion.Inverse(rotation);
-                    }
-                    Matrix.FromQuaternionToRef(rotation, babylonTexture.getReflectionTextureMatrix());
-                }
-                if (!light.irradianceCoefficients) {
-                    throw new Error("".concat(context, ": Irradiance coefficients are missing"));
-                }
-                var sphericalHarmonics = SphericalHarmonics.FromArray(light.irradianceCoefficients);
-                sphericalHarmonics.scaleInPlace(light.intensity);
-                sphericalHarmonics.convertIrradianceToLambertianRadiance();
-                var sphericalPolynomial = SphericalPolynomial.FromHarmonics(sphericalHarmonics);
-                // Compute the lod generation scale to fit exactly to the number of levels available.
-                var lodGenerationScale = (imageData_1.length - 1) / Scalar.Log2(light.specularImageSize);
-                return babylonTexture.updateRGBDAsync(imageData_1, sphericalPolynomial, lodGenerationScale);
-            });
-        }
-        return light._loaded.then(function () {
-            return light._babylonTexture;
-        });
-    };
-    return EXT_lights_image_based;
-}());
-export { EXT_lights_image_based };
-GLTFLoader.RegisterExtension(NAME, function (loader) { return new EXT_lights_image_based(loader); });
+import { Scalar } from "@babylonjs/core/Maths/math.scalar.js";
+import { SphericalHarmonics, SphericalPolynomial } from "@babylonjs/core/Maths/sphericalPolynomial.js";
+import { Quaternion, Matrix } from "@babylonjs/core/Maths/math.vector.js";
+import { RawCubeTexture } from "@babylonjs/core/Materials/Textures/rawCubeTexture.js";
+import { GLTFLoader, ArrayItem } from "../glTFLoader";
+var NAME = "EXT_lights_image_based";
+/**
+ * [Specification](https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Vendor/EXT_lights_image_based/README.md)
+ */
+var EXT_lights_image_based = /** @class */ (function () {
+    /**
+     * @param loader
+     * @hidden
+     */
+    function EXT_lights_image_based(loader) {
+        /**
+         * The name of this extension.
+         */
+        this.name = NAME;
+        this._loader = loader;
+        this.enabled = this._loader.isExtensionUsed(NAME);
+    }
+    /** @hidden */
+    EXT_lights_image_based.prototype.dispose = function () {
+        this._loader = null;
+        delete this._lights;
+    };
+    /** @hidden */
+    EXT_lights_image_based.prototype.onLoading = function () {
+        var extensions = this._loader.gltf.extensions;
+        if (extensions && extensions[this.name]) {
+            var extension = extensions[this.name];
+            this._lights = extension.lights;
+        }
+    };
+    /**
+     * @param context
+     * @param scene
+     * @hidden
+     */
+    EXT_lights_image_based.prototype.loadSceneAsync = function (context, scene) {
+        var _this = this;
+        return GLTFLoader.LoadExtensionAsync(context, scene, this.name, function (extensionContext, extension) {
+            var promises = new Array();
+            promises.push(_this._loader.loadSceneAsync(context, scene));
+            _this._loader.logOpen("".concat(extensionContext));
+            var light = ArrayItem.Get("".concat(extensionContext, "/light"), _this._lights, extension.light);
+            promises.push(_this._loadLightAsync("/extensions/".concat(_this.name, "/lights/").concat(extension.light), light).then(function (texture) {
+                _this._loader.babylonScene.environmentTexture = texture;
+            }));
+            _this._loader.logClose();
+            return Promise.all(promises).then(function () { });
+        });
+    };
+    EXT_lights_image_based.prototype._loadLightAsync = function (context, light) {
+        var _this = this;
+        if (!light._loaded) {
+            var promises = new Array();
+            this._loader.logOpen("".concat(context));
+            var imageData_1 = new Array(light.specularImages.length);
+            var _loop_1 = function (mipmap) {
+                var faces = light.specularImages[mipmap];
+                imageData_1[mipmap] = new Array(faces.length);
+                var _loop_2 = function (face) {
+                    var specularImageContext = "".concat(context, "/specularImages/").concat(mipmap, "/").concat(face);
+                    this_1._loader.logOpen("".concat(specularImageContext));
+                    var index = faces[face];
+                    var image = ArrayItem.Get(specularImageContext, this_1._loader.gltf.images, index);
+                    promises.push(this_1._loader.loadImageAsync("/images/".concat(index), image).then(function (data) {
+                        imageData_1[mipmap][face] = data;
+                    }));
+                    this_1._loader.logClose();
+                };
+                for (var face = 0; face < faces.length; face++) {
+                    _loop_2(face);
+                }
+            };
+            var this_1 = this;
+            for (var mipmap = 0; mipmap < light.specularImages.length; mipmap++) {
+                _loop_1(mipmap);
+            }
+            this._loader.logClose();
+            light._loaded = Promise.all(promises).then(function () {
+                var babylonTexture = new RawCubeTexture(_this._loader.babylonScene, null, light.specularImageSize);
+                babylonTexture.name = light.name || "environment";
+                light._babylonTexture = babylonTexture;
+                if (light.intensity != undefined) {
+                    babylonTexture.level = light.intensity;
+                }
+                if (light.rotation) {
+                    var rotation = Quaternion.FromArray(light.rotation);
+                    // Invert the rotation so that positive rotation is counter-clockwise.
+                    if (!_this._loader.babylonScene.useRightHandedSystem) {
+                        rotation = Quaternion.Inverse(rotation);
+                    }
+                    Matrix.FromQuaternionToRef(rotation, babylonTexture.getReflectionTextureMatrix());
+                }
+                if (!light.irradianceCoefficients) {
+                    throw new Error("".concat(context, ": Irradiance coefficients are missing"));
+                }
+                var sphericalHarmonics = SphericalHarmonics.FromArray(light.irradianceCoefficients);
+                sphericalHarmonics.scaleInPlace(light.intensity);
+                sphericalHarmonics.convertIrradianceToLambertianRadiance();
+                var sphericalPolynomial = SphericalPolynomial.FromHarmonics(sphericalHarmonics);
+                // Compute the lod generation scale to fit exactly to the number of levels available.
+                var lodGenerationScale = (imageData_1.length - 1) / Scalar.Log2(light.specularImageSize);
+                return babylonTexture.updateRGBDAsync(imageData_1, sphericalPolynomial, lodGenerationScale);
+            });
+        }
+        return light._loaded.then(function () {
+            return light._babylonTexture;
+        });
+    };
+    return EXT_lights_image_based;
+}());
+export { EXT_lights_image_based };
+GLTFLoader.RegisterExtension(NAME, function (loader) { return new EXT_lights_image_based(loader); });
 //# sourceMappingURL=EXT_lights_image_based.js.map