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

package/dist/node_modules/@babylonjs/core/Materials/materialHelper.esm.js

@@ -1,501 +0,0 @@
-import { Logger as n } from "../Misc/logger.esm.js";
-import { Camera as p } from "../Cameras/camera.esm.js";
-import { Scene as P } from "../scene.esm.js";
-import { EngineStore as N } from "../Engines/engineStore.esm.js";
-import { VertexBuffer as T } from "../Buffers/buffer.esm.js";
-import { LightConstants as u } from "../Lights/lightConstants.esm.js";
-import { Color3 as R } from "../Maths/math.color.esm.js";
-import { prepareDefinesForClipPlanes as O } from "./clipPlaneMaterialHelper.esm.js";
-class i {
-  /**
-   * Binds the scene's uniform buffer to the effect.
-   * @param effect defines the effect to bind to the scene uniform buffer
-   * @param sceneUbo defines the uniform buffer storing scene data
-   */
-  static BindSceneUniformBuffer(r, a) {
-    a.bindToEffect(r, "Scene");
-  }
-  /**
-   * Helps preparing the defines values about the UVs in used in the effect.
-   * UVs are shared as much as we can across channels in the shaders.
-   * @param texture The texture we are preparing the UVs for
-   * @param defines The defines to update
-   * @param key The channel key "diffuse", "specular"... used in the shader
-   */
-  static PrepareDefinesForMergedUV(r, a, t) {
-    a._needUVs = !0, a[t] = !0, r.optimizeUVAllocation && r.getTextureMatrix().isIdentityAs3x2() ? (a[t + "DIRECTUV"] = r.coordinatesIndex + 1, a["MAINUV" + (r.coordinatesIndex + 1)] = !0) : a[t + "DIRECTUV"] = 0;
-  }
-  /**
-   * Binds a texture matrix value to its corresponding uniform
-   * @param texture The texture to bind the matrix for
-   * @param uniformBuffer The uniform buffer receiving the data
-   * @param key The channel key "diffuse", "specular"... used in the shader
-   */
-  static BindTextureMatrix(r, a, t) {
-    const e = r.getTextureMatrix();
-    a.updateMatrix(t + "Matrix", e);
-  }
-  /**
-   * Gets the current status of the fog (should it be enabled?)
-   * @param mesh defines the mesh to evaluate for fog support
-   * @param scene defines the hosting scene
-   * @returns true if fog must be enabled
-   */
-  static GetFogState(r, a) {
-    return a.fogEnabled && r.applyFog && a.fogMode !== P.FOGMODE_NONE;
-  }
-  /**
-   * Helper used to prepare the list of defines associated with misc. values for shader compilation
-   * @param mesh defines the current mesh
-   * @param scene defines the current scene
-   * @param useLogarithmicDepth defines if logarithmic depth has to be turned on
-   * @param pointsCloud defines if point cloud rendering has to be turned on
-   * @param fogEnabled defines if fog has to be turned on
-   * @param alphaTest defines if alpha testing has to be turned on
-   * @param defines defines the current list of defines
-   * @param applyDecalAfterDetail Defines if the decal is applied after or before the detail
-   */
-  static PrepareDefinesForMisc(r, a, t, e, o, E, s, A = !1) {
-    s._areMiscDirty && (s.LOGARITHMICDEPTH = t, s.POINTSIZE = e, s.FOG = o && this.GetFogState(r, a), s.NONUNIFORMSCALING = r.nonUniformScaling, s.ALPHATEST = E, s.DECAL_AFTER_DETAIL = A);
-  }
-  /**
-   * Helper used to prepare the defines relative to the active camera
-   * @param scene defines the current scene
-   * @param defines specifies the list of active defines
-   * @returns true if the defines have been updated, else false
-   */
-  static PrepareDefinesForCamera(r, a) {
-    let t = !1;
-    if (r.activeCamera) {
-      const e = a.CAMERA_ORTHOGRAPHIC ? 1 : 0, o = a.CAMERA_PERSPECTIVE ? 1 : 0, E = r.activeCamera.mode === p.ORTHOGRAPHIC_CAMERA ? 1 : 0, s = r.activeCamera.mode === p.PERSPECTIVE_CAMERA ? 1 : 0;
-      (e ^ E || o ^ s) && (a.CAMERA_ORTHOGRAPHIC = E === 1, a.CAMERA_PERSPECTIVE = s === 1, t = !0);
-    }
-    return t;
-  }
-  /**
-   * Helper used to prepare the list of defines associated with frame values for shader compilation
-   * @param scene defines the current scene
-   * @param engine defines the current engine
-   * @param material defines the material we are compiling the shader for
-   * @param defines specifies the list of active defines
-   * @param useInstances defines if instances have to be turned on
-   * @param useClipPlane defines if clip plane have to be turned on
-   * @param useThinInstances defines if thin instances have to be turned on
-   */
-  static PrepareDefinesForFrameBoundValues(r, a, t, e, o, E = null, s = !1) {
-    let A = i.PrepareDefinesForCamera(r, e);
-    E !== !1 && (A = O(t, r, e)), e.DEPTHPREPASS !== !a.getColorWrite() && (e.DEPTHPREPASS = !e.DEPTHPREPASS, A = !0), e.INSTANCES !== o && (e.INSTANCES = o, A = !0), e.THIN_INSTANCES !== s && (e.THIN_INSTANCES = s, A = !0), A && e.markAsUnprocessed();
-  }
-  /**
-   * Prepares the defines for bones
-   * @param mesh The mesh containing the geometry data we will draw
-   * @param defines The defines to update
-   */
-  static PrepareDefinesForBones(r, a) {
-    if (r.useBones && r.computeBonesUsingShaders && r.skeleton) {
-      a.NUM_BONE_INFLUENCERS = r.numBoneInfluencers;
-      const t = a.BONETEXTURE !== void 0;
-      if (r.skeleton.isUsingTextureForMatrices && t)
-        a.BONETEXTURE = !0;
-      else {
-        a.BonesPerMesh = r.skeleton.bones.length + 1, a.BONETEXTURE = t ? !1 : void 0;
-        const e = r.getScene().prePassRenderer;
-        if (e && e.enabled) {
-          const o = e.excludedSkinnedMesh.indexOf(r) === -1;
-          a.BONES_VELOCITY_ENABLED = o;
-        }
-      }
-    } else
-      a.NUM_BONE_INFLUENCERS = 0, a.BonesPerMesh = 0, a.BONETEXTURE !== void 0 && (a.BONETEXTURE = !1);
-  }
-  /**
-   * Prepares the defines for morph targets
-   * @param mesh The mesh containing the geometry data we will draw
-   * @param defines The defines to update
-   */
-  static PrepareDefinesForMorphTargets(r, a) {
-    const t = r.morphTargetManager;
-    t ? (a.MORPHTARGETS_UV = t.supportsUVs && a.UV1, a.MORPHTARGETS_TANGENT = t.supportsTangents && a.TANGENT, a.MORPHTARGETS_NORMAL = t.supportsNormals && a.NORMAL, a.MORPHTARGETS = t.numInfluencers > 0, a.NUM_MORPH_INFLUENCERS = t.numInfluencers, a.MORPHTARGETS_TEXTURE = t.isUsingTextureForTargets) : (a.MORPHTARGETS_UV = !1, a.MORPHTARGETS_TANGENT = !1, a.MORPHTARGETS_NORMAL = !1, a.MORPHTARGETS = !1, a.NUM_MORPH_INFLUENCERS = 0);
-  }
-  /**
-   * Prepares the defines for baked vertex animation
-   * @param mesh The mesh containing the geometry data we will draw
-   * @param defines The defines to update
-   */
-  static PrepareDefinesForBakedVertexAnimation(r, a) {
-    const t = r.bakedVertexAnimationManager;
-    a.BAKED_VERTEX_ANIMATION_TEXTURE = !!(t && t.isEnabled);
-  }
-  /**
-   * Prepares the defines used in the shader depending on the attributes data available in the mesh
-   * @param mesh The mesh containing the geometry data we will draw
-   * @param defines The defines to update
-   * @param useVertexColor Precise whether vertex colors should be used or not (override mesh info)
-   * @param useBones Precise whether bones should be used or not (override mesh info)
-   * @param useMorphTargets Precise whether morph targets should be used or not (override mesh info)
-   * @param useVertexAlpha Precise whether vertex alpha should be used or not (override mesh info)
-   * @param useBakedVertexAnimation Precise whether baked vertex animation should be used or not (override mesh info)
-   * @returns false if defines are considered not dirty and have not been checked
-   */
-  static PrepareDefinesForAttributes(r, a, t, e, o = !1, E = !0, s = !0) {
-    if (!a._areAttributesDirty && a._needNormals === a._normals && a._needUVs === a._uvs)
-      return !1;
-    a._normals = a._needNormals, a._uvs = a._needUVs, a.NORMAL = a._needNormals && r.isVerticesDataPresent(T.NormalKind), a._needNormals && r.isVerticesDataPresent(T.TangentKind) && (a.TANGENT = !0);
-    for (let A = 1; A <= 6; ++A)
-      a["UV" + A] = a._needUVs ? r.isVerticesDataPresent(`uv${A === 1 ? "" : A}`) : !1;
-    if (t) {
-      const A = r.useVertexColors && r.isVerticesDataPresent(T.ColorKind);
-      a.VERTEXCOLOR = A, a.VERTEXALPHA = r.hasVertexAlpha && A && E;
-    }
-    return r.isVerticesDataPresent(T.ColorInstanceKind) && (r.hasInstances || r.hasThinInstances) && (a.INSTANCESCOLOR = !0), e && this.PrepareDefinesForBones(r, a), o && this.PrepareDefinesForMorphTargets(r, a), s && this.PrepareDefinesForBakedVertexAnimation(r, a), !0;
-  }
-  /**
-   * Prepares the defines related to multiview
-   * @param scene The scene we are intending to draw
-   * @param defines The defines to update
-   */
-  static PrepareDefinesForMultiview(r, a) {
-    if (r.activeCamera) {
-      const t = a.MULTIVIEW;
-      a.MULTIVIEW = r.activeCamera.outputRenderTarget !== null && r.activeCamera.outputRenderTarget.getViewCount() > 1, a.MULTIVIEW != t && a.markAsUnprocessed();
-    }
-  }
-  /**
-   * Prepares the defines related to order independant transparency
-   * @param scene The scene we are intending to draw
-   * @param defines The defines to update
-   * @param needAlphaBlending Determines if the material needs alpha blending
-   */
-  static PrepareDefinesForOIT(r, a, t) {
-    const e = a.ORDER_INDEPENDENT_TRANSPARENCY, o = a.ORDER_INDEPENDENT_TRANSPARENCY_16BITS;
-    a.ORDER_INDEPENDENT_TRANSPARENCY = r.useOrderIndependentTransparency && t, a.ORDER_INDEPENDENT_TRANSPARENCY_16BITS = !r.getEngine().getCaps().textureFloatLinearFiltering, (e !== a.ORDER_INDEPENDENT_TRANSPARENCY || o !== a.ORDER_INDEPENDENT_TRANSPARENCY_16BITS) && a.markAsUnprocessed();
-  }
-  /**
-   * Prepares the defines related to the prepass
-   * @param scene The scene we are intending to draw
-   * @param defines The defines to update
-   * @param canRenderToMRT Indicates if this material renders to several textures in the prepass
-   */
-  static PrepareDefinesForPrePass(r, a, t) {
-    const e = a.PREPASS;
-    if (!a._arePrePassDirty)
-      return;
-    const o = [
-      {
-        type: 1,
-        define: "PREPASS_POSITION",
-        index: "PREPASS_POSITION_INDEX"
-      },
-      {
-        type: 2,
-        define: "PREPASS_VELOCITY",
-        index: "PREPASS_VELOCITY_INDEX"
-      },
-      {
-        type: 3,
-        define: "PREPASS_REFLECTIVITY",
-        index: "PREPASS_REFLECTIVITY_INDEX"
-      },
-      {
-        type: 0,
-        define: "PREPASS_IRRADIANCE",
-        index: "PREPASS_IRRADIANCE_INDEX"
-      },
-      {
-        type: 7,
-        define: "PREPASS_ALBEDO_SQRT",
-        index: "PREPASS_ALBEDO_SQRT_INDEX"
-      },
-      {
-        type: 5,
-        define: "PREPASS_DEPTH",
-        index: "PREPASS_DEPTH_INDEX"
-      },
-      {
-        type: 6,
-        define: "PREPASS_NORMAL",
-        index: "PREPASS_NORMAL_INDEX"
-      }
-    ];
-    if (r.prePassRenderer && r.prePassRenderer.enabled && t) {
-      a.PREPASS = !0, a.SCENE_MRT_COUNT = r.prePassRenderer.mrtCount;
-      for (let E = 0; E < o.length; E++) {
-        const s = r.prePassRenderer.getIndex(o[E].type);
-        s !== -1 ? (a[o[E].define] = !0, a[o[E].index] = s) : a[o[E].define] = !1;
-      }
-    } else {
-      a.PREPASS = !1;
-      for (let E = 0; E < o.length; E++)
-        a[o[E].define] = !1;
-    }
-    a.PREPASS != e && (a.markAsUnprocessed(), a.markAsImageProcessingDirty());
-  }
-  /**
-   * Prepares the defines related to the light information passed in parameter
-   * @param scene The scene we are intending to draw
-   * @param mesh The mesh the effect is compiling for
-   * @param light The light the effect is compiling for
-   * @param lightIndex The index of the light
-   * @param defines The defines to update
-   * @param specularSupported Specifies whether specular is supported or not (override lights data)
-   * @param state Defines the current state regarding what is needed (normals, etc...)
-   * @param state.needNormals
-   * @param state.needRebuild
-   * @param state.shadowEnabled
-   * @param state.specularEnabled
-   * @param state.lightmapMode
-   */
-  static PrepareDefinesForLight(r, a, t, e, o, E, s) {
-    var A;
-    switch (s.needNormals = !0, o["LIGHT" + e] === void 0 && (s.needRebuild = !0), o["LIGHT" + e] = !0, o["SPOTLIGHT" + e] = !1, o["HEMILIGHT" + e] = !1, o["POINTLIGHT" + e] = !1, o["DIRLIGHT" + e] = !1, t.prepareLightSpecificDefines(o, e), o["LIGHT_FALLOFF_PHYSICAL" + e] = !1, o["LIGHT_FALLOFF_GLTF" + e] = !1, o["LIGHT_FALLOFF_STANDARD" + e] = !1, t.falloffType) {
-      case u.FALLOFF_GLTF:
-        o["LIGHT_FALLOFF_GLTF" + e] = !0;
-        break;
-      case u.FALLOFF_PHYSICAL:
-        o["LIGHT_FALLOFF_PHYSICAL" + e] = !0;
-        break;
-      case u.FALLOFF_STANDARD:
-        o["LIGHT_FALLOFF_STANDARD" + e] = !0;
-        break;
-    }
-    if (E && !t.specular.equalsFloats(0, 0, 0) && (s.specularEnabled = !0), o["SHADOW" + e] = !1, o["SHADOWCSM" + e] = !1, o["SHADOWCSMDEBUG" + e] = !1, o["SHADOWCSMNUM_CASCADES" + e] = !1, o["SHADOWCSMUSESHADOWMAXZ" + e] = !1, o["SHADOWCSMNOBLEND" + e] = !1, o["SHADOWCSM_RIGHTHANDED" + e] = !1, o["SHADOWPCF" + e] = !1, o["SHADOWPCSS" + e] = !1, o["SHADOWPOISSON" + e] = !1, o["SHADOWESM" + e] = !1, o["SHADOWCLOSEESM" + e] = !1, o["SHADOWCUBE" + e] = !1, o["SHADOWLOWQUALITY" + e] = !1, o["SHADOWMEDIUMQUALITY" + e] = !1, a && a.receiveShadows && r.shadowsEnabled && t.shadowEnabled) {
-      const l = (A = t.getShadowGenerator(r.activeCamera)) !== null && A !== void 0 ? A : t.getShadowGenerator();
-      if (l) {
-        const S = l.getShadowMap();
-        S && S.renderList && S.renderList.length > 0 && (s.shadowEnabled = !0, l.prepareDefines(o, e));
-      }
-    }
-    t.lightmapMode != u.LIGHTMAP_DEFAULT ? (s.lightmapMode = !0, o["LIGHTMAPEXCLUDED" + e] = !0, o["LIGHTMAPNOSPECULAR" + e] = t.lightmapMode == u.LIGHTMAP_SHADOWSONLY) : (o["LIGHTMAPEXCLUDED" + e] = !1, o["LIGHTMAPNOSPECULAR" + e] = !1);
-  }
-  /**
-   * Prepares the defines related to the light information passed in parameter
-   * @param scene The scene we are intending to draw
-   * @param mesh The mesh the effect is compiling for
-   * @param defines The defines to update
-   * @param specularSupported Specifies whether specular is supported or not (override lights data)
-   * @param maxSimultaneousLights Specifies how manuy lights can be added to the effect at max
-   * @param disableLighting Specifies whether the lighting is disabled (override scene and light)
-   * @returns true if normals will be required for the rest of the effect
-   */
-  static PrepareDefinesForLights(r, a, t, e, o = 4, E = !1) {
-    if (!t._areLightsDirty)
-      return t._needNormals;
-    let s = 0;
-    const A = {
-      needNormals: t._needNormals,
-      needRebuild: !1,
-      lightmapMode: !1,
-      shadowEnabled: !1,
-      specularEnabled: !1
-    };
-    if (r.lightsEnabled && !E) {
-      for (const S of a.lightSources)
-        if (this.PrepareDefinesForLight(r, a, S, s, t, e, A), s++, s === o)
-          break;
-    }
-    t.SPECULARTERM = A.specularEnabled, t.SHADOWS = A.shadowEnabled;
-    for (let S = s; S < o; S++)
-      t["LIGHT" + S] !== void 0 && (t["LIGHT" + S] = !1, t["HEMILIGHT" + S] = !1, t["POINTLIGHT" + S] = !1, t["DIRLIGHT" + S] = !1, t["SPOTLIGHT" + S] = !1, t["SHADOW" + S] = !1, t["SHADOWCSM" + S] = !1, t["SHADOWCSMDEBUG" + S] = !1, t["SHADOWCSMNUM_CASCADES" + S] = !1, t["SHADOWCSMUSESHADOWMAXZ" + S] = !1, t["SHADOWCSMNOBLEND" + S] = !1, t["SHADOWCSM_RIGHTHANDED" + S] = !1, t["SHADOWPCF" + S] = !1, t["SHADOWPCSS" + S] = !1, t["SHADOWPOISSON" + S] = !1, t["SHADOWESM" + S] = !1, t["SHADOWCLOSEESM" + S] = !1, t["SHADOWCUBE" + S] = !1, t["SHADOWLOWQUALITY" + S] = !1, t["SHADOWMEDIUMQUALITY" + S] = !1);
-    const l = r.getEngine().getCaps();
-    return t.SHADOWFLOAT === void 0 && (A.needRebuild = !0), t.SHADOWFLOAT = A.shadowEnabled && (l.textureFloatRender && l.textureFloatLinearFiltering || l.textureHalfFloatRender && l.textureHalfFloatLinearFiltering), t.LIGHTMAPEXCLUDED = A.lightmapMode, A.needRebuild && t.rebuild(), A.needNormals;
-  }
-  /**
-   * Prepares the uniforms and samplers list to be used in the effect (for a specific light)
-   * @param lightIndex defines the light index
-   * @param uniformsList The uniform list
-   * @param samplersList The sampler list
-   * @param projectedLightTexture defines if projected texture must be used
-   * @param uniformBuffersList defines an optional list of uniform buffers
-   * @param updateOnlyBuffersList True to only update the uniformBuffersList array
-   */
-  static PrepareUniformsAndSamplersForLight(r, a, t, e, o = null, E = !1) {
-    o && o.push("Light" + r), !E && (a.push("vLightData" + r, "vLightDiffuse" + r, "vLightSpecular" + r, "vLightDirection" + r, "vLightFalloff" + r, "vLightGround" + r, "lightMatrix" + r, "shadowsInfo" + r, "depthValues" + r), t.push("shadowSampler" + r), t.push("depthSampler" + r), a.push("viewFrustumZ" + r, "cascadeBlendFactor" + r, "lightSizeUVCorrection" + r, "depthCorrection" + r, "penumbraDarkness" + r, "frustumLengths" + r), e && (t.push("projectionLightSampler" + r), a.push("textureProjectionMatrix" + r)));
-  }
-  /**
-   * Prepares the uniforms and samplers list to be used in the effect
-   * @param uniformsListOrOptions The uniform names to prepare or an EffectCreationOptions containing the list and extra information
-   * @param samplersList The sampler list
-   * @param defines The defines helping in the list generation
-   * @param maxSimultaneousLights The maximum number of simultaneous light allowed in the effect
-   */
-  static PrepareUniformsAndSamplersList(r, a, t, e = 4) {
-    let o, E = null;
-    if (r.uniformsNames) {
-      const s = r;
-      o = s.uniformsNames, E = s.uniformBuffersNames, a = s.samplers, t = s.defines, e = s.maxSimultaneousLights || 0;
-    } else
-      o = r, a || (a = []);
-    for (let s = 0; s < e && t["LIGHT" + s]; s++)
-      this.PrepareUniformsAndSamplersForLight(s, o, a, t["PROJECTEDLIGHTTEXTURE" + s], E);
-    t.NUM_MORPH_INFLUENCERS && o.push("morphTargetInfluences"), t.BAKED_VERTEX_ANIMATION_TEXTURE && (o.push("bakedVertexAnimationSettings"), o.push("bakedVertexAnimationTextureSizeInverted"), o.push("bakedVertexAnimationTime"), a.push("bakedVertexAnimationTexture"));
-  }
-  /**
-   * This helps decreasing rank by rank the shadow quality (0 being the highest rank and quality)
-   * @param defines The defines to update while falling back
-   * @param fallbacks The authorized effect fallbacks
-   * @param maxSimultaneousLights The maximum number of lights allowed
-   * @param rank the current rank of the Effect
-   * @returns The newly affected rank
-   */
-  static HandleFallbacksForShadows(r, a, t = 4, e = 0) {
-    let o = 0;
-    for (let E = 0; E < t && r["LIGHT" + E]; E++)
-      E > 0 && (o = e + E, a.addFallback(o, "LIGHT" + E)), r.SHADOWS || (r["SHADOW" + E] && a.addFallback(e, "SHADOW" + E), r["SHADOWPCF" + E] && a.addFallback(e, "SHADOWPCF" + E), r["SHADOWPCSS" + E] && a.addFallback(e, "SHADOWPCSS" + E), r["SHADOWPOISSON" + E] && a.addFallback(e, "SHADOWPOISSON" + E), r["SHADOWESM" + E] && a.addFallback(e, "SHADOWESM" + E), r["SHADOWCLOSEESM" + E] && a.addFallback(e, "SHADOWCLOSEESM" + E));
-    return o++;
-  }
-  /**
-   * Prepares the list of attributes required for morph targets according to the effect defines.
-   * @param attribs The current list of supported attribs
-   * @param mesh The mesh to prepare the morph targets attributes for
-   * @param influencers The number of influencers
-   */
-  static PrepareAttributesForMorphTargetsInfluencers(r, a, t) {
-    this._TmpMorphInfluencers.NUM_MORPH_INFLUENCERS = t, this.PrepareAttributesForMorphTargets(r, a, this._TmpMorphInfluencers);
-  }
-  /**
-   * Prepares the list of attributes required for morph targets according to the effect defines.
-   * @param attribs The current list of supported attribs
-   * @param mesh The mesh to prepare the morph targets attributes for
-   * @param defines The current Defines of the effect
-   */
-  static PrepareAttributesForMorphTargets(r, a, t) {
-    const e = t.NUM_MORPH_INFLUENCERS;
-    if (e > 0 && N.LastCreatedEngine) {
-      const o = N.LastCreatedEngine.getCaps().maxVertexAttribs, E = a.morphTargetManager;
-      if (E != null && E.isUsingTextureForTargets)
-        return;
-      const s = E && E.supportsNormals && t.NORMAL, A = E && E.supportsTangents && t.TANGENT, l = E && E.supportsUVs && t.UV1;
-      for (let S = 0; S < e; S++)
-        r.push(T.PositionKind + S), s && r.push(T.NormalKind + S), A && r.push(T.TangentKind + S), l && r.push(T.UVKind + "_" + S), r.length > o && n.Error("Cannot add more vertex attributes for mesh " + a.name);
-    }
-  }
-  /**
-   * Prepares the list of attributes required for baked vertex animations according to the effect defines.
-   * @param attribs The current list of supported attribs
-   * @param mesh The mesh to prepare the morph targets attributes for
-   * @param defines The current Defines of the effect
-   */
-  static PrepareAttributesForBakedVertexAnimation(r, a, t) {
-    t.BAKED_VERTEX_ANIMATION_TEXTURE && t.INSTANCES && r.push("bakedVertexAnimationSettingsInstanced");
-  }
-  /**
-   * Prepares the list of attributes required for bones according to the effect defines.
-   * @param attribs The current list of supported attribs
-   * @param mesh The mesh to prepare the bones attributes for
-   * @param defines The current Defines of the effect
-   * @param fallbacks The current effect fallback strategy
-   */
-  static PrepareAttributesForBones(r, a, t, e) {
-    t.NUM_BONE_INFLUENCERS > 0 && (e.addCPUSkinningFallback(0, a), r.push(T.MatricesIndicesKind), r.push(T.MatricesWeightsKind), t.NUM_BONE_INFLUENCERS > 4 && (r.push(T.MatricesIndicesExtraKind), r.push(T.MatricesWeightsExtraKind)));
-  }
-  /**
-   * Check and prepare the list of attributes required for instances according to the effect defines.
-   * @param attribs The current list of supported attribs
-   * @param defines The current MaterialDefines of the effect
-   */
-  static PrepareAttributesForInstances(r, a) {
-    (a.INSTANCES || a.THIN_INSTANCES) && this.PushAttributesForInstances(r, !!a.PREPASS_VELOCITY), a.INSTANCESCOLOR && r.push(T.ColorInstanceKind);
-  }
-  /**
-   * Add the list of attributes required for instances to the attribs array.
-   * @param attribs The current list of supported attribs
-   * @param needsPreviousMatrices If the shader needs previous matrices
-   */
-  static PushAttributesForInstances(r, a = !1) {
-    r.push("world0"), r.push("world1"), r.push("world2"), r.push("world3"), a && (r.push("previousWorld0"), r.push("previousWorld1"), r.push("previousWorld2"), r.push("previousWorld3"));
-  }
-  /**
-   * Binds the light information to the effect.
-   * @param light The light containing the generator
-   * @param effect The effect we are binding the data to
-   * @param lightIndex The light index in the effect used to render
-   */
-  static BindLightProperties(r, a, t) {
-    r.transferToEffect(a, t + "");
-  }
-  /**
-   * Binds the lights information from the scene to the effect for the given mesh.
-   * @param light Light to bind
-   * @param lightIndex Light index
-   * @param scene The scene where the light belongs to
-   * @param effect The effect we are binding the data to
-   * @param useSpecular Defines if specular is supported
-   * @param receiveShadows Defines if the effect (mesh) we bind the light for receives shadows
-   */
-  static BindLight(r, a, t, e, o, E = !0) {
-    r._bindLight(a, t, e, o, E);
-  }
-  /**
-   * Binds the lights information from the scene to the effect for the given mesh.
-   * @param scene The scene the lights belongs to
-   * @param mesh The mesh we are binding the information to render
-   * @param effect The effect we are binding the data to
-   * @param defines The generated defines for the effect
-   * @param maxSimultaneousLights The maximum number of light that can be bound to the effect
-   */
-  static BindLights(r, a, t, e, o = 4) {
-    const E = Math.min(a.lightSources.length, o);
-    for (let s = 0; s < E; s++) {
-      const A = a.lightSources[s];
-      this.BindLight(A, s, r, t, typeof e == "boolean" ? e : e.SPECULARTERM, a.receiveShadows);
-    }
-  }
-  /**
-   * Binds the fog information from the scene to the effect for the given mesh.
-   * @param scene The scene the lights belongs to
-   * @param mesh The mesh we are binding the information to render
-   * @param effect The effect we are binding the data to
-   * @param linearSpace Defines if the fog effect is applied in linear space
-   */
-  static BindFogParameters(r, a, t, e = !1) {
-    r.fogEnabled && a.applyFog && r.fogMode !== P.FOGMODE_NONE && (t.setFloat4("vFogInfos", r.fogMode, r.fogStart, r.fogEnd, r.fogDensity), e ? (r.fogColor.toLinearSpaceToRef(this._TempFogColor, r.getEngine().useExactSrgbConversions), t.setColor3("vFogColor", this._TempFogColor)) : t.setColor3("vFogColor", r.fogColor));
-  }
-  /**
-   * Binds the bones information from the mesh to the effect.
-   * @param mesh The mesh we are binding the information to render
-   * @param effect The effect we are binding the data to
-   * @param prePassConfiguration Configuration for the prepass, in case prepass is activated
-   */
-  static BindBonesParameters(r, a, t) {
-    if (!(!a || !r) && (r.computeBonesUsingShaders && a._bonesComputationForcedToCPU && (r.computeBonesUsingShaders = !1), r.useBones && r.computeBonesUsingShaders && r.skeleton)) {
-      const e = r.skeleton;
-      if (e.isUsingTextureForMatrices && a.getUniformIndex("boneTextureWidth") > -1) {
-        const o = e.getTransformMatrixTexture(r);
-        a.setTexture("boneSampler", o), a.setFloat("boneTextureWidth", 4 * (e.bones.length + 1));
-      } else {
-        const o = e.getTransformMatrices(r);
-        o && (a.setMatrices("mBones", o), t && r.getScene().prePassRenderer && r.getScene().prePassRenderer.getIndex(2) && (t.previousBones[r.uniqueId] || (t.previousBones[r.uniqueId] = o.slice()), a.setMatrices("mPreviousBones", t.previousBones[r.uniqueId]), i._CopyBonesTransformationMatrices(o, t.previousBones[r.uniqueId])));
-      }
-    }
-  }
-  // Copies the bones transformation matrices into the target array and returns the target's reference
-  static _CopyBonesTransformationMatrices(r, a) {
-    return a.set(r), a;
-  }
-  /**
-   * Binds the morph targets information from the mesh to the effect.
-   * @param abstractMesh The mesh we are binding the information to render
-   * @param effect The effect we are binding the data to
-   */
-  static BindMorphTargetParameters(r, a) {
-    const t = r.morphTargetManager;
-    !r || !t || a.setFloatArray("morphTargetInfluences", t.influences);
-  }
-  /**
-   * Binds the logarithmic depth information from the scene to the effect for the given defines.
-   * @param defines The generated defines used in the effect
-   * @param effect The effect we are binding the data to
-   * @param scene The scene we are willing to render with logarithmic scale for
-   */
-  static BindLogDepth(r, a, t) {
-    if (!r || r.LOGARITHMICDEPTH || r.indexOf && r.indexOf("LOGARITHMICDEPTH") >= 0) {
-      const e = t.activeCamera;
-      e.mode === p.ORTHOGRAPHIC_CAMERA && n.Error("Logarithmic depth is not compatible with orthographic cameras!", 20), a.setFloat("logarithmicDepthConstant", 2 / (Math.log(e.maxZ + 1) / Math.LN2));
-    }
-  }
-}
-i._TmpMorphInfluencers = { NUM_MORPH_INFLUENCERS: 0 };
-i._TempFogColor = R.Black();
-export {
-  i as MaterialHelper
-};