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

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

@@ -0,0 +1,906 @@
+import { __decorate as a } from "../tslib.es6.esm.js";
+import { SerializationHelper as m, serialize as l } from "../Misc/decorators.esm.js";
+import { Tools as y } from "../Misc/tools.esm.js";
+import { Observable as p } from "../Misc/observable.esm.js";
+import { EngineStore as D } from "../Engines/engineStore.esm.js";
+import { SubMesh as A } from "../Meshes/subMesh.esm.js";
+import { UniformBuffer as k } from "./uniformBuffer.esm.js";
+import { Logger as M } from "../Misc/logger.esm.js";
+import { Plane as v } from "../Maths/math.plane.esm.js";
+import { MaterialHelper as S } from "./materialHelper.esm.js";
+import { DrawWrapper as P } from "./drawWrapper.esm.js";
+import { MaterialStencilState as B } from "./materialStencilState.esm.js";
+import { ScenePerformancePriority as C } from "../scene.esm.js";
+import { MaterialPluginEvent as f } from "./materialPluginEvent.esm.js";
+class t {
+  /**
+   * If the material can be rendered to several textures with MRT extension
+   */
+  get canRenderToMRT() {
+    return !1;
+  }
+  /**
+   * Sets the alpha value of the material
+   */
+  set alpha(e) {
+    if (this._alpha === e)
+      return;
+    const s = this._alpha;
+    this._alpha = e, (s === 1 || e === 1) && this.markAsDirty(t.MiscDirtyFlag + t.PrePassDirtyFlag);
+  }
+  /**
+   * Gets the alpha value of the material
+   */
+  get alpha() {
+    return this._alpha;
+  }
+  /**
+   * Sets the culling state (true to enable culling, false to disable)
+   */
+  set backFaceCulling(e) {
+    this._backFaceCulling !== e && (this._backFaceCulling = e, this.markAsDirty(t.TextureDirtyFlag));
+  }
+  /**
+   * Gets the culling state
+   */
+  get backFaceCulling() {
+    return this._backFaceCulling;
+  }
+  /**
+   * Sets the type of faces that should be culled (true for back faces, false for front faces)
+   */
+  set cullBackFaces(e) {
+    this._cullBackFaces !== e && (this._cullBackFaces = e, this.markAsDirty(t.TextureDirtyFlag));
+  }
+  /**
+   * Gets the type of faces that should be culled
+   */
+  get cullBackFaces() {
+    return this._cullBackFaces;
+  }
+  /**
+   * Block the dirty-mechanism for this specific material
+   * When set to false after being true the material will be marked as dirty.
+   */
+  get blockDirtyMechanism() {
+    return this._blockDirtyMechanism;
+  }
+  set blockDirtyMechanism(e) {
+    this._blockDirtyMechanism !== e && (this._blockDirtyMechanism = e, e || this.markDirty());
+  }
+  /**
+   * This allows you to modify the material without marking it as dirty after every change.
+   * This function should be used if you need to make more than one dirty-enabling change to the material - adding a texture, setting a new fill mode and so on.
+   * The callback will pass the material as an argument, so you can make your changes to it.
+   * @param callback the callback to be executed that will update the material
+   */
+  atomicMaterialsUpdate(e) {
+    this.blockDirtyMechanism = !0;
+    try {
+      e(this);
+    } finally {
+      this.blockDirtyMechanism = !1;
+    }
+  }
+  /**
+   * Gets a boolean indicating that current material needs to register RTT
+   */
+  get hasRenderTargetTextures() {
+    return this._eventInfo.hasRenderTargetTextures = !1, this._callbackPluginEventHasRenderTargetTextures(this._eventInfo), this._eventInfo.hasRenderTargetTextures;
+  }
+  /**
+   * Called during a dispose event
+   */
+  set onDispose(e) {
+    this._onDisposeObserver && this.onDisposeObservable.remove(this._onDisposeObserver), this._onDisposeObserver = this.onDisposeObservable.add(e);
+  }
+  /**
+   * An event triggered when the material is bound
+   */
+  get onBindObservable() {
+    return this._onBindObservable || (this._onBindObservable = new p()), this._onBindObservable;
+  }
+  /**
+   * Called during a bind event
+   */
+  set onBind(e) {
+    this._onBindObserver && this.onBindObservable.remove(this._onBindObserver), this._onBindObserver = this.onBindObservable.add(e);
+  }
+  /**
+   * An event triggered when the material is unbound
+   */
+  get onUnBindObservable() {
+    return this._onUnBindObservable || (this._onUnBindObservable = new p()), this._onUnBindObservable;
+  }
+  /**
+   * An event triggered when the effect is (re)created
+   */
+  get onEffectCreatedObservable() {
+    return this._onEffectCreatedObservable || (this._onEffectCreatedObservable = new p()), this._onEffectCreatedObservable;
+  }
+  /**
+   * Sets the value of the alpha mode.
+   *
+   * | Value | Type | Description |
+   * | --- | --- | --- |
+   * | 0 | ALPHA_DISABLE |   |
+   * | 1 | ALPHA_ADD |   |
+   * | 2 | ALPHA_COMBINE |   |
+   * | 3 | ALPHA_SUBTRACT |   |
+   * | 4 | ALPHA_MULTIPLY |   |
+   * | 5 | ALPHA_MAXIMIZED |   |
+   * | 6 | ALPHA_ONEONE |   |
+   * | 7 | ALPHA_PREMULTIPLIED |   |
+   * | 8 | ALPHA_PREMULTIPLIED_PORTERDUFF |   |
+   * | 9 | ALPHA_INTERPOLATE |   |
+   * | 10 | ALPHA_SCREENMODE |   |
+   *
+   */
+  set alphaMode(e) {
+    this._alphaMode !== e && (this._alphaMode = e, this.markAsDirty(t.TextureDirtyFlag));
+  }
+  /**
+   * Gets the value of the alpha mode
+   */
+  get alphaMode() {
+    return this._alphaMode;
+  }
+  /**
+   * Sets the need depth pre-pass value
+   */
+  set needDepthPrePass(e) {
+    this._needDepthPrePass !== e && (this._needDepthPrePass = e, this._needDepthPrePass && (this.checkReadyOnEveryCall = !0));
+  }
+  /**
+   * Gets the depth pre-pass value
+   */
+  get needDepthPrePass() {
+    return this._needDepthPrePass;
+  }
+  /**
+   * Can this material render to prepass
+   */
+  get isPrePassCapable() {
+    return !1;
+  }
+  /**
+   * Sets the state for enabling fog
+   */
+  set fogEnabled(e) {
+    this._fogEnabled !== e && (this._fogEnabled = e, this.markAsDirty(t.MiscDirtyFlag));
+  }
+  /**
+   * Gets the value of the fog enabled state
+   */
+  get fogEnabled() {
+    return this._fogEnabled;
+  }
+  get wireframe() {
+    switch (this._fillMode) {
+      case t.WireFrameFillMode:
+      case t.LineListDrawMode:
+      case t.LineLoopDrawMode:
+      case t.LineStripDrawMode:
+        return !0;
+    }
+    return this._scene.forceWireframe;
+  }
+  /**
+   * Sets the state of wireframe mode
+   */
+  set wireframe(e) {
+    this.fillMode = e ? t.WireFrameFillMode : t.TriangleFillMode;
+  }
+  /**
+   * Gets the value specifying if point clouds are enabled
+   */
+  get pointsCloud() {
+    switch (this._fillMode) {
+      case t.PointFillMode:
+      case t.PointListDrawMode:
+        return !0;
+    }
+    return this._scene.forcePointsCloud;
+  }
+  /**
+   * Sets the state of point cloud mode
+   */
+  set pointsCloud(e) {
+    this.fillMode = e ? t.PointFillMode : t.TriangleFillMode;
+  }
+  /**
+   * Gets the material fill mode
+   */
+  get fillMode() {
+    return this._fillMode;
+  }
+  /**
+   * Sets the material fill mode
+   */
+  set fillMode(e) {
+    this._fillMode !== e && (this._fillMode = e, this.markAsDirty(t.MiscDirtyFlag));
+  }
+  /** @internal */
+  _getDrawWrapper() {
+    return this._drawWrapper;
+  }
+  /**
+   * @internal
+   */
+  _setDrawWrapper(e) {
+    this._drawWrapper = e;
+  }
+  /**
+   * Creates a material instance
+   * @param name defines the name of the material
+   * @param scene defines the scene to reference
+   * @param doNotAdd specifies if the material should be added to the scene
+   */
+  constructor(e, s, i) {
+    this.shadowDepthWrapper = null, this.allowShaderHotSwapping = !0, this.metadata = null, this.reservedDataStore = null, this.checkReadyOnEveryCall = !1, this.checkReadyOnlyOnce = !1, this.state = "", this._alpha = 1, this._backFaceCulling = !0, this._cullBackFaces = !0, this._blockDirtyMechanism = !1, this.onCompiled = null, this.onError = null, this.getRenderTargetTextures = null, this.doNotSerialize = !1, this._storeEffectOnSubMeshes = !1, this.animations = null, this.onDisposeObservable = new p(), this._onDisposeObserver = null, this._onUnBindObservable = null, this._onBindObserver = null, this._alphaMode = 2, this._needDepthPrePass = !1, this.disableDepthWrite = !1, this.disableColorWrite = !1, this.forceDepthWrite = !1, this.depthFunction = 0, this.separateCullingPass = !1, this._fogEnabled = !0, this.pointSize = 1, this.zOffset = 0, this.zOffsetUnits = 0, this.stencil = new B(), this._useUBO = !1, this._fillMode = t.TriangleFillMode, this._cachedDepthWriteState = !1, this._cachedColorWriteState = !1, this._cachedDepthFunctionState = 0, this._indexInSceneMaterialArray = -1, this.meshMap = null, this._parentContainer = null, this._uniformBufferLayoutBuilt = !1, this._eventInfo = {}, this._callbackPluginEventGeneric = () => {
+    }, this._callbackPluginEventIsReadyForSubMesh = () => {
+    }, this._callbackPluginEventPrepareDefines = () => {
+    }, this._callbackPluginEventPrepareDefinesBeforeAttributes = () => {
+    }, this._callbackPluginEventHardBindForSubMesh = () => {
+    }, this._callbackPluginEventBindForSubMesh = () => {
+    }, this._callbackPluginEventHasRenderTargetTextures = () => {
+    }, this._callbackPluginEventFillRenderTargetTextures = () => {
+    }, this._forceAlphaTest = !1, this._transparencyMode = null, this.name = e;
+    const r = s || D.LastCreatedScene;
+    r && (this._scene = r, this._dirtyCallbacks = {}, this._dirtyCallbacks[1] = this._markAllSubMeshesAsTexturesDirty.bind(this), this._dirtyCallbacks[2] = this._markAllSubMeshesAsLightsDirty.bind(this), this._dirtyCallbacks[4] = this._markAllSubMeshesAsFresnelDirty.bind(this), this._dirtyCallbacks[8] = this._markAllSubMeshesAsAttributesDirty.bind(this), this._dirtyCallbacks[16] = this._markAllSubMeshesAsMiscDirty.bind(this), this._dirtyCallbacks[32] = this._markAllSubMeshesAsPrePassDirty.bind(this), this._dirtyCallbacks[63] = this._markAllSubMeshesAsAllDirty.bind(this), this.id = e || y.RandomId(), this.uniqueId = this._scene.getUniqueId(), this._materialContext = this._scene.getEngine().createMaterialContext(), this._drawWrapper = new P(this._scene.getEngine(), !1), this._drawWrapper.materialContext = this._materialContext, this._scene.useRightHandedSystem ? this.sideOrientation = t.ClockWiseSideOrientation : this.sideOrientation = t.CounterClockWiseSideOrientation, this._uniformBuffer = new k(this._scene.getEngine(), void 0, void 0, e), this._useUBO = this.getScene().getEngine().supportsUniformBuffers, i || this._scene.addMaterial(this), this._scene.useMaterialMeshMap && (this.meshMap = {}), t.OnEventObservable.notifyObservers(this, f.Created));
+  }
+  /**
+   * Returns a string representation of the current material
+   * @param fullDetails defines a boolean indicating which levels of logging is desired
+   * @returns a string with material information
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  toString(e) {
+    return "Name: " + this.name;
+  }
+  /**
+   * Gets the class name of the material
+   * @returns a string with the class name of the material
+   */
+  getClassName() {
+    return "Material";
+  }
+  /** @internal */
+  get _isMaterial() {
+    return !0;
+  }
+  /**
+   * Specifies if updates for the material been locked
+   */
+  get isFrozen() {
+    return this.checkReadyOnlyOnce;
+  }
+  /**
+   * Locks updates for the material
+   */
+  freeze() {
+    this.markDirty(), this.checkReadyOnlyOnce = !0;
+  }
+  /**
+   * Unlocks updates for the material
+   */
+  unfreeze() {
+    this.markDirty(), this.checkReadyOnlyOnce = !1;
+  }
+  /**
+   * Specifies if the material is ready to be used
+   * @param mesh defines the mesh to check
+   * @param useInstances specifies if instances should be used
+   * @returns a boolean indicating if the material is ready to be used
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  isReady(e, s) {
+    return !0;
+  }
+  /**
+   * 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
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  isReadyForSubMesh(e, s, i) {
+    const r = s.materialDefines;
+    return r ? (this._eventInfo.isReadyForSubMesh = !0, this._eventInfo.defines = r, this._callbackPluginEventIsReadyForSubMesh(this._eventInfo), this._eventInfo.isReadyForSubMesh) : !1;
+  }
+  /**
+   * Returns the material effect
+   * @returns the effect associated with the material
+   */
+  getEffect() {
+    return this._drawWrapper.effect;
+  }
+  /**
+   * Returns the current scene
+   * @returns a Scene
+   */
+  getScene() {
+    return this._scene;
+  }
+  /**
+   * Gets the current transparency mode.
+   */
+  get transparencyMode() {
+    return this._transparencyMode;
+  }
+  /**
+   * Sets the transparency mode of the material.
+   *
+   * | Value | Type                                | Description |
+   * | ----- | ----------------------------------- | ----------- |
+   * | 0     | OPAQUE                              |             |
+   * | 1     | ALPHATEST                           |             |
+   * | 2     | ALPHABLEND                          |             |
+   * | 3     | ALPHATESTANDBLEND                   |             |
+   *
+   */
+  set transparencyMode(e) {
+    this._transparencyMode !== e && (this._transparencyMode = e, this._forceAlphaTest = e === t.MATERIAL_ALPHATESTANDBLEND, this._markAllSubMeshesAsTexturesAndMiscDirty());
+  }
+  /**
+   * Returns true if alpha blending should be disabled.
+   */
+  get _disableAlphaBlending() {
+    return this._transparencyMode === t.MATERIAL_OPAQUE || this._transparencyMode === t.MATERIAL_ALPHATEST;
+  }
+  /**
+   * Specifies whether or not this material should be rendered in alpha blend mode.
+   * @returns a boolean specifying if alpha blending is needed
+   */
+  needAlphaBlending() {
+    return this._disableAlphaBlending ? !1 : this.alpha < 1;
+  }
+  /**
+   * Specifies if the mesh will require alpha blending
+   * @param mesh defines the mesh to check
+   * @returns a boolean specifying if alpha blending is needed for the mesh
+   */
+  needAlphaBlendingForMesh(e) {
+    return e.visibility < 1 ? !0 : this._disableAlphaBlending ? !1 : e.hasVertexAlpha || this.needAlphaBlending();
+  }
+  /**
+   * Specifies whether or not this material should be rendered in alpha test mode.
+   * @returns a boolean specifying if an alpha test is needed.
+   */
+  needAlphaTesting() {
+    return !!this._forceAlphaTest;
+  }
+  /**
+   * Specifies if material alpha testing should be turned on for the mesh
+   * @param mesh defines the mesh to check
+   */
+  _shouldTurnAlphaTestOn(e) {
+    return !this.needAlphaBlendingForMesh(e) && this.needAlphaTesting();
+  }
+  /**
+   * Gets the texture used for the alpha test
+   * @returns the texture to use for alpha testing
+   */
+  getAlphaTestTexture() {
+    return null;
+  }
+  /**
+   * Marks the material to indicate that it needs to be re-calculated
+   * @param forceMaterialDirty - Forces the material to be marked as dirty for all components (same as this.markAsDirty(Material.AllDirtyFlag)). You should use this flag if the material is frozen and you want to force a recompilation.
+   */
+  markDirty(e = !1) {
+    const s = this.getScene().meshes;
+    for (const i of s)
+      if (i.subMeshes)
+        for (const r of i.subMeshes)
+          r.getMaterial() === this && r.effect && (r.effect._wasPreviouslyReady = !1, r.effect._wasPreviouslyUsingInstances = null, r.effect._forceRebindOnNextCall = e);
+    e && this.markAsDirty(t.AllDirtyFlag);
+  }
+  /**
+   * @internal
+   */
+  _preBind(e, s = null) {
+    const i = this._scene.getEngine(), n = (s ?? this.sideOrientation) === t.ClockWiseSideOrientation;
+    return i.enableEffect(e || this._getDrawWrapper()), i.setState(this.backFaceCulling, this.zOffset, !1, n, this._scene._mirroredCameraPosition ? !this.cullBackFaces : this.cullBackFaces, this.stencil, this.zOffsetUnits), n;
+  }
+  /**
+   * Binds the material to the mesh
+   * @param world defines the world transformation matrix
+   * @param mesh defines the mesh to bind the material to
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  bind(e, s) {
+  }
+  /**
+   * Initializes the uniform buffer layout for the shader.
+   */
+  buildUniformLayout() {
+    const e = this._uniformBuffer;
+    this._eventInfo.ubo = e, this._callbackPluginEventGeneric(f.PrepareUniformBuffer, this._eventInfo), e.create(), this._uniformBufferLayoutBuilt = !0;
+  }
+  /**
+   * Binds the submesh to the material
+   * @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(e, s, i) {
+    const r = i.effect;
+    r && (this._eventInfo.subMesh = i, this._callbackPluginEventBindForSubMesh(this._eventInfo), r._forceRebindOnNextCall = !1);
+  }
+  /**
+   * Binds the world matrix to the material
+   * @param world defines the world transformation matrix
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  bindOnlyWorldMatrix(e) {
+  }
+  /**
+   * Binds the view matrix to the effect
+   * @param effect defines the effect to bind the view matrix to
+   */
+  bindView(e) {
+    this._useUBO ? this._needToBindSceneUbo = !0 : e.setMatrix("view", this.getScene().getViewMatrix());
+  }
+  /**
+   * Binds the view projection and projection matrices to the effect
+   * @param effect defines the effect to bind the view projection and projection matrices to
+   */
+  bindViewProjection(e) {
+    this._useUBO ? this._needToBindSceneUbo = !0 : (e.setMatrix("viewProjection", this.getScene().getTransformMatrix()), e.setMatrix("projection", this.getScene().getProjectionMatrix()));
+  }
+  /**
+   * Binds the view matrix to the effect
+   * @param effect defines the effect to bind the view matrix to
+   * @param variableName name of the shader variable that will hold the eye position
+   */
+  bindEyePosition(e, s) {
+    this._useUBO ? this._needToBindSceneUbo = !0 : this._scene.bindEyePosition(e, s);
+  }
+  /**
+   * Processes to execute after binding the material to a mesh
+   * @param mesh defines the rendered mesh
+   * @param effect
+   */
+  _afterBind(e, s = null) {
+    if (this._scene._cachedMaterial = this, this._needToBindSceneUbo && s && (this._needToBindSceneUbo = !1, S.BindSceneUniformBuffer(s, this.getScene().getSceneUniformBuffer()), this._scene.finalizeSceneUbo()), e ? this._scene._cachedVisibility = e.visibility : this._scene._cachedVisibility = 1, this._onBindObservable && e && this._onBindObservable.notifyObservers(e), this.disableDepthWrite) {
+      const i = this._scene.getEngine();
+      this._cachedDepthWriteState = i.getDepthWrite(), i.setDepthWrite(!1);
+    }
+    if (this.disableColorWrite) {
+      const i = this._scene.getEngine();
+      this._cachedColorWriteState = i.getColorWrite(), i.setColorWrite(!1);
+    }
+    if (this.depthFunction !== 0) {
+      const i = this._scene.getEngine();
+      this._cachedDepthFunctionState = i.getDepthFunction() || 0, i.setDepthFunction(this.depthFunction);
+    }
+  }
+  /**
+   * Unbinds the material from the mesh
+   */
+  unbind() {
+    this._onUnBindObservable && this._onUnBindObservable.notifyObservers(this), this.depthFunction !== 0 && this._scene.getEngine().setDepthFunction(this._cachedDepthFunctionState), this.disableDepthWrite && this._scene.getEngine().setDepthWrite(this._cachedDepthWriteState), this.disableColorWrite && this._scene.getEngine().setColorWrite(this._cachedColorWriteState);
+  }
+  /**
+   * Returns the animatable textures.
+   * @returns - Array of animatable textures.
+   */
+  getAnimatables() {
+    return this._eventInfo.animatables = [], this._callbackPluginEventGeneric(f.GetAnimatables, this._eventInfo), this._eventInfo.animatables;
+  }
+  /**
+   * Gets the active textures from the material
+   * @returns an array of textures
+   */
+  getActiveTextures() {
+    return this._eventInfo.activeTextures = [], this._callbackPluginEventGeneric(f.GetActiveTextures, this._eventInfo), this._eventInfo.activeTextures;
+  }
+  /**
+   * 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(e) {
+    return this._eventInfo.hasTexture = !1, this._eventInfo.texture = e, this._callbackPluginEventGeneric(f.HasTexture, this._eventInfo), this._eventInfo.hasTexture;
+  }
+  /**
+   * 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
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  clone(e) {
+    return null;
+  }
+  _clonePlugins(e, s) {
+    const i = {};
+    if (this._serializePlugins(i), t._parsePlugins(i, e, this._scene, s), this.pluginManager)
+      for (const r of this.pluginManager._plugins) {
+        const n = e.pluginManager.getPlugin(r.name);
+        r.copyTo(n);
+      }
+  }
+  /**
+   * Gets the meshes bound to the material
+   * @returns an array of meshes bound to the material
+   */
+  getBindedMeshes() {
+    if (this.meshMap) {
+      const e = new Array();
+      for (const s in this.meshMap) {
+        const i = this.meshMap[s];
+        i && e.push(i);
+      }
+      return e;
+    } else
+      return this._scene.meshes.filter((s) => s.material === this);
+  }
+  /**
+   * Force shader compilation
+   * @param mesh defines the mesh associated with this material
+   * @param onCompiled defines a function to execute once the material is compiled
+   * @param options defines the options to configure the compilation
+   * @param onError defines a function to execute if the material fails compiling
+   */
+  forceCompilation(e, s, i, r) {
+    const n = Object.assign({ clipPlane: !1, useInstances: !1 }, i), h = this.getScene(), d = this.allowShaderHotSwapping;
+    this.allowShaderHotSwapping = !1;
+    const c = () => {
+      if (!this._scene || !this._scene.getEngine())
+        return;
+      const b = h.clipPlane;
+      if (n.clipPlane && (h.clipPlane = new v(0, 0, 0, 1)), this._storeEffectOnSubMeshes) {
+        let g = !0, _ = null;
+        if (e.subMeshes) {
+          const u = new A(0, 0, 0, 0, 0, e, void 0, !1, !1);
+          u.materialDefines && (u.materialDefines._renderId = -1), this.isReadyForSubMesh(e, u, n.useInstances) || (u.effect && u.effect.getCompilationError() && u.effect.allFallbacksProcessed() ? _ = u.effect.getCompilationError() : (g = !1, setTimeout(c, 16)));
+        }
+        g && (this.allowShaderHotSwapping = d, _ && r && r(_), s && s(this));
+      } else
+        this.isReady() ? (this.allowShaderHotSwapping = d, s && s(this)) : setTimeout(c, 16);
+      n.clipPlane && (h.clipPlane = b);
+    };
+    c();
+  }
+  /**
+   * Force shader compilation
+   * @param mesh defines the mesh that will use this material
+   * @param options defines additional options for compiling the shaders
+   * @returns a promise that resolves when the compilation completes
+   */
+  forceCompilationAsync(e, s) {
+    return new Promise((i, r) => {
+      this.forceCompilation(e, () => {
+        i();
+      }, s, (n) => {
+        r(n);
+      });
+    });
+  }
+  /**
+   * Marks a define in the material to indicate that it needs to be re-computed
+   * @param flag defines a flag used to determine which parts of the material have to be marked as dirty
+   */
+  markAsDirty(e) {
+    this.getScene().blockMaterialDirtyMechanism || this._blockDirtyMechanism || (t._DirtyCallbackArray.length = 0, e & t.TextureDirtyFlag && t._DirtyCallbackArray.push(t._TextureDirtyCallBack), e & t.LightDirtyFlag && t._DirtyCallbackArray.push(t._LightsDirtyCallBack), e & t.FresnelDirtyFlag && t._DirtyCallbackArray.push(t._FresnelDirtyCallBack), e & t.AttributesDirtyFlag && t._DirtyCallbackArray.push(t._AttributeDirtyCallBack), e & t.MiscDirtyFlag && t._DirtyCallbackArray.push(t._MiscDirtyCallBack), e & t.PrePassDirtyFlag && t._DirtyCallbackArray.push(t._PrePassDirtyCallBack), t._DirtyCallbackArray.length && this._markAllSubMeshesAsDirty(t._RunDirtyCallBacks), this.getScene().resetCachedMaterial());
+  }
+  /**
+   * Resets the draw wrappers cache for all submeshes that are using this material
+   */
+  resetDrawCache() {
+    const e = this.getScene().meshes;
+    for (const s of e)
+      if (s.subMeshes)
+        for (const i of s.subMeshes)
+          i.getMaterial() === this && i.resetDrawCache();
+  }
+  /**
+   * Marks all submeshes of a material to indicate that their material defines need to be re-calculated
+   * @param func defines a function which checks material defines against the submeshes
+   */
+  _markAllSubMeshesAsDirty(e) {
+    if (this.getScene().blockMaterialDirtyMechanism || this._blockDirtyMechanism)
+      return;
+    const s = this.getScene().meshes;
+    for (const i of s)
+      if (i.subMeshes) {
+        for (const r of i.subMeshes)
+          if (r.getMaterial(!1) === this)
+            for (const n of r._drawWrappers)
+              !n || !n.defines || !n.defines.markAllAsDirty || this._materialContext === n.materialContext && e(n.defines);
+      }
+  }
+  /**
+   * Indicates that the scene should check if the rendering now needs a prepass
+   */
+  _markScenePrePassDirty() {
+    if (this.getScene().blockMaterialDirtyMechanism || this._blockDirtyMechanism)
+      return;
+    const e = this.getScene().enablePrePassRenderer();
+    e && e.markAsDirty();
+  }
+  /**
+   * Indicates that we need to re-calculated for all submeshes
+   */
+  _markAllSubMeshesAsAllDirty() {
+    this._markAllSubMeshesAsDirty(t._AllDirtyCallBack);
+  }
+  /**
+   * Indicates that image processing needs to be re-calculated for all submeshes
+   */
+  _markAllSubMeshesAsImageProcessingDirty() {
+    this._markAllSubMeshesAsDirty(t._ImageProcessingDirtyCallBack);
+  }
+  /**
+   * Indicates that textures need to be re-calculated for all submeshes
+   */
+  _markAllSubMeshesAsTexturesDirty() {
+    this._markAllSubMeshesAsDirty(t._TextureDirtyCallBack);
+  }
+  /**
+   * Indicates that fresnel needs to be re-calculated for all submeshes
+   */
+  _markAllSubMeshesAsFresnelDirty() {
+    this._markAllSubMeshesAsDirty(t._FresnelDirtyCallBack);
+  }
+  /**
+   * Indicates that fresnel and misc need to be re-calculated for all submeshes
+   */
+  _markAllSubMeshesAsFresnelAndMiscDirty() {
+    this._markAllSubMeshesAsDirty(t._FresnelAndMiscDirtyCallBack);
+  }
+  /**
+   * Indicates that lights need to be re-calculated for all submeshes
+   */
+  _markAllSubMeshesAsLightsDirty() {
+    this._markAllSubMeshesAsDirty(t._LightsDirtyCallBack);
+  }
+  /**
+   * Indicates that attributes need to be re-calculated for all submeshes
+   */
+  _markAllSubMeshesAsAttributesDirty() {
+    this._markAllSubMeshesAsDirty(t._AttributeDirtyCallBack);
+  }
+  /**
+   * Indicates that misc needs to be re-calculated for all submeshes
+   */
+  _markAllSubMeshesAsMiscDirty() {
+    this._markAllSubMeshesAsDirty(t._MiscDirtyCallBack);
+  }
+  /**
+   * Indicates that prepass needs to be re-calculated for all submeshes
+   */
+  _markAllSubMeshesAsPrePassDirty() {
+    this._markAllSubMeshesAsDirty(t._MiscDirtyCallBack);
+  }
+  /**
+   * Indicates that textures and misc need to be re-calculated for all submeshes
+   */
+  _markAllSubMeshesAsTexturesAndMiscDirty() {
+    this._markAllSubMeshesAsDirty(t._TextureAndMiscDirtyCallBack);
+  }
+  _checkScenePerformancePriority() {
+    if (this._scene.performancePriority !== C.BackwardCompatible) {
+      this.checkReadyOnlyOnce = !0;
+      const e = this._scene.onScenePerformancePriorityChangedObservable.addOnce(() => {
+        this.checkReadyOnlyOnce = !1;
+      });
+      this.onDisposeObservable.add(() => {
+        this._scene.onScenePerformancePriorityChangedObservable.remove(e);
+      });
+    }
+  }
+  /**
+   * Sets the required values to the prepass renderer.
+   * @param prePassRenderer defines the prepass renderer to setup.
+   * @returns true if the pre pass is needed.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  setPrePassRenderer(e) {
+    return !1;
+  }
+  /**
+   * 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(e, s, i) {
+    const r = this.getScene();
+    if (r.stopAnimation(this), r.freeProcessedMaterials(), r.removeMaterial(this), this._eventInfo.forceDisposeTextures = s, this._callbackPluginEventGeneric(f.Disposed, this._eventInfo), this._parentContainer) {
+      const n = this._parentContainer.materials.indexOf(this);
+      n > -1 && this._parentContainer.materials.splice(n, 1), this._parentContainer = null;
+    }
+    if (i !== !0)
+      if (this.meshMap)
+        for (const n in this.meshMap) {
+          const h = this.meshMap[n];
+          h && (h.material = null, this.releaseVertexArrayObject(h, e));
+        }
+      else {
+        const n = r.meshes;
+        for (const h of n)
+          h.material === this && !h.sourceMesh && (h.material = null, this.releaseVertexArrayObject(h, e));
+      }
+    this._uniformBuffer.dispose(), e && this._drawWrapper.effect && (this._storeEffectOnSubMeshes || this._drawWrapper.effect.dispose(), this._drawWrapper.effect = null), this.metadata = null, this.onDisposeObservable.notifyObservers(this), this.onDisposeObservable.clear(), this._onBindObservable && this._onBindObservable.clear(), this._onUnBindObservable && this._onUnBindObservable.clear(), this._onEffectCreatedObservable && this._onEffectCreatedObservable.clear(), this._eventInfo && (this._eventInfo = {});
+  }
+  /**
+   * @internal
+   */
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  releaseVertexArrayObject(e, s) {
+    if (e.geometry) {
+      const i = e.geometry;
+      if (this._storeEffectOnSubMeshes)
+        for (const r of e.subMeshes)
+          i._releaseVertexArrayObject(r.effect), s && r.effect && r.effect.dispose();
+      else
+        i._releaseVertexArrayObject(this._drawWrapper.effect);
+    }
+  }
+  /**
+   * Serializes this material
+   * @returns the serialized material object
+   */
+  serialize() {
+    const e = m.Serialize(this);
+    return e.stencil = this.stencil.serialize(), e.uniqueId = this.uniqueId, this._serializePlugins(e), e;
+  }
+  _serializePlugins(e) {
+    if (e.plugins = {}, this.pluginManager)
+      for (const s of this.pluginManager._plugins)
+        e.plugins[s.getClassName()] = s.serialize();
+  }
+  /**
+   * Creates a material from parsed material data
+   * @param parsedMaterial defines parsed material data
+   * @param scene defines the hosting scene
+   * @param rootUrl defines the root URL to use to load textures
+   * @returns a new material
+   */
+  static Parse(e, s, i) {
+    if (!e.customType)
+      e.customType = "BABYLON.StandardMaterial";
+    else if (e.customType === "BABYLON.PBRMaterial" && e.overloadedAlbedo && (e.customType = "BABYLON.LegacyPBRMaterial", !BABYLON.LegacyPBRMaterial))
+      return M.Error("Your scene is trying to load a legacy version of the PBRMaterial, please, include it from the materials library."), null;
+    const n = y.Instantiate(e.customType).Parse(e, s, i);
+    return n._loadedUniqueId = e.uniqueId, n;
+  }
+  static _parsePlugins(e, s, i, r) {
+    var n;
+    if (e.plugins)
+      for (const h in e.plugins) {
+        const d = e.plugins[h];
+        let c = (n = s.pluginManager) === null || n === void 0 ? void 0 : n.getPlugin(d.name);
+        if (!c) {
+          const b = y.Instantiate("BABYLON." + h);
+          b && (c = new b(s));
+        }
+        c == null || c.parse(d, i, r);
+      }
+  }
+}
+t.TriangleFillMode = 0;
+t.WireFrameFillMode = 1;
+t.PointFillMode = 2;
+t.PointListDrawMode = 3;
+t.LineListDrawMode = 4;
+t.LineLoopDrawMode = 5;
+t.LineStripDrawMode = 6;
+t.TriangleStripDrawMode = 7;
+t.TriangleFanDrawMode = 8;
+t.ClockWiseSideOrientation = 0;
+t.CounterClockWiseSideOrientation = 1;
+t.TextureDirtyFlag = 1;
+t.LightDirtyFlag = 2;
+t.FresnelDirtyFlag = 4;
+t.AttributesDirtyFlag = 8;
+t.MiscDirtyFlag = 16;
+t.PrePassDirtyFlag = 32;
+t.AllDirtyFlag = 63;
+t.MATERIAL_OPAQUE = 0;
+t.MATERIAL_ALPHATEST = 1;
+t.MATERIAL_ALPHABLEND = 2;
+t.MATERIAL_ALPHATESTANDBLEND = 3;
+t.MATERIAL_NORMALBLENDMETHOD_WHITEOUT = 0;
+t.MATERIAL_NORMALBLENDMETHOD_RNM = 1;
+t.OnEventObservable = new p();
+t._AllDirtyCallBack = (o) => o.markAllAsDirty();
+t._ImageProcessingDirtyCallBack = (o) => o.markAsImageProcessingDirty();
+t._TextureDirtyCallBack = (o) => o.markAsTexturesDirty();
+t._FresnelDirtyCallBack = (o) => o.markAsFresnelDirty();
+t._MiscDirtyCallBack = (o) => o.markAsMiscDirty();
+t._PrePassDirtyCallBack = (o) => o.markAsPrePassDirty();
+t._LightsDirtyCallBack = (o) => o.markAsLightDirty();
+t._AttributeDirtyCallBack = (o) => o.markAsAttributesDirty();
+t._FresnelAndMiscDirtyCallBack = (o) => {
+  t._FresnelDirtyCallBack(o), t._MiscDirtyCallBack(o);
+};
+t._TextureAndMiscDirtyCallBack = (o) => {
+  t._TextureDirtyCallBack(o), t._MiscDirtyCallBack(o);
+};
+t._DirtyCallbackArray = [];
+t._RunDirtyCallBacks = (o) => {
+  for (const e of t._DirtyCallbackArray)
+    e(o);
+};
+a([
+  l()
+], t.prototype, "id", void 0);
+a([
+  l()
+], t.prototype, "uniqueId", void 0);
+a([
+  l()
+], t.prototype, "name", void 0);
+a([
+  l()
+], t.prototype, "metadata", void 0);
+a([
+  l()
+], t.prototype, "checkReadyOnEveryCall", void 0);
+a([
+  l()
+], t.prototype, "checkReadyOnlyOnce", void 0);
+a([
+  l()
+], t.prototype, "state", void 0);
+a([
+  l("alpha")
+], t.prototype, "_alpha", void 0);
+a([
+  l("backFaceCulling")
+], t.prototype, "_backFaceCulling", void 0);
+a([
+  l("cullBackFaces")
+], t.prototype, "_cullBackFaces", void 0);
+a([
+  l()
+], t.prototype, "sideOrientation", void 0);
+a([
+  l("alphaMode")
+], t.prototype, "_alphaMode", void 0);
+a([
+  l()
+], t.prototype, "_needDepthPrePass", void 0);
+a([
+  l()
+], t.prototype, "disableDepthWrite", void 0);
+a([
+  l()
+], t.prototype, "disableColorWrite", void 0);
+a([
+  l()
+], t.prototype, "forceDepthWrite", void 0);
+a([
+  l()
+], t.prototype, "depthFunction", void 0);
+a([
+  l()
+], t.prototype, "separateCullingPass", void 0);
+a([
+  l("fogEnabled")
+], t.prototype, "_fogEnabled", void 0);
+a([
+  l()
+], t.prototype, "pointSize", void 0);
+a([
+  l()
+], t.prototype, "zOffset", void 0);
+a([
+  l()
+], t.prototype, "zOffsetUnits", void 0);
+a([
+  l()
+], t.prototype, "pointsCloud", null);
+a([
+  l()
+], t.prototype, "fillMode", null);
+a([
+  l()
+], t.prototype, "transparencyMode", null);
+export {
+  t as Material
+};