@babylonjs/loaders 5.0.0-rc.1 → 5.0.0-rc.10

package/glTF/2.0/Extensions/KHR_materials_transmission.js

@@ -1,278 +1,289 @@
-import { __assign } from "tslib";
-import { PBRMaterial } from "@babylonjs/core/Materials/PBR/pbrMaterial.js";
-import { GLTFLoader } from "../glTFLoader.js";
-import { RenderTargetTexture } from "@babylonjs/core/Materials/Textures/renderTargetTexture.js";
-import { Observable } from "@babylonjs/core/Misc/observable.js";
-import { Constants } from "@babylonjs/core/Engines/constants.js";
-import { Tools } from "@babylonjs/core/Misc/tools.js";
-/**
- * A class to handle setting up the rendering of opaque objects to be shown through transmissive objects.
- */
-var TransmissionHelper = /** @class */ (function () {
-    /**
-     * constructor
-     * @param options Defines the options we want to customize the helper
-     * @param scene The scene to add the material to
-     */
-    function TransmissionHelper(options, scene) {
-        var _this = this;
-        this._opaqueRenderTarget = null;
-        this._opaqueMeshesCache = [];
-        this._transparentMeshesCache = [];
-        this._materialObservers = {};
-        this._options = __assign(__assign({}, TransmissionHelper._getDefaultOptions()), options);
-        this._scene = scene;
-        this._scene._transmissionHelper = this;
-        this.onErrorObservable = new Observable();
-        this._scene.onDisposeObservable.addOnce(function (scene) {
-            _this.dispose();
-        });
-        this._parseScene();
-        this._setupRenderTargets();
-    }
-    /**
-     * Creates the default options for the helper.
-     */
-    TransmissionHelper._getDefaultOptions = function () {
-        return {
-            renderSize: 1024,
-            samples: 4,
-            lodGenerationScale: 1,
-            lodGenerationOffset: -4,
-            renderTargetTextureType: Constants.TEXTURETYPE_HALF_FLOAT,
-            generateMipmaps: true,
-        };
-    };
-    /**
-     * Updates the background according to the new options
-     * @param options
-     */
-    TransmissionHelper.prototype.updateOptions = function (options) {
-        var _this = this;
-        // First check if any options are actually being changed. If not, exit.
-        var newValues = Object.keys(options).filter(function (key) { return _this._options[key] !== options[key]; });
-        if (!newValues.length) {
-            return;
-        }
-        var newOptions = __assign(__assign({}, this._options), options);
-        var oldOptions = this._options;
-        this._options = newOptions;
-        // If size changes, recreate everything
-        if (newOptions.renderSize !== oldOptions.renderSize || newOptions.renderTargetTextureType !== oldOptions.renderTargetTextureType || newOptions.generateMipmaps !== oldOptions.generateMipmaps || !this._opaqueRenderTarget) {
-            this._setupRenderTargets();
-        }
-        else {
-            this._opaqueRenderTarget.samples = newOptions.samples;
-            this._opaqueRenderTarget.lodGenerationScale = newOptions.lodGenerationScale;
-            this._opaqueRenderTarget.lodGenerationOffset = newOptions.lodGenerationOffset;
-        }
-    };
-    TransmissionHelper.prototype.getOpaqueTarget = function () {
-        return this._opaqueRenderTarget;
-    };
-    TransmissionHelper.prototype.shouldRenderAsTransmission = function (material) {
-        if (!material) {
-            return false;
-        }
-        if (material instanceof PBRMaterial && (material.subSurface.isRefractionEnabled)) {
-            return true;
-        }
-        return false;
-    };
-    TransmissionHelper.prototype._addMesh = function (mesh) {
-        var _this = this;
-        this._materialObservers[mesh.uniqueId] = mesh.onMaterialChangedObservable.add(this._onMeshMaterialChanged.bind(this));
-        // we need to defer the processing because _addMesh may be called as part as an instance mesh creation, in which case some
-        // internal properties are not setup yet, like _sourceMesh (needed when doing mesh.material below)
-        Tools.SetImmediate(function () {
-            if (_this.shouldRenderAsTransmission(mesh.material)) {
-                mesh.material.refractionTexture = _this._opaqueRenderTarget;
-                _this._transparentMeshesCache.push(mesh);
-            }
-            else {
-                _this._opaqueMeshesCache.push(mesh);
-            }
-        });
-    };
-    TransmissionHelper.prototype._removeMesh = function (mesh) {
-        mesh.onMaterialChangedObservable.remove(this._materialObservers[mesh.uniqueId]);
-        delete this._materialObservers[mesh.uniqueId];
-        var idx = this._transparentMeshesCache.indexOf(mesh);
-        if (idx !== -1) {
-            this._transparentMeshesCache.splice(idx, 1);
-        }
-        idx = this._opaqueMeshesCache.indexOf(mesh);
-        if (idx !== -1) {
-            this._opaqueMeshesCache.splice(idx, 1);
-        }
-    };
-    TransmissionHelper.prototype._parseScene = function () {
-        this._scene.meshes.forEach(this._addMesh.bind(this));
-        // Listen for when a mesh is added to the scene and add it to our cache lists.
-        this._scene.onNewMeshAddedObservable.add(this._addMesh.bind(this));
-        // Listen for when a mesh is removed from to the scene and remove it from our cache lists.
-        this._scene.onMeshRemovedObservable.add(this._removeMesh.bind(this));
-    };
-    // When one of the meshes in the scene has its material changed, make sure that it's in the correct cache list.
-    TransmissionHelper.prototype._onMeshMaterialChanged = function (mesh) {
-        var transparentIdx = this._transparentMeshesCache.indexOf(mesh);
-        var opaqueIdx = this._opaqueMeshesCache.indexOf(mesh);
-        // If the material is transparent, make sure that it's added to the transparent list and removed from the opaque list
-        var useTransmission = this.shouldRenderAsTransmission(mesh.material);
-        if (useTransmission) {
-            if (mesh.material instanceof PBRMaterial) {
-                mesh.material.subSurface.refractionTexture = this._opaqueRenderTarget;
-            }
-            if (opaqueIdx !== -1) {
-                this._opaqueMeshesCache.splice(opaqueIdx, 1);
-                this._transparentMeshesCache.push(mesh);
-            }
-            else if (transparentIdx === -1) {
-                this._transparentMeshesCache.push(mesh);
-            }
-            // If the material is opaque, make sure that it's added to the opaque list and removed from the transparent list
-        }
-        else {
-            if (transparentIdx !== -1) {
-                this._transparentMeshesCache.splice(transparentIdx, 1);
-                this._opaqueMeshesCache.push(mesh);
-            }
-            else if (opaqueIdx === -1) {
-                this._opaqueMeshesCache.push(mesh);
-            }
-        }
-    };
-    /**
-     * Setup the render targets according to the specified options.
-     */
-    TransmissionHelper.prototype._setupRenderTargets = function () {
-        var _this = this;
-        var _a, _b;
-        if (this._opaqueRenderTarget) {
-            this._opaqueRenderTarget.dispose();
-        }
-        this._opaqueRenderTarget = new RenderTargetTexture("opaqueSceneTexture", this._options.renderSize, this._scene, this._options.generateMipmaps, undefined, this._options.renderTargetTextureType);
-        this._opaqueRenderTarget.ignoreCameraViewport = true;
-        this._opaqueRenderTarget.renderList = this._opaqueMeshesCache;
-        this._opaqueRenderTarget.clearColor = (_b = (_a = this._options.clearColor) === null || _a === void 0 ? void 0 : _a.clone()) !== null && _b !== void 0 ? _b : this._scene.clearColor.clone();
-        this._opaqueRenderTarget.gammaSpace = false;
-        this._opaqueRenderTarget.lodGenerationScale = this._options.lodGenerationScale;
-        this._opaqueRenderTarget.lodGenerationOffset = this._options.lodGenerationOffset;
-        this._opaqueRenderTarget.samples = this._options.samples;
-        var sceneImageProcessingapplyByPostProcess;
-        var saveSceneEnvIntensity;
-        this._opaqueRenderTarget.onBeforeBindObservable.add(function (opaqueRenderTarget) {
-            saveSceneEnvIntensity = _this._scene.environmentIntensity;
-            _this._scene.environmentIntensity = 1.0;
-            sceneImageProcessingapplyByPostProcess = _this._scene.imageProcessingConfiguration.applyByPostProcess;
-            if (!_this._options.clearColor) {
-                _this._scene.clearColor.toLinearSpaceToRef(opaqueRenderTarget.clearColor);
-            }
-            else {
-                opaqueRenderTarget.clearColor.copyFrom(_this._options.clearColor);
-            }
-            // we do not use the applyByPostProcess setter to avoid flagging all the materials as "image processing dirty"!
-            _this._scene.imageProcessingConfiguration._applyByPostProcess = true;
-        });
-        this._opaqueRenderTarget.onAfterUnbindObservable.add(function () {
-            _this._scene.environmentIntensity = saveSceneEnvIntensity;
-            _this._scene.imageProcessingConfiguration._applyByPostProcess = sceneImageProcessingapplyByPostProcess;
-        });
-        this._transparentMeshesCache.forEach(function (mesh) {
-            if (_this.shouldRenderAsTransmission(mesh.material)) {
-                mesh.material.refractionTexture = _this._opaqueRenderTarget;
-            }
-        });
-    };
-    /**
-     * Dispose all the elements created by the Helper.
-     */
-    TransmissionHelper.prototype.dispose = function () {
-        this._scene._transmissionHelper = undefined;
-        if (this._opaqueRenderTarget) {
-            this._opaqueRenderTarget.dispose();
-            this._opaqueRenderTarget = null;
-        }
-        this._transparentMeshesCache = [];
-        this._opaqueMeshesCache = [];
-    };
-    return TransmissionHelper;
-}());
-var NAME = "KHR_materials_transmission";
-/**
- * [Specification](https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_materials_transmission/README.md)
- */
-var KHR_materials_transmission = /** @class */ (function () {
-    /** @hidden */
-    function KHR_materials_transmission(loader) {
-        /**
-         * The name of this extension.
-         */
-        this.name = NAME;
-        /**
-         * Defines a number that determines the order the extensions are applied.
-         */
-        this.order = 175;
-        this._loader = loader;
-        this.enabled = this._loader.isExtensionUsed(NAME);
-        if (this.enabled) {
-            loader.parent.transparencyAsCoverage = true;
-        }
-    }
-    /** @hidden */
-    KHR_materials_transmission.prototype.dispose = function () {
-        this._loader = null;
-    };
-    /** @hidden */
-    KHR_materials_transmission.prototype.loadMaterialPropertiesAsync = function (context, material, babylonMaterial) {
-        var _this = this;
-        return GLTFLoader.LoadExtensionAsync(context, material, this.name, function (extensionContext, extension) {
-            var promises = new Array();
-            promises.push(_this._loader.loadMaterialBasePropertiesAsync(context, material, babylonMaterial));
-            promises.push(_this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));
-            promises.push(_this._loadTransparentPropertiesAsync(extensionContext, material, babylonMaterial, extension));
-            return Promise.all(promises).then(function () { });
-        });
-    };
-    KHR_materials_transmission.prototype._loadTransparentPropertiesAsync = function (context, material, babylonMaterial, extension) {
-        if (!(babylonMaterial instanceof PBRMaterial)) {
-            throw new Error("".concat(context, ": Material type not supported"));
-        }
-        var pbrMaterial = babylonMaterial;
-        // Enables "refraction" texture which represents transmitted light.
-        pbrMaterial.subSurface.isRefractionEnabled = true;
-        // Since this extension models thin-surface transmission only, we must make IOR = 1.0
-        pbrMaterial.subSurface.volumeIndexOfRefraction = 1.0;
-        // Albedo colour will tint transmission.
-        pbrMaterial.subSurface.useAlbedoToTintRefraction = true;
-        if (extension.transmissionFactor !== undefined) {
-            pbrMaterial.subSurface.refractionIntensity = extension.transmissionFactor;
-            var scene = pbrMaterial.getScene();
-            if (pbrMaterial.subSurface.refractionIntensity && !scene._transmissionHelper) {
-                new TransmissionHelper({}, pbrMaterial.getScene());
-            }
-        }
-        else {
-            pbrMaterial.subSurface.refractionIntensity = 0.0;
-            pbrMaterial.subSurface.isRefractionEnabled = false;
-            return Promise.resolve();
-        }
-        pbrMaterial.subSurface.minimumThickness = 0.0;
-        pbrMaterial.subSurface.maximumThickness = 0.0;
-        if (extension.transmissionTexture) {
-            extension.transmissionTexture.nonColorData = true;
-            return this._loader.loadTextureInfoAsync("".concat(context, "/transmissionTexture"), extension.transmissionTexture, undefined)
-                .then(function (texture) {
-                pbrMaterial.subSurface.refractionIntensityTexture = texture;
-                pbrMaterial.subSurface.useGltfStyleTextures = true;
-            });
-        }
-        else {
-            return Promise.resolve();
-        }
-    };
-    return KHR_materials_transmission;
-}());
-export { KHR_materials_transmission };
-GLTFLoader.RegisterExtension(NAME, function (loader) { return new KHR_materials_transmission(loader); });
+import { __assign } from "tslib";
+import { PBRMaterial } from "@babylonjs/core/Materials/PBR/pbrMaterial.js";
+import { GLTFLoader } from "../glTFLoader";
+import { RenderTargetTexture } from "@babylonjs/core/Materials/Textures/renderTargetTexture.js";
+import { Observable } from "@babylonjs/core/Misc/observable.js";
+import { Constants } from "@babylonjs/core/Engines/constants.js";
+import { Tools } from "@babylonjs/core/Misc/tools.js";
+/**
+ * A class to handle setting up the rendering of opaque objects to be shown through transmissive objects.
+ */
+var TransmissionHelper = /** @class */ (function () {
+    /**
+     * constructor
+     * @param options Defines the options we want to customize the helper
+     * @param scene The scene to add the material to
+     */
+    function TransmissionHelper(options, scene) {
+        var _this = this;
+        this._opaqueRenderTarget = null;
+        this._opaqueMeshesCache = [];
+        this._transparentMeshesCache = [];
+        this._materialObservers = {};
+        this._options = __assign(__assign({}, TransmissionHelper._GetDefaultOptions()), options);
+        this._scene = scene;
+        this._scene._transmissionHelper = this;
+        this.onErrorObservable = new Observable();
+        this._scene.onDisposeObservable.addOnce(function () {
+            _this.dispose();
+        });
+        this._parseScene();
+        this._setupRenderTargets();
+    }
+    /**
+     * Creates the default options for the helper.
+     */
+    TransmissionHelper._GetDefaultOptions = function () {
+        return {
+            renderSize: 1024,
+            samples: 4,
+            lodGenerationScale: 1,
+            lodGenerationOffset: -4,
+            renderTargetTextureType: Constants.TEXTURETYPE_HALF_FLOAT,
+            generateMipmaps: true,
+        };
+    };
+    /**
+     * Updates the background according to the new options
+     * @param options
+     */
+    TransmissionHelper.prototype.updateOptions = function (options) {
+        var _this = this;
+        // First check if any options are actually being changed. If not, exit.
+        var newValues = Object.keys(options).filter(function (key) { return _this._options[key] !== options[key]; });
+        if (!newValues.length) {
+            return;
+        }
+        var newOptions = __assign(__assign({}, this._options), options);
+        var oldOptions = this._options;
+        this._options = newOptions;
+        // If size changes, recreate everything
+        if (newOptions.renderSize !== oldOptions.renderSize ||
+            newOptions.renderTargetTextureType !== oldOptions.renderTargetTextureType ||
+            newOptions.generateMipmaps !== oldOptions.generateMipmaps ||
+            !this._opaqueRenderTarget) {
+            this._setupRenderTargets();
+        }
+        else {
+            this._opaqueRenderTarget.samples = newOptions.samples;
+            this._opaqueRenderTarget.lodGenerationScale = newOptions.lodGenerationScale;
+            this._opaqueRenderTarget.lodGenerationOffset = newOptions.lodGenerationOffset;
+        }
+    };
+    TransmissionHelper.prototype.getOpaqueTarget = function () {
+        return this._opaqueRenderTarget;
+    };
+    TransmissionHelper.prototype._shouldRenderAsTransmission = function (material) {
+        if (!material) {
+            return false;
+        }
+        if (material instanceof PBRMaterial && material.subSurface.isRefractionEnabled) {
+            return true;
+        }
+        return false;
+    };
+    TransmissionHelper.prototype._addMesh = function (mesh) {
+        var _this = this;
+        this._materialObservers[mesh.uniqueId] = mesh.onMaterialChangedObservable.add(this._onMeshMaterialChanged.bind(this));
+        // we need to defer the processing because _addMesh may be called as part as an instance mesh creation, in which case some
+        // internal properties are not setup yet, like _sourceMesh (needed when doing mesh.material below)
+        Tools.SetImmediate(function () {
+            if (_this._shouldRenderAsTransmission(mesh.material)) {
+                mesh.material.refractionTexture = _this._opaqueRenderTarget;
+                _this._transparentMeshesCache.push(mesh);
+            }
+            else {
+                _this._opaqueMeshesCache.push(mesh);
+            }
+        });
+    };
+    TransmissionHelper.prototype._removeMesh = function (mesh) {
+        mesh.onMaterialChangedObservable.remove(this._materialObservers[mesh.uniqueId]);
+        delete this._materialObservers[mesh.uniqueId];
+        var idx = this._transparentMeshesCache.indexOf(mesh);
+        if (idx !== -1) {
+            this._transparentMeshesCache.splice(idx, 1);
+        }
+        idx = this._opaqueMeshesCache.indexOf(mesh);
+        if (idx !== -1) {
+            this._opaqueMeshesCache.splice(idx, 1);
+        }
+    };
+    TransmissionHelper.prototype._parseScene = function () {
+        this._scene.meshes.forEach(this._addMesh.bind(this));
+        // Listen for when a mesh is added to the scene and add it to our cache lists.
+        this._scene.onNewMeshAddedObservable.add(this._addMesh.bind(this));
+        // Listen for when a mesh is removed from to the scene and remove it from our cache lists.
+        this._scene.onMeshRemovedObservable.add(this._removeMesh.bind(this));
+    };
+    // When one of the meshes in the scene has its material changed, make sure that it's in the correct cache list.
+    TransmissionHelper.prototype._onMeshMaterialChanged = function (mesh) {
+        var transparentIdx = this._transparentMeshesCache.indexOf(mesh);
+        var opaqueIdx = this._opaqueMeshesCache.indexOf(mesh);
+        // If the material is transparent, make sure that it's added to the transparent list and removed from the opaque list
+        var useTransmission = this._shouldRenderAsTransmission(mesh.material);
+        if (useTransmission) {
+            if (mesh.material instanceof PBRMaterial) {
+                mesh.material.subSurface.refractionTexture = this._opaqueRenderTarget;
+            }
+            if (opaqueIdx !== -1) {
+                this._opaqueMeshesCache.splice(opaqueIdx, 1);
+                this._transparentMeshesCache.push(mesh);
+            }
+            else if (transparentIdx === -1) {
+                this._transparentMeshesCache.push(mesh);
+            }
+            // If the material is opaque, make sure that it's added to the opaque list and removed from the transparent list
+        }
+        else {
+            if (transparentIdx !== -1) {
+                this._transparentMeshesCache.splice(transparentIdx, 1);
+                this._opaqueMeshesCache.push(mesh);
+            }
+            else if (opaqueIdx === -1) {
+                this._opaqueMeshesCache.push(mesh);
+            }
+        }
+    };
+    /**
+     * Setup the render targets according to the specified options.
+     */
+    TransmissionHelper.prototype._setupRenderTargets = function () {
+        var _this = this;
+        var _a, _b;
+        if (this._opaqueRenderTarget) {
+            this._opaqueRenderTarget.dispose();
+        }
+        this._opaqueRenderTarget = new RenderTargetTexture("opaqueSceneTexture", this._options.renderSize, this._scene, this._options.generateMipmaps, undefined, this._options.renderTargetTextureType);
+        this._opaqueRenderTarget.ignoreCameraViewport = true;
+        this._opaqueRenderTarget.renderList = this._opaqueMeshesCache;
+        this._opaqueRenderTarget.clearColor = (_b = (_a = this._options.clearColor) === null || _a === void 0 ? void 0 : _a.clone()) !== null && _b !== void 0 ? _b : this._scene.clearColor.clone();
+        this._opaqueRenderTarget.gammaSpace = false;
+        this._opaqueRenderTarget.lodGenerationScale = this._options.lodGenerationScale;
+        this._opaqueRenderTarget.lodGenerationOffset = this._options.lodGenerationOffset;
+        this._opaqueRenderTarget.samples = this._options.samples;
+        var sceneImageProcessingapplyByPostProcess;
+        var saveSceneEnvIntensity;
+        this._opaqueRenderTarget.onBeforeBindObservable.add(function (opaqueRenderTarget) {
+            saveSceneEnvIntensity = _this._scene.environmentIntensity;
+            _this._scene.environmentIntensity = 1.0;
+            sceneImageProcessingapplyByPostProcess = _this._scene.imageProcessingConfiguration.applyByPostProcess;
+            if (!_this._options.clearColor) {
+                _this._scene.clearColor.toLinearSpaceToRef(opaqueRenderTarget.clearColor);
+            }
+            else {
+                opaqueRenderTarget.clearColor.copyFrom(_this._options.clearColor);
+            }
+            // we do not use the applyByPostProcess setter to avoid flagging all the materials as "image processing dirty"!
+            _this._scene.imageProcessingConfiguration._applyByPostProcess = true;
+        });
+        this._opaqueRenderTarget.onAfterUnbindObservable.add(function () {
+            _this._scene.environmentIntensity = saveSceneEnvIntensity;
+            _this._scene.imageProcessingConfiguration._applyByPostProcess = sceneImageProcessingapplyByPostProcess;
+        });
+        this._transparentMeshesCache.forEach(function (mesh) {
+            if (_this._shouldRenderAsTransmission(mesh.material)) {
+                mesh.material.refractionTexture = _this._opaqueRenderTarget;
+            }
+        });
+    };
+    /**
+     * Dispose all the elements created by the Helper.
+     */
+    TransmissionHelper.prototype.dispose = function () {
+        this._scene._transmissionHelper = undefined;
+        if (this._opaqueRenderTarget) {
+            this._opaqueRenderTarget.dispose();
+            this._opaqueRenderTarget = null;
+        }
+        this._transparentMeshesCache = [];
+        this._opaqueMeshesCache = [];
+    };
+    return TransmissionHelper;
+}());
+var NAME = "KHR_materials_transmission";
+/**
+ * [Specification](https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_materials_transmission/README.md)
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+var KHR_materials_transmission = /** @class */ (function () {
+    /**
+     * @param loader
+     * @hidden
+     */
+    function KHR_materials_transmission(loader) {
+        /**
+         * The name of this extension.
+         */
+        this.name = NAME;
+        /**
+         * Defines a number that determines the order the extensions are applied.
+         */
+        this.order = 175;
+        this._loader = loader;
+        this.enabled = this._loader.isExtensionUsed(NAME);
+        if (this.enabled) {
+            loader.parent.transparencyAsCoverage = true;
+        }
+    }
+    /** @hidden */
+    KHR_materials_transmission.prototype.dispose = function () {
+        this._loader = null;
+    };
+    /**
+     * @param context
+     * @param material
+     * @param babylonMaterial
+     * @hidden
+     */
+    KHR_materials_transmission.prototype.loadMaterialPropertiesAsync = function (context, material, babylonMaterial) {
+        var _this = this;
+        return GLTFLoader.LoadExtensionAsync(context, material, this.name, function (extensionContext, extension) {
+            var promises = new Array();
+            promises.push(_this._loader.loadMaterialBasePropertiesAsync(context, material, babylonMaterial));
+            promises.push(_this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));
+            promises.push(_this._loadTransparentPropertiesAsync(extensionContext, material, babylonMaterial, extension));
+            return Promise.all(promises).then(function () { });
+        });
+    };
+    KHR_materials_transmission.prototype._loadTransparentPropertiesAsync = function (context, material, babylonMaterial, extension) {
+        if (!(babylonMaterial instanceof PBRMaterial)) {
+            throw new Error("".concat(context, ": Material type not supported"));
+        }
+        var pbrMaterial = babylonMaterial;
+        // Enables "refraction" texture which represents transmitted light.
+        pbrMaterial.subSurface.isRefractionEnabled = true;
+        // Since this extension models thin-surface transmission only, we must make IOR = 1.0
+        pbrMaterial.subSurface.volumeIndexOfRefraction = 1.0;
+        // Albedo colour will tint transmission.
+        pbrMaterial.subSurface.useAlbedoToTintRefraction = true;
+        if (extension.transmissionFactor !== undefined) {
+            pbrMaterial.subSurface.refractionIntensity = extension.transmissionFactor;
+            var scene = pbrMaterial.getScene();
+            if (pbrMaterial.subSurface.refractionIntensity && !scene._transmissionHelper) {
+                new TransmissionHelper({}, pbrMaterial.getScene());
+            }
+        }
+        else {
+            pbrMaterial.subSurface.refractionIntensity = 0.0;
+            pbrMaterial.subSurface.isRefractionEnabled = false;
+            return Promise.resolve();
+        }
+        pbrMaterial.subSurface.minimumThickness = 0.0;
+        pbrMaterial.subSurface.maximumThickness = 0.0;
+        if (extension.transmissionTexture) {
+            extension.transmissionTexture.nonColorData = true;
+            return this._loader.loadTextureInfoAsync("".concat(context, "/transmissionTexture"), extension.transmissionTexture, undefined).then(function (texture) {
+                pbrMaterial.subSurface.refractionIntensityTexture = texture;
+                pbrMaterial.subSurface.useGltfStyleTextures = true;
+            });
+        }
+        else {
+            return Promise.resolve();
+        }
+    };
+    return KHR_materials_transmission;
+}());
+export { KHR_materials_transmission };
+GLTFLoader.RegisterExtension(NAME, function (loader) { return new KHR_materials_transmission(loader); });
 //# sourceMappingURL=KHR_materials_transmission.js.map