@babylonjs/core 7.41.1 → 7.43.0

package/Layers/effectLayer.js

@@ -2,19 +2,13 @@ import { __decorate } from "../tslib.es6.js";
 import { serialize, serializeAsColor4, serializeAsCameraReference } from "../Misc/decorators.js";
 import { Tools } from "../Misc/tools.js";
 import { Observable } from "../Misc/observable.js";
-import { Color4 } from "../Maths/math.color.js";
 import { EngineStore } from "../Engines/engineStore.js";
-import { VertexBuffer } from "../Buffers/buffer.js";
 import { Texture } from "../Materials/Textures/texture.js";
 import { RenderTargetTexture } from "../Materials/Textures/renderTargetTexture.js";
-import { Material } from "../Materials/material.js";
 
 import { _WarnImport } from "../Misc/devTools.js";
-import { EffectFallbacks } from "../Materials/effectFallbacks.js";
-import { DrawWrapper } from "../Materials/drawWrapper.js";
-import { addClipPlaneUniforms, bindClipPlane, prepareStringDefinesForClipPlanes } from "../Materials/clipPlaneMaterialHelper.js";
-import { BindMorphTargetParameters, PrepareAttributesForMorphTargetsInfluencers, PushAttributesForInstances } from "../Materials/materialHelper.functions.js";
 import { GetExponentOfTwo } from "../Misc/tools.functions.js";
+import { ThinEffectLayer } from "./thinEffectLayer.js";
 /**
  * The effect layer Helps adding post process effect blended with the main pass.
  *
@@ -24,20 +18,84 @@ import { GetExponentOfTwo } from "../Misc/tools.functions.js";
  * customized per effects.
  */
 export class EffectLayer {
+    get _shouldRender() {
+        return this._thinEffectLayer._shouldRender;
+    }
+    set _shouldRender(value) {
+        this._thinEffectLayer._shouldRender = value;
+    }
+    get _emissiveTextureAndColor() {
+        return this._thinEffectLayer._emissiveTextureAndColor;
+    }
+    set _emissiveTextureAndColor(value) {
+        this._thinEffectLayer._emissiveTextureAndColor = value;
+    }
+    get _effectIntensity() {
+        return this._thinEffectLayer._effectIntensity;
+    }
+    set _effectIntensity(value) {
+        this._thinEffectLayer._effectIntensity = value;
+    }
+    /**
+     * Force all the effect layers to compile to glsl even on WebGPU engines.
+     * False by default. This is mostly meant for backward compatibility.
+     */
+    static get ForceGLSL() {
+        return ThinEffectLayer.ForceGLSL;
+    }
+    static set ForceGLSL(value) {
+        ThinEffectLayer.ForceGLSL = value;
+    }
+    /**
+     * The name of the layer
+     */
+    get name() {
+        return this._thinEffectLayer.name;
+    }
+    set name(value) {
+        this._thinEffectLayer.name = value;
+    }
+    /**
+     * The clear color of the texture used to generate the glow map.
+     */
+    get neutralColor() {
+        return this._thinEffectLayer.neutralColor;
+    }
+    set neutralColor(value) {
+        this._thinEffectLayer.neutralColor = value;
+    }
+    /**
+     * Specifies whether the highlight layer is enabled or not.
+     */
+    get isEnabled() {
+        return this._thinEffectLayer.isEnabled;
+    }
+    set isEnabled(value) {
+        this._thinEffectLayer.isEnabled = value;
+    }
     /**
      * Gets the camera attached to the layer.
      */
     get camera() {
-        return this._effectLayerOptions.camera;
+        return this._thinEffectLayer.camera;
     }
     /**
      * Gets the rendering group id the layer should render in.
      */
     get renderingGroupId() {
-        return this._effectLayerOptions.renderingGroupId;
+        return this._thinEffectLayer.renderingGroupId;
     }
     set renderingGroupId(renderingGroupId) {
-        this._effectLayerOptions.renderingGroupId = renderingGroupId;
+        this._thinEffectLayer.renderingGroupId = renderingGroupId;
+    }
+    /**
+     * Specifies if the bounding boxes should be rendered normally or if they should undergo the effect of the layer
+     */
+    get disableBoundingBoxesFromEffectLayer() {
+        return this._thinEffectLayer.disableBoundingBoxesFromEffectLayer;
+    }
+    set disableBoundingBoxesFromEffectLayer(value) {
+        this._thinEffectLayer.disableBoundingBoxesFromEffectLayer = value;
     }
     /**
      * Gets the main texture where the effect is rendered
@@ -45,11 +103,14 @@ export class EffectLayer {
     get mainTexture() {
         return this._mainTexture;
     }
+    get _shaderLanguage() {
+        return this._thinEffectLayer.shaderLanguage;
+    }
     /**
      * Gets the shader language used in this material.
      */
     get shaderLanguage() {
-        return this._shaderLanguage;
+        return this._thinEffectLayer.shaderLanguage;
     }
     /**
      * Sets a specific material to be used to render a mesh/a list of meshes in the layer
@@ -57,26 +118,7 @@ export class EffectLayer {
      * @param material material to use by the layer when rendering the mesh(es). If undefined is passed, the specific material created by the layer will be used.
      */
     setMaterialForRendering(mesh, material) {
-        this._mainTexture.setMaterialForRendering(mesh, material);
-        if (Array.isArray(mesh)) {
-            for (let i = 0; i < mesh.length; ++i) {
-                const currentMesh = mesh[i];
-                if (!material) {
-                    delete this._materialForRendering[currentMesh.uniqueId];
-                }
-                else {
-                    this._materialForRendering[currentMesh.uniqueId] = [currentMesh, material];
-                }
-            }
-        }
-        else {
-            if (!material) {
-                delete this._materialForRendering[mesh.uniqueId];
-            }
-            else {
-                this._materialForRendering[mesh.uniqueId] = [mesh, material];
-            }
-        }
+        this._thinEffectLayer.setMaterialForRendering(mesh, material);
     }
     /**
      * Gets the intensity of the effect for a specific mesh.
@@ -84,7 +126,7 @@ export class EffectLayer {
      * @returns The intensity of the effect for the mesh
      */
     getEffectIntensity(mesh) {
-        return this._effectIntensity[mesh.uniqueId] ?? 1;
+        return this._thinEffectLayer.getEffectIntensity(mesh);
     }
     /**
      * Sets the intensity of the effect for a specific mesh.
@@ -92,37 +134,22 @@ export class EffectLayer {
      * @param intensity The intensity of the effect for the mesh
      */
     setEffectIntensity(mesh, intensity) {
-        this._effectIntensity[mesh.uniqueId] = intensity;
+        this._thinEffectLayer.setEffectIntensity(mesh, intensity);
     }
     /**
      * Instantiates a new effect Layer and references it in the scene.
      * @param name The name of the layer
      * @param scene The scene to use the layer in
      * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+     * @param thinEffectLayer The thin instance of the effect layer (optional)
      */
     constructor(
     /** The Friendly of the effect in the scene */
-    name, scene, forceGLSL = false) {
-        this._vertexBuffers = {};
+    name, scene, forceGLSL = false, thinEffectLayer) {
         this._maxSize = 0;
         this._mainTextureDesiredSize = { width: 0, height: 0 };
-        this._shouldRender = true;
         this._postProcesses = [];
         this._textures = [];
-        this._emissiveTextureAndColor = { texture: null, color: new Color4() };
-        this._effectIntensity = {};
-        /**
-         * The clear color of the texture used to generate the glow map.
-         */
-        this.neutralColor = new Color4();
-        /**
-         * Specifies whether the highlight layer is enabled or not.
-         */
-        this.isEnabled = true;
-        /**
-         * Specifies if the bounding boxes should be rendered normally or if they should undergo the effect of the layer
-         */
-        this.disableBoundingBoxesFromEffectLayer = false;
         /**
          * An event triggered when the effect layer has been disposed.
          */
@@ -151,31 +178,61 @@ export class EffectLayer {
          * An event triggered when the effect layer changes its size.
          */
         this.onSizeChangedObservable = new Observable();
-        /** Shader language used by the material */
-        this._shaderLanguage = 0 /* ShaderLanguage.GLSL */;
-        this._materialForRendering = {};
-        this._shadersLoaded = false;
+        this._internalThinEffectLayer = !thinEffectLayer;
+        if (!thinEffectLayer) {
+            thinEffectLayer = new ThinEffectLayer(name, scene, forceGLSL, false, this._importShadersAsync.bind(this));
+            thinEffectLayer.getEffectName = this.getEffectName.bind(this);
+            thinEffectLayer.isReady = this.isReady.bind(this);
+            thinEffectLayer._createMergeEffect = this._createMergeEffect.bind(this);
+            thinEffectLayer._createTextureAndPostProcesses = this._createTextureAndPostProcesses.bind(this);
+            thinEffectLayer._internalCompose = this._internalRender.bind(this);
+            thinEffectLayer._setEmissiveTextureAndColor = this._setEmissiveTextureAndColor.bind(this);
+            thinEffectLayer._numInternalDraws = this._numInternalDraws.bind(this);
+            thinEffectLayer._addCustomEffectDefines = this._addCustomEffectDefines.bind(this);
+            thinEffectLayer.hasMesh = this.hasMesh.bind(this);
+            thinEffectLayer.shouldRender = this.shouldRender.bind(this);
+            thinEffectLayer._shouldRenderMesh = this._shouldRenderMesh.bind(this);
+            thinEffectLayer._canRenderMesh = this._canRenderMesh.bind(this);
+            thinEffectLayer._useMeshMaterial = this._useMeshMaterial.bind(this);
+        }
+        this._thinEffectLayer = thinEffectLayer;
         this.name = name;
         this._scene = scene || EngineStore.LastCreatedScene;
         EffectLayer._SceneComponentInitialization(this._scene);
-        const engine = this._scene.getEngine();
-        if (engine.isWebGPU && !forceGLSL && !EffectLayer.ForceGLSL) {
-            this._shaderLanguage = 1 /* ShaderLanguage.WGSL */;
-        }
         this._engine = this._scene.getEngine();
         this._maxSize = this._engine.getCaps().maxTextureSize;
         this._scene.effectLayers.push(this);
-        this._mergeDrawWrapper = [];
-        // Generate Buffers
-        this._generateIndexBuffer();
-        this._generateVertexBuffer();
+        this._thinEffectLayer.onDisposeObservable.add(() => {
+            this.onDisposeObservable.notifyObservers(this);
+        });
+        this._thinEffectLayer.onBeforeRenderLayerObservable.add(() => {
+            this.onBeforeRenderMainTextureObservable.notifyObservers(this);
+        });
+        this._thinEffectLayer.onBeforeComposeObservable.add(() => {
+            this.onBeforeComposeObservable.notifyObservers(this);
+        });
+        this._thinEffectLayer.onBeforeRenderMeshToEffect.add((mesh) => {
+            this.onBeforeRenderMeshToEffect.notifyObservers(mesh);
+        });
+        this._thinEffectLayer.onAfterRenderMeshToEffect.add((mesh) => {
+            this.onAfterRenderMeshToEffect.notifyObservers(mesh);
+        });
+        this._thinEffectLayer.onAfterComposeObservable.add(() => {
+            this.onAfterComposeObservable.notifyObservers(this);
+        });
+    }
+    get _shadersLoaded() {
+        return this._thinEffectLayer._shadersLoaded;
+    }
+    set _shadersLoaded(value) {
+        this._thinEffectLayer._shadersLoaded = value;
     }
     /**
      * Number of times _internalRender will be called. Some effect layers need to render the mesh several times, so they should override this method with the number of times the mesh should be rendered
      * @returns Number of times a mesh must be rendered in the layer
      */
     _numInternalDraws() {
-        return 1;
+        return this._internalThinEffectLayer ? 1 : this._thinEffectLayer._numInternalDraws();
     }
     /**
      * Initializes the effect layer with the required options.
@@ -193,36 +250,10 @@ export class EffectLayer {
             ...options,
         };
         this._setMainTextureSize();
+        this._thinEffectLayer._init(options);
         this._createMainTexture();
         this._createTextureAndPostProcesses();
     }
-    /**
-     * Generates the index buffer of the full screen quad blending to the main canvas.
-     */
-    _generateIndexBuffer() {
-        // Indices
-        const indices = [];
-        indices.push(0);
-        indices.push(1);
-        indices.push(2);
-        indices.push(0);
-        indices.push(2);
-        indices.push(3);
-        this._indexBuffer = this._engine.createIndexBuffer(indices);
-    }
-    /**
-     * Generates the vertex buffer of the full screen quad blending to the main canvas.
-     */
-    _generateVertexBuffer() {
-        // VBO
-        const vertices = [];
-        vertices.push(1, 1);
-        vertices.push(-1, 1);
-        vertices.push(-1, -1);
-        vertices.push(1, -1);
-        const vertexBuffer = new VertexBuffer(this._engine, vertices, VertexBuffer.PositionKind, false, false, 2);
-        this._vertexBuffers[VertexBuffer.PositionKind] = vertexBuffer;
-    }
     /**
      * Sets the main texture desired size which is the closest power of two
      * of the engine canvas size.
@@ -252,7 +283,12 @@ export class EffectLayer {
         this._mainTexture = new RenderTargetTexture("EffectLayerMainRTT", {
             width: this._mainTextureDesiredSize.width,
             height: this._mainTextureDesiredSize.height,
-        }, this._scene, false, true, this._effectLayerOptions.mainTextureType, false, Texture.TRILINEAR_SAMPLINGMODE, true, this._effectLayerOptions.generateStencilBuffer);
+        }, this._scene, {
+            type: this._effectLayerOptions.mainTextureType,
+            samplingMode: Texture.TRILINEAR_SAMPLINGMODE,
+            generateStencilBuffer: this._effectLayerOptions.generateStencilBuffer,
+            existingObjectRenderer: this._thinEffectLayer.objectRenderer,
+        });
         this._mainTexture.activeCamera = this._effectLayerOptions.camera;
         this._mainTexture.wrapU = Texture.CLAMP_ADDRESSMODE;
         this._mainTexture.wrapV = Texture.CLAMP_ADDRESSMODE;
@@ -261,74 +297,9 @@ export class EffectLayer {
         this._mainTexture.renderParticles = false;
         this._mainTexture.renderList = null;
         this._mainTexture.ignoreCameraViewport = true;
-        for (const id in this._materialForRendering) {
-            const [mesh, material] = this._materialForRendering[id];
-            this._mainTexture.setMaterialForRendering(mesh, material);
-        }
-        this._mainTexture.customIsReadyFunction = (mesh, refreshRate, preWarm) => {
-            if ((preWarm || refreshRate === 0) && mesh.subMeshes) {
-                for (let i = 0; i < mesh.subMeshes.length; ++i) {
-                    const subMesh = mesh.subMeshes[i];
-                    const material = subMesh.getMaterial();
-                    const renderingMesh = subMesh.getRenderingMesh();
-                    if (!material) {
-                        continue;
-                    }
-                    const batch = renderingMesh._getInstancesRenderList(subMesh._id, !!subMesh.getReplacementMesh());
-                    const hardwareInstancedRendering = batch.hardwareInstancedRendering[subMesh._id] || renderingMesh.hasThinInstances;
-                    this._setEmissiveTextureAndColor(renderingMesh, subMesh, material);
-                    if (!this._isReady(subMesh, hardwareInstancedRendering, this._emissiveTextureAndColor.texture)) {
-                        return false;
-                    }
-                }
-            }
-            return true;
-        };
-        // Custom render function
-        this._mainTexture.customRenderFunction = (opaqueSubMeshes, alphaTestSubMeshes, transparentSubMeshes, depthOnlySubMeshes) => {
-            this.onBeforeRenderMainTextureObservable.notifyObservers(this);
-            let index;
-            const engine = this._scene.getEngine();
-            if (depthOnlySubMeshes.length) {
-                engine.setColorWrite(false);
-                for (index = 0; index < depthOnlySubMeshes.length; index++) {
-                    this._renderSubMesh(depthOnlySubMeshes.data[index]);
-                }
-                engine.setColorWrite(true);
-            }
-            for (index = 0; index < opaqueSubMeshes.length; index++) {
-                this._renderSubMesh(opaqueSubMeshes.data[index]);
-            }
-            for (index = 0; index < alphaTestSubMeshes.length; index++) {
-                this._renderSubMesh(alphaTestSubMeshes.data[index]);
-            }
-            const previousAlphaMode = engine.getAlphaMode();
-            for (index = 0; index < transparentSubMeshes.length; index++) {
-                const subMesh = transparentSubMeshes.data[index];
-                const material = subMesh.getMaterial();
-                if (material && material.needDepthPrePass) {
-                    const engine = material.getScene().getEngine();
-                    engine.setColorWrite(false);
-                    this._renderSubMesh(subMesh);
-                    engine.setColorWrite(true);
-                }
-                this._renderSubMesh(subMesh, true);
-            }
-            engine.setAlphaMode(previousAlphaMode);
-        };
         this._mainTexture.onClearObservable.add((engine) => {
             engine.clear(this.neutralColor, true, true, true);
         });
-        // Prevent package size in es6 (getBoundingBoxRenderer might not be present)
-        if (this._scene.getBoundingBoxRenderer) {
-            const boundingBoxRendererEnabled = this._scene.getBoundingBoxRenderer().enabled;
-            this._mainTexture.onBeforeBindObservable.add(() => {
-                this._scene.getBoundingBoxRenderer().enabled = !this.disableBoundingBoxesFromEffectLayer && boundingBoxRendererEnabled;
-            });
-            this._mainTexture.onAfterUnbindObservable.add(() => {
-                this._scene.getBoundingBoxRenderer().enabled = boundingBoxRendererEnabled;
-            });
-        }
     }
     /**
      * Adds specific effects defines.
@@ -346,219 +317,21 @@ export class EffectLayer {
      * @returns true if ready otherwise, false
      */
     _isReady(subMesh, useInstances, emissiveTexture) {
-        const engine = this._scene.getEngine();
-        const mesh = subMesh.getMesh();
-        const renderingMaterial = mesh._internalAbstractMeshDataInfo._materialForRenderPass?.[engine.currentRenderPassId];
-        if (renderingMaterial) {
-            return renderingMaterial.isReadyForSubMesh(mesh, subMesh, useInstances);
-        }
-        const material = subMesh.getMaterial();
-        if (!material) {
-            return false;
-        }
-        if (this._useMeshMaterial(subMesh.getRenderingMesh())) {
-            return material.isReadyForSubMesh(subMesh.getMesh(), subMesh, useInstances);
-        }
-        const defines = [];
-        const attribs = [VertexBuffer.PositionKind];
-        let uv1 = false;
-        let uv2 = false;
-        // Diffuse
-        if (material) {
-            const needAlphaTest = material.needAlphaTesting();
-            const diffuseTexture = material.getAlphaTestTexture();
-            const needAlphaBlendFromDiffuse = diffuseTexture && diffuseTexture.hasAlpha && (material.useAlphaFromDiffuseTexture || material._useAlphaFromAlbedoTexture);
-            if (diffuseTexture && (needAlphaTest || needAlphaBlendFromDiffuse)) {
-                defines.push("#define DIFFUSE");
-                if (mesh.isVerticesDataPresent(VertexBuffer.UV2Kind) && diffuseTexture.coordinatesIndex === 1) {
-                    defines.push("#define DIFFUSEUV2");
-                    uv2 = true;
-                }
-                else if (mesh.isVerticesDataPresent(VertexBuffer.UVKind)) {
-                    defines.push("#define DIFFUSEUV1");
-                    uv1 = true;
-                }
-                if (needAlphaTest) {
-                    defines.push("#define ALPHATEST");
-                    defines.push("#define ALPHATESTVALUE 0.4");
-                }
-                if (!diffuseTexture.gammaSpace) {
-                    defines.push("#define DIFFUSE_ISLINEAR");
-                }
-            }
-            const opacityTexture = material.opacityTexture;
-            if (opacityTexture) {
-                defines.push("#define OPACITY");
-                if (mesh.isVerticesDataPresent(VertexBuffer.UV2Kind) && opacityTexture.coordinatesIndex === 1) {
-                    defines.push("#define OPACITYUV2");
-                    uv2 = true;
-                }
-                else if (mesh.isVerticesDataPresent(VertexBuffer.UVKind)) {
-                    defines.push("#define OPACITYUV1");
-                    uv1 = true;
-                }
-            }
-        }
-        // Emissive
-        if (emissiveTexture) {
-            defines.push("#define EMISSIVE");
-            if (mesh.isVerticesDataPresent(VertexBuffer.UV2Kind) && emissiveTexture.coordinatesIndex === 1) {
-                defines.push("#define EMISSIVEUV2");
-                uv2 = true;
-            }
-            else if (mesh.isVerticesDataPresent(VertexBuffer.UVKind)) {
-                defines.push("#define EMISSIVEUV1");
-                uv1 = true;
-            }
-            if (!emissiveTexture.gammaSpace) {
-                defines.push("#define EMISSIVE_ISLINEAR");
-            }
-        }
-        // Vertex
-        if (mesh.useVertexColors && mesh.isVerticesDataPresent(VertexBuffer.ColorKind) && mesh.hasVertexAlpha && material.transparencyMode !== Material.MATERIAL_OPAQUE) {
-            attribs.push(VertexBuffer.ColorKind);
-            defines.push("#define VERTEXALPHA");
-        }
-        if (uv1) {
-            attribs.push(VertexBuffer.UVKind);
-            defines.push("#define UV1");
-        }
-        if (uv2) {
-            attribs.push(VertexBuffer.UV2Kind);
-            defines.push("#define UV2");
-        }
-        // Bones
-        const fallbacks = new EffectFallbacks();
-        if (mesh.useBones && mesh.computeBonesUsingShaders) {
-            attribs.push(VertexBuffer.MatricesIndicesKind);
-            attribs.push(VertexBuffer.MatricesWeightsKind);
-            if (mesh.numBoneInfluencers > 4) {
-                attribs.push(VertexBuffer.MatricesIndicesExtraKind);
-                attribs.push(VertexBuffer.MatricesWeightsExtraKind);
-            }
-            defines.push("#define NUM_BONE_INFLUENCERS " + mesh.numBoneInfluencers);
-            const skeleton = mesh.skeleton;
-            if (skeleton && skeleton.isUsingTextureForMatrices) {
-                defines.push("#define BONETEXTURE");
-            }
-            else {
-                defines.push("#define BonesPerMesh " + (skeleton ? skeleton.bones.length + 1 : 0));
-            }
-            if (mesh.numBoneInfluencers > 0) {
-                fallbacks.addCPUSkinningFallback(0, mesh);
-            }
-        }
-        else {
-            defines.push("#define NUM_BONE_INFLUENCERS 0");
-        }
-        // Morph targets
-        const manager = mesh.morphTargetManager;
-        let morphInfluencers = 0;
-        if (manager) {
-            morphInfluencers = manager.numMaxInfluencers || manager.numInfluencers;
-            if (morphInfluencers > 0) {
-                defines.push("#define MORPHTARGETS");
-                defines.push("#define MORPHTARGETS_POSITION");
-                defines.push("#define NUM_MORPH_INFLUENCERS " + morphInfluencers);
-                if (manager.isUsingTextureForTargets) {
-                    defines.push("#define MORPHTARGETS_TEXTURE");
-                }
-                PrepareAttributesForMorphTargetsInfluencers(attribs, mesh, morphInfluencers);
-            }
-        }
-        // Instances
-        if (useInstances) {
-            defines.push("#define INSTANCES");
-            PushAttributesForInstances(attribs);
-            if (subMesh.getRenderingMesh().hasThinInstances) {
-                defines.push("#define THIN_INSTANCES");
-            }
-        }
-        // ClipPlanes
-        prepareStringDefinesForClipPlanes(material, this._scene, defines);
-        this._addCustomEffectDefines(defines);
-        // Get correct effect
-        const drawWrapper = subMesh._getDrawWrapper(undefined, true);
-        const cachedDefines = drawWrapper.defines;
-        const join = defines.join("\n");
-        if (cachedDefines !== join) {
-            const uniforms = [
-                "world",
-                "mBones",
-                "viewProjection",
-                "glowColor",
-                "morphTargetInfluences",
-                "morphTargetCount",
-                "boneTextureWidth",
-                "diffuseMatrix",
-                "emissiveMatrix",
-                "opacityMatrix",
-                "opacityIntensity",
-                "morphTargetTextureInfo",
-                "morphTargetTextureIndices",
-                "glowIntensity",
-            ];
-            addClipPlaneUniforms(uniforms);
-            drawWrapper.setEffect(this._engine.createEffect("glowMapGeneration", attribs, uniforms, ["diffuseSampler", "emissiveSampler", "opacitySampler", "boneSampler", "morphTargets"], join, fallbacks, undefined, undefined, { maxSimultaneousMorphTargets: morphInfluencers }, this._shaderLanguage, this._shadersLoaded
-                ? undefined
-                : async () => {
-                    await this._importShadersAsync();
-                    this._shadersLoaded = true;
-                }), join);
-        }
-        const effectIsReady = drawWrapper.effect.isReady();
-        return this._arePostProcessAndMergeReady() && effectIsReady;
-    }
-    async _importShadersAsync() {
-        if (this._shaderLanguage === 1 /* ShaderLanguage.WGSL */) {
-            await Promise.all([import("../ShadersWGSL/glowMapGeneration.vertex.js"), import("../ShadersWGSL/glowMapGeneration.fragment.js")]);
-        }
-        else {
-            await Promise.all([import("../Shaders/glowMapGeneration.vertex.js"), import("../Shaders/glowMapGeneration.fragment.js")]);
-        }
+        return this._internalThinEffectLayer
+            ? this._thinEffectLayer._internalIsSubMeshReady(subMesh, useInstances, emissiveTexture)
+            : this._thinEffectLayer._isSubMeshReady(subMesh, useInstances, emissiveTexture);
     }
+    async _importShadersAsync() { }
     _arePostProcessAndMergeReady() {
-        let isReady = true;
-        for (let i = 0; i < this._postProcesses.length; i++) {
-            isReady = this._postProcesses[i].isReady() && isReady;
-        }
-        const numDraws = this._numInternalDraws();
-        for (let i = 0; i < numDraws; ++i) {
-            let currentEffect = this._mergeDrawWrapper[i];
-            if (!currentEffect) {
-                currentEffect = this._mergeDrawWrapper[i] = new DrawWrapper(this._engine);
-                currentEffect.setEffect(this._createMergeEffect());
-            }
-            isReady = currentEffect.effect.isReady() && isReady;
-        }
-        return isReady;
+        return this._internalThinEffectLayer ? this._thinEffectLayer._internalIsLayerReady() : this._thinEffectLayer.isLayerReady();
     }
     /**
      * Renders the glowing part of the scene by blending the blurred glowing meshes on top of the rendered scene.
      */
     render() {
-        if (!this._arePostProcessAndMergeReady()) {
+        if (!this._thinEffectLayer.compose()) {
             return;
         }
-        const engine = this._scene.getEngine();
-        const numDraws = this._numInternalDraws();
-        this.onBeforeComposeObservable.notifyObservers(this);
-        const previousAlphaMode = engine.getAlphaMode();
-        for (let i = 0; i < numDraws; ++i) {
-            const currentEffect = this._mergeDrawWrapper[i];
-            // Render
-            engine.enableEffect(currentEffect);
-            engine.setState(false);
-            // VBOs
-            engine.bindBuffers(this._vertexBuffers, this._indexBuffer, currentEffect.effect);
-            // Go Blend.
-            engine.setAlphaMode(this._effectLayerOptions.alphaBlendingMode);
-            // Blends the map on the main canvas.
-            this._internalRender(currentEffect.effect, i);
-        }
-        // Restore Alpha
-        engine.setAlphaMode(previousAlphaMode);
-        this.onAfterComposeObservable.notifyObservers(this);
         // Handle size changes.
         const size = this._mainTexture.getSize();
         this._setMainTextureSize();
@@ -578,17 +351,14 @@ export class EffectLayer {
      * @returns true if the mesh will be used
      */
     hasMesh(mesh) {
-        if (this.renderingGroupId === -1 || mesh.renderingGroupId === this.renderingGroupId) {
-            return true;
-        }
-        return false;
+        return this._internalThinEffectLayer ? this._thinEffectLayer._internalHasMesh(mesh) : this._thinEffectLayer.hasMesh(mesh);
     }
     /**
      * Returns true if the layer contains information to display, otherwise false.
      * @returns true if the glow layer should be rendered
      */
     shouldRender() {
-        return this.isEnabled && this._shouldRender;
+        return this._internalThinEffectLayer ? this._thinEffectLayer._internalShouldRender() : this._thinEffectLayer.shouldRender();
     }
     /**
      * Returns true if the mesh should render, otherwise false.
@@ -597,7 +367,7 @@ export class EffectLayer {
      */
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     _shouldRenderMesh(mesh) {
-        return true;
+        return this._internalThinEffectLayer ? true : this._thinEffectLayer._shouldRenderMesh(mesh);
     }
     /**
      * Returns true if the mesh can be rendered, otherwise false.
@@ -606,7 +376,7 @@ export class EffectLayer {
      * @returns true if it can be rendered otherwise false
      */
     _canRenderMesh(mesh, material) {
-        return !material.needAlphaBlendingForMesh(mesh);
+        return this._internalThinEffectLayer ? this._thinEffectLayer._internalCanRenderMesh(mesh, material) : this._thinEffectLayer._canRenderMesh(mesh, material);
     }
     /**
      * Returns true if the mesh should render, otherwise false.
@@ -615,140 +385,6 @@ export class EffectLayer {
     _shouldRenderEmissiveTextureForMesh() {
         return true;
     }
-    /**
-     * Renders the submesh passed in parameter to the generation map.
-     * @param subMesh
-     * @param enableAlphaMode
-     */
-    _renderSubMesh(subMesh, enableAlphaMode = false) {
-        if (!this.shouldRender()) {
-            return;
-        }
-        const material = subMesh.getMaterial();
-        const ownerMesh = subMesh.getMesh();
-        const replacementMesh = subMesh.getReplacementMesh();
-        const renderingMesh = subMesh.getRenderingMesh();
-        const effectiveMesh = subMesh.getEffectiveMesh();
-        const scene = this._scene;
-        const engine = scene.getEngine();
-        effectiveMesh._internalAbstractMeshDataInfo._isActiveIntermediate = false;
-        if (!material) {
-            return;
-        }
-        // Do not block in blend mode.
-        if (!this._canRenderMesh(renderingMesh, material)) {
-            return;
-        }
-        // Culling
-        let sideOrientation = material._getEffectiveOrientation(renderingMesh);
-        const mainDeterminant = effectiveMesh._getWorldMatrixDeterminant();
-        if (mainDeterminant < 0) {
-            sideOrientation = sideOrientation === Material.ClockWiseSideOrientation ? Material.CounterClockWiseSideOrientation : Material.ClockWiseSideOrientation;
-        }
-        const reverse = sideOrientation === Material.ClockWiseSideOrientation;
-        engine.setState(material.backFaceCulling, material.zOffset, undefined, reverse, material.cullBackFaces, undefined, material.zOffsetUnits);
-        // Managing instances
-        const batch = renderingMesh._getInstancesRenderList(subMesh._id, !!replacementMesh);
-        if (batch.mustReturn) {
-            return;
-        }
-        // Early Exit per mesh
-        if (!this._shouldRenderMesh(renderingMesh)) {
-            return;
-        }
-        const hardwareInstancedRendering = batch.hardwareInstancedRendering[subMesh._id] || renderingMesh.hasThinInstances;
-        this._setEmissiveTextureAndColor(renderingMesh, subMesh, material);
-        this.onBeforeRenderMeshToEffect.notifyObservers(ownerMesh);
-        if (this._useMeshMaterial(renderingMesh)) {
-            subMesh.getMaterial()._glowModeEnabled = true;
-            renderingMesh.render(subMesh, enableAlphaMode, replacementMesh || undefined);
-            subMesh.getMaterial()._glowModeEnabled = false;
-        }
-        else if (this._isReady(subMesh, hardwareInstancedRendering, this._emissiveTextureAndColor.texture)) {
-            const renderingMaterial = effectiveMesh._internalAbstractMeshDataInfo._materialForRenderPass?.[engine.currentRenderPassId];
-            let drawWrapper = subMesh._getDrawWrapper();
-            if (!drawWrapper && renderingMaterial) {
-                drawWrapper = renderingMaterial._getDrawWrapper();
-            }
-            if (!drawWrapper) {
-                return;
-            }
-            const effect = drawWrapper.effect;
-            engine.enableEffect(drawWrapper);
-            if (!hardwareInstancedRendering) {
-                renderingMesh._bind(subMesh, effect, material.fillMode);
-            }
-            if (!renderingMaterial) {
-                effect.setMatrix("viewProjection", scene.getTransformMatrix());
-                effect.setMatrix("world", effectiveMesh.getWorldMatrix());
-                effect.setFloat4("glowColor", this._emissiveTextureAndColor.color.r, this._emissiveTextureAndColor.color.g, this._emissiveTextureAndColor.color.b, this._emissiveTextureAndColor.color.a);
-            }
-            else {
-                renderingMaterial.bindForSubMesh(effectiveMesh.getWorldMatrix(), effectiveMesh, subMesh);
-            }
-            if (!renderingMaterial) {
-                const needAlphaTest = material.needAlphaTesting();
-                const diffuseTexture = material.getAlphaTestTexture();
-                const needAlphaBlendFromDiffuse = diffuseTexture && diffuseTexture.hasAlpha && (material.useAlphaFromDiffuseTexture || material._useAlphaFromAlbedoTexture);
-                if (diffuseTexture && (needAlphaTest || needAlphaBlendFromDiffuse)) {
-                    effect.setTexture("diffuseSampler", diffuseTexture);
-                    const textureMatrix = diffuseTexture.getTextureMatrix();
-                    if (textureMatrix) {
-                        effect.setMatrix("diffuseMatrix", textureMatrix);
-                    }
-                }
-                const opacityTexture = material.opacityTexture;
-                if (opacityTexture) {
-                    effect.setTexture("opacitySampler", opacityTexture);
-                    effect.setFloat("opacityIntensity", opacityTexture.level);
-                    const textureMatrix = opacityTexture.getTextureMatrix();
-                    if (textureMatrix) {
-                        effect.setMatrix("opacityMatrix", textureMatrix);
-                    }
-                }
-                // Glow emissive only
-                if (this._emissiveTextureAndColor.texture) {
-                    effect.setTexture("emissiveSampler", this._emissiveTextureAndColor.texture);
-                    effect.setMatrix("emissiveMatrix", this._emissiveTextureAndColor.texture.getTextureMatrix());
-                }
-                // Bones
-                if (renderingMesh.useBones && renderingMesh.computeBonesUsingShaders && renderingMesh.skeleton) {
-                    const skeleton = renderingMesh.skeleton;
-                    if (skeleton.isUsingTextureForMatrices) {
-                        const boneTexture = skeleton.getTransformMatrixTexture(renderingMesh);
-                        if (!boneTexture) {
-                            return;
-                        }
-                        effect.setTexture("boneSampler", boneTexture);
-                        effect.setFloat("boneTextureWidth", 4.0 * (skeleton.bones.length + 1));
-                    }
-                    else {
-                        effect.setMatrices("mBones", skeleton.getTransformMatrices(renderingMesh));
-                    }
-                }
-                // Morph targets
-                BindMorphTargetParameters(renderingMesh, effect);
-                if (renderingMesh.morphTargetManager && renderingMesh.morphTargetManager.isUsingTextureForTargets) {
-                    renderingMesh.morphTargetManager._bind(effect);
-                }
-                // Alpha mode
-                if (enableAlphaMode) {
-                    engine.setAlphaMode(material.alphaMode);
-                }
-                // Intensity of effect
-                effect.setFloat("glowIntensity", this.getEffectIntensity(renderingMesh));
-                // Clip planes
-                bindClipPlane(effect, material, scene);
-            }
-            // Draw
-            renderingMesh._processRendering(effectiveMesh, subMesh, effect, material.fillMode, batch, hardwareInstancedRendering, (isInstance, world) => effect.setMatrix("world", world));
-        }
-        else {
-            // Need to reset refresh rate of the main map
-            this._mainTexture.resetRefreshCounter();
-        }
-        this.onAfterRenderMeshToEffect.notifyObservers(ownerMesh);
-    }
     /**
      * Defines whether the current material of the mesh should be use to render the effect.
      * @param mesh defines the current mesh to render
@@ -756,18 +392,14 @@ export class EffectLayer {
      */
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     _useMeshMaterial(mesh) {
-        return false;
+        return this._internalThinEffectLayer ? false : this._thinEffectLayer._useMeshMaterial(mesh);
     }
     /**
      * Rebuild the required buffers.
      * @internal Internal use only.
      */
     _rebuild() {
-        const vb = this._vertexBuffers[VertexBuffer.PositionKind];
-        if (vb) {
-            vb._rebuild();
-        }
-        this._generateIndexBuffer();
+        this._thinEffectLayer._rebuild();
     }
     /**
      * Dispose only the render target textures and post process.
@@ -791,19 +423,7 @@ export class EffectLayer {
      * Dispose the highlight layer and free resources.
      */
     dispose() {
-        const vertexBuffer = this._vertexBuffers[VertexBuffer.PositionKind];
-        if (vertexBuffer) {
-            vertexBuffer.dispose();
-            this._vertexBuffers[VertexBuffer.PositionKind] = null;
-        }
-        if (this._indexBuffer) {
-            this._scene.getEngine()._releaseBuffer(this._indexBuffer);
-            this._indexBuffer = null;
-        }
-        for (const drawWrapper of this._mergeDrawWrapper) {
-            drawWrapper.dispose();
-        }
-        this._mergeDrawWrapper = [];
+        this._thinEffectLayer.dispose();
         // Clean textures and post processes
         this._disposeTextureAndPostProcesses();
         // Remove from scene
@@ -812,7 +432,6 @@ export class EffectLayer {
             this._scene.effectLayers.splice(index, 1);
         }
         // Callback
-        this.onDisposeObservable.notifyObservers(this);
         this.onDisposeObservable.clear();
         this.onBeforeRenderMainTextureObservable.clear();
         this.onBeforeComposeObservable.clear();
@@ -840,11 +459,6 @@ export class EffectLayer {
         return effectLayerType.Parse(parsedEffectLayer, scene, rootUrl);
     }
 }
-/**
- * Force all the effect layers to compile to glsl even on WebGPU engines.
- * False by default. This is mostly meant for backward compatibility.
- */
-EffectLayer.ForceGLSL = false;
 /**
  * @internal
  */
@@ -853,13 +467,13 @@ EffectLayer._SceneComponentInitialization = (_) => {
 };
 __decorate([
     serialize()
-], EffectLayer.prototype, "name", void 0);
+], EffectLayer.prototype, "name", null);
 __decorate([
     serializeAsColor4()
-], EffectLayer.prototype, "neutralColor", void 0);
+], EffectLayer.prototype, "neutralColor", null);
 __decorate([
     serialize()
-], EffectLayer.prototype, "isEnabled", void 0);
+], EffectLayer.prototype, "isEnabled", null);
 __decorate([
     serializeAsCameraReference()
 ], EffectLayer.prototype, "camera", null);
@@ -868,5 +482,5 @@ __decorate([
 ], EffectLayer.prototype, "renderingGroupId", null);
 __decorate([
     serialize()
-], EffectLayer.prototype, "disableBoundingBoxesFromEffectLayer", void 0);
+], EffectLayer.prototype, "disableBoundingBoxesFromEffectLayer", null);
 //# sourceMappingURL=effectLayer.js.map