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

package/dist/dynamicTexture.esm.js

@@ -0,0 +1,105 @@
+import { E as Engine } from './engine.esm.js';
+import { P as PBRMaterial } from './pbrMaterial.esm.js';
+import { D as DynamicTexture } from './dynamicTexture.esm2.js';
+import { T as Texture } from './helperFunctions.esm.js';
+import { RenderingConfiguration } from './renderConstants.esm.js';
+import './webRequest.esm.js';
+import './math.color.esm.js';
+import './hdrFilteringFunctions.esm.js';
+import './pbrBRDFFunctions.esm.js';
+import './math.axis.esm.js';
+import './math.path.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';
+
+/**
+ * Iterates through the given panels and
+ * attaches a dynamic texture to the relevant material in the array. This allows changes
+ * on the panel to be represented on a 3D model.
+ * @param materials The materials to search for the relevant material in. Supply scene.materials if you want to search all materials.
+ * @param scene The scene to search for materials in.
+ * @param renderableContexts A list of canvas panels associated to the current workflow.
+ * @param existingTextures Any generated textures will be stored in this map against the panel name they relate to.
+ * @param materialPrefix An optional prefix to apply to the material name when searching for the relevant material.
+ * Materials attached to a ModelContainer should all be prefixed with the id of the container.
+ */
+function attachDynamicTextures(materials, scene, renderableContexts, existingTextures, materialPrefix = '') {
+    renderableContexts.forEach((context) => {
+        const contextID = context.getID();
+        const contextName = context.getName();
+        const renderDims = RenderingConfiguration.getDynamicTextureResolution();
+        // Find any materials in the supplied array with the name of
+        // this layout and are included in our filter if one is provided.
+        const targetMaterials = materials.filter((mat) => {
+            return mat.name === materialPrefix + contextName;
+        });
+        targetMaterials.forEach((mat) => {
+            const curDynamicTexture = existingTextures.get(contextID);
+            const invertYAxis = false;
+            if (!curDynamicTexture) {
+                const newTexture = createDynamicTexture(contextName, scene, renderDims.width, renderDims.height);
+                existingTextures.set(contextID, newTexture);
+                context.setStaticContext(newTexture.getContext());
+                applyDynamicTexture(mat, newTexture);
+                newTexture.onLoadObservable.addOnce(() => {
+                    newTexture.update(invertYAxis);
+                });
+            }
+            else {
+                applyDynamicTexture(mat, curDynamicTexture);
+                curDynamicTexture.update(invertYAxis);
+            }
+        });
+    });
+}
+/**
+ * Construct a new dynamic texture to listen for changes to a panel.
+ * @param scene The screen the resource will be associated to.
+ * @param layoutKey The key for the layout this dynamic texture relates to.
+ * @param RenderableContextService The canvas service, used to pull the layout with the given key.
+ */
+function createDynamicTexture(name, scene, width, height) {
+    const dynamicTex = new DynamicTexture(name, { width, height }, scene, RenderingConfiguration.shouldMipMap(), Texture.TRILINEAR_SAMPLINGMODE, Engine.TEXTUREFORMAT_RGBA);
+    const ctx = dynamicTex.getContext();
+    if (ctx) {
+        ctx.fillStyle = '#f5f5f5';
+        ctx.fillRect(0, 0, width, height);
+        dynamicTex.update();
+    }
+    return dynamicTex;
+}
+/**
+ * Applies a given dynamic texture to a target material.
+ * @param mat The material to apply to.
+ * @param dynamicTexture The dynamic texture we want to apply.
+ */
+function applyDynamicTexture(mat, dynamicTexture) {
+    if (mat instanceof PBRMaterial) {
+        const pbrMat = mat;
+        const albedoTexture = pbrMat.albedoTexture;
+        if (albedoTexture) {
+            dynamicTexture.wrapU = albedoTexture.wrapU;
+            dynamicTexture.wrapV = albedoTexture.wrapV;
+        }
+        else {
+            dynamicTexture.wrapU = 1;
+            dynamicTexture.wrapV = 1;
+        }
+        pbrMat.albedoTexture = dynamicTexture;
+    }
+    else {
+        const standardMat = mat;
+        const diffuseTexture = standardMat.diffuseTexture;
+        if (diffuseTexture) {
+            dynamicTexture.wrapU = diffuseTexture.wrapU;
+            dynamicTexture.wrapV = diffuseTexture.wrapV;
+        }
+        standardMat.diffuseTexture = dynamicTexture;
+    }
+}
+
+export { attachDynamicTextures };

package/dist/easing.esm.js

@@ -0,0 +1,130 @@
+import './math.path.esm.js';
+
+/**
+ * Base class used for every default easing function.
+ * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#easing-functions
+ */
+class EasingFunction {
+    constructor() {
+        this._easingMode = EasingFunction.EASINGMODE_EASEIN;
+    }
+    /**
+     * Sets the easing mode of the current function.
+     * @param easingMode Defines the willing mode (EASINGMODE_EASEIN, EASINGMODE_EASEOUT or EASINGMODE_EASEINOUT)
+     */
+    setEasingMode(easingMode) {
+        const n = Math.min(Math.max(easingMode, 0), 2);
+        this._easingMode = n;
+    }
+    /**
+     * Gets the current easing mode.
+     * @returns the easing mode
+     */
+    getEasingMode() {
+        return this._easingMode;
+    }
+    /**
+     * @internal
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    easeInCore(gradient) {
+        throw new Error("You must implement this method");
+    }
+    /**
+     * Given an input gradient between 0 and 1, this returns the corresponding value
+     * of the easing function.
+     * @param gradient Defines the value between 0 and 1 we want the easing value for
+     * @returns the corresponding value on the curve defined by the easing function
+     */
+    ease(gradient) {
+        switch (this._easingMode) {
+            case EasingFunction.EASINGMODE_EASEIN:
+                return this.easeInCore(gradient);
+            case EasingFunction.EASINGMODE_EASEOUT:
+                return 1 - this.easeInCore(1 - gradient);
+        }
+        if (gradient >= 0.5) {
+            return (1 - this.easeInCore((1 - gradient) * 2)) * 0.5 + 0.5;
+        }
+        return this.easeInCore(gradient * 2) * 0.5;
+    }
+}
+/**
+ * Interpolation follows the mathematical formula associated with the easing function.
+ */
+EasingFunction.EASINGMODE_EASEIN = 0;
+/**
+ * Interpolation follows 100% interpolation minus the output of the formula associated with the easing function.
+ */
+EasingFunction.EASINGMODE_EASEOUT = 1;
+/**
+ * Interpolation uses EaseIn for the first half of the animation and EaseOut for the second half.
+ */
+EasingFunction.EASINGMODE_EASEINOUT = 2;
+/**
+ * Easing function with a ease back shape (see link below).
+ * @see https://easings.net/#easeInBack
+ * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#easing-functions
+ */
+class BackEase extends EasingFunction {
+    /**
+     * Instantiates a back ease easing
+     * @see https://easings.net/#easeInBack
+     * @param amplitude Defines the amplitude of the function
+     */
+    constructor(
+    /** Defines the amplitude of the function */
+    amplitude = 1) {
+        super();
+        this.amplitude = amplitude;
+    }
+    /**
+     * @internal
+     */
+    easeInCore(gradient) {
+        const num = Math.max(0, this.amplitude);
+        return Math.pow(gradient, 3.0) - gradient * num * Math.sin(3.1415926535897931 * gradient);
+    }
+}
+/**
+ * Easing function with an exponential shape (see link below).
+ * @see https://easings.net/#easeInExpo
+ * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#easing-functions
+ */
+class ExponentialEase extends EasingFunction {
+    /**
+     * Instantiates an exponential easing function
+     * @see https://easings.net/#easeInExpo
+     * @param exponent Defines the exponent of the function
+     */
+    constructor(
+    /** Defines the exponent of the function */
+    exponent = 2) {
+        super();
+        this.exponent = exponent;
+    }
+    /**
+     * @internal
+     */
+    easeInCore(gradient) {
+        if (this.exponent <= 0) {
+            return gradient;
+        }
+        return (Math.exp(this.exponent * gradient) - 1.0) / (Math.exp(this.exponent) - 1.0);
+    }
+}
+/**
+ * Easing function with a power of 2 shape (see link below).
+ * @see https://easings.net/#easeInQuad
+ * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#easing-functions
+ */
+class QuadraticEase extends EasingFunction {
+    /**
+     * @internal
+     */
+    easeInCore(gradient) {
+        return gradient * gradient;
+    }
+}
+
+export { BackEase as B, EasingFunction as E, QuadraticEase as Q, ExponentialEase as a };

package/dist/effectFallbacks.esm.js

@@ -0,0 +1,378 @@
+import { e as ShaderStore } from './engine.esm.js';
+
+// Do not edit.
+const name$d = "clipPlaneFragmentDeclaration";
+const shader$d = `#ifdef CLIPPLANE
+varying float fClipDistance;
+#ifdef CLIPPLANE2
+varying float fClipDistance2;
+#ifdef CLIPPLANE3
+varying float fClipDistance3;
+#ifdef CLIPPLANE4
+varying float fClipDistance4;
+#ifdef CLIPPLANE5
+varying float fClipDistance5;
+#ifdef CLIPPLANE6
+varying float fClipDistance6;
+`;
+// Sideeffect
+ShaderStore.IncludesShadersStore[name$d] = shader$d;
+
+// Do not edit.
+const name$c = "clipPlaneFragment";
+const shader$c = `#if defined(CLIPPLANE) || defined(CLIPPLANE2) || defined(CLIPPLANE3) || defined(CLIPPLANE4) || defined(CLIPPLANE5) || defined(CLIPPLANE6)
+if (false) {}
+#ifdef CLIPPLANE
+else if (fClipDistance>0.0)
+#ifdef CLIPPLANE2
+else if (fClipDistance2>0.0)
+#ifdef CLIPPLANE3
+else if (fClipDistance3>0.0)
+#ifdef CLIPPLANE4
+else if (fClipDistance4>0.0)
+#ifdef CLIPPLANE5
+else if (fClipDistance5>0.0)
+#ifdef CLIPPLANE6
+else if (fClipDistance6>0.0)
+`;
+// Sideeffect
+ShaderStore.IncludesShadersStore[name$c] = shader$c;
+
+// Do not edit.
+const name$b = "bonesDeclaration";
+const shader$b = `#if NUM_BONE_INFLUENCERS>0
+attribute vec4 matricesIndices;
+attribute vec4 matricesIndicesExtra;
+#ifndef BAKED_VERTEX_ANIMATION_TEXTURE
+#ifdef BONETEXTURE
+uniform sampler2D boneSampler;
+uniform mat4 mBones[BonesPerMesh];
+uniform mat4 mPreviousBones[BonesPerMesh];
+#endif
+#ifdef BONETEXTURE
+#define inline
+mat4 readMatrixFromRawSampler(sampler2D smp,float index)
+#endif
+#endif
+`;
+// Sideeffect
+ShaderStore.IncludesShadersStore[name$b] = shader$b;
+
+// Do not edit.
+const name$a = "bakedVertexAnimationDeclaration";
+const shader$a = `#ifdef BAKED_VERTEX_ANIMATION_TEXTURE
+uniform float bakedVertexAnimationTime;
+attribute vec4 bakedVertexAnimationSettingsInstanced;
+#define inline
+mat4 readMatrixFromRawSamplerVAT(sampler2D smp,float index,float frame)
+`;
+// Sideeffect
+ShaderStore.IncludesShadersStore[name$a] = shader$a;
+
+// Do not edit.
+const name$9 = "morphTargetsVertexGlobalDeclaration";
+const shader$9 = `#ifdef MORPHTARGETS
+uniform float morphTargetInfluences[NUM_MORPH_INFLUENCERS];
+precision mediump sampler2DArray; 
+#endif
+`;
+// Sideeffect
+ShaderStore.IncludesShadersStore[name$9] = shader$9;
+
+// Do not edit.
+const name$8 = "morphTargetsVertexDeclaration";
+const shader$8 = `#ifdef MORPHTARGETS
+#ifndef MORPHTARGETS_TEXTURE
+attribute vec3 position{X};
+attribute vec3 normal{X};
+#ifdef MORPHTARGETS_TANGENT
+attribute vec3 tangent{X};
+#ifdef MORPHTARGETS_UV
+attribute vec2 uv_{X};
+#endif
+#endif
+`;
+// Sideeffect
+ShaderStore.IncludesShadersStore[name$8] = shader$8;
+
+// Do not edit.
+const name$7 = "clipPlaneVertexDeclaration";
+const shader$7 = `#ifdef CLIPPLANE
+uniform vec4 vClipPlane;
+#ifdef CLIPPLANE2
+uniform vec4 vClipPlane2;
+#ifdef CLIPPLANE3
+uniform vec4 vClipPlane3;
+#ifdef CLIPPLANE4
+uniform vec4 vClipPlane4;
+#ifdef CLIPPLANE5
+uniform vec4 vClipPlane5;
+#ifdef CLIPPLANE6
+uniform vec4 vClipPlane6;
+`;
+// Sideeffect
+ShaderStore.IncludesShadersStore[name$7] = shader$7;
+
+// Do not edit.
+const name$6 = "instancesDeclaration";
+const shader$6 = `#ifdef INSTANCES
+attribute vec4 world0;
+attribute vec4 instanceColor;
+#if defined(THIN_INSTANCES) && !defined(WORLD_UBO)
+uniform mat4 world;
+#if defined(VELOCITY) || defined(PREPASS_VELOCITY)
+attribute vec4 previousWorld0;
+uniform mat4 previousWorld;
+#endif
+#else
+#if !defined(WORLD_UBO)
+uniform mat4 world;
+#if defined(VELOCITY) || defined(PREPASS_VELOCITY)
+uniform mat4 previousWorld;
+#endif
+`;
+// Sideeffect
+ShaderStore.IncludesShadersStore[name$6] = shader$6;
+
+// Do not edit.
+const name$5 = "morphTargetsVertexGlobal";
+const shader$5 = `#ifdef MORPHTARGETS
+#ifdef MORPHTARGETS_TEXTURE
+float vertexID;
+#endif
+`;
+// Sideeffect
+ShaderStore.IncludesShadersStore[name$5] = shader$5;
+
+// Do not edit.
+const name$4 = "morphTargetsVertex";
+const shader$4 = `#ifdef MORPHTARGETS
+#ifdef MORPHTARGETS_TEXTURE 
+vertexID=float(gl_VertexID)*morphTargetTextureInfo.x;
+normalUpdated+=(readVector3FromRawSampler({X},vertexID) -normal)*morphTargetInfluences[{X}];
+#ifdef MORPHTARGETS_UV
+uvUpdated+=(readVector3FromRawSampler({X},vertexID).xy-uv)*morphTargetInfluences[{X}];
+#ifdef MORPHTARGETS_TANGENT
+tangentUpdated.xyz+=(readVector3FromRawSampler({X},vertexID) -tangent.xyz)*morphTargetInfluences[{X}];
+#else
+positionUpdated+=(position{X}-position)*morphTargetInfluences[{X}];
+normalUpdated+=(normal{X}-normal)*morphTargetInfluences[{X}];
+#ifdef MORPHTARGETS_TANGENT
+tangentUpdated.xyz+=(tangent{X}-tangent.xyz)*morphTargetInfluences[{X}];
+#ifdef MORPHTARGETS_UV
+uvUpdated+=(uv_{X}-uv)*morphTargetInfluences[{X}];
+#endif
+#endif
+`;
+// Sideeffect
+ShaderStore.IncludesShadersStore[name$4] = shader$4;
+
+// Do not edit.
+const name$3 = "instancesVertex";
+const shader$3 = `#ifdef INSTANCES
+mat4 finalWorld=mat4(world0,world1,world2,world3);
+mat4 finalPreviousWorld=mat4(previousWorld0,previousWorld1,previousWorld2,previousWorld3);
+#ifdef THIN_INSTANCES
+finalWorld=world*finalWorld;
+finalPreviousWorld=previousWorld*finalPreviousWorld;
+#endif
+#else
+mat4 finalWorld=world;
+mat4 finalPreviousWorld=previousWorld;
+#endif
+`;
+// Sideeffect
+ShaderStore.IncludesShadersStore[name$3] = shader$3;
+
+// Do not edit.
+const name$2 = "bonesVertex";
+const shader$2 = `#ifndef BAKED_VERTEX_ANIMATION_TEXTURE
+#if NUM_BONE_INFLUENCERS>0
+mat4 influence;
+influence=readMatrixFromRawSampler(boneSampler,matricesIndices[0])*matricesWeights[0];
+influence+=readMatrixFromRawSampler(boneSampler,matricesIndices[1])*matricesWeights[1];
+#if NUM_BONE_INFLUENCERS>2
+influence+=readMatrixFromRawSampler(boneSampler,matricesIndices[2])*matricesWeights[2];
+#if NUM_BONE_INFLUENCERS>3
+influence+=readMatrixFromRawSampler(boneSampler,matricesIndices[3])*matricesWeights[3];
+#if NUM_BONE_INFLUENCERS>4
+influence+=readMatrixFromRawSampler(boneSampler,matricesIndicesExtra[0])*matricesWeightsExtra[0];
+#if NUM_BONE_INFLUENCERS>5
+influence+=readMatrixFromRawSampler(boneSampler,matricesIndicesExtra[1])*matricesWeightsExtra[1];
+#if NUM_BONE_INFLUENCERS>6
+influence+=readMatrixFromRawSampler(boneSampler,matricesIndicesExtra[2])*matricesWeightsExtra[2];
+#if NUM_BONE_INFLUENCERS>7
+influence+=readMatrixFromRawSampler(boneSampler,matricesIndicesExtra[3])*matricesWeightsExtra[3];
+#else
+influence=mBones[int(matricesIndices[0])]*matricesWeights[0];
+influence+=mBones[int(matricesIndices[1])]*matricesWeights[1];
+#if NUM_BONE_INFLUENCERS>2
+influence+=mBones[int(matricesIndices[2])]*matricesWeights[2];
+#if NUM_BONE_INFLUENCERS>3
+influence+=mBones[int(matricesIndices[3])]*matricesWeights[3];
+#if NUM_BONE_INFLUENCERS>4
+influence+=mBones[int(matricesIndicesExtra[0])]*matricesWeightsExtra[0];
+#if NUM_BONE_INFLUENCERS>5
+influence+=mBones[int(matricesIndicesExtra[1])]*matricesWeightsExtra[1];
+#if NUM_BONE_INFLUENCERS>6
+influence+=mBones[int(matricesIndicesExtra[2])]*matricesWeightsExtra[2];
+#if NUM_BONE_INFLUENCERS>7
+influence+=mBones[int(matricesIndicesExtra[3])]*matricesWeightsExtra[3];
+#endif
+finalWorld=finalWorld*influence;
+#endif
+`;
+// Sideeffect
+ShaderStore.IncludesShadersStore[name$2] = shader$2;
+
+// Do not edit.
+const name$1 = "bakedVertexAnimation";
+const shader$1 = `#ifdef BAKED_VERTEX_ANIMATION_TEXTURE
+{
+#define BVASNAME bakedVertexAnimationSettingsInstanced
+#else
+#define BVASNAME bakedVertexAnimationSettings
+#endif
+float VATStartFrame=BVASNAME.x;
+VATInfluence+=readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,matricesIndices[1],VATFrameNum)*matricesWeights[1];
+#if NUM_BONE_INFLUENCERS>2
+VATInfluence+=readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,matricesIndices[2],VATFrameNum)*matricesWeights[2];
+#if NUM_BONE_INFLUENCERS>3
+VATInfluence+=readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,matricesIndices[3],VATFrameNum)*matricesWeights[3];
+#if NUM_BONE_INFLUENCERS>4
+VATInfluence+=readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,matricesIndicesExtra[0],VATFrameNum)*matricesWeightsExtra[0];
+#if NUM_BONE_INFLUENCERS>5
+VATInfluence+=readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,matricesIndicesExtra[1],VATFrameNum)*matricesWeightsExtra[1];
+#if NUM_BONE_INFLUENCERS>6
+VATInfluence+=readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,matricesIndicesExtra[2],VATFrameNum)*matricesWeightsExtra[2];
+#if NUM_BONE_INFLUENCERS>7
+VATInfluence+=readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,matricesIndicesExtra[3],VATFrameNum)*matricesWeightsExtra[3];
+finalWorld=finalWorld*VATInfluence;
+`;
+// Sideeffect
+ShaderStore.IncludesShadersStore[name$1] = shader$1;
+
+// Do not edit.
+const name = "clipPlaneVertex";
+const shader = `#ifdef CLIPPLANE
+fClipDistance=dot(worldPos,vClipPlane);
+#ifdef CLIPPLANE2
+fClipDistance2=dot(worldPos,vClipPlane2);
+#ifdef CLIPPLANE3
+fClipDistance3=dot(worldPos,vClipPlane3);
+#ifdef CLIPPLANE4
+fClipDistance4=dot(worldPos,vClipPlane4);
+#ifdef CLIPPLANE5
+fClipDistance5=dot(worldPos,vClipPlane5);
+#ifdef CLIPPLANE6
+fClipDistance6=dot(worldPos,vClipPlane6);
+`;
+// Sideeffect
+ShaderStore.IncludesShadersStore[name] = shader;
+
+/**
+ * EffectFallbacks can be used to add fallbacks (properties to disable) to certain properties when desired to improve performance.
+ * (Eg. Start at high quality with reflection and fog, if fps is low, remove reflection, if still low remove fog)
+ */
+class EffectFallbacks {
+    constructor() {
+        this._defines = {};
+        this._currentRank = 32;
+        this._maxRank = -1;
+        this._mesh = null;
+    }
+    /**
+     * Removes the fallback from the bound mesh.
+     */
+    unBindMesh() {
+        this._mesh = null;
+    }
+    /**
+     * Adds a fallback on the specified property.
+     * @param rank The rank of the fallback (Lower ranks will be fallbacked to first)
+     * @param define The name of the define in the shader
+     */
+    addFallback(rank, define) {
+        if (!this._defines[rank]) {
+            if (rank < this._currentRank) {
+                this._currentRank = rank;
+            }
+            if (rank > this._maxRank) {
+                this._maxRank = rank;
+            }
+            this._defines[rank] = new Array();
+        }
+        this._defines[rank].push(define);
+    }
+    /**
+     * Sets the mesh to use CPU skinning when needing to fallback.
+     * @param rank The rank of the fallback (Lower ranks will be fallbacked to first)
+     * @param mesh The mesh to use the fallbacks.
+     */
+    addCPUSkinningFallback(rank, mesh) {
+        this._mesh = mesh;
+        if (rank < this._currentRank) {
+            this._currentRank = rank;
+        }
+        if (rank > this._maxRank) {
+            this._maxRank = rank;
+        }
+    }
+    /**
+     * Checks to see if more fallbacks are still available.
+     */
+    get hasMoreFallbacks() {
+        return this._currentRank <= this._maxRank;
+    }
+    /**
+     * Removes the defines that should be removed when falling back.
+     * @param currentDefines defines the current define statements for the shader.
+     * @param effect defines the current effect we try to compile
+     * @returns The resulting defines with defines of the current rank removed.
+     */
+    reduce(currentDefines, effect) {
+        // First we try to switch to CPU skinning
+        if (this._mesh && this._mesh.computeBonesUsingShaders && this._mesh.numBoneInfluencers > 0) {
+            this._mesh.computeBonesUsingShaders = false;
+            currentDefines = currentDefines.replace("#define NUM_BONE_INFLUENCERS " + this._mesh.numBoneInfluencers, "#define NUM_BONE_INFLUENCERS 0");
+            effect._bonesComputationForcedToCPU = true;
+            const scene = this._mesh.getScene();
+            for (let index = 0; index < scene.meshes.length; index++) {
+                const otherMesh = scene.meshes[index];
+                if (!otherMesh.material) {
+                    if (!this._mesh.material && otherMesh.computeBonesUsingShaders && otherMesh.numBoneInfluencers > 0) {
+                        otherMesh.computeBonesUsingShaders = false;
+                    }
+                    continue;
+                }
+                if (!otherMesh.computeBonesUsingShaders || otherMesh.numBoneInfluencers === 0) {
+                    continue;
+                }
+                if (otherMesh.material.getEffect() === effect) {
+                    otherMesh.computeBonesUsingShaders = false;
+                }
+                else if (otherMesh.subMeshes) {
+                    for (const subMesh of otherMesh.subMeshes) {
+                        const subMeshEffect = subMesh.effect;
+                        if (subMeshEffect === effect) {
+                            otherMesh.computeBonesUsingShaders = false;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            const currentFallbacks = this._defines[this._currentRank];
+            if (currentFallbacks) {
+                for (let index = 0; index < currentFallbacks.length; index++) {
+                    currentDefines = currentDefines.replace("#define " + currentFallbacks[index], "");
+                }
+            }
+            this._currentRank++;
+        }
+        return currentDefines;
+    }
+}
+
+export { EffectFallbacks as E };