@spiffcommerce/preview 3.6.2-rc.5 → 3.6.2-rc.7

package/dist/glbLoaderExtensions.esm.js

@@ -0,0 +1,690 @@
+import { _ as __awaiter } from './_tslib.esm.js';
+import { P as PBRMaterial } from './pbrMaterial.esm.js';
+import { M as Matrix, V as Vector3, b as Vector2, _ as __decorate, c as serializeAsMeshReference, d as serializeAsVector3, S as SerializationHelper } from './webRequest.esm.js';
+import { T as Texture, R as RenderTargetTexture } from './helperFunctions.esm.js';
+import { B as BlurPostProcess } from './blurPostProcess.esm.js';
+import { P as Plane, A as AbstractScene } from './engine.esm.js';
+import './math.axis.esm.js';
+import { a as Color3 } from './math.color.esm.js';
+import './math.path.esm.js';
+import { RenderingConfiguration, REFLECTION_PROBE_RESOLUTION } from './renderConstants.esm.js';
+import './hdrFilteringFunctions.esm.js';
+import './pbrBRDFFunctions.esm.js';
+import './material.esm2.js';
+import './node.esm.js';
+import './compatibilityOptions.esm.js';
+import './bumpVertex.esm.js';
+import './effectFallbacks.esm.js';
+import './math.size.esm.js';
+
+/**
+ * Mirror texture can be used to simulate the view from a mirror in a scene.
+ * It will dynamically be rendered every frame to adapt to the camera point of view.
+ * You can then easily use it as a reflectionTexture on a flat surface.
+ * In case the surface is not a plane, please consider relying on reflection probes.
+ * @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/reflectionTexture#mirrortexture
+ */
+class MirrorTexture extends RenderTargetTexture {
+    /**
+     * Define the blur ratio used to blur the reflection if needed.
+     */
+    set blurRatio(value) {
+        if (this._blurRatio === value) {
+            return;
+        }
+        this._blurRatio = value;
+        this._preparePostProcesses();
+    }
+    get blurRatio() {
+        return this._blurRatio;
+    }
+    /**
+     * Define the adaptive blur kernel used to blur the reflection if needed.
+     * This will autocompute the closest best match for the `blurKernel`
+     */
+    set adaptiveBlurKernel(value) {
+        this._adaptiveBlurKernel = value;
+        this._autoComputeBlurKernel();
+    }
+    /**
+     * Define the blur kernel used to blur the reflection if needed.
+     * Please consider using `adaptiveBlurKernel` as it could find the closest best value for you.
+     */
+    set blurKernel(value) {
+        this.blurKernelX = value;
+        this.blurKernelY = value;
+    }
+    /**
+     * Define the blur kernel on the X Axis used to blur the reflection if needed.
+     * Please consider using `adaptiveBlurKernel` as it could find the closest best value for you.
+     */
+    set blurKernelX(value) {
+        if (this._blurKernelX === value) {
+            return;
+        }
+        this._blurKernelX = value;
+        this._preparePostProcesses();
+    }
+    get blurKernelX() {
+        return this._blurKernelX;
+    }
+    /**
+     * Define the blur kernel on the Y Axis used to blur the reflection if needed.
+     * Please consider using `adaptiveBlurKernel` as it could find the closest best value for you.
+     */
+    set blurKernelY(value) {
+        if (this._blurKernelY === value) {
+            return;
+        }
+        this._blurKernelY = value;
+        this._preparePostProcesses();
+    }
+    get blurKernelY() {
+        return this._blurKernelY;
+    }
+    _autoComputeBlurKernel() {
+        const engine = this.getScene().getEngine();
+        const dw = this.getRenderWidth() / engine.getRenderWidth();
+        const dh = this.getRenderHeight() / engine.getRenderHeight();
+        this.blurKernelX = this._adaptiveBlurKernel * dw;
+        this.blurKernelY = this._adaptiveBlurKernel * dh;
+    }
+    _onRatioRescale() {
+        if (this._sizeRatio) {
+            this.resize(this._initialSizeParameter);
+            if (!this._adaptiveBlurKernel) {
+                this._preparePostProcesses();
+            }
+        }
+        if (this._adaptiveBlurKernel) {
+            this._autoComputeBlurKernel();
+        }
+    }
+    _updateGammaSpace() {
+        const scene = this.getScene();
+        if (!scene) {
+            return;
+        }
+        this.gammaSpace = !scene.imageProcessingConfiguration.isEnabled || !scene.imageProcessingConfiguration.applyByPostProcess;
+    }
+    /**
+     * Instantiates a Mirror Texture.
+     * Mirror texture can be used to simulate the view from a mirror in a scene.
+     * It will dynamically be rendered every frame to adapt to the camera point of view.
+     * You can then easily use it as a reflectionTexture on a flat surface.
+     * In case the surface is not a plane, please consider relying on reflection probes.
+     * @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/reflectionTexture#mirrors
+     * @param name
+     * @param size
+     * @param scene
+     * @param generateMipMaps
+     * @param type
+     * @param samplingMode
+     * @param generateDepthBuffer
+     */
+    constructor(name, size, scene, generateMipMaps, type = 0, samplingMode = Texture.BILINEAR_SAMPLINGMODE, generateDepthBuffer = true) {
+        super(name, size, scene, generateMipMaps, true, type, false, samplingMode, generateDepthBuffer);
+        /**
+         * Define the reflection plane we want to use. The mirrorPlane is usually set to the constructed reflector.
+         * It is possible to directly set the mirrorPlane by directly using a Plane(a, b, c, d) where a, b and c give the plane normal vector (a, b, c) and d is a scalar displacement from the mirrorPlane to the origin. However in all but the very simplest of situations it is more straight forward to set it to the reflector as stated in the doc.
+         * @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/reflectionTexture#mirrors
+         */
+        this.mirrorPlane = new Plane(0, 1, 0, 1);
+        this._transformMatrix = Matrix.Zero();
+        this._mirrorMatrix = Matrix.Zero();
+        this._adaptiveBlurKernel = 0;
+        this._blurKernelX = 0;
+        this._blurKernelY = 0;
+        this._blurRatio = 1.0;
+        scene = this.getScene();
+        if (!scene) {
+            return this;
+        }
+        this.ignoreCameraViewport = true;
+        this._updateGammaSpace();
+        this._imageProcessingConfigChangeObserver = scene.imageProcessingConfiguration.onUpdateParameters.add(() => {
+            this._updateGammaSpace();
+        });
+        const engine = scene.getEngine();
+        if (engine.supportsUniformBuffers) {
+            this._sceneUBO = scene.createSceneUniformBuffer(`Scene for Mirror Texture (name "${name}")`);
+        }
+        this.onBeforeBindObservable.add(() => {
+            var _a;
+            (_a = engine._debugPushGroup) === null || _a === void 0 ? void 0 : _a.call(engine, `mirror generation for ${name}`, 1);
+        });
+        this.onAfterUnbindObservable.add(() => {
+            var _a;
+            (_a = engine._debugPopGroup) === null || _a === void 0 ? void 0 : _a.call(engine, 1);
+        });
+        let saveClipPlane;
+        this.onBeforeRenderObservable.add(() => {
+            if (this._sceneUBO) {
+                this._currentSceneUBO = scene.getSceneUniformBuffer();
+                scene.setSceneUniformBuffer(this._sceneUBO);
+                scene.getSceneUniformBuffer().unbindEffect();
+            }
+            Matrix.ReflectionToRef(this.mirrorPlane, this._mirrorMatrix);
+            this._mirrorMatrix.multiplyToRef(scene.getViewMatrix(), this._transformMatrix);
+            scene.setTransformMatrix(this._transformMatrix, scene.getProjectionMatrix());
+            saveClipPlane = scene.clipPlane;
+            scene.clipPlane = this.mirrorPlane;
+            scene._mirroredCameraPosition = Vector3.TransformCoordinates(scene.activeCamera.globalPosition, this._mirrorMatrix);
+        });
+        this.onAfterRenderObservable.add(() => {
+            if (this._sceneUBO) {
+                scene.setSceneUniformBuffer(this._currentSceneUBO);
+            }
+            scene.updateTransformMatrix();
+            scene._mirroredCameraPosition = null;
+            scene.clipPlane = saveClipPlane;
+        });
+    }
+    _preparePostProcesses() {
+        this.clearPostProcesses(true);
+        if (this._blurKernelX && this._blurKernelY) {
+            const engine = this.getScene().getEngine();
+            const textureType = engine.getCaps().textureFloatRender && engine.getCaps().textureFloatLinearFiltering ? 1 : 2;
+            this._blurX = new BlurPostProcess("horizontal blur", new Vector2(1.0, 0), this._blurKernelX, this._blurRatio, null, Texture.BILINEAR_SAMPLINGMODE, engine, false, textureType);
+            this._blurX.autoClear = false;
+            if (this._blurRatio === 1 && this.samples < 2 && this._texture) {
+                this._blurX.inputTexture = this._renderTarget;
+            }
+            else {
+                this._blurX.alwaysForcePOT = true;
+            }
+            this._blurY = new BlurPostProcess("vertical blur", new Vector2(0, 1.0), this._blurKernelY, this._blurRatio, null, Texture.BILINEAR_SAMPLINGMODE, engine, false, textureType);
+            this._blurY.autoClear = false;
+            this._blurY.alwaysForcePOT = this._blurRatio !== 1;
+            this.addPostProcess(this._blurX);
+            this.addPostProcess(this._blurY);
+        }
+        else {
+            if (this._blurY) {
+                this.removePostProcess(this._blurY);
+                this._blurY.dispose();
+                this._blurY = null;
+            }
+            if (this._blurX) {
+                this.removePostProcess(this._blurX);
+                this._blurX.dispose();
+                this._blurX = null;
+            }
+        }
+    }
+    /**
+     * Clone the mirror texture.
+     * @returns the cloned texture
+     */
+    clone() {
+        const scene = this.getScene();
+        if (!scene) {
+            return this;
+        }
+        const textureSize = this.getSize();
+        const newTexture = new MirrorTexture(this.name, textureSize.width, scene, this._renderTargetOptions.generateMipMaps, this._renderTargetOptions.type, this._renderTargetOptions.samplingMode, this._renderTargetOptions.generateDepthBuffer);
+        // Base texture
+        newTexture.hasAlpha = this.hasAlpha;
+        newTexture.level = this.level;
+        // Mirror Texture
+        newTexture.mirrorPlane = this.mirrorPlane.clone();
+        if (this.renderList) {
+            newTexture.renderList = this.renderList.slice(0);
+        }
+        return newTexture;
+    }
+    /**
+     * Serialize the texture to a JSON representation you could use in Parse later on
+     * @returns the serialized JSON representation
+     */
+    serialize() {
+        if (!this.name) {
+            return null;
+        }
+        const serializationObject = super.serialize();
+        serializationObject.mirrorPlane = this.mirrorPlane.asArray();
+        return serializationObject;
+    }
+    /**
+     * Dispose the texture and release its associated resources.
+     */
+    dispose() {
+        var _a;
+        super.dispose();
+        const scene = this.getScene();
+        if (scene) {
+            scene.imageProcessingConfiguration.onUpdateParameters.remove(this._imageProcessingConfigChangeObserver);
+        }
+        (_a = this._sceneUBO) === null || _a === void 0 ? void 0 : _a.dispose();
+    }
+}
+Texture._CreateMirror = (name, renderTargetSize, scene, generateMipMaps) => {
+    return new MirrorTexture(name, renderTargetSize, scene, generateMipMaps);
+};
+
+AbstractScene.prototype.removeReflectionProbe = function (toRemove) {
+    if (!this.reflectionProbes) {
+        return -1;
+    }
+    const index = this.reflectionProbes.indexOf(toRemove);
+    if (index !== -1) {
+        this.reflectionProbes.splice(index, 1);
+    }
+    return index;
+};
+AbstractScene.prototype.addReflectionProbe = function (newReflectionProbe) {
+    if (!this.reflectionProbes) {
+        this.reflectionProbes = [];
+    }
+    this.reflectionProbes.push(newReflectionProbe);
+};
+/**
+ * Class used to generate realtime reflection / refraction cube textures
+ * @see https://doc.babylonjs.com/features/featuresDeepDive/environment/reflectionProbes
+ */
+class ReflectionProbe {
+    /**
+     * Creates a new reflection probe
+     * @param name defines the name of the probe
+     * @param size defines the texture resolution (for each face)
+     * @param scene defines the hosting scene
+     * @param generateMipMaps defines if mip maps should be generated automatically (true by default)
+     * @param useFloat defines if HDR data (float data) should be used to store colors (false by default)
+     * @param linearSpace defines if the probe should be generated in linear space or not (false by default)
+     */
+    constructor(
+    /** defines the name of the probe */
+    name, size, scene, generateMipMaps = true, useFloat = false, linearSpace = false) {
+        this.name = name;
+        this._viewMatrix = Matrix.Identity();
+        this._target = Vector3.Zero();
+        this._add = Vector3.Zero();
+        this._invertYAxis = false;
+        /** Gets or sets probe position (center of the cube map) */
+        this.position = Vector3.Zero();
+        /**
+         * Gets or sets an object used to store user defined information for the reflection probe.
+         */
+        this.metadata = null;
+        /** @internal */
+        this._parentContainer = null;
+        this._scene = scene;
+        if (scene.getEngine().supportsUniformBuffers) {
+            this._sceneUBOs = [];
+            for (let i = 0; i < 6; ++i) {
+                this._sceneUBOs.push(scene.createSceneUniformBuffer(`Scene for Reflection Probe (name "${name}") face #${i}`));
+            }
+        }
+        // Create the scene field if not exist.
+        if (!this._scene.reflectionProbes) {
+            this._scene.reflectionProbes = new Array();
+        }
+        this._scene.reflectionProbes.push(this);
+        let textureType = 0;
+        if (useFloat) {
+            const caps = this._scene.getEngine().getCaps();
+            if (caps.textureHalfFloatRender) {
+                textureType = 2;
+            }
+            else if (caps.textureFloatRender) {
+                textureType = 1;
+            }
+        }
+        this._renderTargetTexture = new RenderTargetTexture(name, size, scene, generateMipMaps, true, textureType, true);
+        this._renderTargetTexture.gammaSpace = !linearSpace;
+        this._renderTargetTexture.invertZ = scene.useRightHandedSystem;
+        const useReverseDepthBuffer = scene.getEngine().useReverseDepthBuffer;
+        this._renderTargetTexture.onBeforeRenderObservable.add((faceIndex) => {
+            if (this._sceneUBOs) {
+                scene.setSceneUniformBuffer(this._sceneUBOs[faceIndex]);
+                scene.getSceneUniformBuffer().unbindEffect();
+            }
+            switch (faceIndex) {
+                case 0:
+                    this._add.copyFromFloats(1, 0, 0);
+                    break;
+                case 1:
+                    this._add.copyFromFloats(-1, 0, 0);
+                    break;
+                case 2:
+                    this._add.copyFromFloats(0, this._invertYAxis ? 1 : -1, 0);
+                    break;
+                case 3:
+                    this._add.copyFromFloats(0, this._invertYAxis ? -1 : 1, 0);
+                    break;
+                case 4:
+                    this._add.copyFromFloats(0, 0, scene.useRightHandedSystem ? -1 : 1);
+                    break;
+                case 5:
+                    this._add.copyFromFloats(0, 0, scene.useRightHandedSystem ? 1 : -1);
+                    break;
+            }
+            if (this._attachedMesh) {
+                this.position.copyFrom(this._attachedMesh.getAbsolutePosition());
+            }
+            this.position.addToRef(this._add, this._target);
+            const lookAtFunction = scene.useRightHandedSystem ? Matrix.LookAtRHToRef : Matrix.LookAtLHToRef;
+            const perspectiveFunction = scene.useRightHandedSystem ? Matrix.PerspectiveFovRH : Matrix.PerspectiveFovLH;
+            lookAtFunction(this.position, this._target, Vector3.Up(), this._viewMatrix);
+            if (scene.activeCamera) {
+                this._projectionMatrix = perspectiveFunction(Math.PI / 2, 1, useReverseDepthBuffer ? scene.activeCamera.maxZ : scene.activeCamera.minZ, useReverseDepthBuffer ? scene.activeCamera.minZ : scene.activeCamera.maxZ, this._scene.getEngine().isNDCHalfZRange);
+                scene.setTransformMatrix(this._viewMatrix, this._projectionMatrix);
+                if (scene.activeCamera.isRigCamera && !this._renderTargetTexture.activeCamera) {
+                    this._renderTargetTexture.activeCamera = scene.activeCamera.rigParent || null;
+                }
+            }
+            scene._forcedViewPosition = this.position;
+        });
+        let currentApplyByPostProcess;
+        this._renderTargetTexture.onBeforeBindObservable.add(() => {
+            var _a, _b;
+            this._currentSceneUBO = scene.getSceneUniformBuffer();
+            (_b = (_a = scene.getEngine())._debugPushGroup) === null || _b === void 0 ? void 0 : _b.call(_a, `reflection probe generation for ${name}`, 1);
+            currentApplyByPostProcess = this._scene.imageProcessingConfiguration.applyByPostProcess;
+            if (linearSpace) {
+                scene.imageProcessingConfiguration.applyByPostProcess = true;
+            }
+        });
+        this._renderTargetTexture.onAfterUnbindObservable.add(() => {
+            var _a, _b;
+            scene.imageProcessingConfiguration.applyByPostProcess = currentApplyByPostProcess;
+            scene._forcedViewPosition = null;
+            if (this._sceneUBOs) {
+                scene.setSceneUniformBuffer(this._currentSceneUBO);
+            }
+            scene.updateTransformMatrix(true);
+            (_b = (_a = scene.getEngine())._debugPopGroup) === null || _b === void 0 ? void 0 : _b.call(_a, 1);
+        });
+    }
+    /** Gets or sets the number of samples to use for multi-sampling (0 by default). Required WebGL2 */
+    get samples() {
+        return this._renderTargetTexture.samples;
+    }
+    set samples(value) {
+        this._renderTargetTexture.samples = value;
+    }
+    /** Gets or sets the refresh rate to use (on every frame by default) */
+    get refreshRate() {
+        return this._renderTargetTexture.refreshRate;
+    }
+    set refreshRate(value) {
+        this._renderTargetTexture.refreshRate = value;
+    }
+    /**
+     * Gets the hosting scene
+     * @returns a Scene
+     */
+    getScene() {
+        return this._scene;
+    }
+    /** Gets the internal CubeTexture used to render to */
+    get cubeTexture() {
+        return this._renderTargetTexture;
+    }
+    /** Gets the list of meshes to render */
+    get renderList() {
+        return this._renderTargetTexture.renderList;
+    }
+    /**
+     * Attach the probe to a specific mesh (Rendering will be done from attached mesh's position)
+     * @param mesh defines the mesh to attach to
+     */
+    attachToMesh(mesh) {
+        this._attachedMesh = mesh;
+    }
+    /**
+     * Specifies whether or not the stencil and depth buffer are cleared between two rendering groups
+     * @param renderingGroupId The rendering group id corresponding to its index
+     * @param autoClearDepthStencil Automatically clears depth and stencil between groups if true.
+     */
+    setRenderingAutoClearDepthStencil(renderingGroupId, autoClearDepthStencil) {
+        this._renderTargetTexture.setRenderingAutoClearDepthStencil(renderingGroupId, autoClearDepthStencil);
+    }
+    /**
+     * Clean all associated resources
+     */
+    dispose() {
+        const index = this._scene.reflectionProbes.indexOf(this);
+        if (index !== -1) {
+            // Remove from the scene if found
+            this._scene.reflectionProbes.splice(index, 1);
+        }
+        if (this._parentContainer) {
+            const index = this._parentContainer.reflectionProbes.indexOf(this);
+            if (index > -1) {
+                this._parentContainer.reflectionProbes.splice(index, 1);
+            }
+            this._parentContainer = null;
+        }
+        if (this._renderTargetTexture) {
+            this._renderTargetTexture.dispose();
+            this._renderTargetTexture = null;
+        }
+        if (this._sceneUBOs) {
+            for (const ubo of this._sceneUBOs) {
+                ubo.dispose();
+            }
+            this._sceneUBOs = [];
+        }
+    }
+    /**
+     * Converts the reflection probe information to a readable string for debug purpose.
+     * @param fullDetails Supports for multiple levels of logging within scene loading
+     * @returns the human readable reflection probe info
+     */
+    toString(fullDetails) {
+        let ret = "Name: " + this.name;
+        if (fullDetails) {
+            ret += ", position: " + this.position.toString();
+            if (this._attachedMesh) {
+                ret += ", attached mesh: " + this._attachedMesh.name;
+            }
+        }
+        return ret;
+    }
+    /**
+     * Get the class name of the refection probe.
+     * @returns "ReflectionProbe"
+     */
+    getClassName() {
+        return "ReflectionProbe";
+    }
+    /**
+     * Serialize the reflection probe to a JSON representation we can easily use in the respective Parse function.
+     * @returns The JSON representation of the texture
+     */
+    serialize() {
+        const serializationObject = SerializationHelper.Serialize(this, this._renderTargetTexture.serialize());
+        serializationObject.isReflectionProbe = true;
+        serializationObject.metadata = this.metadata;
+        return serializationObject;
+    }
+    /**
+     * Parse the JSON representation of a reflection probe in order to recreate the reflection probe in the given scene.
+     * @param parsedReflectionProbe Define the JSON representation of the reflection probe
+     * @param scene Define the scene the parsed reflection probe should be instantiated in
+     * @param rootUrl Define the root url of the parsing sequence in the case of relative dependencies
+     * @returns The parsed reflection probe if successful
+     */
+    static Parse(parsedReflectionProbe, scene, rootUrl) {
+        let reflectionProbe = null;
+        if (scene.reflectionProbes) {
+            for (let index = 0; index < scene.reflectionProbes.length; index++) {
+                const rp = scene.reflectionProbes[index];
+                if (rp.name === parsedReflectionProbe.name) {
+                    reflectionProbe = rp;
+                    break;
+                }
+            }
+        }
+        reflectionProbe = SerializationHelper.Parse(() => reflectionProbe || new ReflectionProbe(parsedReflectionProbe.name, parsedReflectionProbe.renderTargetSize, scene, parsedReflectionProbe._generateMipMaps), parsedReflectionProbe, scene, rootUrl);
+        reflectionProbe.cubeTexture._waitingRenderList = parsedReflectionProbe.renderList;
+        if (parsedReflectionProbe._attachedMesh) {
+            reflectionProbe.attachToMesh(scene.getMeshById(parsedReflectionProbe._attachedMesh));
+        }
+        if (parsedReflectionProbe.metadata) {
+            reflectionProbe.metadata = parsedReflectionProbe.metadata;
+        }
+        return reflectionProbe;
+    }
+}
+__decorate([
+    serializeAsMeshReference()
+], ReflectionProbe.prototype, "_attachedMesh", void 0);
+__decorate([
+    serializeAsVector3()
+], ReflectionProbe.prototype, "position", void 0);
+
+/**
+ * We extend the GLTF loader with our own custom logic. This allows us to read nodes
+ * and materials as they load in and parse any additional metadata set in the glb file that
+ * babylon would ignore otherwise. eg. metadata set by Blender.
+ */
+class GLBLoaderExtension {
+    constructor(loader) {
+        this.name = 'glbPostProcessor';
+        this.enabled = true;
+        this.loader = loader;
+    }
+    onReady() {
+        this.applyReflections(this.loader.babylonScene);
+    }
+    /**
+     * Any custom properties set in blender on transform nodes will appear here. We can
+     * write the properties into the object metadata for retrieval at runtime.
+     */
+    loadNodeAsync(context, node, assign) {
+        return this.loader.loadNodeAsync(context, node, function (babylonMesh) {
+            node.extras &&
+                Object.keys(node.extras).forEach((key) => {
+                    const value = node.extras[key];
+                    babylonMesh.metadata[key] = value;
+                });
+            assign(babylonMesh);
+        });
+    }
+    /**
+     * Material properties can be set at load time as we don't depend
+     * on the entire scene graph being loaded (for reflection render lists).
+     * The need for these properties may go over time as the relevant exporters/importers are updated.
+     */
+    loadMaterialPropertiesAsync(context, material, babylonMaterial) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.loader.loadMaterialPropertiesAsync(context, material, babylonMaterial);
+            this.enableMaterialExtrasIfRequired(material, babylonMaterial);
+            babylonMaterial.needDepthPrePass = true;
+        });
+    }
+    dispose() {
+        // Nothing to dispose, we have to implement this however..
+    }
+    /**
+     * With a given material descriptor and babylon material instance, looks for any
+     * metadata defined on the descriptor and applies to the babylon material.
+     * @param material A material descriptor
+     * @param babylonMaterial An instance of a material representation in babylon.
+     */
+    enableMaterialExtrasIfRequired(material, babylonMaterial) {
+        if (!material.extras || !(babylonMaterial instanceof PBRMaterial)) {
+            return;
+        }
+        if (material.extras.sheen) {
+            const mat = babylonMaterial;
+            mat.sheen.isEnabled = true;
+            mat.sheen.intensity = material.extras.sheen;
+        }
+        if (material.extras.translucency) {
+            const mat = babylonMaterial;
+            mat.subSurface.isTranslucencyEnabled = true;
+            mat.subSurface.translucencyIntensity = material.extras.translucency;
+            if (material.extras.translucencyR &&
+                material.extras.translucencyG &&
+                material.extras.translucencyB) {
+                mat.subSurface.tintColor = new Color3(material.extras.translucencyR, material.extras.translucencyG, material.extras.translucencyB);
+            }
+        }
+        if (material.extras.refractionIOR) {
+            const mat = babylonMaterial;
+            mat.subSurface.isRefractionEnabled = true;
+            mat.subSurface.volumeIndexOfRefraction = material.extras.refractionIOR;
+        }
+        if (material.extras.useDepthPrePass) {
+            const mat = babylonMaterial;
+            mat.needDepthPrePass = true;
+            mat.forceIrradianceInFragment = true; // https://forum.babylonjs.com/t/rendering-artificats-on-safari-ios-14-pbrmaterial-depth-prepass-ibl/15670/5
+        }
+        if (material.extras.useParallax) {
+            const mat = babylonMaterial;
+            mat.useParallax = true;
+            mat.useParallaxOcclusion = true;
+            mat.parallaxScaleBias = material.extras.useParallax;
+        }
+    }
+    /**
+     * Called with a loaded scene. Will finish initialization
+     * of any reflective properties within the scene.
+     * @param scene The scene to parse.
+     */
+    applyReflections(scene) {
+        function getReflectiveMeshes(scene) {
+            const reflectiveMeshes = [];
+            scene.transformNodes.forEach((node) => {
+                if (node.metadata && node.metadata.reflective) {
+                    reflectiveMeshes.push(...node.getChildMeshes());
+                }
+            });
+            scene.meshes.forEach((mesh) => {
+                if (mesh.metadata &&
+                    mesh.metadata.reflective &&
+                    !reflectiveMeshes.includes(mesh)) {
+                    reflectiveMeshes.push(mesh);
+                }
+            });
+            return reflectiveMeshes;
+        }
+        function buildMirrorTexture(mesh, reflectivity = 1) {
+            const mat = mesh.material;
+            if (!mat) {
+                return;
+            }
+            // Create a new mirror texture
+            const mirrorTex = new MirrorTexture('mirror', RenderingConfiguration.getMirrorTextureResolution(), scene, true);
+            mirrorTex.renderList = getReflectiveMeshes(scene);
+            // Calculate reflectance plane for mirror based on target mesh transform
+            const targetVertices = mesh.getVerticesData('normal');
+            if (!targetVertices) {
+                throw new Error('Mirror attribute specified on: ' +
+                    mesh.name +
+                    'But no normals exist to generate a mirror from!');
+            }
+            mesh.computeWorldMatrix(true);
+            const worldMatrix = mesh.getWorldMatrix();
+            const normal = Vector3.TransformNormal(new Vector3(targetVertices[0], targetVertices[1], targetVertices[2]), worldMatrix).normalize();
+            const reflector = Plane.FromPositionAndNormal(mesh.position, normal.scale(-1));
+            mirrorTex.mirrorPlane = reflector;
+            mirrorTex.level = reflectivity;
+            mat.reflectionTexture = mirrorTex;
+        }
+        function buildReflectionProbe(mesh) {
+            const mat = mesh.material;
+            const probe = new ReflectionProbe('probe-' + mat.name, REFLECTION_PROBE_RESOLUTION, scene);
+            probe.attachToMesh(mesh);
+            probe.renderList && probe.renderList.push(...getReflectiveMeshes(scene));
+            mat.reflectionTexture = probe.cubeTexture;
+        }
+        scene.meshes.forEach((mesh) => {
+            const tags = mesh.metadata;
+            if (!tags) {
+                return;
+            }
+            if (tags.mirrorTexture) {
+                buildMirrorTexture(mesh, tags.mirrorTexture);
+            }
+            if (tags.reflectionProbe) {
+                buildReflectionProbe(mesh);
+            }
+        });
+    }
+}
+
+export { GLBLoaderExtension };