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

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

@@ -1,838 +0,0 @@
-import { SerializationHelper as E } from "../Misc/decorators.esm.js";
-import { Matrix as O, Vector2 as j, Vector3 as q, Vector4 as W, Quaternion as L } from "../Maths/math.vector.esm.js";
-import { VertexBuffer as l } from "../Buffers/buffer.esm.js";
-import { Texture as C } from "./Textures/texture.esm.js";
-import { MaterialHelper as g } from "./materialHelper.esm.js";
-import { RegisterClass as z } from "../Misc/typeStore.esm.js";
-import { Color3 as V, Color4 as N } from "../Maths/math.color.esm.js";
-import { EffectFallbacks as H } from "./effectFallbacks.esm.js";
-import { WebRequest as R } from "../Misc/webRequest.esm.js";
-import { PushMaterial as K } from "./pushMaterial.esm.js";
-import { EngineStore as I } from "../Engines/engineStore.esm.js";
-import { addClipPlaneUniforms as G, prepareStringDefinesForClipPlanes as D, bindClipPlane as Q } from "./clipPlaneMaterialHelper.esm.js";
-const k = { effect: null, subMesh: null };
-class x extends K {
-  /**
-   * Instantiate a new shader material.
-   * The ShaderMaterial object has the necessary methods to pass data from your scene to the Vertex and Fragment Shaders and returns a material that can be applied to any mesh.
-   * This returned material effects how the mesh will look based on the code in the shaders.
-   * @see https://doc.babylonjs.com/features/featuresDeepDive/materials/shaders/shaderMaterial
-   * @param name Define the name of the material in the scene
-   * @param scene Define the scene the material belongs to
-   * @param shaderPath Defines  the route to the shader code in one of three ways:
-   *  * object: \{ vertex: "custom", fragment: "custom" \}, used with Effect.ShadersStore["customVertexShader"] and Effect.ShadersStore["customFragmentShader"]
-   *  * object: \{ vertexElement: "vertexShaderCode", fragmentElement: "fragmentShaderCode" \}, used with shader code in script tags
-   *  * object: \{ vertexSource: "vertex shader code string", fragmentSource: "fragment shader code string" \} using with strings containing the shaders code
-   *  * string: "./COMMON_NAME", used with external files COMMON_NAME.vertex.fx and COMMON_NAME.fragment.fx in index.html folder.
-   * @param options Define the options used to create the shader
-   * @param storeEffectOnSubMeshes true to store effect on submeshes, false to store the effect directly in the material class.
-   */
-  constructor(t, s, e, o = {}, i = !0) {
-    super(t, s, i), this._textures = {}, this._textureArrays = {}, this._externalTextures = {}, this._floats = {}, this._ints = {}, this._uints = {}, this._floatsArrays = {}, this._colors3 = {}, this._colors3Arrays = {}, this._colors4 = {}, this._colors4Arrays = {}, this._vectors2 = {}, this._vectors3 = {}, this._vectors4 = {}, this._quaternions = {}, this._quaternionsArrays = {}, this._matrices = {}, this._matrixArrays = {}, this._matrices3x3 = {}, this._matrices2x2 = {}, this._vectors2Arrays = {}, this._vectors3Arrays = {}, this._vectors4Arrays = {}, this._uniformBuffers = {}, this._textureSamplers = {}, this._storageBuffers = {}, this._cachedWorldViewMatrix = new O(), this._cachedWorldViewProjectionMatrix = new O(), this._multiview = !1, this._materialHelperNeedsPreviousMatrices = !1, this._shaderPath = e, this._options = Object.assign({ needAlphaBlending: !1, needAlphaTesting: !1, attributes: ["position", "normal", "uv"], uniforms: ["worldViewProjection"], uniformBuffers: [], samplers: [], externalTextures: [], samplerObjects: [], storageBuffers: [], defines: [], useClipPlane: !1 }, o);
-  }
-  /**
-   * Gets the shader path used to define the shader code
-   * It can be modified to trigger a new compilation
-   */
-  get shaderPath() {
-    return this._shaderPath;
-  }
-  /**
-   * Sets the shader path used to define the shader code
-   * It can be modified to trigger a new compilation
-   */
-  set shaderPath(t) {
-    this._shaderPath = t;
-  }
-  /**
-   * Gets the options used to compile the shader.
-   * They can be modified to trigger a new compilation
-   */
-  get options() {
-    return this._options;
-  }
-  /**
-   * is multiview set to true?
-   */
-  get isMultiview() {
-    return this._multiview;
-  }
-  /**
-   * Gets the current class name of the material e.g. "ShaderMaterial"
-   * Mainly use in serialization.
-   * @returns the class name
-   */
-  getClassName() {
-    return "ShaderMaterial";
-  }
-  /**
-   * Specifies if the material will require alpha blending
-   * @returns a boolean specifying if alpha blending is needed
-   */
-  needAlphaBlending() {
-    return this.alpha < 1 || this._options.needAlphaBlending;
-  }
-  /**
-   * Specifies if this material should be rendered in alpha test mode
-   * @returns a boolean specifying if an alpha test is needed.
-   */
-  needAlphaTesting() {
-    return this._options.needAlphaTesting;
-  }
-  _checkUniform(t) {
-    this._options.uniforms.indexOf(t) === -1 && this._options.uniforms.push(t);
-  }
-  /**
-   * Set a texture in the shader.
-   * @param name Define the name of the uniform samplers as defined in the shader
-   * @param texture Define the texture to bind to this sampler
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setTexture(t, s) {
-    return this._options.samplers.indexOf(t) === -1 && this._options.samplers.push(t), this._textures[t] = s, this;
-  }
-  /**
-   * Set a texture array in the shader.
-   * @param name Define the name of the uniform sampler array as defined in the shader
-   * @param textures Define the list of textures to bind to this sampler
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setTextureArray(t, s) {
-    return this._options.samplers.indexOf(t) === -1 && this._options.samplers.push(t), this._checkUniform(t), this._textureArrays[t] = s, this;
-  }
-  /**
-   * Set an internal texture in the shader.
-   * @param name Define the name of the uniform samplers as defined in the shader
-   * @param texture Define the texture to bind to this sampler
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setExternalTexture(t, s) {
-    return this._options.externalTextures.indexOf(t) === -1 && this._options.externalTextures.push(t), this._externalTextures[t] = s, this;
-  }
-  /**
-   * Set a float in the shader.
-   * @param name Define the name of the uniform as defined in the shader
-   * @param value Define the value to give to the uniform
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setFloat(t, s) {
-    return this._checkUniform(t), this._floats[t] = s, this;
-  }
-  /**
-   * Set a int in the shader.
-   * @param name Define the name of the uniform as defined in the shader
-   * @param value Define the value to give to the uniform
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setInt(t, s) {
-    return this._checkUniform(t), this._ints[t] = s, this;
-  }
-  /**
-   * Set a unsigned int in the shader.
-   * @param name Define the name of the uniform as defined in the shader
-   * @param value Define the value to give to the uniform
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setUInt(t, s) {
-    return this._checkUniform(t), this._uints[t] = s, this;
-  }
-  /**
-   * Set an array of floats in the shader.
-   * @param name Define the name of the uniform as defined in the shader
-   * @param value Define the value to give to the uniform
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setFloats(t, s) {
-    return this._checkUniform(t), this._floatsArrays[t] = s, this;
-  }
-  /**
-   * Set a vec3 in the shader from a Color3.
-   * @param name Define the name of the uniform as defined in the shader
-   * @param value Define the value to give to the uniform
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setColor3(t, s) {
-    return this._checkUniform(t), this._colors3[t] = s, this;
-  }
-  /**
-   * Set a vec3 array in the shader from a Color3 array.
-   * @param name Define the name of the uniform as defined in the shader
-   * @param value Define the value to give to the uniform
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setColor3Array(t, s) {
-    return this._checkUniform(t), this._colors3Arrays[t] = s.reduce((e, o) => (o.toArray(e, e.length), e), []), this;
-  }
-  /**
-   * Set a vec4 in the shader from a Color4.
-   * @param name Define the name of the uniform as defined in the shader
-   * @param value Define the value to give to the uniform
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setColor4(t, s) {
-    return this._checkUniform(t), this._colors4[t] = s, this;
-  }
-  /**
-   * Set a vec4 array in the shader from a Color4 array.
-   * @param name Define the name of the uniform as defined in the shader
-   * @param value Define the value to give to the uniform
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setColor4Array(t, s) {
-    return this._checkUniform(t), this._colors4Arrays[t] = s.reduce((e, o) => (o.toArray(e, e.length), e), []), this;
-  }
-  /**
-   * Set a vec2 in the shader from a Vector2.
-   * @param name Define the name of the uniform as defined in the shader
-   * @param value Define the value to give to the uniform
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setVector2(t, s) {
-    return this._checkUniform(t), this._vectors2[t] = s, this;
-  }
-  /**
-   * Set a vec3 in the shader from a Vector3.
-   * @param name Define the name of the uniform as defined in the shader
-   * @param value Define the value to give to the uniform
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setVector3(t, s) {
-    return this._checkUniform(t), this._vectors3[t] = s, this;
-  }
-  /**
-   * Set a vec4 in the shader from a Vector4.
-   * @param name Define the name of the uniform as defined in the shader
-   * @param value Define the value to give to the uniform
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setVector4(t, s) {
-    return this._checkUniform(t), this._vectors4[t] = s, this;
-  }
-  /**
-   * Set a vec4 in the shader from a Quaternion.
-   * @param name Define the name of the uniform as defined in the shader
-   * @param value Define the value to give to the uniform
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setQuaternion(t, s) {
-    return this._checkUniform(t), this._quaternions[t] = s, this;
-  }
-  /**
-   * Set a vec4 array in the shader from a Quaternion array.
-   * @param name Define the name of the uniform as defined in the shader
-   * @param value Define the value to give to the uniform
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setQuaternionArray(t, s) {
-    return this._checkUniform(t), this._quaternionsArrays[t] = s.reduce((e, o) => (o.toArray(e, e.length), e), []), this;
-  }
-  /**
-   * Set a mat4 in the shader from a Matrix.
-   * @param name Define the name of the uniform as defined in the shader
-   * @param value Define the value to give to the uniform
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setMatrix(t, s) {
-    return this._checkUniform(t), this._matrices[t] = s, this;
-  }
-  /**
-   * Set a float32Array in the shader from a matrix array.
-   * @param name Define the name of the uniform as defined in the shader
-   * @param value Define the value to give to the uniform
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setMatrices(t, s) {
-    this._checkUniform(t);
-    const e = new Float32Array(s.length * 16);
-    for (let o = 0; o < s.length; o++)
-      s[o].copyToArray(e, o * 16);
-    return this._matrixArrays[t] = e, this;
-  }
-  /**
-   * Set a mat3 in the shader from a Float32Array.
-   * @param name Define the name of the uniform as defined in the shader
-   * @param value Define the value to give to the uniform
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setMatrix3x3(t, s) {
-    return this._checkUniform(t), this._matrices3x3[t] = s, this;
-  }
-  /**
-   * Set a mat2 in the shader from a Float32Array.
-   * @param name Define the name of the uniform as defined in the shader
-   * @param value Define the value to give to the uniform
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setMatrix2x2(t, s) {
-    return this._checkUniform(t), this._matrices2x2[t] = s, this;
-  }
-  /**
-   * Set a vec2 array in the shader from a number array.
-   * @param name Define the name of the uniform as defined in the shader
-   * @param value Define the value to give to the uniform
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setArray2(t, s) {
-    return this._checkUniform(t), this._vectors2Arrays[t] = s, this;
-  }
-  /**
-   * Set a vec3 array in the shader from a number array.
-   * @param name Define the name of the uniform as defined in the shader
-   * @param value Define the value to give to the uniform
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setArray3(t, s) {
-    return this._checkUniform(t), this._vectors3Arrays[t] = s, this;
-  }
-  /**
-   * Set a vec4 array in the shader from a number array.
-   * @param name Define the name of the uniform as defined in the shader
-   * @param value Define the value to give to the uniform
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setArray4(t, s) {
-    return this._checkUniform(t), this._vectors4Arrays[t] = s, this;
-  }
-  /**
-   * Set a uniform buffer in the shader
-   * @param name Define the name of the uniform as defined in the shader
-   * @param buffer Define the value to give to the uniform
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setUniformBuffer(t, s) {
-    return this._options.uniformBuffers.indexOf(t) === -1 && this._options.uniformBuffers.push(t), this._uniformBuffers[t] = s, this;
-  }
-  /**
-   * Set a texture sampler in the shader
-   * @param name Define the name of the uniform as defined in the shader
-   * @param sampler Define the value to give to the uniform
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setTextureSampler(t, s) {
-    return this._options.samplerObjects.indexOf(t) === -1 && this._options.samplerObjects.push(t), this._textureSamplers[t] = s, this;
-  }
-  /**
-   * Set a storage buffer in the shader
-   * @param name Define the name of the storage buffer as defined in the shader
-   * @param buffer Define the value to give to the uniform
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setStorageBuffer(t, s) {
-    return this._options.storageBuffers.indexOf(t) === -1 && this._options.storageBuffers.push(t), this._storageBuffers[t] = s, this;
-  }
-  /**
-   * Adds, removes, or replaces the specified shader define and value.
-   * * setDefine("MY_DEFINE", true); // enables a boolean define
-   * * setDefine("MY_DEFINE", "0.5"); // adds "#define MY_DEFINE 0.5" to the shader (or sets and replaces the value of any existing define with that name)
-   * * setDefine("MY_DEFINE", false); // disables and removes the define
-   * Note if the active defines do change, the shader will be recompiled and this can be expensive.
-   * @param define the define name e.g., "OUTPUT_TO_SRGB" or "#define OUTPUT_TO_SRGB". If the define was passed into the constructor already, the version used should match that, and in either case, it should not include any appended value.
-   * @param value either the value of the define (e.g. a numerical value) or for booleans, true if the define should be enabled or false if it should be disabled
-   * @returns the material itself allowing "fluent" like uniform updates
-   */
-  setDefine(t, s) {
-    const e = t.trimEnd() + " ", o = this.options.defines.findIndex((i) => i === t || i.startsWith(e));
-    return o >= 0 && this.options.defines.splice(o, 1), (typeof s != "boolean" || s) && this.options.defines.push(e + s), this;
-  }
-  /**
-   * Specifies that the submesh is ready to be used
-   * @param mesh defines the mesh to check
-   * @param subMesh defines which submesh to check
-   * @param useInstances specifies that instances should be used
-   * @returns a boolean indicating that the submesh is ready or not
-   */
-  isReadyForSubMesh(t, s, e) {
-    return this.isReady(t, e, s);
-  }
-  /**
-   * Checks if the material is ready to render the requested mesh
-   * @param mesh Define the mesh to render
-   * @param useInstances Define whether or not the material is used with instances
-   * @param subMesh defines which submesh to render
-   * @returns true if ready, otherwise false
-   */
-  isReady(t, s, e) {
-    var o, i, h, n;
-    const c = e && this._storeEffectOnSubMeshes;
-    if (this.isFrozen)
-      if (c) {
-        if (e.effect && e.effect._wasPreviouslyReady)
-          return !0;
-      } else {
-        const f = this._drawWrapper.effect;
-        if (f && f._wasPreviouslyReady && f._wasPreviouslyUsingInstances === s)
-          return !0;
-      }
-    const u = this.getScene(), y = u.getEngine(), r = [], a = [], B = new H();
-    let P = this._shaderPath, _ = this._options.uniforms, T = this._options.uniformBuffers, S = this._options.samplers;
-    y.getCaps().multiview && u.activeCamera && u.activeCamera.outputRenderTarget && u.activeCamera.outputRenderTarget.getViewCount() > 1 && (this._multiview = !0, r.push("#define MULTIVIEW"), this._options.uniforms.indexOf("viewProjection") !== -1 && this._options.uniforms.indexOf("viewProjectionR") === -1 && this._options.uniforms.push("viewProjectionR"));
-    for (let f = 0; f < this._options.defines.length; f++) {
-      const b = this._options.defines[f].indexOf("#define") === 0 ? this._options.defines[f] : `#define ${this._options.defines[f]}`;
-      r.push(b);
-    }
-    for (let f = 0; f < this._options.attributes.length; f++)
-      a.push(this._options.attributes[f]);
-    if (t && t.isVerticesDataPresent(l.ColorKind) && (a.push(l.ColorKind), r.push("#define VERTEXCOLOR")), s && (r.push("#define INSTANCES"), g.PushAttributesForInstances(a, this._materialHelperNeedsPreviousMatrices), t != null && t.hasThinInstances && (r.push("#define THIN_INSTANCES"), t && t.isVerticesDataPresent(l.ColorInstanceKind) && (a.push(l.ColorInstanceKind), r.push("#define INSTANCESCOLOR")))), t && t.useBones && t.computeBonesUsingShaders && t.skeleton) {
-      a.push(l.MatricesIndicesKind), a.push(l.MatricesWeightsKind), t.numBoneInfluencers > 4 && (a.push(l.MatricesIndicesExtraKind), a.push(l.MatricesWeightsExtraKind));
-      const f = t.skeleton;
-      r.push("#define NUM_BONE_INFLUENCERS " + t.numBoneInfluencers), B.addCPUSkinningFallback(0, t), f.isUsingTextureForMatrices ? (r.push("#define BONETEXTURE"), this._options.uniforms.indexOf("boneTextureWidth") === -1 && this._options.uniforms.push("boneTextureWidth"), this._options.samplers.indexOf("boneSampler") === -1 && this._options.samplers.push("boneSampler")) : (r.push("#define BonesPerMesh " + (f.bones.length + 1)), this._options.uniforms.indexOf("mBones") === -1 && this._options.uniforms.push("mBones"));
-    } else
-      r.push("#define NUM_BONE_INFLUENCERS 0");
-    let A = 0;
-    const m = t ? t.morphTargetManager : null;
-    if (m) {
-      const f = m.supportsUVs && r.indexOf("#define UV1") !== -1, b = m.supportsTangents && r.indexOf("#define TANGENT") !== -1, w = m.supportsNormals && r.indexOf("#define NORMAL") !== -1;
-      A = m.numInfluencers, f && r.push("#define MORPHTARGETS_UV"), b && r.push("#define MORPHTARGETS_TANGENT"), w && r.push("#define MORPHTARGETS_NORMAL"), A > 0 && r.push("#define MORPHTARGETS"), m.isUsingTextureForTargets && (r.push("#define MORPHTARGETS_TEXTURE"), this._options.uniforms.indexOf("morphTargetTextureIndices") === -1 && this._options.uniforms.push("morphTargetTextureIndices"), this._options.samplers.indexOf("morphTargets") === -1 && this._options.samplers.push("morphTargets")), r.push("#define NUM_MORPH_INFLUENCERS " + A);
-      for (let v = 0; v < A; v++)
-        a.push(l.PositionKind + v), w && a.push(l.NormalKind + v), b && a.push(l.TangentKind + v), f && a.push(l.UVKind + "_" + v);
-      A > 0 && (_ = _.slice(), _.push("morphTargetInfluences"), _.push("morphTargetTextureInfo"), _.push("morphTargetTextureIndices"));
-    } else
-      r.push("#define NUM_MORPH_INFLUENCERS 0");
-    if (t) {
-      const f = t.bakedVertexAnimationManager;
-      f && f.isEnabled && (r.push("#define BAKED_VERTEX_ANIMATION_TEXTURE"), this._options.uniforms.indexOf("bakedVertexAnimationSettings") === -1 && this._options.uniforms.push("bakedVertexAnimationSettings"), this._options.uniforms.indexOf("bakedVertexAnimationTextureSizeInverted") === -1 && this._options.uniforms.push("bakedVertexAnimationTextureSizeInverted"), this._options.uniforms.indexOf("bakedVertexAnimationTime") === -1 && this._options.uniforms.push("bakedVertexAnimationTime"), this._options.samplers.indexOf("bakedVertexAnimationTexture") === -1 && this._options.samplers.push("bakedVertexAnimationTexture")), g.PrepareAttributesForBakedVertexAnimation(a, t, r);
-    }
-    for (const f in this._textures)
-      if (!this._textures[f].isReady())
-        return !1;
-    t && this._shouldTurnAlphaTestOn(t) && r.push("#define ALPHATEST"), this._options.useClipPlane !== !1 && (G(_), D(this, u, r)), this.customShaderNameResolve && (_ = _.slice(), T = T.slice(), S = S.slice(), P = this.customShaderNameResolve(P, _, T, S, r, a));
-    const d = c ? e._getDrawWrapper() : this._drawWrapper, U = (o = d == null ? void 0 : d.effect) !== null && o !== void 0 ? o : null, F = (i = d == null ? void 0 : d.defines) !== null && i !== void 0 ? i : null, M = r.join(`
-`);
-    let p = U;
-    return F !== M && (p = y.createEffect(P, {
-      attributes: a,
-      uniformsNames: _,
-      uniformBuffersNames: T,
-      samplers: S,
-      defines: M,
-      fallbacks: B,
-      onCompiled: this.onCompiled,
-      onError: this.onError,
-      indexParameters: { maxSimultaneousMorphTargets: A },
-      shaderLanguage: this._options.shaderLanguage
-    }, y), c ? e.setEffect(p, M, this._materialContext) : d && d.setEffect(p, M), this._onEffectCreatedObservable && (k.effect = p, k.subMesh = (h = e ?? (t == null ? void 0 : t.subMeshes[0])) !== null && h !== void 0 ? h : null, this._onEffectCreatedObservable.notifyObservers(k))), p._wasPreviouslyUsingInstances = !!s, !((n = !(p != null && p.isReady())) !== null && n !== void 0) || n ? !1 : (U !== p && u.resetCachedMaterial(), p._wasPreviouslyReady = !0, !0);
-  }
-  /**
-   * Binds the world matrix to the material
-   * @param world defines the world transformation matrix
-   * @param effectOverride - If provided, use this effect instead of internal effect
-   */
-  bindOnlyWorldMatrix(t, s) {
-    const e = this.getScene(), o = s ?? this.getEffect();
-    o && (this._options.uniforms.indexOf("world") !== -1 && o.setMatrix("world", t), this._options.uniforms.indexOf("worldView") !== -1 && (t.multiplyToRef(e.getViewMatrix(), this._cachedWorldViewMatrix), o.setMatrix("worldView", this._cachedWorldViewMatrix)), this._options.uniforms.indexOf("worldViewProjection") !== -1 && (t.multiplyToRef(e.getTransformMatrix(), this._cachedWorldViewProjectionMatrix), o.setMatrix("worldViewProjection", this._cachedWorldViewProjectionMatrix)));
-  }
-  /**
-   * Binds the submesh to this material by preparing the effect and shader to draw
-   * @param world defines the world transformation matrix
-   * @param mesh defines the mesh containing the submesh
-   * @param subMesh defines the submesh to bind the material to
-   */
-  bindForSubMesh(t, s, e) {
-    var o;
-    this.bind(t, s, (o = e._drawWrapperOverride) === null || o === void 0 ? void 0 : o.effect, e);
-  }
-  /**
-   * Binds the material to the mesh
-   * @param world defines the world transformation matrix
-   * @param mesh defines the mesh to bind the material to
-   * @param effectOverride - If provided, use this effect instead of internal effect
-   * @param subMesh defines the submesh to bind the material to
-   */
-  bind(t, s, e, o) {
-    var i;
-    const h = o && this._storeEffectOnSubMeshes, n = e ?? (h ? o.effect : this.getEffect());
-    if (!n)
-      return;
-    this._activeEffect = n, this.bindOnlyWorldMatrix(t, e);
-    const c = this._options.uniformBuffers;
-    let u = !1;
-    if (n && c && c.length > 0 && this.getScene().getEngine().supportsUniformBuffers)
-      for (let r = 0; r < c.length; ++r)
-        switch (c[r]) {
-          case "Mesh":
-            s && (s.getMeshUniformBuffer().bindToEffect(n, "Mesh"), s.transferToEffect(t));
-            break;
-          case "Scene":
-            g.BindSceneUniformBuffer(n, this.getScene().getSceneUniformBuffer()), this.getScene().finalizeSceneUbo(), u = !0;
-            break;
-        }
-    const y = s && h ? this._mustRebind(this.getScene(), n, s.visibility) : this.getScene().getCachedMaterial() !== this;
-    if (n && y) {
-      !u && this._options.uniforms.indexOf("view") !== -1 && n.setMatrix("view", this.getScene().getViewMatrix()), !u && this._options.uniforms.indexOf("projection") !== -1 && n.setMatrix("projection", this.getScene().getProjectionMatrix()), !u && this._options.uniforms.indexOf("viewProjection") !== -1 && (n.setMatrix("viewProjection", this.getScene().getTransformMatrix()), this._multiview && n.setMatrix("viewProjectionR", this.getScene()._transformMatrixR)), this.getScene().activeCamera && this._options.uniforms.indexOf("cameraPosition") !== -1 && n.setVector3("cameraPosition", this.getScene().activeCamera.globalPosition), g.BindBonesParameters(s, n), Q(n, this, this.getScene());
-      let r;
-      for (r in this._textures)
-        n.setTexture(r, this._textures[r]);
-      for (r in this._textureArrays)
-        n.setTextureArray(r, this._textureArrays[r]);
-      for (r in this._externalTextures)
-        n.setExternalTexture(r, this._externalTextures[r]);
-      for (r in this._ints)
-        n.setInt(r, this._ints[r]);
-      for (r in this._uints)
-        n.setUInt(r, this._uints[r]);
-      for (r in this._floats)
-        n.setFloat(r, this._floats[r]);
-      for (r in this._floatsArrays)
-        n.setArray(r, this._floatsArrays[r]);
-      for (r in this._colors3)
-        n.setColor3(r, this._colors3[r]);
-      for (r in this._colors3Arrays)
-        n.setArray3(r, this._colors3Arrays[r]);
-      for (r in this._colors4) {
-        const a = this._colors4[r];
-        n.setFloat4(r, a.r, a.g, a.b, a.a);
-      }
-      for (r in this._colors4Arrays)
-        n.setArray4(r, this._colors4Arrays[r]);
-      for (r in this._vectors2)
-        n.setVector2(r, this._vectors2[r]);
-      for (r in this._vectors3)
-        n.setVector3(r, this._vectors3[r]);
-      for (r in this._vectors4)
-        n.setVector4(r, this._vectors4[r]);
-      for (r in this._quaternions)
-        n.setQuaternion(r, this._quaternions[r]);
-      for (r in this._matrices)
-        n.setMatrix(r, this._matrices[r]);
-      for (r in this._matrixArrays)
-        n.setMatrices(r, this._matrixArrays[r]);
-      for (r in this._matrices3x3)
-        n.setMatrix3x3(r, this._matrices3x3[r]);
-      for (r in this._matrices2x2)
-        n.setMatrix2x2(r, this._matrices2x2[r]);
-      for (r in this._vectors2Arrays)
-        n.setArray2(r, this._vectors2Arrays[r]);
-      for (r in this._vectors3Arrays)
-        n.setArray3(r, this._vectors3Arrays[r]);
-      for (r in this._vectors4Arrays)
-        n.setArray4(r, this._vectors4Arrays[r]);
-      for (r in this._quaternionsArrays)
-        n.setArray4(r, this._quaternionsArrays[r]);
-      for (r in this._uniformBuffers) {
-        const a = this._uniformBuffers[r].getBuffer();
-        a && n.bindUniformBuffer(a, r);
-      }
-      for (r in this._textureSamplers)
-        n.setTextureSampler(r, this._textureSamplers[r]);
-      for (r in this._storageBuffers)
-        n.setStorageBuffer(r, this._storageBuffers[r]);
-    }
-    if (n && s && (y || !this.isFrozen)) {
-      const r = s.morphTargetManager;
-      r && r.numInfluencers > 0 && g.BindMorphTargetParameters(s, n);
-      const a = s.bakedVertexAnimationManager;
-      a && a.isEnabled && ((i = s.bakedVertexAnimationManager) === null || i === void 0 || i.bind(n, !!n._wasPreviouslyUsingInstances));
-    }
-    this._afterBind(s, n);
-  }
-  /**
-   * Gets the active textures from the material
-   * @returns an array of textures
-   */
-  getActiveTextures() {
-    const t = super.getActiveTextures();
-    for (const s in this._textures)
-      t.push(this._textures[s]);
-    for (const s in this._textureArrays) {
-      const e = this._textureArrays[s];
-      for (let o = 0; o < e.length; o++)
-        t.push(e[o]);
-    }
-    return t;
-  }
-  /**
-   * Specifies if the material uses a texture
-   * @param texture defines the texture to check against the material
-   * @returns a boolean specifying if the material uses the texture
-   */
-  hasTexture(t) {
-    if (super.hasTexture(t))
-      return !0;
-    for (const s in this._textures)
-      if (this._textures[s] === t)
-        return !0;
-    for (const s in this._textureArrays) {
-      const e = this._textureArrays[s];
-      for (let o = 0; o < e.length; o++)
-        if (e[o] === t)
-          return !0;
-    }
-    return !1;
-  }
-  /**
-   * Makes a duplicate of the material, and gives it a new name
-   * @param name defines the new name for the duplicated material
-   * @returns the cloned material
-   */
-  clone(t) {
-    const s = E.Clone(() => new x(t, this.getScene(), this._shaderPath, this._options, this._storeEffectOnSubMeshes), this);
-    s.name = t, s.id = t, typeof s._shaderPath == "object" && (s._shaderPath = Object.assign({}, s._shaderPath)), this._options = Object.assign({}, this._options), Object.keys(this._options).forEach((e) => {
-      const o = this._options[e];
-      Array.isArray(o) && (this._options[e] = o.slice(0));
-    }), this.stencil.copyTo(s.stencil);
-    for (const e in this._textures)
-      s.setTexture(e, this._textures[e]);
-    for (const e in this._textureArrays)
-      s.setTextureArray(e, this._textureArrays[e]);
-    for (const e in this._externalTextures)
-      s.setExternalTexture(e, this._externalTextures[e]);
-    for (const e in this._ints)
-      s.setInt(e, this._ints[e]);
-    for (const e in this._uints)
-      s.setUInt(e, this._uints[e]);
-    for (const e in this._floats)
-      s.setFloat(e, this._floats[e]);
-    for (const e in this._floatsArrays)
-      s.setFloats(e, this._floatsArrays[e]);
-    for (const e in this._colors3)
-      s.setColor3(e, this._colors3[e]);
-    for (const e in this._colors3Arrays)
-      s._colors3Arrays[e] = this._colors3Arrays[e];
-    for (const e in this._colors4)
-      s.setColor4(e, this._colors4[e]);
-    for (const e in this._colors4Arrays)
-      s._colors4Arrays[e] = this._colors4Arrays[e];
-    for (const e in this._vectors2)
-      s.setVector2(e, this._vectors2[e]);
-    for (const e in this._vectors3)
-      s.setVector3(e, this._vectors3[e]);
-    for (const e in this._vectors4)
-      s.setVector4(e, this._vectors4[e]);
-    for (const e in this._quaternions)
-      s.setQuaternion(e, this._quaternions[e]);
-    for (const e in this._quaternionsArrays)
-      s._quaternionsArrays[e] = this._quaternionsArrays[e];
-    for (const e in this._matrices)
-      s.setMatrix(e, this._matrices[e]);
-    for (const e in this._matrixArrays)
-      s._matrixArrays[e] = this._matrixArrays[e].slice();
-    for (const e in this._matrices3x3)
-      s.setMatrix3x3(e, this._matrices3x3[e]);
-    for (const e in this._matrices2x2)
-      s.setMatrix2x2(e, this._matrices2x2[e]);
-    for (const e in this._vectors2Arrays)
-      s.setArray2(e, this._vectors2Arrays[e]);
-    for (const e in this._vectors3Arrays)
-      s.setArray3(e, this._vectors3Arrays[e]);
-    for (const e in this._vectors4Arrays)
-      s.setArray4(e, this._vectors4Arrays[e]);
-    for (const e in this._uniformBuffers)
-      s.setUniformBuffer(e, this._uniformBuffers[e]);
-    for (const e in this._textureSamplers)
-      s.setTextureSampler(e, this._textureSamplers[e]);
-    for (const e in this._storageBuffers)
-      s.setStorageBuffer(e, this._storageBuffers[e]);
-    return s;
-  }
-  /**
-   * Disposes the material
-   * @param forceDisposeEffect specifies if effects should be forcefully disposed
-   * @param forceDisposeTextures specifies if textures should be forcefully disposed
-   * @param notBoundToMesh specifies if the material that is being disposed is known to be not bound to any mesh
-   */
-  dispose(t, s, e) {
-    if (s) {
-      let o;
-      for (o in this._textures)
-        this._textures[o].dispose();
-      for (o in this._textureArrays) {
-        const i = this._textureArrays[o];
-        for (let h = 0; h < i.length; h++)
-          i[h].dispose();
-      }
-    }
-    this._textures = {}, super.dispose(t, s, e);
-  }
-  /**
-   * Serializes this material in a JSON representation
-   * @returns the serialized material object
-   */
-  serialize() {
-    const t = E.Serialize(this);
-    t.customType = "BABYLON.ShaderMaterial", t.uniqueId = this.uniqueId, t.options = this._options, t.shaderPath = this._shaderPath, t.storeEffectOnSubMeshes = this._storeEffectOnSubMeshes;
-    let s;
-    t.stencil = this.stencil.serialize(), t.textures = {};
-    for (s in this._textures)
-      t.textures[s] = this._textures[s].serialize();
-    t.textureArrays = {};
-    for (s in this._textureArrays) {
-      t.textureArrays[s] = [];
-      const e = this._textureArrays[s];
-      for (let o = 0; o < e.length; o++)
-        t.textureArrays[s].push(e[o].serialize());
-    }
-    t.ints = {};
-    for (s in this._ints)
-      t.ints[s] = this._ints[s];
-    t.uints = {};
-    for (s in this._uints)
-      t.uints[s] = this._uints[s];
-    t.floats = {};
-    for (s in this._floats)
-      t.floats[s] = this._floats[s];
-    t.FloatArrays = {};
-    for (s in this._floatsArrays)
-      t.FloatArrays[s] = this._floatsArrays[s];
-    t.colors3 = {};
-    for (s in this._colors3)
-      t.colors3[s] = this._colors3[s].asArray();
-    t.colors3Arrays = {};
-    for (s in this._colors3Arrays)
-      t.colors3Arrays[s] = this._colors3Arrays[s];
-    t.colors4 = {};
-    for (s in this._colors4)
-      t.colors4[s] = this._colors4[s].asArray();
-    t.colors4Arrays = {};
-    for (s in this._colors4Arrays)
-      t.colors4Arrays[s] = this._colors4Arrays[s];
-    t.vectors2 = {};
-    for (s in this._vectors2)
-      t.vectors2[s] = this._vectors2[s].asArray();
-    t.vectors3 = {};
-    for (s in this._vectors3)
-      t.vectors3[s] = this._vectors3[s].asArray();
-    t.vectors4 = {};
-    for (s in this._vectors4)
-      t.vectors4[s] = this._vectors4[s].asArray();
-    t.quaternions = {};
-    for (s in this._quaternions)
-      t.quaternions[s] = this._quaternions[s].asArray();
-    t.matrices = {};
-    for (s in this._matrices)
-      t.matrices[s] = this._matrices[s].asArray();
-    t.matrixArray = {};
-    for (s in this._matrixArrays)
-      t.matrixArray[s] = this._matrixArrays[s];
-    t.matrices3x3 = {};
-    for (s in this._matrices3x3)
-      t.matrices3x3[s] = this._matrices3x3[s];
-    t.matrices2x2 = {};
-    for (s in this._matrices2x2)
-      t.matrices2x2[s] = this._matrices2x2[s];
-    t.vectors2Arrays = {};
-    for (s in this._vectors2Arrays)
-      t.vectors2Arrays[s] = this._vectors2Arrays[s];
-    t.vectors3Arrays = {};
-    for (s in this._vectors3Arrays)
-      t.vectors3Arrays[s] = this._vectors3Arrays[s];
-    t.vectors4Arrays = {};
-    for (s in this._vectors4Arrays)
-      t.vectors4Arrays[s] = this._vectors4Arrays[s];
-    t.quaternionsArrays = {};
-    for (s in this._quaternionsArrays)
-      t.quaternionsArrays[s] = this._quaternionsArrays[s];
-    return t;
-  }
-  /**
-   * Creates a shader material from parsed shader material data
-   * @param source defines the JSON representation of the material
-   * @param scene defines the hosting scene
-   * @param rootUrl defines the root URL to use to load textures and relative dependencies
-   * @returns a new material
-   */
-  static Parse(t, s, e) {
-    const o = E.Parse(() => new x(t.name, s, t.shaderPath, t.options, t.storeEffectOnSubMeshes), t, s, e);
-    let i;
-    t.stencil && o.stencil.parse(t.stencil, s, e);
-    for (i in t.textures)
-      o.setTexture(i, C.Parse(t.textures[i], s, e));
-    for (i in t.textureArrays) {
-      const h = t.textureArrays[i], n = new Array();
-      for (let c = 0; c < h.length; c++)
-        n.push(C.Parse(h[c], s, e));
-      o.setTextureArray(i, n);
-    }
-    for (i in t.ints)
-      o.setInt(i, t.ints[i]);
-    for (i in t.uints)
-      o.setUInt(i, t.uints[i]);
-    for (i in t.floats)
-      o.setFloat(i, t.floats[i]);
-    for (i in t.floatsArrays)
-      o.setFloats(i, t.floatsArrays[i]);
-    for (i in t.colors3)
-      o.setColor3(i, V.FromArray(t.colors3[i]));
-    for (i in t.colors3Arrays) {
-      const h = t.colors3Arrays[i].reduce((n, c, u) => (u % 3 === 0 ? n.push([c]) : n[n.length - 1].push(c), n), []).map((n) => V.FromArray(n));
-      o.setColor3Array(i, h);
-    }
-    for (i in t.colors4)
-      o.setColor4(i, N.FromArray(t.colors4[i]));
-    for (i in t.colors4Arrays) {
-      const h = t.colors4Arrays[i].reduce((n, c, u) => (u % 4 === 0 ? n.push([c]) : n[n.length - 1].push(c), n), []).map((n) => N.FromArray(n));
-      o.setColor4Array(i, h);
-    }
-    for (i in t.vectors2)
-      o.setVector2(i, j.FromArray(t.vectors2[i]));
-    for (i in t.vectors3)
-      o.setVector3(i, q.FromArray(t.vectors3[i]));
-    for (i in t.vectors4)
-      o.setVector4(i, W.FromArray(t.vectors4[i]));
-    for (i in t.quaternions)
-      o.setQuaternion(i, L.FromArray(t.quaternions[i]));
-    for (i in t.matrices)
-      o.setMatrix(i, O.FromArray(t.matrices[i]));
-    for (i in t.matrixArray)
-      o._matrixArrays[i] = new Float32Array(t.matrixArray[i]);
-    for (i in t.matrices3x3)
-      o.setMatrix3x3(i, t.matrices3x3[i]);
-    for (i in t.matrices2x2)
-      o.setMatrix2x2(i, t.matrices2x2[i]);
-    for (i in t.vectors2Arrays)
-      o.setArray2(i, t.vectors2Arrays[i]);
-    for (i in t.vectors3Arrays)
-      o.setArray3(i, t.vectors3Arrays[i]);
-    for (i in t.vectors4Arrays)
-      o.setArray4(i, t.vectors4Arrays[i]);
-    for (i in t.quaternionsArrays)
-      o.setArray4(i, t.quaternionsArrays[i]);
-    return o;
-  }
-  /**
-   * Creates a new ShaderMaterial from a snippet saved in a remote file
-   * @param name defines the name of the ShaderMaterial to create (can be null or empty to use the one from the json data)
-   * @param url defines the url to load from
-   * @param scene defines the hosting scene
-   * @param rootUrl defines the root URL to use to load textures and relative dependencies
-   * @returns a promise that will resolve to the new ShaderMaterial
-   */
-  static ParseFromFileAsync(t, s, e, o = "") {
-    return new Promise((i, h) => {
-      const n = new R();
-      n.addEventListener("readystatechange", () => {
-        if (n.readyState == 4)
-          if (n.status == 200) {
-            const c = JSON.parse(n.responseText), u = this.Parse(c, e || I.LastCreatedScene, o);
-            t && (u.name = t), i(u);
-          } else
-            h("Unable to load the ShaderMaterial");
-      }), n.open("GET", s), n.send();
-    });
-  }
-  /**
-   * Creates a ShaderMaterial from a snippet saved by the Inspector
-   * @param snippetId defines the snippet to load
-   * @param scene defines the hosting scene
-   * @param rootUrl defines the root URL to use to load textures and relative dependencies
-   * @returns a promise that will resolve to the new ShaderMaterial
-   */
-  static ParseFromSnippetAsync(t, s, e = "") {
-    return new Promise((o, i) => {
-      const h = new R();
-      h.addEventListener("readystatechange", () => {
-        if (h.readyState == 4)
-          if (h.status == 200) {
-            const n = JSON.parse(JSON.parse(h.responseText).jsonPayload), c = JSON.parse(n.shaderMaterial), u = this.Parse(c, s || I.LastCreatedScene, e);
-            u.snippetId = t, o(u);
-          } else
-            i("Unable to load the snippet " + t);
-      }), h.open("GET", this.SnippetUrl + "/" + t.replace(/#/g, "/")), h.send();
-    });
-  }
-}
-x.SnippetUrl = "https://snippet.babylonjs.com";
-x.CreateFromSnippetAsync = x.ParseFromSnippetAsync;
-z("BABYLON.ShaderMaterial", x);
-export {
-  x as ShaderMaterial
-};