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

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

@@ -0,0 +1,934 @@
+import { __decorate as s } from "../tslib.es6.esm.js";
+import { serializeAsTexture as _, expandToProperty as l, serializeAsColor3 as v, serialize as p, serializeAsFresnelParameters as I, SerializationHelper as y } from "../Misc/decorators.esm.js";
+import { SmartArray as V } from "../Misc/smartArray.esm.js";
+import { Scene as k } from "../scene.esm.js";
+import { Matrix as H } from "../Maths/math.vector.esm.js";
+import { Color3 as x } from "../Maths/math.color.esm.js";
+import { VertexBuffer as S } from "../Buffers/buffer.esm.js";
+import { PrePassConfiguration as U } from "./prePassConfiguration.esm.js";
+import { ImageProcessingConfiguration as L } from "./imageProcessingConfiguration.esm.js";
+import { Material as F } from "./material.esm.js";
+import { MaterialPluginEvent as B } from "./materialPluginEvent.esm.js";
+import { MaterialDefines as X } from "./materialDefines.esm.js";
+import { PushMaterial as w } from "./pushMaterial.esm.js";
+import { MaterialHelper as n } from "./materialHelper.esm.js";
+import { Texture as m } from "./Textures/texture.esm.js";
+import { RegisterClass as Y } from "../Misc/typeStore.esm.js";
+import { MaterialFlags as h } from "./materialFlags.esm.js";
+import "../Shaders/default.fragment.esm.js";
+import "../Shaders/default.vertex.esm.js";
+import { EffectFallbacks as z } from "./effectFallbacks.esm.js";
+import { DetailMapConfiguration as W } from "./material.detailMapConfiguration.esm.js";
+import { addClipPlaneUniforms as Q, bindClipPlane as K } from "./clipPlaneMaterialHelper.esm.js";
+const M = { effect: null, subMesh: null };
+class j extends X {
+  /**
+   * Initializes the Standard Material defines.
+   * @param externalProperties The external properties
+   */
+  constructor(t) {
+    super(t), this.MAINUV1 = !1, this.MAINUV2 = !1, this.MAINUV3 = !1, this.MAINUV4 = !1, this.MAINUV5 = !1, this.MAINUV6 = !1, this.DIFFUSE = !1, this.DIFFUSEDIRECTUV = 0, this.BAKED_VERTEX_ANIMATION_TEXTURE = !1, this.AMBIENT = !1, this.AMBIENTDIRECTUV = 0, this.OPACITY = !1, this.OPACITYDIRECTUV = 0, this.OPACITYRGB = !1, this.REFLECTION = !1, this.EMISSIVE = !1, this.EMISSIVEDIRECTUV = 0, this.SPECULAR = !1, this.SPECULARDIRECTUV = 0, this.BUMP = !1, this.BUMPDIRECTUV = 0, this.PARALLAX = !1, this.PARALLAXOCCLUSION = !1, this.SPECULAROVERALPHA = !1, this.CLIPPLANE = !1, this.CLIPPLANE2 = !1, this.CLIPPLANE3 = !1, this.CLIPPLANE4 = !1, this.CLIPPLANE5 = !1, this.CLIPPLANE6 = !1, this.ALPHATEST = !1, this.DEPTHPREPASS = !1, this.ALPHAFROMDIFFUSE = !1, this.POINTSIZE = !1, this.FOG = !1, this.SPECULARTERM = !1, this.DIFFUSEFRESNEL = !1, this.OPACITYFRESNEL = !1, this.REFLECTIONFRESNEL = !1, this.REFRACTIONFRESNEL = !1, this.EMISSIVEFRESNEL = !1, this.FRESNEL = !1, this.NORMAL = !1, this.TANGENT = !1, this.UV1 = !1, this.UV2 = !1, this.UV3 = !1, this.UV4 = !1, this.UV5 = !1, this.UV6 = !1, this.VERTEXCOLOR = !1, this.VERTEXALPHA = !1, this.NUM_BONE_INFLUENCERS = 0, this.BonesPerMesh = 0, this.BONETEXTURE = !1, this.BONES_VELOCITY_ENABLED = !1, this.INSTANCES = !1, this.THIN_INSTANCES = !1, this.INSTANCESCOLOR = !1, this.GLOSSINESS = !1, this.ROUGHNESS = !1, this.EMISSIVEASILLUMINATION = !1, this.LINKEMISSIVEWITHDIFFUSE = !1, this.REFLECTIONFRESNELFROMSPECULAR = !1, this.LIGHTMAP = !1, this.LIGHTMAPDIRECTUV = 0, this.OBJECTSPACE_NORMALMAP = !1, this.USELIGHTMAPASSHADOWMAP = !1, this.REFLECTIONMAP_3D = !1, this.REFLECTIONMAP_SPHERICAL = !1, this.REFLECTIONMAP_PLANAR = !1, this.REFLECTIONMAP_CUBIC = !1, this.USE_LOCAL_REFLECTIONMAP_CUBIC = !1, this.USE_LOCAL_REFRACTIONMAP_CUBIC = !1, this.REFLECTIONMAP_PROJECTION = !1, this.REFLECTIONMAP_SKYBOX = !1, this.REFLECTIONMAP_EXPLICIT = !1, this.REFLECTIONMAP_EQUIRECTANGULAR = !1, this.REFLECTIONMAP_EQUIRECTANGULAR_FIXED = !1, this.REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED = !1, this.REFLECTIONMAP_OPPOSITEZ = !1, this.INVERTCUBICMAP = !1, this.LOGARITHMICDEPTH = !1, this.REFRACTION = !1, this.REFRACTIONMAP_3D = !1, this.REFLECTIONOVERALPHA = !1, this.TWOSIDEDLIGHTING = !1, this.SHADOWFLOAT = !1, this.MORPHTARGETS = !1, this.MORPHTARGETS_NORMAL = !1, this.MORPHTARGETS_TANGENT = !1, this.MORPHTARGETS_UV = !1, this.NUM_MORPH_INFLUENCERS = 0, this.MORPHTARGETS_TEXTURE = !1, this.NONUNIFORMSCALING = !1, this.PREMULTIPLYALPHA = !1, this.ALPHATEST_AFTERALLALPHACOMPUTATIONS = !1, this.ALPHABLEND = !0, this.PREPASS = !1, this.PREPASS_IRRADIANCE = !1, this.PREPASS_IRRADIANCE_INDEX = -1, this.PREPASS_ALBEDO_SQRT = !1, this.PREPASS_ALBEDO_SQRT_INDEX = -1, this.PREPASS_DEPTH = !1, this.PREPASS_DEPTH_INDEX = -1, this.PREPASS_NORMAL = !1, this.PREPASS_NORMAL_INDEX = -1, this.PREPASS_POSITION = !1, this.PREPASS_POSITION_INDEX = -1, this.PREPASS_VELOCITY = !1, this.PREPASS_VELOCITY_INDEX = -1, this.PREPASS_REFLECTIVITY = !1, this.PREPASS_REFLECTIVITY_INDEX = -1, this.SCENE_MRT_COUNT = 0, this.RGBDLIGHTMAP = !1, this.RGBDREFLECTION = !1, this.RGBDREFRACTION = !1, this.IMAGEPROCESSING = !1, this.VIGNETTE = !1, this.VIGNETTEBLENDMODEMULTIPLY = !1, this.VIGNETTEBLENDMODEOPAQUE = !1, this.TONEMAPPING = !1, this.TONEMAPPING_ACES = !1, this.CONTRAST = !1, this.COLORCURVES = !1, this.COLORGRADING = !1, this.COLORGRADING3D = !1, this.SAMPLER3DGREENDEPTH = !1, this.SAMPLER3DBGRMAP = !1, this.DITHER = !1, this.IMAGEPROCESSINGPOSTPROCESS = !1, this.SKIPFINALCOLORCLAMP = !1, this.MULTIVIEW = !1, this.ORDER_INDEPENDENT_TRANSPARENCY = !1, this.ORDER_INDEPENDENT_TRANSPARENCY_16BITS = !1, this.CAMERA_ORTHOGRAPHIC = !1, this.CAMERA_PERSPECTIVE = !1, this.IS_REFLECTION_LINEAR = !1, this.IS_REFRACTION_LINEAR = !1, this.EXPOSURE = !1, this.DECAL_AFTER_DETAIL = !1, this.rebuild();
+  }
+  setReflectionMode(t) {
+    const a = [
+      "REFLECTIONMAP_CUBIC",
+      "REFLECTIONMAP_EXPLICIT",
+      "REFLECTIONMAP_PLANAR",
+      "REFLECTIONMAP_PROJECTION",
+      "REFLECTIONMAP_PROJECTION",
+      "REFLECTIONMAP_SKYBOX",
+      "REFLECTIONMAP_SPHERICAL",
+      "REFLECTIONMAP_EQUIRECTANGULAR",
+      "REFLECTIONMAP_EQUIRECTANGULAR_FIXED",
+      "REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED"
+    ];
+    for (const T of a)
+      this[T] = T === t;
+  }
+}
+class i extends w {
+  /**
+   * Gets the image processing configuration used either in this material.
+   */
+  get imageProcessingConfiguration() {
+    return this._imageProcessingConfiguration;
+  }
+  /**
+   * Sets the Default image processing configuration used either in the this material.
+   *
+   * If sets to null, the scene one is in use.
+   */
+  set imageProcessingConfiguration(t) {
+    this._attachImageProcessingConfiguration(t), this._markAllSubMeshesAsTexturesDirty();
+  }
+  /**
+   * Attaches a new image processing configuration to the Standard Material.
+   * @param configuration
+   */
+  _attachImageProcessingConfiguration(t) {
+    t !== this._imageProcessingConfiguration && (this._imageProcessingConfiguration && this._imageProcessingObserver && this._imageProcessingConfiguration.onUpdateParameters.remove(this._imageProcessingObserver), t ? this._imageProcessingConfiguration = t : this._imageProcessingConfiguration = this.getScene().imageProcessingConfiguration, this._imageProcessingConfiguration && (this._imageProcessingObserver = this._imageProcessingConfiguration.onUpdateParameters.add(() => {
+      this._markAllSubMeshesAsImageProcessingDirty();
+    })));
+  }
+  /**
+   * Can this material render to prepass
+   */
+  get isPrePassCapable() {
+    return !this.disableDepthWrite;
+  }
+  /**
+   * Gets whether the color curves effect is enabled.
+   */
+  get cameraColorCurvesEnabled() {
+    return this.imageProcessingConfiguration.colorCurvesEnabled;
+  }
+  /**
+   * Sets whether the color curves effect is enabled.
+   */
+  set cameraColorCurvesEnabled(t) {
+    this.imageProcessingConfiguration.colorCurvesEnabled = t;
+  }
+  /**
+   * Gets whether the color grading effect is enabled.
+   */
+  get cameraColorGradingEnabled() {
+    return this.imageProcessingConfiguration.colorGradingEnabled;
+  }
+  /**
+   * Gets whether the color grading effect is enabled.
+   */
+  set cameraColorGradingEnabled(t) {
+    this.imageProcessingConfiguration.colorGradingEnabled = t;
+  }
+  /**
+   * Gets whether tonemapping is enabled or not.
+   */
+  get cameraToneMappingEnabled() {
+    return this._imageProcessingConfiguration.toneMappingEnabled;
+  }
+  /**
+   * Sets whether tonemapping is enabled or not
+   */
+  set cameraToneMappingEnabled(t) {
+    this._imageProcessingConfiguration.toneMappingEnabled = t;
+  }
+  /**
+   * The camera exposure used on this material.
+   * This property is here and not in the camera to allow controlling exposure without full screen post process.
+   * This corresponds to a photographic exposure.
+   */
+  get cameraExposure() {
+    return this._imageProcessingConfiguration.exposure;
+  }
+  /**
+   * The camera exposure used on this material.
+   * This property is here and not in the camera to allow controlling exposure without full screen post process.
+   * This corresponds to a photographic exposure.
+   */
+  set cameraExposure(t) {
+    this._imageProcessingConfiguration.exposure = t;
+  }
+  /**
+   * Gets The camera contrast used on this material.
+   */
+  get cameraContrast() {
+    return this._imageProcessingConfiguration.contrast;
+  }
+  /**
+   * Sets The camera contrast used on this material.
+   */
+  set cameraContrast(t) {
+    this._imageProcessingConfiguration.contrast = t;
+  }
+  /**
+   * Gets the Color Grading 2D Lookup Texture.
+   */
+  get cameraColorGradingTexture() {
+    return this._imageProcessingConfiguration.colorGradingTexture;
+  }
+  /**
+   * Sets the Color Grading 2D Lookup Texture.
+   */
+  set cameraColorGradingTexture(t) {
+    this._imageProcessingConfiguration.colorGradingTexture = t;
+  }
+  /**
+   * The color grading curves provide additional color adjustmnent that is applied after any color grading transform (3D LUT).
+   * They allow basic adjustment of saturation and small exposure adjustments, along with color filter tinting to provide white balance adjustment or more stylistic effects.
+   * These are similar to controls found in many professional imaging or colorist software. The global controls are applied to the entire image. For advanced tuning, extra controls are provided to adjust the shadow, midtone and highlight areas of the image;
+   * corresponding to low luminance, medium luminance, and high luminance areas respectively.
+   */
+  get cameraColorCurves() {
+    return this._imageProcessingConfiguration.colorCurves;
+  }
+  /**
+   * The color grading curves provide additional color adjustment that is applied after any color grading transform (3D LUT).
+   * They allow basic adjustment of saturation and small exposure adjustments, along with color filter tinting to provide white balance adjustment or more stylistic effects.
+   * These are similar to controls found in many professional imaging or colorist software. The global controls are applied to the entire image. For advanced tuning, extra controls are provided to adjust the shadow, midtone and highlight areas of the image;
+   * corresponding to low luminance, medium luminance, and high luminance areas respectively.
+   */
+  set cameraColorCurves(t) {
+    this._imageProcessingConfiguration.colorCurves = t;
+  }
+  /**
+   * Can this material render to several textures at once
+   */
+  get canRenderToMRT() {
+    return !0;
+  }
+  /**
+   * Instantiates a new standard material.
+   * This is the default material used in Babylon. It is the best trade off between quality
+   * and performances.
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/materials_introduction
+   * @param name Define the name of the material in the scene
+   * @param scene Define the scene the material belong to
+   */
+  constructor(t, a) {
+    super(t, a), this._diffuseTexture = null, this._ambientTexture = null, this._opacityTexture = null, this._reflectionTexture = null, this._emissiveTexture = null, this._specularTexture = null, this._bumpTexture = null, this._lightmapTexture = null, this._refractionTexture = null, this.ambientColor = new x(0, 0, 0), this.diffuseColor = new x(1, 1, 1), this.specularColor = new x(1, 1, 1), this.emissiveColor = new x(0, 0, 0), this.specularPower = 64, this._useAlphaFromDiffuseTexture = !1, this._useEmissiveAsIllumination = !1, this._linkEmissiveWithDiffuse = !1, this._useSpecularOverAlpha = !1, this._useReflectionOverAlpha = !1, this._disableLighting = !1, this._useObjectSpaceNormalMap = !1, this._useParallax = !1, this._useParallaxOcclusion = !1, this.parallaxScaleBias = 0.05, this._roughness = 0, this.indexOfRefraction = 0.98, this.invertRefractionY = !0, this.alphaCutOff = 0.4, this._useLightmapAsShadowmap = !1, this._useReflectionFresnelFromSpecular = !1, this._useGlossinessFromSpecularMapAlpha = !1, this._maxSimultaneousLights = 4, this._invertNormalMapX = !1, this._invertNormalMapY = !1, this._twoSidedLighting = !1, this._applyDecalMapAfterDetailMap = !1, this._renderTargets = new V(16), this._worldViewProjectionMatrix = H.Zero(), this._globalAmbientColor = new x(0, 0, 0), this._cacheHasRenderTargetTextures = !1, this.detailMap = new W(this), this._attachImageProcessingConfiguration(null), this.prePassConfiguration = new U(), this.getRenderTargetTextures = () => (this._renderTargets.reset(), i.ReflectionTextureEnabled && this._reflectionTexture && this._reflectionTexture.isRenderTarget && this._renderTargets.push(this._reflectionTexture), i.RefractionTextureEnabled && this._refractionTexture && this._refractionTexture.isRenderTarget && this._renderTargets.push(this._refractionTexture), this._eventInfo.renderTargets = this._renderTargets, this._callbackPluginEventFillRenderTargetTextures(this._eventInfo), this._renderTargets);
+  }
+  /**
+   * Gets a boolean indicating that current material needs to register RTT
+   */
+  get hasRenderTargetTextures() {
+    return i.ReflectionTextureEnabled && this._reflectionTexture && this._reflectionTexture.isRenderTarget || i.RefractionTextureEnabled && this._refractionTexture && this._refractionTexture.isRenderTarget ? !0 : this._cacheHasRenderTargetTextures;
+  }
+  /**
+   * Gets the current class name of the material e.g. "StandardMaterial"
+   * Mainly use in serialization.
+   * @returns the class name
+   */
+  getClassName() {
+    return "StandardMaterial";
+  }
+  /**
+   * In case the depth buffer does not allow enough depth precision for your scene (might be the case in large scenes)
+   * You can try switching to logarithmic depth.
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/materials/advanced/logarithmicDepthBuffer
+   */
+  get useLogarithmicDepth() {
+    return this._useLogarithmicDepth;
+  }
+  set useLogarithmicDepth(t) {
+    this._useLogarithmicDepth = t && this.getScene().getEngine().getCaps().fragmentDepthSupported, this._markAllSubMeshesAsMiscDirty();
+  }
+  /**
+   * Specifies if the material will require alpha blending
+   * @returns a boolean specifying if alpha blending is needed
+   */
+  needAlphaBlending() {
+    return this._disableAlphaBlending ? !1 : this.alpha < 1 || this._opacityTexture != null || this._shouldUseAlphaFromDiffuseTexture() || this._opacityFresnelParameters && this._opacityFresnelParameters.isEnabled;
+  }
+  /**
+   * Specifies if this material should be rendered in alpha test mode
+   * @returns a boolean specifying if an alpha test is needed.
+   */
+  needAlphaTesting() {
+    return this._forceAlphaTest ? !0 : this._hasAlphaChannel() && (this._transparencyMode == null || this._transparencyMode === F.MATERIAL_ALPHATEST);
+  }
+  /**
+   * Specifies whether or not the alpha value of the diffuse texture should be used for alpha blending.
+   */
+  _shouldUseAlphaFromDiffuseTexture() {
+    return this._diffuseTexture != null && this._diffuseTexture.hasAlpha && this._useAlphaFromDiffuseTexture && this._transparencyMode !== F.MATERIAL_OPAQUE;
+  }
+  /**
+   * Specifies whether or not there is a usable alpha channel for transparency.
+   */
+  _hasAlphaChannel() {
+    return this._diffuseTexture != null && this._diffuseTexture.hasAlpha || this._opacityTexture != null;
+  }
+  /**
+   * Get the texture used for alpha test purpose.
+   * @returns the diffuse texture in case of the standard material.
+   */
+  getAlphaTestTexture() {
+    return this._diffuseTexture;
+  }
+  /**
+   * Get if the submesh is ready to be used and all its information available.
+   * Child classes can use it to update shaders
+   * @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, a, T = !1) {
+    if (this._uniformBufferLayoutBuilt || this.buildUniformLayout(), a.effect && this.isFrozen && a.effect._wasPreviouslyReady && a.effect._wasPreviouslyUsingInstances === T)
+      return !0;
+    a.materialDefines || (this._callbackPluginEventGeneric(B.GetDefineNames, this._eventInfo), a.materialDefines = new j(this._eventInfo.defineNames));
+    const u = this.getScene(), e = a.materialDefines;
+    if (this._isReadyForSubMesh(a))
+      return !0;
+    const c = u.getEngine();
+    e._needNormals = n.PrepareDefinesForLights(u, t, e, !0, this._maxSimultaneousLights, this._disableLighting), n.PrepareDefinesForMultiview(u, e);
+    const o = this.needAlphaBlendingForMesh(t) && this.getScene().useOrderIndependentTransparency;
+    if (n.PrepareDefinesForPrePass(u, e, this.canRenderToMRT && !o), n.PrepareDefinesForOIT(u, e, o), e._areTexturesDirty) {
+      this._eventInfo.hasRenderTargetTextures = !1, this._callbackPluginEventHasRenderTargetTextures(this._eventInfo), this._cacheHasRenderTargetTextures = this._eventInfo.hasRenderTargetTextures, e._needUVs = !1;
+      for (let r = 1; r <= 6; ++r)
+        e["MAINUV" + r] = !1;
+      if (u.texturesEnabled) {
+        if (e.DIFFUSEDIRECTUV = 0, e.BUMPDIRECTUV = 0, e.AMBIENTDIRECTUV = 0, e.OPACITYDIRECTUV = 0, e.EMISSIVEDIRECTUV = 0, e.SPECULARDIRECTUV = 0, e.LIGHTMAPDIRECTUV = 0, this._diffuseTexture && i.DiffuseTextureEnabled)
+          if (this._diffuseTexture.isReadyOrNotBlocking())
+            n.PrepareDefinesForMergedUV(this._diffuseTexture, e, "DIFFUSE");
+          else
+            return !1;
+        else
+          e.DIFFUSE = !1;
+        if (this._ambientTexture && i.AmbientTextureEnabled)
+          if (this._ambientTexture.isReadyOrNotBlocking())
+            n.PrepareDefinesForMergedUV(this._ambientTexture, e, "AMBIENT");
+          else
+            return !1;
+        else
+          e.AMBIENT = !1;
+        if (this._opacityTexture && i.OpacityTextureEnabled)
+          if (this._opacityTexture.isReadyOrNotBlocking())
+            n.PrepareDefinesForMergedUV(this._opacityTexture, e, "OPACITY"), e.OPACITYRGB = this._opacityTexture.getAlphaFromRGB;
+          else
+            return !1;
+        else
+          e.OPACITY = !1;
+        if (this._reflectionTexture && i.ReflectionTextureEnabled)
+          if (this._reflectionTexture.isReadyOrNotBlocking()) {
+            switch (e._needNormals = !0, e.REFLECTION = !0, e.ROUGHNESS = this._roughness > 0, e.REFLECTIONOVERALPHA = this._useReflectionOverAlpha, e.INVERTCUBICMAP = this._reflectionTexture.coordinatesMode === m.INVCUBIC_MODE, e.REFLECTIONMAP_3D = this._reflectionTexture.isCube, e.REFLECTIONMAP_OPPOSITEZ = e.REFLECTIONMAP_3D && this.getScene().useRightHandedSystem ? !this._reflectionTexture.invertZ : this._reflectionTexture.invertZ, e.RGBDREFLECTION = this._reflectionTexture.isRGBD, this._reflectionTexture.coordinatesMode) {
+              case m.EXPLICIT_MODE:
+                e.setReflectionMode("REFLECTIONMAP_EXPLICIT");
+                break;
+              case m.PLANAR_MODE:
+                e.setReflectionMode("REFLECTIONMAP_PLANAR");
+                break;
+              case m.PROJECTION_MODE:
+                e.setReflectionMode("REFLECTIONMAP_PROJECTION");
+                break;
+              case m.SKYBOX_MODE:
+                e.setReflectionMode("REFLECTIONMAP_SKYBOX");
+                break;
+              case m.SPHERICAL_MODE:
+                e.setReflectionMode("REFLECTIONMAP_SPHERICAL");
+                break;
+              case m.EQUIRECTANGULAR_MODE:
+                e.setReflectionMode("REFLECTIONMAP_EQUIRECTANGULAR");
+                break;
+              case m.FIXED_EQUIRECTANGULAR_MODE:
+                e.setReflectionMode("REFLECTIONMAP_EQUIRECTANGULAR_FIXED");
+                break;
+              case m.FIXED_EQUIRECTANGULAR_MIRRORED_MODE:
+                e.setReflectionMode("REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED");
+                break;
+              case m.CUBIC_MODE:
+              case m.INVCUBIC_MODE:
+              default:
+                e.setReflectionMode("REFLECTIONMAP_CUBIC");
+                break;
+            }
+            e.USE_LOCAL_REFLECTIONMAP_CUBIC = !!this._reflectionTexture.boundingBoxSize;
+          } else
+            return !1;
+        else
+          e.REFLECTION = !1, e.REFLECTIONMAP_OPPOSITEZ = !1;
+        if (this._emissiveTexture && i.EmissiveTextureEnabled)
+          if (this._emissiveTexture.isReadyOrNotBlocking())
+            n.PrepareDefinesForMergedUV(this._emissiveTexture, e, "EMISSIVE");
+          else
+            return !1;
+        else
+          e.EMISSIVE = !1;
+        if (this._lightmapTexture && i.LightmapTextureEnabled)
+          if (this._lightmapTexture.isReadyOrNotBlocking())
+            n.PrepareDefinesForMergedUV(this._lightmapTexture, e, "LIGHTMAP"), e.USELIGHTMAPASSHADOWMAP = this._useLightmapAsShadowmap, e.RGBDLIGHTMAP = this._lightmapTexture.isRGBD;
+          else
+            return !1;
+        else
+          e.LIGHTMAP = !1;
+        if (this._specularTexture && i.SpecularTextureEnabled)
+          if (this._specularTexture.isReadyOrNotBlocking())
+            n.PrepareDefinesForMergedUV(this._specularTexture, e, "SPECULAR"), e.GLOSSINESS = this._useGlossinessFromSpecularMapAlpha;
+          else
+            return !1;
+        else
+          e.SPECULAR = !1;
+        if (u.getEngine().getCaps().standardDerivatives && this._bumpTexture && i.BumpTextureEnabled) {
+          if (this._bumpTexture.isReady())
+            n.PrepareDefinesForMergedUV(this._bumpTexture, e, "BUMP"), e.PARALLAX = this._useParallax, e.PARALLAXOCCLUSION = this._useParallaxOcclusion;
+          else
+            return !1;
+          e.OBJECTSPACE_NORMALMAP = this._useObjectSpaceNormalMap;
+        } else
+          e.BUMP = !1, e.PARALLAX = !1, e.PARALLAXOCCLUSION = !1;
+        if (this._refractionTexture && i.RefractionTextureEnabled)
+          if (this._refractionTexture.isReadyOrNotBlocking())
+            e._needUVs = !0, e.REFRACTION = !0, e.REFRACTIONMAP_3D = this._refractionTexture.isCube, e.RGBDREFRACTION = this._refractionTexture.isRGBD, e.USE_LOCAL_REFRACTIONMAP_CUBIC = !!this._refractionTexture.boundingBoxSize;
+          else
+            return !1;
+        else
+          e.REFRACTION = !1;
+        e.TWOSIDEDLIGHTING = !this._backFaceCulling && this._twoSidedLighting;
+      } else
+        e.DIFFUSE = !1, e.AMBIENT = !1, e.OPACITY = !1, e.REFLECTION = !1, e.EMISSIVE = !1, e.LIGHTMAP = !1, e.BUMP = !1, e.REFRACTION = !1;
+      e.ALPHAFROMDIFFUSE = this._shouldUseAlphaFromDiffuseTexture(), e.EMISSIVEASILLUMINATION = this._useEmissiveAsIllumination, e.LINKEMISSIVEWITHDIFFUSE = this._linkEmissiveWithDiffuse, e.SPECULAROVERALPHA = this._useSpecularOverAlpha, e.PREMULTIPLYALPHA = this.alphaMode === 7 || this.alphaMode === 8, e.ALPHATEST_AFTERALLALPHACOMPUTATIONS = this.transparencyMode !== null, e.ALPHABLEND = this.transparencyMode === null || this.needAlphaBlendingForMesh(t);
+    }
+    if (this._eventInfo.isReadyForSubMesh = !0, this._eventInfo.defines = e, this._eventInfo.subMesh = a, this._callbackPluginEventIsReadyForSubMesh(this._eventInfo), !this._eventInfo.isReadyForSubMesh)
+      return !1;
+    if (e._areImageProcessingDirty && this._imageProcessingConfiguration) {
+      if (!this._imageProcessingConfiguration.isReady())
+        return !1;
+      this._imageProcessingConfiguration.prepareDefines(e), e.IS_REFLECTION_LINEAR = this.reflectionTexture != null && !this.reflectionTexture.gammaSpace, e.IS_REFRACTION_LINEAR = this.refractionTexture != null && !this.refractionTexture.gammaSpace;
+    }
+    e._areFresnelDirty && (i.FresnelEnabled ? (this._diffuseFresnelParameters || this._opacityFresnelParameters || this._emissiveFresnelParameters || this._refractionFresnelParameters || this._reflectionFresnelParameters) && (e.DIFFUSEFRESNEL = this._diffuseFresnelParameters && this._diffuseFresnelParameters.isEnabled, e.OPACITYFRESNEL = this._opacityFresnelParameters && this._opacityFresnelParameters.isEnabled, e.REFLECTIONFRESNEL = this._reflectionFresnelParameters && this._reflectionFresnelParameters.isEnabled, e.REFLECTIONFRESNELFROMSPECULAR = this._useReflectionFresnelFromSpecular, e.REFRACTIONFRESNEL = this._refractionFresnelParameters && this._refractionFresnelParameters.isEnabled, e.EMISSIVEFRESNEL = this._emissiveFresnelParameters && this._emissiveFresnelParameters.isEnabled, e._needNormals = !0, e.FRESNEL = !0) : e.FRESNEL = !1), n.PrepareDefinesForMisc(t, u, this._useLogarithmicDepth, this.pointsCloud, this.fogEnabled, this._shouldTurnAlphaTestOn(t) || this._forceAlphaTest, e, this._applyDecalMapAfterDetailMap), n.PrepareDefinesForFrameBoundValues(u, c, this, e, T, null, a.getRenderingMesh().hasThinInstances), this._eventInfo.defines = e, this._eventInfo.mesh = t, this._callbackPluginEventPrepareDefinesBeforeAttributes(this._eventInfo), n.PrepareDefinesForAttributes(t, e, !0, !0, !0), this._callbackPluginEventPrepareDefines(this._eventInfo);
+    let d = !1;
+    if (e.isDirty) {
+      const r = e._areLightsDisposed;
+      e.markAsProcessed();
+      const f = new z();
+      e.REFLECTION && f.addFallback(0, "REFLECTION"), e.SPECULAR && f.addFallback(0, "SPECULAR"), e.BUMP && f.addFallback(0, "BUMP"), e.PARALLAX && f.addFallback(1, "PARALLAX"), e.PARALLAXOCCLUSION && f.addFallback(0, "PARALLAXOCCLUSION"), e.SPECULAROVERALPHA && f.addFallback(0, "SPECULAROVERALPHA"), e.FOG && f.addFallback(1, "FOG"), e.POINTSIZE && f.addFallback(0, "POINTSIZE"), e.LOGARITHMICDEPTH && f.addFallback(0, "LOGARITHMICDEPTH"), n.HandleFallbacksForShadows(e, f, this._maxSimultaneousLights), e.SPECULARTERM && f.addFallback(0, "SPECULARTERM"), e.DIFFUSEFRESNEL && f.addFallback(1, "DIFFUSEFRESNEL"), e.OPACITYFRESNEL && f.addFallback(2, "OPACITYFRESNEL"), e.REFLECTIONFRESNEL && f.addFallback(3, "REFLECTIONFRESNEL"), e.EMISSIVEFRESNEL && f.addFallback(4, "EMISSIVEFRESNEL"), e.FRESNEL && f.addFallback(4, "FRESNEL"), e.MULTIVIEW && f.addFallback(0, "MULTIVIEW");
+      const E = [S.PositionKind];
+      e.NORMAL && E.push(S.NormalKind), e.TANGENT && E.push(S.TangentKind);
+      for (let g = 1; g <= 6; ++g)
+        e["UV" + g] && E.push(`uv${g === 1 ? "" : g}`);
+      e.VERTEXCOLOR && E.push(S.ColorKind), n.PrepareAttributesForBones(E, t, e, f), n.PrepareAttributesForInstances(E, e), n.PrepareAttributesForMorphTargets(E, t, e), n.PrepareAttributesForBakedVertexAnimation(E, t, e);
+      let b = "default";
+      const A = [
+        "world",
+        "view",
+        "viewProjection",
+        "vEyePosition",
+        "vLightsType",
+        "vAmbientColor",
+        "vDiffuseColor",
+        "vSpecularColor",
+        "vEmissiveColor",
+        "visibility",
+        "vFogInfos",
+        "vFogColor",
+        "pointSize",
+        "vDiffuseInfos",
+        "vAmbientInfos",
+        "vOpacityInfos",
+        "vReflectionInfos",
+        "vEmissiveInfos",
+        "vSpecularInfos",
+        "vBumpInfos",
+        "vLightmapInfos",
+        "vRefractionInfos",
+        "mBones",
+        "diffuseMatrix",
+        "ambientMatrix",
+        "opacityMatrix",
+        "reflectionMatrix",
+        "emissiveMatrix",
+        "specularMatrix",
+        "bumpMatrix",
+        "normalMatrix",
+        "lightmapMatrix",
+        "refractionMatrix",
+        "diffuseLeftColor",
+        "diffuseRightColor",
+        "opacityParts",
+        "reflectionLeftColor",
+        "reflectionRightColor",
+        "emissiveLeftColor",
+        "emissiveRightColor",
+        "refractionLeftColor",
+        "refractionRightColor",
+        "vReflectionPosition",
+        "vReflectionSize",
+        "vRefractionPosition",
+        "vRefractionSize",
+        "logarithmicDepthConstant",
+        "vTangentSpaceParams",
+        "alphaCutOff",
+        "boneTextureWidth",
+        "morphTargetTextureInfo",
+        "morphTargetTextureIndices"
+      ], R = [
+        "diffuseSampler",
+        "ambientSampler",
+        "opacitySampler",
+        "reflectionCubeSampler",
+        "reflection2DSampler",
+        "emissiveSampler",
+        "specularSampler",
+        "bumpSampler",
+        "lightmapSampler",
+        "refractionCubeSampler",
+        "refraction2DSampler",
+        "boneSampler",
+        "morphTargets",
+        "oitDepthSampler",
+        "oitFrontColorSampler"
+      ], C = ["Material", "Scene", "Mesh"];
+      this._eventInfo.fallbacks = f, this._eventInfo.fallbackRank = 0, this._eventInfo.defines = e, this._eventInfo.uniforms = A, this._eventInfo.attributes = E, this._eventInfo.samplers = R, this._eventInfo.uniformBuffersNames = C, this._eventInfo.customCode = void 0, this._eventInfo.mesh = t, this._callbackPluginEventGeneric(B.PrepareEffect, this._eventInfo), U.AddUniforms(A), L && (L.PrepareUniforms(A, e), L.PrepareSamplers(R, e)), n.PrepareUniformsAndSamplersList({
+        uniformsNames: A,
+        uniformBuffersNames: C,
+        samplers: R,
+        defines: e,
+        maxSimultaneousLights: this._maxSimultaneousLights
+      }), Q(A);
+      const O = {};
+      this.customShaderNameResolve && (b = this.customShaderNameResolve(b, A, C, R, e, E, O));
+      const G = e.toString(), D = a.effect;
+      let P = u.getEngine().createEffect(b, {
+        attributes: E,
+        uniformsNames: A,
+        uniformBuffersNames: C,
+        samplers: R,
+        defines: G,
+        fallbacks: f,
+        onCompiled: this.onCompiled,
+        onError: this.onError,
+        indexParameters: { maxSimultaneousLights: this._maxSimultaneousLights, maxSimultaneousMorphTargets: e.NUM_MORPH_INFLUENCERS },
+        processFinalCode: O.processFinalCode,
+        processCodeAfterIncludes: this._eventInfo.customCode,
+        multiTarget: e.PREPASS
+      }, c);
+      if (this._eventInfo.customCode = void 0, P)
+        if (this._onEffectCreatedObservable && (M.effect = P, M.subMesh = a, this._onEffectCreatedObservable.notifyObservers(M)), this.allowShaderHotSwapping && D && !P.isReady()) {
+          if (P = D, e.markAsUnprocessed(), d = this.isFrozen, r)
+            return e._areLightsDisposed = !0, !1;
+        } else
+          u.resetCachedMaterial(), a.setEffect(P, e, this._materialContext);
+    }
+    return !a.effect || !a.effect.isReady() ? !1 : (e._renderId = u.getRenderId(), a.effect._wasPreviouslyReady = !d, a.effect._wasPreviouslyUsingInstances = T, this._checkScenePerformancePriority(), !0);
+  }
+  /**
+   * Builds the material UBO layouts.
+   * Used internally during the effect preparation.
+   */
+  buildUniformLayout() {
+    const t = this._uniformBuffer;
+    t.addUniform("diffuseLeftColor", 4), t.addUniform("diffuseRightColor", 4), t.addUniform("opacityParts", 4), t.addUniform("reflectionLeftColor", 4), t.addUniform("reflectionRightColor", 4), t.addUniform("refractionLeftColor", 4), t.addUniform("refractionRightColor", 4), t.addUniform("emissiveLeftColor", 4), t.addUniform("emissiveRightColor", 4), t.addUniform("vDiffuseInfos", 2), t.addUniform("vAmbientInfos", 2), t.addUniform("vOpacityInfos", 2), t.addUniform("vReflectionInfos", 2), t.addUniform("vReflectionPosition", 3), t.addUniform("vReflectionSize", 3), t.addUniform("vEmissiveInfos", 2), t.addUniform("vLightmapInfos", 2), t.addUniform("vSpecularInfos", 2), t.addUniform("vBumpInfos", 3), t.addUniform("diffuseMatrix", 16), t.addUniform("ambientMatrix", 16), t.addUniform("opacityMatrix", 16), t.addUniform("reflectionMatrix", 16), t.addUniform("emissiveMatrix", 16), t.addUniform("lightmapMatrix", 16), t.addUniform("specularMatrix", 16), t.addUniform("bumpMatrix", 16), t.addUniform("vTangentSpaceParams", 2), t.addUniform("pointSize", 1), t.addUniform("alphaCutOff", 1), t.addUniform("refractionMatrix", 16), t.addUniform("vRefractionInfos", 4), t.addUniform("vRefractionPosition", 3), t.addUniform("vRefractionSize", 3), t.addUniform("vSpecularColor", 4), t.addUniform("vEmissiveColor", 3), t.addUniform("vDiffuseColor", 4), t.addUniform("vAmbientColor", 3), super.buildUniformLayout();
+  }
+  /**
+   * 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, a, T) {
+    var u;
+    const e = this.getScene(), c = T.materialDefines;
+    if (!c)
+      return;
+    const o = T.effect;
+    if (!o)
+      return;
+    this._activeEffect = o, a.getMeshUniformBuffer().bindToEffect(o, "Mesh"), a.transferToEffect(t), this._uniformBuffer.bindToEffect(o, "Material"), this.prePassConfiguration.bindForSubMesh(this._activeEffect, e, a, t, this.isFrozen), this._eventInfo.subMesh = T, this._callbackPluginEventHardBindForSubMesh(this._eventInfo), c.OBJECTSPACE_NORMALMAP && (t.toNormalMatrix(this._normalMatrix), this.bindOnlyNormalMatrix(this._normalMatrix));
+    const d = o._forceRebindOnNextCall || this._mustRebind(e, o, a.visibility);
+    n.BindBonesParameters(a, o);
+    const r = this._uniformBuffer;
+    if (d) {
+      if (this.bindViewProjection(o), !r.useUbo || !this.isFrozen || !r.isSync || o._forceRebindOnNextCall) {
+        if (i.FresnelEnabled && c.FRESNEL && (this.diffuseFresnelParameters && this.diffuseFresnelParameters.isEnabled && (r.updateColor4("diffuseLeftColor", this.diffuseFresnelParameters.leftColor, this.diffuseFresnelParameters.power), r.updateColor4("diffuseRightColor", this.diffuseFresnelParameters.rightColor, this.diffuseFresnelParameters.bias)), this.opacityFresnelParameters && this.opacityFresnelParameters.isEnabled && r.updateColor4("opacityParts", new x(this.opacityFresnelParameters.leftColor.toLuminance(), this.opacityFresnelParameters.rightColor.toLuminance(), this.opacityFresnelParameters.bias), this.opacityFresnelParameters.power), this.reflectionFresnelParameters && this.reflectionFresnelParameters.isEnabled && (r.updateColor4("reflectionLeftColor", this.reflectionFresnelParameters.leftColor, this.reflectionFresnelParameters.power), r.updateColor4("reflectionRightColor", this.reflectionFresnelParameters.rightColor, this.reflectionFresnelParameters.bias)), this.refractionFresnelParameters && this.refractionFresnelParameters.isEnabled && (r.updateColor4("refractionLeftColor", this.refractionFresnelParameters.leftColor, this.refractionFresnelParameters.power), r.updateColor4("refractionRightColor", this.refractionFresnelParameters.rightColor, this.refractionFresnelParameters.bias)), this.emissiveFresnelParameters && this.emissiveFresnelParameters.isEnabled && (r.updateColor4("emissiveLeftColor", this.emissiveFresnelParameters.leftColor, this.emissiveFresnelParameters.power), r.updateColor4("emissiveRightColor", this.emissiveFresnelParameters.rightColor, this.emissiveFresnelParameters.bias))), e.texturesEnabled) {
+          if (this._diffuseTexture && i.DiffuseTextureEnabled && (r.updateFloat2("vDiffuseInfos", this._diffuseTexture.coordinatesIndex, this._diffuseTexture.level), n.BindTextureMatrix(this._diffuseTexture, r, "diffuse")), this._ambientTexture && i.AmbientTextureEnabled && (r.updateFloat2("vAmbientInfos", this._ambientTexture.coordinatesIndex, this._ambientTexture.level), n.BindTextureMatrix(this._ambientTexture, r, "ambient")), this._opacityTexture && i.OpacityTextureEnabled && (r.updateFloat2("vOpacityInfos", this._opacityTexture.coordinatesIndex, this._opacityTexture.level), n.BindTextureMatrix(this._opacityTexture, r, "opacity")), this._hasAlphaChannel() && r.updateFloat("alphaCutOff", this.alphaCutOff), this._reflectionTexture && i.ReflectionTextureEnabled && (r.updateFloat2("vReflectionInfos", this._reflectionTexture.level, this.roughness), r.updateMatrix("reflectionMatrix", this._reflectionTexture.getReflectionTextureMatrix()), this._reflectionTexture.boundingBoxSize)) {
+            const f = this._reflectionTexture;
+            r.updateVector3("vReflectionPosition", f.boundingBoxPosition), r.updateVector3("vReflectionSize", f.boundingBoxSize);
+          }
+          if (this._emissiveTexture && i.EmissiveTextureEnabled && (r.updateFloat2("vEmissiveInfos", this._emissiveTexture.coordinatesIndex, this._emissiveTexture.level), n.BindTextureMatrix(this._emissiveTexture, r, "emissive")), this._lightmapTexture && i.LightmapTextureEnabled && (r.updateFloat2("vLightmapInfos", this._lightmapTexture.coordinatesIndex, this._lightmapTexture.level), n.BindTextureMatrix(this._lightmapTexture, r, "lightmap")), this._specularTexture && i.SpecularTextureEnabled && (r.updateFloat2("vSpecularInfos", this._specularTexture.coordinatesIndex, this._specularTexture.level), n.BindTextureMatrix(this._specularTexture, r, "specular")), this._bumpTexture && e.getEngine().getCaps().standardDerivatives && i.BumpTextureEnabled && (r.updateFloat3("vBumpInfos", this._bumpTexture.coordinatesIndex, 1 / this._bumpTexture.level, this.parallaxScaleBias), n.BindTextureMatrix(this._bumpTexture, r, "bump"), e._mirroredCameraPosition ? r.updateFloat2("vTangentSpaceParams", this._invertNormalMapX ? 1 : -1, this._invertNormalMapY ? 1 : -1) : r.updateFloat2("vTangentSpaceParams", this._invertNormalMapX ? -1 : 1, this._invertNormalMapY ? -1 : 1)), this._refractionTexture && i.RefractionTextureEnabled) {
+            let f = 1;
+            if (this._refractionTexture.isCube || (r.updateMatrix("refractionMatrix", this._refractionTexture.getReflectionTextureMatrix()), this._refractionTexture.depth && (f = this._refractionTexture.depth)), r.updateFloat4("vRefractionInfos", this._refractionTexture.level, this.indexOfRefraction, f, this.invertRefractionY ? -1 : 1), this._refractionTexture.boundingBoxSize) {
+              const E = this._refractionTexture;
+              r.updateVector3("vRefractionPosition", E.boundingBoxPosition), r.updateVector3("vRefractionSize", E.boundingBoxSize);
+            }
+          }
+        }
+        this.pointsCloud && r.updateFloat("pointSize", this.pointSize), c.SPECULARTERM && r.updateColor4("vSpecularColor", this.specularColor, this.specularPower), r.updateColor3("vEmissiveColor", i.EmissiveTextureEnabled ? this.emissiveColor : x.BlackReadOnly), r.updateColor4("vDiffuseColor", this.diffuseColor, this.alpha), e.ambientColor.multiplyToRef(this.ambientColor, this._globalAmbientColor), r.updateColor3("vAmbientColor", this._globalAmbientColor);
+      }
+      e.texturesEnabled && (this._diffuseTexture && i.DiffuseTextureEnabled && o.setTexture("diffuseSampler", this._diffuseTexture), this._ambientTexture && i.AmbientTextureEnabled && o.setTexture("ambientSampler", this._ambientTexture), this._opacityTexture && i.OpacityTextureEnabled && o.setTexture("opacitySampler", this._opacityTexture), this._reflectionTexture && i.ReflectionTextureEnabled && (this._reflectionTexture.isCube ? o.setTexture("reflectionCubeSampler", this._reflectionTexture) : o.setTexture("reflection2DSampler", this._reflectionTexture)), this._emissiveTexture && i.EmissiveTextureEnabled && o.setTexture("emissiveSampler", this._emissiveTexture), this._lightmapTexture && i.LightmapTextureEnabled && o.setTexture("lightmapSampler", this._lightmapTexture), this._specularTexture && i.SpecularTextureEnabled && o.setTexture("specularSampler", this._specularTexture), this._bumpTexture && e.getEngine().getCaps().standardDerivatives && i.BumpTextureEnabled && o.setTexture("bumpSampler", this._bumpTexture), this._refractionTexture && i.RefractionTextureEnabled && (this._refractionTexture.isCube ? o.setTexture("refractionCubeSampler", this._refractionTexture) : o.setTexture("refraction2DSampler", this._refractionTexture))), this.getScene().useOrderIndependentTransparency && this.needAlphaBlendingForMesh(a) && this.getScene().depthPeelingRenderer.bind(o), this._eventInfo.subMesh = T, this._callbackPluginEventBindForSubMesh(this._eventInfo), K(o, this, e), this.bindEyePosition(o);
+    } else
+      e.getEngine()._features.needToAlwaysBindUniformBuffers && (this._needToBindSceneUbo = !0);
+    (d || !this.isFrozen) && (e.lightsEnabled && !this._disableLighting && n.BindLights(e, a, o, c, this._maxSimultaneousLights), (e.fogEnabled && a.applyFog && e.fogMode !== k.FOGMODE_NONE || this._reflectionTexture || this._refractionTexture || a.receiveShadows || c.PREPASS) && this.bindView(o), n.BindFogParameters(e, a, o), c.NUM_MORPH_INFLUENCERS && n.BindMorphTargetParameters(a, o), c.BAKED_VERTEX_ANIMATION_TEXTURE && ((u = a.bakedVertexAnimationManager) === null || u === void 0 || u.bind(o, c.INSTANCES)), this.useLogarithmicDepth && n.BindLogDepth(c, o, e), this._imageProcessingConfiguration && !this._imageProcessingConfiguration.applyByPostProcess && this._imageProcessingConfiguration.bind(this._activeEffect)), this._afterBind(a, this._activeEffect), r.update();
+  }
+  /**
+   * Get the list of animatables in the material.
+   * @returns the list of animatables object used in the material
+   */
+  getAnimatables() {
+    const t = super.getAnimatables();
+    return this._diffuseTexture && this._diffuseTexture.animations && this._diffuseTexture.animations.length > 0 && t.push(this._diffuseTexture), this._ambientTexture && this._ambientTexture.animations && this._ambientTexture.animations.length > 0 && t.push(this._ambientTexture), this._opacityTexture && this._opacityTexture.animations && this._opacityTexture.animations.length > 0 && t.push(this._opacityTexture), this._reflectionTexture && this._reflectionTexture.animations && this._reflectionTexture.animations.length > 0 && t.push(this._reflectionTexture), this._emissiveTexture && this._emissiveTexture.animations && this._emissiveTexture.animations.length > 0 && t.push(this._emissiveTexture), this._specularTexture && this._specularTexture.animations && this._specularTexture.animations.length > 0 && t.push(this._specularTexture), this._bumpTexture && this._bumpTexture.animations && this._bumpTexture.animations.length > 0 && t.push(this._bumpTexture), this._lightmapTexture && this._lightmapTexture.animations && this._lightmapTexture.animations.length > 0 && t.push(this._lightmapTexture), this._refractionTexture && this._refractionTexture.animations && this._refractionTexture.animations.length > 0 && t.push(this._refractionTexture), t;
+  }
+  /**
+   * Gets the active textures from the material
+   * @returns an array of textures
+   */
+  getActiveTextures() {
+    const t = super.getActiveTextures();
+    return this._diffuseTexture && t.push(this._diffuseTexture), this._ambientTexture && t.push(this._ambientTexture), this._opacityTexture && t.push(this._opacityTexture), this._reflectionTexture && t.push(this._reflectionTexture), this._emissiveTexture && t.push(this._emissiveTexture), this._specularTexture && t.push(this._specularTexture), this._bumpTexture && t.push(this._bumpTexture), this._lightmapTexture && t.push(this._lightmapTexture), this._refractionTexture && t.push(this._refractionTexture), 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) {
+    return !!(super.hasTexture(t) || this._diffuseTexture === t || this._ambientTexture === t || this._opacityTexture === t || this._reflectionTexture === t || this._emissiveTexture === t || this._specularTexture === t || this._bumpTexture === t || this._lightmapTexture === t || this._refractionTexture === t);
+  }
+  /**
+   * Disposes the material
+   * @param forceDisposeEffect specifies if effects should be forcefully disposed
+   * @param forceDisposeTextures specifies if textures should be forcefully disposed
+   */
+  dispose(t, a) {
+    var T, u, e, c, o, d, r, f, E;
+    a && ((T = this._diffuseTexture) === null || T === void 0 || T.dispose(), (u = this._ambientTexture) === null || u === void 0 || u.dispose(), (e = this._opacityTexture) === null || e === void 0 || e.dispose(), (c = this._reflectionTexture) === null || c === void 0 || c.dispose(), (o = this._emissiveTexture) === null || o === void 0 || o.dispose(), (d = this._specularTexture) === null || d === void 0 || d.dispose(), (r = this._bumpTexture) === null || r === void 0 || r.dispose(), (f = this._lightmapTexture) === null || f === void 0 || f.dispose(), (E = this._refractionTexture) === null || E === void 0 || E.dispose()), this._imageProcessingConfiguration && this._imageProcessingObserver && this._imageProcessingConfiguration.onUpdateParameters.remove(this._imageProcessingObserver), super.dispose(t, a);
+  }
+  /**
+   * Makes a duplicate of the material, and gives it a new name
+   * @param name defines the new name for the duplicated material
+   * @param cloneTexturesOnlyOnce - if a texture is used in more than one channel (e.g diffuse and opacity), only clone it once and reuse it on the other channels. Default false.
+   * @param rootUrl defines the root URL to use to load textures
+   * @returns the cloned material
+   */
+  clone(t, a = !0, T = "") {
+    const u = y.Clone(() => new i(t, this.getScene()), this, { cloneTexturesOnlyOnce: a });
+    return u.name = t, u.id = t, this.stencil.copyTo(u.stencil), this._clonePlugins(u, T), u;
+  }
+  /**
+   * Creates a standard material from parsed 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 standard material
+   */
+  static Parse(t, a, T) {
+    const u = y.Parse(() => new i(t.name, a), t, a, T);
+    return t.stencil && u.stencil.parse(t.stencil, a, T), F._parsePlugins(t, u, a, T), u;
+  }
+  // Flags used to enable or disable a type of texture for all Standard Materials
+  /**
+   * Are diffuse textures enabled in the application.
+   */
+  static get DiffuseTextureEnabled() {
+    return h.DiffuseTextureEnabled;
+  }
+  static set DiffuseTextureEnabled(t) {
+    h.DiffuseTextureEnabled = t;
+  }
+  /**
+   * Are detail textures enabled in the application.
+   */
+  static get DetailTextureEnabled() {
+    return h.DetailTextureEnabled;
+  }
+  static set DetailTextureEnabled(t) {
+    h.DetailTextureEnabled = t;
+  }
+  /**
+   * Are ambient textures enabled in the application.
+   */
+  static get AmbientTextureEnabled() {
+    return h.AmbientTextureEnabled;
+  }
+  static set AmbientTextureEnabled(t) {
+    h.AmbientTextureEnabled = t;
+  }
+  /**
+   * Are opacity textures enabled in the application.
+   */
+  static get OpacityTextureEnabled() {
+    return h.OpacityTextureEnabled;
+  }
+  static set OpacityTextureEnabled(t) {
+    h.OpacityTextureEnabled = t;
+  }
+  /**
+   * Are reflection textures enabled in the application.
+   */
+  static get ReflectionTextureEnabled() {
+    return h.ReflectionTextureEnabled;
+  }
+  static set ReflectionTextureEnabled(t) {
+    h.ReflectionTextureEnabled = t;
+  }
+  /**
+   * Are emissive textures enabled in the application.
+   */
+  static get EmissiveTextureEnabled() {
+    return h.EmissiveTextureEnabled;
+  }
+  static set EmissiveTextureEnabled(t) {
+    h.EmissiveTextureEnabled = t;
+  }
+  /**
+   * Are specular textures enabled in the application.
+   */
+  static get SpecularTextureEnabled() {
+    return h.SpecularTextureEnabled;
+  }
+  static set SpecularTextureEnabled(t) {
+    h.SpecularTextureEnabled = t;
+  }
+  /**
+   * Are bump textures enabled in the application.
+   */
+  static get BumpTextureEnabled() {
+    return h.BumpTextureEnabled;
+  }
+  static set BumpTextureEnabled(t) {
+    h.BumpTextureEnabled = t;
+  }
+  /**
+   * Are lightmap textures enabled in the application.
+   */
+  static get LightmapTextureEnabled() {
+    return h.LightmapTextureEnabled;
+  }
+  static set LightmapTextureEnabled(t) {
+    h.LightmapTextureEnabled = t;
+  }
+  /**
+   * Are refraction textures enabled in the application.
+   */
+  static get RefractionTextureEnabled() {
+    return h.RefractionTextureEnabled;
+  }
+  static set RefractionTextureEnabled(t) {
+    h.RefractionTextureEnabled = t;
+  }
+  /**
+   * Are color grading textures enabled in the application.
+   */
+  static get ColorGradingTextureEnabled() {
+    return h.ColorGradingTextureEnabled;
+  }
+  static set ColorGradingTextureEnabled(t) {
+    h.ColorGradingTextureEnabled = t;
+  }
+  /**
+   * Are fresnels enabled in the application.
+   */
+  static get FresnelEnabled() {
+    return h.FresnelEnabled;
+  }
+  static set FresnelEnabled(t) {
+    h.FresnelEnabled = t;
+  }
+}
+s([
+  _("diffuseTexture")
+], i.prototype, "_diffuseTexture", void 0);
+s([
+  l("_markAllSubMeshesAsTexturesAndMiscDirty")
+], i.prototype, "diffuseTexture", void 0);
+s([
+  _("ambientTexture")
+], i.prototype, "_ambientTexture", void 0);
+s([
+  l("_markAllSubMeshesAsTexturesDirty")
+], i.prototype, "ambientTexture", void 0);
+s([
+  _("opacityTexture")
+], i.prototype, "_opacityTexture", void 0);
+s([
+  l("_markAllSubMeshesAsTexturesAndMiscDirty")
+], i.prototype, "opacityTexture", void 0);
+s([
+  _("reflectionTexture")
+], i.prototype, "_reflectionTexture", void 0);
+s([
+  l("_markAllSubMeshesAsTexturesDirty")
+], i.prototype, "reflectionTexture", void 0);
+s([
+  _("emissiveTexture")
+], i.prototype, "_emissiveTexture", void 0);
+s([
+  l("_markAllSubMeshesAsTexturesDirty")
+], i.prototype, "emissiveTexture", void 0);
+s([
+  _("specularTexture")
+], i.prototype, "_specularTexture", void 0);
+s([
+  l("_markAllSubMeshesAsTexturesDirty")
+], i.prototype, "specularTexture", void 0);
+s([
+  _("bumpTexture")
+], i.prototype, "_bumpTexture", void 0);
+s([
+  l("_markAllSubMeshesAsTexturesDirty")
+], i.prototype, "bumpTexture", void 0);
+s([
+  _("lightmapTexture")
+], i.prototype, "_lightmapTexture", void 0);
+s([
+  l("_markAllSubMeshesAsTexturesDirty")
+], i.prototype, "lightmapTexture", void 0);
+s([
+  _("refractionTexture")
+], i.prototype, "_refractionTexture", void 0);
+s([
+  l("_markAllSubMeshesAsTexturesDirty")
+], i.prototype, "refractionTexture", void 0);
+s([
+  v("ambient")
+], i.prototype, "ambientColor", void 0);
+s([
+  v("diffuse")
+], i.prototype, "diffuseColor", void 0);
+s([
+  v("specular")
+], i.prototype, "specularColor", void 0);
+s([
+  v("emissive")
+], i.prototype, "emissiveColor", void 0);
+s([
+  p()
+], i.prototype, "specularPower", void 0);
+s([
+  p("useAlphaFromDiffuseTexture")
+], i.prototype, "_useAlphaFromDiffuseTexture", void 0);
+s([
+  l("_markAllSubMeshesAsTexturesAndMiscDirty")
+], i.prototype, "useAlphaFromDiffuseTexture", void 0);
+s([
+  p("useEmissiveAsIllumination")
+], i.prototype, "_useEmissiveAsIllumination", void 0);
+s([
+  l("_markAllSubMeshesAsTexturesDirty")
+], i.prototype, "useEmissiveAsIllumination", void 0);
+s([
+  p("linkEmissiveWithDiffuse")
+], i.prototype, "_linkEmissiveWithDiffuse", void 0);
+s([
+  l("_markAllSubMeshesAsTexturesDirty")
+], i.prototype, "linkEmissiveWithDiffuse", void 0);
+s([
+  p("useSpecularOverAlpha")
+], i.prototype, "_useSpecularOverAlpha", void 0);
+s([
+  l("_markAllSubMeshesAsTexturesDirty")
+], i.prototype, "useSpecularOverAlpha", void 0);
+s([
+  p("useReflectionOverAlpha")
+], i.prototype, "_useReflectionOverAlpha", void 0);
+s([
+  l("_markAllSubMeshesAsTexturesDirty")
+], i.prototype, "useReflectionOverAlpha", void 0);
+s([
+  p("disableLighting")
+], i.prototype, "_disableLighting", void 0);
+s([
+  l("_markAllSubMeshesAsLightsDirty")
+], i.prototype, "disableLighting", void 0);
+s([
+  p("useObjectSpaceNormalMap")
+], i.prototype, "_useObjectSpaceNormalMap", void 0);
+s([
+  l("_markAllSubMeshesAsTexturesDirty")
+], i.prototype, "useObjectSpaceNormalMap", void 0);
+s([
+  p("useParallax")
+], i.prototype, "_useParallax", void 0);
+s([
+  l("_markAllSubMeshesAsTexturesDirty")
+], i.prototype, "useParallax", void 0);
+s([
+  p("useParallaxOcclusion")
+], i.prototype, "_useParallaxOcclusion", void 0);
+s([
+  l("_markAllSubMeshesAsTexturesDirty")
+], i.prototype, "useParallaxOcclusion", void 0);
+s([
+  p()
+], i.prototype, "parallaxScaleBias", void 0);
+s([
+  p("roughness")
+], i.prototype, "_roughness", void 0);
+s([
+  l("_markAllSubMeshesAsTexturesDirty")
+], i.prototype, "roughness", void 0);
+s([
+  p()
+], i.prototype, "indexOfRefraction", void 0);
+s([
+  p()
+], i.prototype, "invertRefractionY", void 0);
+s([
+  p()
+], i.prototype, "alphaCutOff", void 0);
+s([
+  p("useLightmapAsShadowmap")
+], i.prototype, "_useLightmapAsShadowmap", void 0);
+s([
+  l("_markAllSubMeshesAsTexturesDirty")
+], i.prototype, "useLightmapAsShadowmap", void 0);
+s([
+  I("diffuseFresnelParameters")
+], i.prototype, "_diffuseFresnelParameters", void 0);
+s([
+  l("_markAllSubMeshesAsFresnelDirty")
+], i.prototype, "diffuseFresnelParameters", void 0);
+s([
+  I("opacityFresnelParameters")
+], i.prototype, "_opacityFresnelParameters", void 0);
+s([
+  l("_markAllSubMeshesAsFresnelAndMiscDirty")
+], i.prototype, "opacityFresnelParameters", void 0);
+s([
+  I("reflectionFresnelParameters")
+], i.prototype, "_reflectionFresnelParameters", void 0);
+s([
+  l("_markAllSubMeshesAsFresnelDirty")
+], i.prototype, "reflectionFresnelParameters", void 0);
+s([
+  I("refractionFresnelParameters")
+], i.prototype, "_refractionFresnelParameters", void 0);
+s([
+  l("_markAllSubMeshesAsFresnelDirty")
+], i.prototype, "refractionFresnelParameters", void 0);
+s([
+  I("emissiveFresnelParameters")
+], i.prototype, "_emissiveFresnelParameters", void 0);
+s([
+  l("_markAllSubMeshesAsFresnelDirty")
+], i.prototype, "emissiveFresnelParameters", void 0);
+s([
+  p("useReflectionFresnelFromSpecular")
+], i.prototype, "_useReflectionFresnelFromSpecular", void 0);
+s([
+  l("_markAllSubMeshesAsFresnelDirty")
+], i.prototype, "useReflectionFresnelFromSpecular", void 0);
+s([
+  p("useGlossinessFromSpecularMapAlpha")
+], i.prototype, "_useGlossinessFromSpecularMapAlpha", void 0);
+s([
+  l("_markAllSubMeshesAsTexturesDirty")
+], i.prototype, "useGlossinessFromSpecularMapAlpha", void 0);
+s([
+  p("maxSimultaneousLights")
+], i.prototype, "_maxSimultaneousLights", void 0);
+s([
+  l("_markAllSubMeshesAsLightsDirty")
+], i.prototype, "maxSimultaneousLights", void 0);
+s([
+  p("invertNormalMapX")
+], i.prototype, "_invertNormalMapX", void 0);
+s([
+  l("_markAllSubMeshesAsTexturesDirty")
+], i.prototype, "invertNormalMapX", void 0);
+s([
+  p("invertNormalMapY")
+], i.prototype, "_invertNormalMapY", void 0);
+s([
+  l("_markAllSubMeshesAsTexturesDirty")
+], i.prototype, "invertNormalMapY", void 0);
+s([
+  p("twoSidedLighting")
+], i.prototype, "_twoSidedLighting", void 0);
+s([
+  l("_markAllSubMeshesAsTexturesDirty")
+], i.prototype, "twoSidedLighting", void 0);
+s([
+  p("applyDecalMapAfterDetailMap")
+], i.prototype, "_applyDecalMapAfterDetailMap", void 0);
+s([
+  l("_markAllSubMeshesAsMiscDirty")
+], i.prototype, "applyDecalMapAfterDetailMap", void 0);
+s([
+  p()
+], i.prototype, "useLogarithmicDepth", null);
+Y("BABYLON.StandardMaterial", i);
+k.DefaultMaterialFactory = (N) => new i("default material", N);
+export {
+  i as StandardMaterial,
+  j as StandardMaterialDefines
+};