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

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

@@ -0,0 +1,501 @@
+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
+};