@onerjs/core 8.26.3 → 8.26.4

package/Materials/standardMaterial.d.ts

@@ -8,52 +8,23 @@ import type { SubMesh } from "../Meshes/subMesh.js";
 import type { AbstractMesh } from "../Meshes/abstractMesh.js";
 import type { Mesh } from "../Meshes/mesh.js";
 import { PrePassConfiguration } from "./prePassConfiguration.js";
+import type { IImageProcessingConfigurationDefines } from "./imageProcessingConfiguration.defines.js";
 import { ImageProcessingConfiguration } from "./imageProcessingConfiguration.js";
+import type { ColorCurves } from "./colorCurves.js";
 import type { FresnelParameters } from "./fresnelParameters.js";
 import { MaterialDefines } from "../Materials/materialDefines.js";
 import { PushMaterial } from "./pushMaterial.js";
 import type { BaseTexture } from "../Materials/Textures/baseTexture.js";
 import type { RenderTargetTexture } from "../Materials/Textures/renderTargetTexture.js";
 import { DetailMapConfiguration } from "./material.detailMapConfiguration.js";
-declare const StandardMaterialDefinesBase_base: {
-    new (...args: any[]): {
-        MAINUV1: boolean;
-        MAINUV2: boolean;
-        MAINUV3: boolean;
-        MAINUV4: boolean;
-        MAINUV5: boolean;
-        MAINUV6: boolean;
-        UV1: boolean;
-        UV2: boolean;
-        UV3: boolean;
-        UV4: boolean;
-        UV5: boolean;
-        UV6: boolean;
-    };
-} & typeof MaterialDefines;
-declare class StandardMaterialDefinesBase extends StandardMaterialDefinesBase_base {
-}
-declare const StandardMaterialDefines_base: {
-    new (...args: any[]): {
-        IMAGEPROCESSING: boolean;
-        VIGNETTE: boolean;
-        VIGNETTEBLENDMODEMULTIPLY: boolean;
-        VIGNETTEBLENDMODEOPAQUE: boolean;
-        TONEMAPPING: number;
-        CONTRAST: boolean;
-        COLORCURVES: boolean;
-        COLORGRADING: boolean;
-        COLORGRADING3D: boolean;
-        SAMPLER3DGREENDEPTH: boolean;
-        SAMPLER3DBGRMAP: boolean;
-        DITHER: boolean;
-        IMAGEPROCESSINGPOSTPROCESS: boolean;
-        SKIPFINALCOLORCLAMP: boolean;
-        EXPOSURE: boolean;
-    };
-} & typeof StandardMaterialDefinesBase;
 /** @internal */
-export declare class StandardMaterialDefines extends StandardMaterialDefines_base {
+export declare class StandardMaterialDefines extends MaterialDefines implements IImageProcessingConfigurationDefines {
+    MAINUV1: boolean;
+    MAINUV2: boolean;
+    MAINUV3: boolean;
+    MAINUV4: boolean;
+    MAINUV5: boolean;
+    MAINUV6: boolean;
     DIFFUSE: boolean;
     DIFFUSEDIRECTUV: number;
     BAKED_VERTEX_ANIMATION_TEXTURE: boolean;
@@ -93,6 +64,12 @@ export declare class StandardMaterialDefines extends StandardMaterialDefines_bas
     FRESNEL: boolean;
     NORMAL: boolean;
     TANGENT: boolean;
+    UV1: boolean;
+    UV2: boolean;
+    UV3: boolean;
+    UV4: boolean;
+    UV5: boolean;
+    UV6: boolean;
     VERTEXCOLOR: boolean;
     VERTEXALPHA: boolean;
     NUM_BONE_INFLUENCERS: number;
@@ -184,6 +161,20 @@ export declare class StandardMaterialDefines extends StandardMaterialDefines_bas
     RGBDLIGHTMAP: boolean;
     RGBDREFLECTION: boolean;
     RGBDREFRACTION: boolean;
+    IMAGEPROCESSING: boolean;
+    VIGNETTE: boolean;
+    VIGNETTEBLENDMODEMULTIPLY: boolean;
+    VIGNETTEBLENDMODEOPAQUE: boolean;
+    TONEMAPPING: number;
+    CONTRAST: boolean;
+    COLORCURVES: boolean;
+    COLORGRADING: boolean;
+    COLORGRADING3D: boolean;
+    SAMPLER3DGREENDEPTH: boolean;
+    SAMPLER3DBGRMAP: boolean;
+    DITHER: boolean;
+    IMAGEPROCESSINGPOSTPROCESS: boolean;
+    SKIPFINALCOLORCLAMP: boolean;
     MULTIVIEW: boolean;
     ORDER_INDEPENDENT_TRANSPARENCY: boolean;
     ORDER_INDEPENDENT_TRANSPARENCY_16BITS: boolean;
@@ -201,6 +192,7 @@ export declare class StandardMaterialDefines extends StandardMaterialDefines_bas
      * @internal
      */
     IS_REFRACTION_LINEAR: boolean;
+    EXPOSURE: boolean;
     DECAL_AFTER_DETAIL: boolean;
     /**
      * Initializes the Standard Material defines.
@@ -212,30 +204,14 @@ export declare class StandardMaterialDefines extends StandardMaterialDefines_bas
             default: any;
         };
     });
-}
-declare const StandardMaterialBase_base: {
-    new (...args: any[]): {
-        _imageProcessingConfiguration: ImageProcessingConfiguration;
-        imageProcessingConfiguration: ImageProcessingConfiguration;
-        _imageProcessingObserver: Nullable<import("../index.js").Observer<ImageProcessingConfiguration>>;
-        _attachImageProcessingConfiguration(configuration: Nullable<ImageProcessingConfiguration>): void;
-        cameraColorCurvesEnabled: boolean;
-        cameraColorGradingEnabled: boolean;
-        cameraToneMappingEnabled: boolean;
-        cameraExposure: number;
-        cameraContrast: number;
-        cameraColorGradingTexture: Nullable<BaseTexture>;
-        cameraColorCurves: Nullable<import("./colorCurves.js").ColorCurves>;
-    };
-} & typeof PushMaterial;
-declare class StandardMaterialBase extends StandardMaterialBase_base {
+    setReflectionMode(modeToEnable: string): void;
 }
 /**
  * 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
  */
-export declare class StandardMaterial extends StandardMaterialBase {
+export declare class StandardMaterial extends PushMaterial {
     /**
      * Force all the standard materials to compile to glsl even on WebGPU engines.
      * False by default. This is mostly meant for backward compatibility.
@@ -466,6 +442,29 @@ export declare class StandardMaterial extends StandardMaterialBase {
      * If sets to true, the decal map will be applied after the detail map. Else, it is applied before (default: false)
      */
     applyDecalMapAfterDetailMap: boolean;
+    /**
+     * Default configuration related to image processing available in the standard Material.
+     */
+    protected _imageProcessingConfiguration: ImageProcessingConfiguration;
+    /**
+     * Gets the image processing configuration used either in this material.
+     */
+    get imageProcessingConfiguration(): 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(value: ImageProcessingConfiguration);
+    /**
+     * Keep track of the image processing observer to allow dispose and replace.
+     */
+    private _imageProcessingObserver;
+    /**
+     * Attaches a new image processing configuration to the Standard Material.
+     * @param configuration
+     */
+    protected _attachImageProcessingConfiguration(configuration: Nullable<ImageProcessingConfiguration>): void;
     private _shadersLoaded;
     /**
      * Defines additional PrePass parameters for the material.
@@ -475,6 +474,72 @@ export declare class StandardMaterial extends StandardMaterialBase {
      * Can this material render to prepass
      */
     get isPrePassCapable(): boolean;
+    /**
+     * Gets whether the color curves effect is enabled.
+     */
+    get cameraColorCurvesEnabled(): boolean;
+    /**
+     * Sets whether the color curves effect is enabled.
+     */
+    set cameraColorCurvesEnabled(value: boolean);
+    /**
+     * Gets whether the color grading effect is enabled.
+     */
+    get cameraColorGradingEnabled(): boolean;
+    /**
+     * Gets whether the color grading effect is enabled.
+     */
+    set cameraColorGradingEnabled(value: boolean);
+    /**
+     * Gets whether tonemapping is enabled or not.
+     */
+    get cameraToneMappingEnabled(): boolean;
+    /**
+     * Sets whether tonemapping is enabled or not
+     */
+    set cameraToneMappingEnabled(value: boolean);
+    /**
+     * 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(): number;
+    /**
+     * 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(value: number);
+    /**
+     * Gets The camera contrast used on this material.
+     */
+    get cameraContrast(): number;
+    /**
+     * Sets The camera contrast used on this material.
+     */
+    set cameraContrast(value: number);
+    /**
+     * Gets the Color Grading 2D Lookup Texture.
+     */
+    get cameraColorGradingTexture(): Nullable<BaseTexture>;
+    /**
+     * Sets the Color Grading 2D Lookup Texture.
+     */
+    set cameraColorGradingTexture(value: Nullable<BaseTexture>);
+    /**
+     * 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(): Nullable<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(value: Nullable<ColorCurves>);
     /**
      * Can this material render to several textures at once
      */
@@ -649,4 +714,3 @@ export declare class StandardMaterial extends StandardMaterialBase {
     static get FresnelEnabled(): boolean;
     static set FresnelEnabled(value: boolean);
 }
-export {};

package/Materials/standardMaterial.js

@@ -6,33 +6,35 @@ import { Scene } from "../scene.js";
 import { Color3 } from "../Maths/math.color.js";
 import { VertexBuffer } from "../Buffers/buffer.js";
 import { PrePassConfiguration } from "./prePassConfiguration.js";
-import { ImageProcessingDefinesMixin } from "./imageProcessingConfiguration.defines.js";
 import { ImageProcessingConfiguration } from "./imageProcessingConfiguration.js";
 import { Material } from "../Materials/material.js";
 import { MaterialDefines } from "../Materials/materialDefines.js";
 import { PushMaterial } from "./pushMaterial.js";
+import { Texture } from "../Materials/Textures/texture.js";
 import { RegisterClass } from "../Misc/typeStore.js";
 import { MaterialFlags } from "./materialFlags.js";
 
 import { EffectFallbacks } from "./effectFallbacks.js";
 import { DetailMapConfiguration } from "./material.detailMapConfiguration.js";
 import { AddClipPlaneUniforms, BindClipPlane } from "./clipPlaneMaterialHelper.js";
-import { BindBonesParameters, BindFogParameters, BindLights, BindLogDepth, BindMorphTargetParameters, BindTextureMatrix, BindIBLParameters, HandleFallbacksForShadows, PrepareAttributesForBakedVertexAnimation, PrepareAttributesForBones, PrepareAttributesForInstances, PrepareAttributesForMorphTargets, PrepareDefinesForAttributes, PrepareDefinesForFrameBoundValues, PrepareDefinesForLights, PrepareDefinesForIBL, PrepareDefinesForMergedUV, PrepareDefinesForMisc, PrepareDefinesForMultiview, PrepareDefinesForOIT, PrepareDefinesForPrePass, PrepareUniformsAndSamplersForIBL, PrepareUniformsAndSamplersList, PrepareUniformLayoutForIBL, } from "./materialHelper.functions.js";
+import { BindBonesParameters, BindFogParameters, BindLights, BindLogDepth, BindMorphTargetParameters, BindTextureMatrix, HandleFallbacksForShadows, PrepareAttributesForBakedVertexAnimation, PrepareAttributesForBones, PrepareAttributesForInstances, PrepareAttributesForMorphTargets, PrepareDefinesForAttributes, PrepareDefinesForFrameBoundValues, PrepareDefinesForLights, PrepareDefinesForMergedUV, PrepareDefinesForMisc, PrepareDefinesForMultiview, PrepareDefinesForOIT, PrepareDefinesForPrePass, PrepareUniformsAndSamplersList, } from "./materialHelper.functions.js";
 import { SerializationHelper } from "../Misc/decorators.serialization.js";
 import { MaterialHelperGeometryRendering } from "./materialHelper.geometryrendering.js";
-import { UVDefinesMixin } from "./uv.defines.js";
-import { ImageProcessingMixin } from "./imageProcessing.js";
 const onCreatedEffectParameters = { effect: null, subMesh: null };
-class StandardMaterialDefinesBase extends UVDefinesMixin(MaterialDefines) {
-}
 /** @internal */
-export class StandardMaterialDefines extends ImageProcessingDefinesMixin(StandardMaterialDefinesBase) {
+export class StandardMaterialDefines extends MaterialDefines {
     /**
      * Initializes the Standard Material defines.
      * @param externalProperties The external properties
      */
     constructor(externalProperties) {
         super(externalProperties);
+        this.MAINUV1 = false;
+        this.MAINUV2 = false;
+        this.MAINUV3 = false;
+        this.MAINUV4 = false;
+        this.MAINUV5 = false;
+        this.MAINUV6 = false;
         this.DIFFUSE = false;
         this.DIFFUSEDIRECTUV = 0;
         this.BAKED_VERTEX_ANIMATION_TEXTURE = false;
@@ -72,6 +74,12 @@ export class StandardMaterialDefines extends ImageProcessingDefinesMixin(Standar
         this.FRESNEL = false;
         this.NORMAL = false;
         this.TANGENT = false;
+        this.UV1 = false;
+        this.UV2 = false;
+        this.UV3 = false;
+        this.UV4 = false;
+        this.UV5 = false;
+        this.UV6 = false;
         this.VERTEXCOLOR = false;
         this.VERTEXALPHA = false;
         this.NUM_BONE_INFLUENCERS = 0;
@@ -163,6 +171,20 @@ export class StandardMaterialDefines extends ImageProcessingDefinesMixin(Standar
         this.RGBDLIGHTMAP = false;
         this.RGBDREFLECTION = false;
         this.RGBDREFRACTION = false;
+        this.IMAGEPROCESSING = false;
+        this.VIGNETTE = false;
+        this.VIGNETTEBLENDMODEMULTIPLY = false;
+        this.VIGNETTEBLENDMODEOPAQUE = false;
+        this.TONEMAPPING = 0;
+        this.CONTRAST = false;
+        this.COLORCURVES = false;
+        this.COLORGRADING = false;
+        this.COLORGRADING3D = false;
+        this.SAMPLER3DGREENDEPTH = false;
+        this.SAMPLER3DBGRMAP = false;
+        this.DITHER = false;
+        this.IMAGEPROCESSINGPOSTPROCESS = false;
+        this.SKIPFINALCOLORCLAMP = false;
         this.MULTIVIEW = false;
         this.ORDER_INDEPENDENT_TRANSPARENCY = false;
         this.ORDER_INDEPENDENT_TRANSPARENCY_16BITS = false;
@@ -180,24 +202,176 @@ export class StandardMaterialDefines extends ImageProcessingDefinesMixin(Standar
          * @internal
          */
         this.IS_REFRACTION_LINEAR = false;
+        this.EXPOSURE = false;
         this.DECAL_AFTER_DETAIL = false;
         this.rebuild();
     }
-}
-class StandardMaterialBase extends ImageProcessingMixin(PushMaterial) {
+    setReflectionMode(modeToEnable) {
+        const modes = [
+            "REFLECTIONMAP_CUBIC",
+            "REFLECTIONMAP_EXPLICIT",
+            "REFLECTIONMAP_PLANAR",
+            "REFLECTIONMAP_PROJECTION",
+            "REFLECTIONMAP_PROJECTION",
+            "REFLECTIONMAP_SKYBOX",
+            "REFLECTIONMAP_SPHERICAL",
+            "REFLECTIONMAP_EQUIRECTANGULAR",
+            "REFLECTIONMAP_EQUIRECTANGULAR_FIXED",
+            "REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED",
+        ];
+        for (const mode of modes) {
+            this[mode] = mode === modeToEnable;
+        }
+    }
 }
 /**
  * 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
  */
-export class StandardMaterial extends StandardMaterialBase {
+export class StandardMaterial extends PushMaterial {
+    /**
+     * 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(value) {
+        this._attachImageProcessingConfiguration(value);
+        // Ensure the effect will be rebuilt.
+        this._markAllSubMeshesAsImageProcessingDirty();
+    }
+    /**
+     * Attaches a new image processing configuration to the Standard Material.
+     * @param configuration
+     */
+    _attachImageProcessingConfiguration(configuration) {
+        if (configuration === this._imageProcessingConfiguration) {
+            return;
+        }
+        // Detaches observer
+        if (this._imageProcessingConfiguration && this._imageProcessingObserver) {
+            this._imageProcessingConfiguration.onUpdateParameters.remove(this._imageProcessingObserver);
+        }
+        // Pick the scene configuration if needed
+        if (!configuration) {
+            this._imageProcessingConfiguration = this.getScene().imageProcessingConfiguration;
+        }
+        else {
+            this._imageProcessingConfiguration = configuration;
+        }
+        // Attaches observer
+        if (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(value) {
+        this.imageProcessingConfiguration.colorCurvesEnabled = value;
+    }
+    /**
+     * Gets whether the color grading effect is enabled.
+     */
+    get cameraColorGradingEnabled() {
+        return this.imageProcessingConfiguration.colorGradingEnabled;
+    }
+    /**
+     * Gets whether the color grading effect is enabled.
+     */
+    set cameraColorGradingEnabled(value) {
+        this.imageProcessingConfiguration.colorGradingEnabled = value;
+    }
+    /**
+     * Gets whether tonemapping is enabled or not.
+     */
+    get cameraToneMappingEnabled() {
+        return this._imageProcessingConfiguration.toneMappingEnabled;
+    }
+    /**
+     * Sets whether tonemapping is enabled or not
+     */
+    set cameraToneMappingEnabled(value) {
+        this._imageProcessingConfiguration.toneMappingEnabled = value;
+    }
+    /**
+     * 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(value) {
+        this._imageProcessingConfiguration.exposure = value;
+    }
+    /**
+     * Gets The camera contrast used on this material.
+     */
+    get cameraContrast() {
+        return this._imageProcessingConfiguration.contrast;
+    }
+    /**
+     * Sets The camera contrast used on this material.
+     */
+    set cameraContrast(value) {
+        this._imageProcessingConfiguration.contrast = value;
+    }
+    /**
+     * Gets the Color Grading 2D Lookup Texture.
+     */
+    get cameraColorGradingTexture() {
+        return this._imageProcessingConfiguration.colorGradingTexture;
+    }
+    /**
+     * Sets the Color Grading 2D Lookup Texture.
+     */
+    set cameraColorGradingTexture(value) {
+        this._imageProcessingConfiguration.colorGradingTexture = value;
+    }
+    /**
+     * 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(value) {
+        this._imageProcessingConfiguration.colorCurves = value;
+    }
     /**
      * Can this material render to several textures at once
      */
@@ -461,15 +635,56 @@ export class StandardMaterial extends StandardMaterialBase {
                     defines.OPACITY = false;
                 }
                 if (this._reflectionTexture && StandardMaterial.ReflectionTextureEnabled) {
-                    defines.ROUGHNESS = this._roughness > 0;
-                    defines.REFLECTIONOVERALPHA = this._useReflectionOverAlpha;
+                    if (!this._reflectionTexture.isReadyOrNotBlocking()) {
+                        return false;
+                    }
+                    else {
+                        defines._needNormals = true;
+                        defines.REFLECTION = true;
+                        defines.ROUGHNESS = this._roughness > 0;
+                        defines.REFLECTIONOVERALPHA = this._useReflectionOverAlpha;
+                        defines.INVERTCUBICMAP = this._reflectionTexture.coordinatesMode === Texture.INVCUBIC_MODE;
+                        defines.REFLECTIONMAP_3D = this._reflectionTexture.isCube;
+                        defines.REFLECTIONMAP_OPPOSITEZ =
+                            defines.REFLECTIONMAP_3D && this.getScene().useRightHandedSystem ? !this._reflectionTexture.invertZ : this._reflectionTexture.invertZ;
+                        defines.RGBDREFLECTION = this._reflectionTexture.isRGBD;
+                        switch (this._reflectionTexture.coordinatesMode) {
+                            case Texture.EXPLICIT_MODE:
+                                defines.setReflectionMode("REFLECTIONMAP_EXPLICIT");
+                                break;
+                            case Texture.PLANAR_MODE:
+                                defines.setReflectionMode("REFLECTIONMAP_PLANAR");
+                                break;
+                            case Texture.PROJECTION_MODE:
+                                defines.setReflectionMode("REFLECTIONMAP_PROJECTION");
+                                break;
+                            case Texture.SKYBOX_MODE:
+                                defines.setReflectionMode("REFLECTIONMAP_SKYBOX");
+                                break;
+                            case Texture.SPHERICAL_MODE:
+                                defines.setReflectionMode("REFLECTIONMAP_SPHERICAL");
+                                break;
+                            case Texture.EQUIRECTANGULAR_MODE:
+                                defines.setReflectionMode("REFLECTIONMAP_EQUIRECTANGULAR");
+                                break;
+                            case Texture.FIXED_EQUIRECTANGULAR_MODE:
+                                defines.setReflectionMode("REFLECTIONMAP_EQUIRECTANGULAR_FIXED");
+                                break;
+                            case Texture.FIXED_EQUIRECTANGULAR_MIRRORED_MODE:
+                                defines.setReflectionMode("REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED");
+                                break;
+                            case Texture.CUBIC_MODE:
+                            case Texture.INVCUBIC_MODE:
+                            default:
+                                defines.setReflectionMode("REFLECTIONMAP_CUBIC");
+                                break;
+                        }
+                        defines.USE_LOCAL_REFLECTIONMAP_CUBIC = this._reflectionTexture.boundingBoxSize ? true : false;
+                    }
                 }
                 else {
-                    defines.ROUGHNESS = false;
-                    defines.REFLECTIONOVERALPHA = false;
-                }
-                if (!PrepareDefinesForIBL(scene, this._reflectionTexture, defines)) {
-                    return false;
+                    defines.REFLECTION = false;
+                    defines.REFLECTIONMAP_OPPOSITEZ = false;
                 }
                 if (this._emissiveTexture && StandardMaterial.EmissiveTextureEnabled) {
                     if (!this._emissiveTexture.isReadyOrNotBlocking()) {
@@ -715,6 +930,7 @@ export class StandardMaterial extends StandardMaterialBase {
                 "vDiffuseInfos",
                 "vAmbientInfos",
                 "vOpacityInfos",
+                "vReflectionInfos",
                 "vEmissiveInfos",
                 "vSpecularInfos",
                 "vBumpInfos",
@@ -724,6 +940,7 @@ export class StandardMaterial extends StandardMaterialBase {
                 "diffuseMatrix",
                 "ambientMatrix",
                 "opacityMatrix",
+                "reflectionMatrix",
                 "emissiveMatrix",
                 "specularMatrix",
                 "bumpMatrix",
@@ -739,6 +956,8 @@ export class StandardMaterial extends StandardMaterialBase {
                 "emissiveRightColor",
                 "refractionLeftColor",
                 "refractionRightColor",
+                "vReflectionPosition",
+                "vReflectionSize",
                 "vRefractionPosition",
                 "vRefractionSize",
                 "logarithmicDepthConstant",
@@ -768,7 +987,6 @@ export class StandardMaterial extends StandardMaterialBase {
                 "areaLightsLTC1Sampler",
                 "areaLightsLTC2Sampler",
             ];
-            PrepareUniformsAndSamplersForIBL(uniforms, samplers, false);
             const uniformBuffers = ["Material", "Scene", "Mesh"];
             const indexParameters = { maxSimultaneousLights: this._maxSimultaneousLights, maxSimultaneousMorphTargets: defines.NUM_MORPH_INFLUENCERS };
             this._eventInfo.fallbacks = fallbacks;
@@ -881,6 +1099,9 @@ export class StandardMaterial extends StandardMaterialBase {
         ubo.addUniform("vDiffuseInfos", 2);
         ubo.addUniform("vAmbientInfos", 2);
         ubo.addUniform("vOpacityInfos", 2);
+        ubo.addUniform("vReflectionInfos", 2);
+        ubo.addUniform("vReflectionPosition", 3);
+        ubo.addUniform("vReflectionSize", 3);
         ubo.addUniform("vEmissiveInfos", 2);
         ubo.addUniform("vLightmapInfos", 2);
         ubo.addUniform("vSpecularInfos", 2);
@@ -888,6 +1109,7 @@ export class StandardMaterial extends StandardMaterialBase {
         ubo.addUniform("diffuseMatrix", 16);
         ubo.addUniform("ambientMatrix", 16);
         ubo.addUniform("opacityMatrix", 16);
+        ubo.addUniform("reflectionMatrix", 16);
         ubo.addUniform("emissiveMatrix", 16);
         ubo.addUniform("lightmapMatrix", 16);
         ubo.addUniform("specularMatrix", 16);
@@ -904,7 +1126,6 @@ export class StandardMaterial extends StandardMaterialBase {
         ubo.addUniform("vDiffuseColor", 4);
         ubo.addUniform("vAmbientColor", 3);
         ubo.addUniform("cameraInfo", 4);
-        PrepareUniformLayoutForIBL(ubo, false, true);
         super.buildUniformLayout();
     }
     /**
@@ -991,8 +1212,16 @@ export class StandardMaterial extends StandardMaterialBase {
                     if (this._hasAlphaChannel()) {
                         ubo.updateFloat("alphaCutOff", this.alphaCutOff);
                     }
-                    BindIBLParameters(scene, defines, ubo, this._reflectionTexture, false, false, true);
-                    if (!this._reflectionTexture || !StandardMaterial.ReflectionTextureEnabled) {
+                    if (this._reflectionTexture && StandardMaterial.ReflectionTextureEnabled) {
+                        ubo.updateFloat2("vReflectionInfos", this._reflectionTexture.level, this.roughness);
+                        ubo.updateMatrix("reflectionMatrix", this._reflectionTexture.getReflectionTextureMatrix());
+                        if (this._reflectionTexture.boundingBoxSize) {
+                            const cubeTexture = this._reflectionTexture;
+                            ubo.updateVector3("vReflectionPosition", cubeTexture.boundingBoxPosition);
+                            ubo.updateVector3("vReflectionSize", cubeTexture.boundingBoxSize);
+                        }
+                    }
+                    else {
                         ubo.updateFloat2("vReflectionInfos", 0.0, this.roughness);
                     }
                     if (this._emissiveTexture && StandardMaterial.EmissiveTextureEnabled) {