@onerjs/core 8.56.3 → 9.0.0

package/Rendering/fluidRenderer/fluidRenderingObjectParticleSystem.js

@@ -1,5 +1,4 @@
 
-import { Logger } from "../../Misc/logger.js";
 import { FluidRenderingObject } from "./fluidRenderingObject.js";
 /**
  * Defines a rendering object based on a particle system
@@ -72,15 +71,21 @@ export class FluidRenderingObjectParticleSystem extends FluidRenderingObject {
         this.useTrueRenderingForDiffuseTexture = false;
     }
     /**
-     * GPUParticleSystem's "size" buffer layout (baseSize, scaleX, scaleY) is incompatible with this feature.
-     * @returns true if the per-particle size attribute is supported
+     * GPUParticleSystem stores "size" as (baseSize, scaleX, scaleY); ParticleSystem as (width, height).
+     * @returns the number of components of the "size" attribute
      */
-    _supportsPerParticleSizeAttribute() {
-        if (this._particleSystem.getClassName() === "GPUParticleSystem") {
-            Logger.Warn("UsePerParticleSizeAttribute is not supported with GPUParticleSystem; falling back to uniform size.");
-            return false;
-        }
-        return true;
+    _getPerParticleSizeAttributeSize() {
+        return this._isGPUParticleSystem ? 3 : 2;
+    }
+    /**
+     * GPUParticleSystem's "offset" quad is centered ([-0.5, 0.5]); ParticleSystem's is in [0, 1].
+     * @returns true if the "offset" attribute is centered
+     */
+    _usesCenteredOffsetAttribute() {
+        return this._isGPUParticleSystem;
+    }
+    get _isGPUParticleSystem() {
+        return this._particleSystem.getClassName() === "GPUParticleSystem";
     }
     /**
      * Indicates if the object is ready to be rendered

package/Rendering/fluidRenderer/fluidRenderingObjectParticleSystem.js.map

@@ -1 +1 @@
-{"version":3,"file":"fluidRenderingObjectParticleSystem.js","sourceRoot":"","sources":["../../../../../dev/core/src/Rendering/fluidRenderer/fluidRenderingObjectParticleSystem.ts"],"names":[],"mappings":"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","sourcesContent":["import { type VertexBuffer } from \"core/Buffers/buffer\";\r\nimport { type DataBuffer } from \"core/Buffers/dataBuffer\";\r\nimport { Constants } from \"core/Engines/constants\";\r\nimport { type Effect } from \"core/Materials/effect\";\r\nimport { Logger } from \"core/Misc/logger\";\r\nimport { type Observer } from \"core/Misc/observable\";\r\nimport { type IParticleSystem } from \"core/Particles/IParticleSystem\";\r\nimport { type Scene } from \"core/scene\";\r\nimport { type Nullable } from \"core/types\";\r\n\r\nimport { FluidRenderingObject } from \"./fluidRenderingObject\";\r\nimport { type ShaderLanguage } from \"core/Materials/shaderLanguage\";\r\n\r\n/**\r\n * Defines a rendering object based on a particle system\r\n */\r\nexport class FluidRenderingObjectParticleSystem extends FluidRenderingObject {\r\n    private _particleSystem: IParticleSystem;\r\n    private _originalRender: () => number;\r\n    private _blendMode: number;\r\n    private _onBeforeDrawParticleObserver: Nullable<Observer<Nullable<Effect>>>;\r\n    private _updateInAnimate: boolean;\r\n\r\n    /** Gets the particle system */\r\n    public get particleSystem() {\r\n        return this._particleSystem;\r\n    }\r\n\r\n    /**\r\n     * @returns the name of the class\r\n     */\r\n    public override getClassName(): string {\r\n        return \"FluidRenderingObjectParticleSystem\";\r\n    }\r\n\r\n    private _useTrueRenderingForDiffuseTexture = true;\r\n\r\n    /**\r\n     * Gets or sets a boolean indicating that the diffuse texture should be generated based on the regular rendering of the particle system (default: true).\r\n     * Sometimes, generating the diffuse texture this way may be sub-optimal. In that case, you can disable this property, in which case the particle system will be\r\n     * rendered using a ALPHA_COMBINE mode instead of the one used by the particle system.\r\n     */\r\n    public get useTrueRenderingForDiffuseTexture() {\r\n        return this._useTrueRenderingForDiffuseTexture;\r\n    }\r\n\r\n    public set useTrueRenderingForDiffuseTexture(use: boolean) {\r\n        if (this._useTrueRenderingForDiffuseTexture === use) {\r\n            return;\r\n        }\r\n\r\n        this._useTrueRenderingForDiffuseTexture = use;\r\n\r\n        if (use) {\r\n            this._particleSystem.blendMode = this._blendMode;\r\n            this._particleSystem.onBeforeDrawParticlesObservable.remove(this._onBeforeDrawParticleObserver);\r\n            this._onBeforeDrawParticleObserver = null;\r\n        } else {\r\n            this._particleSystem.blendMode = -1;\r\n            this._onBeforeDrawParticleObserver = this._particleSystem.onBeforeDrawParticlesObservable.add(() => {\r\n                this._engine.setAlphaMode(Constants.ALPHA_COMBINE);\r\n            });\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Gets the vertex buffers\r\n     */\r\n    public get vertexBuffers(): { [key: string]: VertexBuffer } {\r\n        return this._particleSystem.vertexBuffers as { [key: string]: VertexBuffer };\r\n    }\r\n\r\n    /**\r\n     * Gets the index buffer (or null if the object is using instancing)\r\n     */\r\n    public override get indexBuffer(): Nullable<DataBuffer> {\r\n        return this._particleSystem.indexBuffer;\r\n    }\r\n\r\n    /**\r\n     * Creates a new instance of the class\r\n     * @param scene The scene the particle system is part of\r\n     * @param ps The particle system\r\n     * @param shaderLanguage The shader language to use\r\n     */\r\n    constructor(scene: Scene, ps: IParticleSystem, shaderLanguage?: ShaderLanguage) {\r\n        super(scene, shaderLanguage);\r\n\r\n        this._particleSystem = ps;\r\n\r\n        this._originalRender = ps.render.bind(ps);\r\n        this._blendMode = ps.blendMode;\r\n        this._onBeforeDrawParticleObserver = null;\r\n        this._updateInAnimate = this._particleSystem.updateInAnimate;\r\n        this._particleSystem.updateInAnimate = true;\r\n        this._particleSystem.render = () => 0;\r\n\r\n        this.particleSize = (ps.minSize + ps.maxSize) / 2;\r\n\r\n        this.useTrueRenderingForDiffuseTexture = false;\r\n    }\r\n\r\n    /**\r\n     * GPUParticleSystem's \"size\" buffer layout (baseSize, scaleX, scaleY) is incompatible with this feature.\r\n     * @returns true if the per-particle size attribute is supported\r\n     */\r\n    protected override _supportsPerParticleSizeAttribute(): boolean {\r\n        if (this._particleSystem.getClassName() === \"GPUParticleSystem\") {\r\n            Logger.Warn(\"UsePerParticleSizeAttribute is not supported with GPUParticleSystem; falling back to uniform size.\");\r\n            return false;\r\n        }\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * Indicates if the object is ready to be rendered\r\n     * @returns True if everything is ready for the object to be rendered, otherwise false\r\n     */\r\n    public override isReady(): boolean {\r\n        return super.isReady() && this._particleSystem.isReady();\r\n    }\r\n\r\n    /**\r\n     * Gets the number of particles in this particle system\r\n     * @returns The number of particles\r\n     */\r\n    public get numParticles(): number {\r\n        return this._particleSystem.getActiveCount();\r\n    }\r\n\r\n    /**\r\n     * Render the diffuse texture for this object\r\n     */\r\n    public override renderDiffuseTexture(): void {\r\n        this._originalRender();\r\n    }\r\n\r\n    /**\r\n     * Releases the resources used by the class\r\n     */\r\n    public override dispose() {\r\n        super.dispose();\r\n\r\n        this._particleSystem.onBeforeDrawParticlesObservable.remove(this._onBeforeDrawParticleObserver);\r\n        this._onBeforeDrawParticleObserver = null;\r\n        this._particleSystem.render = this._originalRender;\r\n        this._particleSystem.blendMode = this._blendMode;\r\n        this._particleSystem.updateInAnimate = this._updateInAnimate;\r\n    }\r\n}\r\n"]}
+{"version":3,"file":"fluidRenderingObjectParticleSystem.js","sourceRoot":"","sources":["../../../../../dev/core/src/Rendering/fluidRenderer/fluidRenderingObjectParticleSystem.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAOnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAG9D;;GAEG;AACH,MAAM,OAAO,kCAAmC,SAAQ,oBAAoB;IAOxE,+BAA+B;IAC/B,IAAW,cAAc;QACrB,OAAO,IAAI,CAAC,eAAe,CAAC;IAChC,CAAC;IAED;;OAEG;IACa,YAAY;QACxB,OAAO,oCAAoC,CAAC;IAChD,CAAC;IAID;;;;OAIG;IACH,IAAW,iCAAiC;QACxC,OAAO,IAAI,CAAC,kCAAkC,CAAC;IACnD,CAAC;IAED,IAAW,iCAAiC,CAAC,GAAY;QACrD,IAAI,IAAI,CAAC,kCAAkC,KAAK,GAAG,EAAE,CAAC;YAClD,OAAO;QACX,CAAC;QAED,IAAI,CAAC,kCAAkC,GAAG,GAAG,CAAC;QAE9C,IAAI,GAAG,EAAE,CAAC;YACN,IAAI,CAAC,eAAe,CAAC,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC;YACjD,IAAI,CAAC,eAAe,CAAC,+BAA+B,CAAC,MAAM,CAAC,IAAI,CAAC,6BAA6B,CAAC,CAAC;YAChG,IAAI,CAAC,6BAA6B,GAAG,IAAI,CAAC;QAC9C,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,eAAe,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC;YACpC,IAAI,CAAC,6BAA6B,GAAG,IAAI,CAAC,eAAe,CAAC,+BAA+B,CAAC,GAAG,CAAC,GAAG,EAAE;gBAC/F,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;YACvD,CAAC,CAAC,CAAC;QACP,CAAC;IACL,CAAC;IAED;;OAEG;IACH,IAAW,aAAa;QACpB,OAAO,IAAI,CAAC,eAAe,CAAC,aAAgD,CAAC;IACjF,CAAC;IAED;;OAEG;IACH,IAAoB,WAAW;QAC3B,OAAO,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC;IAC5C,CAAC;IAED;;;;;OAKG;IACH,YAAY,KAAY,EAAE,EAAmB,EAAE,cAA+B;QAC1E,KAAK,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC;QAnDzB,uCAAkC,GAAG,IAAI,CAAC;QAqD9C,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;QAE1B,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC1C,IAAI,CAAC,UAAU,GAAG,EAAE,CAAC,SAAS,CAAC;QAC/B,IAAI,CAAC,6BAA6B,GAAG,IAAI,CAAC;QAC1C,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,eAAe,CAAC,eAAe,CAAC;QAC7D,IAAI,CAAC,eAAe,CAAC,eAAe,GAAG,IAAI,CAAC;QAC5C,IAAI,CAAC,eAAe,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC;QAEtC,IAAI,CAAC,YAAY,GAAG,CAAC,EAAE,CAAC,OAAO,GAAG,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAElD,IAAI,CAAC,iCAAiC,GAAG,KAAK,CAAC;IACnD,CAAC;IAED;;;OAGG;IACgB,gCAAgC;QAC/C,OAAO,IAAI,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7C,CAAC;IAED;;;OAGG;IACgB,4BAA4B;QAC3C,OAAO,IAAI,CAAC,oBAAoB,CAAC;IACrC,CAAC;IAED,IAAY,oBAAoB;QAC5B,OAAO,IAAI,CAAC,eAAe,CAAC,YAAY,EAAE,KAAK,mBAAmB,CAAC;IACvE,CAAC;IAED;;;OAGG;IACa,OAAO;QACnB,OAAO,KAAK,CAAC,OAAO,EAAE,IAAI,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,CAAC;IAC7D,CAAC;IAED;;;OAGG;IACH,IAAW,YAAY;QACnB,OAAO,IAAI,CAAC,eAAe,CAAC,cAAc,EAAE,CAAC;IACjD,CAAC;IAED;;OAEG;IACa,oBAAoB;QAChC,IAAI,CAAC,eAAe,EAAE,CAAC;IAC3B,CAAC;IAED;;OAEG;IACa,OAAO;QACnB,KAAK,CAAC,OAAO,EAAE,CAAC;QAEhB,IAAI,CAAC,eAAe,CAAC,+BAA+B,CAAC,MAAM,CAAC,IAAI,CAAC,6BAA6B,CAAC,CAAC;QAChG,IAAI,CAAC,6BAA6B,GAAG,IAAI,CAAC;QAC1C,IAAI,CAAC,eAAe,CAAC,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;QACnD,IAAI,CAAC,eAAe,CAAC,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC;QACjD,IAAI,CAAC,eAAe,CAAC,eAAe,GAAG,IAAI,CAAC,gBAAgB,CAAC;IACjE,CAAC;CACJ","sourcesContent":["import { type VertexBuffer } from \"core/Buffers/buffer\";\r\nimport { type DataBuffer } from \"core/Buffers/dataBuffer\";\r\nimport { Constants } from \"core/Engines/constants\";\r\nimport { type Effect } from \"core/Materials/effect\";\r\nimport { type Observer } from \"core/Misc/observable\";\r\nimport { type IParticleSystem } from \"core/Particles/IParticleSystem\";\r\nimport { type Scene } from \"core/scene\";\r\nimport { type Nullable } from \"core/types\";\r\n\r\nimport { FluidRenderingObject } from \"./fluidRenderingObject\";\r\nimport { type ShaderLanguage } from \"core/Materials/shaderLanguage\";\r\n\r\n/**\r\n * Defines a rendering object based on a particle system\r\n */\r\nexport class FluidRenderingObjectParticleSystem extends FluidRenderingObject {\r\n    private _particleSystem: IParticleSystem;\r\n    private _originalRender: () => number;\r\n    private _blendMode: number;\r\n    private _onBeforeDrawParticleObserver: Nullable<Observer<Nullable<Effect>>>;\r\n    private _updateInAnimate: boolean;\r\n\r\n    /** Gets the particle system */\r\n    public get particleSystem() {\r\n        return this._particleSystem;\r\n    }\r\n\r\n    /**\r\n     * @returns the name of the class\r\n     */\r\n    public override getClassName(): string {\r\n        return \"FluidRenderingObjectParticleSystem\";\r\n    }\r\n\r\n    private _useTrueRenderingForDiffuseTexture = true;\r\n\r\n    /**\r\n     * Gets or sets a boolean indicating that the diffuse texture should be generated based on the regular rendering of the particle system (default: true).\r\n     * Sometimes, generating the diffuse texture this way may be sub-optimal. In that case, you can disable this property, in which case the particle system will be\r\n     * rendered using a ALPHA_COMBINE mode instead of the one used by the particle system.\r\n     */\r\n    public get useTrueRenderingForDiffuseTexture() {\r\n        return this._useTrueRenderingForDiffuseTexture;\r\n    }\r\n\r\n    public set useTrueRenderingForDiffuseTexture(use: boolean) {\r\n        if (this._useTrueRenderingForDiffuseTexture === use) {\r\n            return;\r\n        }\r\n\r\n        this._useTrueRenderingForDiffuseTexture = use;\r\n\r\n        if (use) {\r\n            this._particleSystem.blendMode = this._blendMode;\r\n            this._particleSystem.onBeforeDrawParticlesObservable.remove(this._onBeforeDrawParticleObserver);\r\n            this._onBeforeDrawParticleObserver = null;\r\n        } else {\r\n            this._particleSystem.blendMode = -1;\r\n            this._onBeforeDrawParticleObserver = this._particleSystem.onBeforeDrawParticlesObservable.add(() => {\r\n                this._engine.setAlphaMode(Constants.ALPHA_COMBINE);\r\n            });\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Gets the vertex buffers\r\n     */\r\n    public get vertexBuffers(): { [key: string]: VertexBuffer } {\r\n        return this._particleSystem.vertexBuffers as { [key: string]: VertexBuffer };\r\n    }\r\n\r\n    /**\r\n     * Gets the index buffer (or null if the object is using instancing)\r\n     */\r\n    public override get indexBuffer(): Nullable<DataBuffer> {\r\n        return this._particleSystem.indexBuffer;\r\n    }\r\n\r\n    /**\r\n     * Creates a new instance of the class\r\n     * @param scene The scene the particle system is part of\r\n     * @param ps The particle system\r\n     * @param shaderLanguage The shader language to use\r\n     */\r\n    constructor(scene: Scene, ps: IParticleSystem, shaderLanguage?: ShaderLanguage) {\r\n        super(scene, shaderLanguage);\r\n\r\n        this._particleSystem = ps;\r\n\r\n        this._originalRender = ps.render.bind(ps);\r\n        this._blendMode = ps.blendMode;\r\n        this._onBeforeDrawParticleObserver = null;\r\n        this._updateInAnimate = this._particleSystem.updateInAnimate;\r\n        this._particleSystem.updateInAnimate = true;\r\n        this._particleSystem.render = () => 0;\r\n\r\n        this.particleSize = (ps.minSize + ps.maxSize) / 2;\r\n\r\n        this.useTrueRenderingForDiffuseTexture = false;\r\n    }\r\n\r\n    /**\r\n     * GPUParticleSystem stores \"size\" as (baseSize, scaleX, scaleY); ParticleSystem as (width, height).\r\n     * @returns the number of components of the \"size\" attribute\r\n     */\r\n    protected override _getPerParticleSizeAttributeSize(): number {\r\n        return this._isGPUParticleSystem ? 3 : 2;\r\n    }\r\n\r\n    /**\r\n     * GPUParticleSystem's \"offset\" quad is centered ([-0.5, 0.5]); ParticleSystem's is in [0, 1].\r\n     * @returns true if the \"offset\" attribute is centered\r\n     */\r\n    protected override _usesCenteredOffsetAttribute(): boolean {\r\n        return this._isGPUParticleSystem;\r\n    }\r\n\r\n    private get _isGPUParticleSystem(): boolean {\r\n        return this._particleSystem.getClassName() === \"GPUParticleSystem\";\r\n    }\r\n\r\n    /**\r\n     * Indicates if the object is ready to be rendered\r\n     * @returns True if everything is ready for the object to be rendered, otherwise false\r\n     */\r\n    public override isReady(): boolean {\r\n        return super.isReady() && this._particleSystem.isReady();\r\n    }\r\n\r\n    /**\r\n     * Gets the number of particles in this particle system\r\n     * @returns The number of particles\r\n     */\r\n    public get numParticles(): number {\r\n        return this._particleSystem.getActiveCount();\r\n    }\r\n\r\n    /**\r\n     * Render the diffuse texture for this object\r\n     */\r\n    public override renderDiffuseTexture(): void {\r\n        this._originalRender();\r\n    }\r\n\r\n    /**\r\n     * Releases the resources used by the class\r\n     */\r\n    public override dispose() {\r\n        super.dispose();\r\n\r\n        this._particleSystem.onBeforeDrawParticlesObservable.remove(this._onBeforeDrawParticleObserver);\r\n        this._onBeforeDrawParticleObserver = null;\r\n        this._particleSystem.render = this._originalRender;\r\n        this._particleSystem.blendMode = this._blendMode;\r\n        this._particleSystem.updateInAnimate = this._updateInAnimate;\r\n    }\r\n}\r\n"]}

package/Rendering/geometryBufferRenderer.pure.d.ts

@@ -8,7 +8,7 @@ import { type Scene } from "../scene.pure.js";
 import { type AbstractMesh } from "../Meshes/abstractMesh.pure.js";
 import { type Nullable } from "../types.js";
 import { ShaderLanguage } from "../Materials/shaderLanguage.js";
-import { type GeometryRenderingObjectIdProvider } from "../Materials/materialHelper.geometryrendering.js";
+import { type GeometryRenderingMeshBlendTagProvider, type GeometryRenderingObjectIdProvider } from "../Materials/materialHelper.geometryrendering.js";
 /** @internal */
 interface ISavedTransformationMatrix {
     world: Matrix;
@@ -82,6 +82,10 @@ export declare class GeometryBufferRenderer {
      * Object IDs are stored as 24-bit unsigned integers encoded in the RGB channels.
      */
     static readonly OBJECT_ID_TEXTURE_TYPE = 8;
+    /**
+     * Constant used to retrieve the packed mesh-blending tag texture index in the G-Buffer textures array.
+     */
+    static readonly MESH_BLEND_TAG_TEXTURE_TYPE = 9;
     /**
      * Dictionary used to store the previous transformation matrices of each rendered mesh
      * in order to compute objects velocities when enableVelocity is set to "true"
@@ -103,8 +107,10 @@ export declare class GeometryBufferRenderer {
      * Avoids computing bones velocities and computes only mesh's velocity itself (position, rotation, scaling).
      */
     excludedSkinnedMeshesFromVelocity: AbstractMesh[];
+    private _renderTransparentMeshes;
     /** Gets or sets a boolean indicating if transparent meshes should be rendered */
-    renderTransparentMeshes: boolean;
+    get renderTransparentMeshes(): boolean;
+    set renderTransparentMeshes(value: boolean);
     /**
      * Provides the object ID written for each rendered mesh.
      *
@@ -112,9 +118,18 @@ export declare class GeometryBufferRenderer {
      * Instances use the ID of their source mesh. The default is the mesh unique ID.
      * Default IDs are only stable for the lifetime of the current scene and should not be persisted.
      * The provider runs in the render hot path and may be called multiple times for the same mesh in a frame.
-     * @see https://playground.babylonjs.com/#REC26C#0
+     * @see https://playground.babylonjs.com/?version=preview#SQXZ3X#1
      */
     objectIdProvider?: GeometryRenderingObjectIdProvider;
+    /**
+     * Provides the packed mesh-blending tag written for each rendered mesh.
+     *
+     * Tags must be 0 or contain a group ID between 1 and 63 in their low six bits. Tag 0 disables mesh blending.
+     * By default, meshes use their `meshBlendingTag` property. Instances and thin instances use the source mesh tag.
+     * The provider runs in the render hot path and receives the source mesh for instanced draws.
+     * It should avoid allocations and return a consistent value for a mesh during a render.
+     */
+    meshBlendTagProvider?: GeometryRenderingMeshBlendTagProvider;
     /**
      * Gets or sets a boolean indicating if normals should be generated in world space (default: false, meaning normals are generated in view space)
      */
@@ -138,6 +153,7 @@ export declare class GeometryBufferRenderer {
     private _enableScreenspaceDepth;
     private _enableIrradiance;
     private _enableObjectId;
+    private _enableMeshBlendTag;
     private _depthFormat;
     private _clearColor;
     private _clearDepthColor;
@@ -150,6 +166,7 @@ export declare class GeometryBufferRenderer {
     private _screenspaceDepthIndex;
     private _irradianceIndex;
     private _objectIdIndex;
+    private _meshBlendTagIndex;
     private _linkedWithPrePass;
     private _prePassRenderer;
     private _attachmentsFromPrePass;
@@ -283,9 +300,25 @@ export declare class GeometryBufferRenderer {
      *
      * Object ID rendering currently requires a single-sample G buffer.
      * Object ID rendering is not supported when the G buffer is linked to the PrePassRenderer.
-     * @see https://playground.babylonjs.com/#REC26C#0
+     * @see https://playground.babylonjs.com/?version=preview#SQXZ3X#1
      */
     set enableObjectId(enable: boolean);
+    /**
+     * Gets whether packed mesh-blending tags are enabled for the G buffer.
+     */
+    get enableMeshBlendingTag(): boolean;
+    /**
+     * Sets whether packed mesh-blending tags are enabled for the G buffer.
+     *
+     * Mesh-blending tags use a single-sample R8UI color attachment and are supported on WebGL2 and WebGPU.
+     * Transparent rendering remains controlled by renderTransparentMeshes. Applications are responsible for
+     * ensuring that transparent draws do not invalidate the SceneColor and geometry-input correspondence required
+     * by the mesh-blending pass. On WebGL2, transparent rendering with this output requires per-target blend parameters.
+     *
+     * Enabling or disabling this output rebuilds the renderer's targets. The application retains ownership
+     * of the GeometryBufferRenderer and of every post process that consumes the output.
+     */
+    set enableMeshBlendingTag(enable: boolean);
     /**
      * This will store a mask in the alpha channel of the irradiance texture to indicate which pixels have
      * scattering and should be taken into account when applying image-based lighting.
@@ -357,6 +390,7 @@ export declare class GeometryBufferRenderer {
     dispose(): void;
     private _assignRenderTargetIndices;
     protected _createRenderTargets(): void;
+    private _getRenderTargetDimensions;
     private _copyBonesTransformationMatrices;
 }
 /**

package/Rendering/geometryBufferRenderer.pure.js

@@ -11,8 +11,9 @@ import { MaterialFlags } from "../Materials/materialFlags.js";
 import { BindClipPlane, PrepareStringDefinesForClipPlanes, AddClipPlaneUniforms } from "../Materials/clipPlaneMaterialHelper.js";
 import { BindMorphTargetParameters, BindSceneUniformBuffer, PrepareDefinesAndAttributesForMorphTargets, PushAttributesForInstances, PrepareDefinesForIBL, PrepareUniformsAndSamplersForIBL, } from "../Materials/materialHelper.functions.js";
 import { RegisterGeometryBufferRendererSceneComponent } from "./geometryBufferRendererSceneComponent.pure.js";
-import { IsGaussianSplattingClassName } from "../Meshes/GaussianSplatting/gaussianSplattingMesh.pure.js";
-import { _GetGeometryRenderingObjectId } from "../Materials/materialHelper.geometryrendering.js";
+import { _IsGaussianSplattingMesh } from "../Meshes/GaussianSplatting/gaussianSplatting.functions.js";
+import { _IsMeshBlendingSupported } from "../Meshes/meshBlendingTag.js";
+import { _GetGeometryRenderingMeshBlendTag, _GetGeometryRenderingObjectId, } from "../Materials/materialHelper.geometryrendering.js";
 export const Samplers = [
     "diffuseSampler",
     "bumpSampler",
@@ -30,6 +31,7 @@ export const Uniforms = [
     "mBones",
     "viewProjection",
     "diffuseMatrix",
+    "alphaCutOff",
     "view",
     "previousWorld",
     "previousViewProjection",
@@ -56,11 +58,22 @@ export const Uniforms = [
     "morphTargetTextureIndices",
     "boneTextureInfo",
     "objectId",
+    "meshBlendTag",
 ];
 /**
  * This renderer is helpful to fill one of the render target with a geometry buffer.
  */
 export class GeometryBufferRenderer {
+    /** Gets or sets a boolean indicating if transparent meshes should be rendered */
+    get renderTransparentMeshes() {
+        return this._renderTransparentMeshes;
+    }
+    set renderTransparentMeshes(value) {
+        if (value && this._enableMeshBlendTag && !this._scene.getEngine().getCaps().blendParametersPerTarget) {
+            throw new Error("GeometryBufferRenderer: transparent mesh-blending tags require per-target blend parameters");
+        }
+        this._renderTransparentMeshes = value;
+    }
     /**
      * Gets a boolean indicating if normals are encoded in the [0,1] range in the render target. If true, you should do `normal = normal_rt * 2.0 - 1.0` to get the right normal
      */
@@ -73,6 +86,9 @@ export class GeometryBufferRenderer {
      * This method should only be called by the PrePassRenderer itself
      */
     _linkPrePassRenderer(prePassRenderer) {
+        if (this._enableObjectId || this._enableMeshBlendTag) {
+            throw new Error("GeometryBufferRenderer: object ID and mesh-blending tag textures are not supported when linked to the PrePassRenderer");
+        }
         this._linkedWithPrePass = true;
         this._prePassRenderer = prePassRenderer;
         if (this._multiRenderTarget) {
@@ -106,6 +122,7 @@ export class GeometryBufferRenderer {
         this._enableScreenspaceDepth = false;
         this._enableIrradiance = false;
         this._enableObjectId = false;
+        this._enableMeshBlendTag = false;
         this._attachmentsFromPrePass = [];
     }
     /**
@@ -150,6 +167,10 @@ export class GeometryBufferRenderer {
             this._objectIdIndex = index;
             this._enableObjectId = true;
         }
+        else if (geometryBufferType === GeometryBufferRenderer.MESH_BLEND_TAG_TEXTURE_TYPE) {
+            this._meshBlendTagIndex = index;
+            this._enableMeshBlendTag = true;
+        }
     }
     /**
      * @internal
@@ -211,6 +232,8 @@ export class GeometryBufferRenderer {
                 return this._irradianceIndex;
             case GeometryBufferRenderer.OBJECT_ID_TEXTURE_TYPE:
                 return this._objectIdIndex;
+            case GeometryBufferRenderer.MESH_BLEND_TAG_TEXTURE_TYPE:
+                return this._meshBlendTagIndex;
             default:
                 return -1;
         }
@@ -360,7 +383,7 @@ export class GeometryBufferRenderer {
      *
      * Object ID rendering currently requires a single-sample G buffer.
      * Object ID rendering is not supported when the G buffer is linked to the PrePassRenderer.
-     * @see https://playground.babylonjs.com/#REC26C#0
+     * @see https://playground.babylonjs.com/?version=preview#SQXZ3X#1
      */
     set enableObjectId(enable) {
         if (enable && this._linkedWithPrePass) {
@@ -386,6 +409,58 @@ export class GeometryBufferRenderer {
             this._createRenderTargets();
         }
     }
+    /**
+     * Gets whether packed mesh-blending tags are enabled for the G buffer.
+     */
+    get enableMeshBlendingTag() {
+        return this._enableMeshBlendTag;
+    }
+    /**
+     * Sets whether packed mesh-blending tags are enabled for the G buffer.
+     *
+     * Mesh-blending tags use a single-sample R8UI color attachment and are supported on WebGL2 and WebGPU.
+     * Transparent rendering remains controlled by renderTransparentMeshes. Applications are responsible for
+     * ensuring that transparent draws do not invalidate the SceneColor and geometry-input correspondence required
+     * by the mesh-blending pass. On WebGL2, transparent rendering with this output requires per-target blend parameters.
+     *
+     * Enabling or disabling this output rebuilds the renderer's targets. The application retains ownership
+     * of the GeometryBufferRenderer and of every post process that consumes the output.
+     */
+    set enableMeshBlendingTag(enable) {
+        if (this._enableMeshBlendTag === enable) {
+            return;
+        }
+        if (enable) {
+            const engine = this._scene.getEngine();
+            if (!_IsMeshBlendingSupported(engine)) {
+                throw new Error("GeometryBufferRenderer: mesh-blending tag textures require WebGL2 or WebGPU");
+            }
+            if (this.renderTransparentMeshes && !engine.isWebGPU && !engine.getCaps().blendParametersPerTarget) {
+                throw new Error("GeometryBufferRenderer: transparent mesh-blending tags require per-target blend parameters");
+            }
+            if (this._linkedWithPrePass) {
+                throw new Error("GeometryBufferRenderer: mesh-blending tag textures are not supported when linked to the PrePassRenderer");
+            }
+            if (this.samples !== 1) {
+                throw new Error("GeometryBufferRenderer: mesh-blending tag textures require samples to be 1");
+            }
+            if (!this._enableMeshBlendTag) {
+                const maxDrawBuffers = Math.min(engine.getCaps().maxDrawBuffers ?? 1, 8);
+                const attachmentCount = this._assignRenderTargetIndices()[0] + 1;
+                if (engine.getCaps().drawBuffersExtension && attachmentCount > maxDrawBuffers) {
+                    throw new Error(`GeometryBufferRenderer: ${attachmentCount} color attachments were requested, but this engine supports at most ${maxDrawBuffers}`);
+                }
+            }
+        }
+        this._enableMeshBlendTag = enable;
+        if (!enable) {
+            this._meshBlendTagIndex = -1;
+        }
+        if (!this._linkedWithPrePass) {
+            this.dispose();
+            this._createRenderTargets();
+        }
+    }
     /**
      * Gets the scene associated with the buffer.
      */
@@ -431,8 +506,7 @@ export class GeometryBufferRenderer {
          * Avoids computing bones velocities and computes only mesh's velocity itself (position, rotation, scaling).
          */
         this.excludedSkinnedMeshesFromVelocity = [];
-        /** Gets or sets a boolean indicating if transparent meshes should be rendered */
-        this.renderTransparentMeshes = true;
+        this._renderTransparentMeshes = true;
         /**
          * Gets or sets a boolean indicating if normals should be generated in world space (default: false, meaning normals are generated in view space)
          */
@@ -448,6 +522,7 @@ export class GeometryBufferRenderer {
         this._enableScreenspaceDepth = false;
         this._enableIrradiance = false;
         this._enableObjectId = false;
+        this._enableMeshBlendTag = false;
         this._clearColor = new Color4(0, 0, 0, 0);
         this._clearDepthColor = new Color4(0, 0, 0, 1); // sets an invalid value by default - depth in the depth texture is view.z, so 0 is not possible because view.z can't be less than camera.minZ
         this._positionIndex = -1;
@@ -459,6 +534,7 @@ export class GeometryBufferRenderer {
         this._screenspaceDepthIndex = -1;
         this._irradianceIndex = -1;
         this._objectIdIndex = -1;
+        this._meshBlendTagIndex = -1;
         this._linkedWithPrePass = false;
         /**
          * This will store a mask in the alpha channel of the irradiance texture to indicate which pixels have
@@ -514,7 +590,7 @@ export class GeometryBufferRenderer {
         // The generic geometry.vertex shader misreads this as world coordinates, producing
         // garbage positions and normals, and thus they should be excluded from the G-buffer
         // rendering.
-        if (IsGaussianSplattingClassName(subMesh.getMesh().getClassName())) {
+        if (_IsGaussianSplattingMesh(subMesh.getMesh())) {
             return false;
         }
         const defines = [];
@@ -816,6 +892,10 @@ export class GeometryBufferRenderer {
             defines.push("#define OBJECT_ID");
             defines.push("#define OBJECT_ID_INDEX " + this._objectIdIndex);
         }
+        if (this._enableMeshBlendTag) {
+            defines.push("#define MESH_BLEND_TAG");
+            defines.push("#define MESH_BLEND_TAG_INDEX " + this._meshBlendTagIndex);
+        }
         if (this.generateNormalsInWorldSpace) {
             defines.push("#define NORMAL_WORLDSPACE");
         }
@@ -906,6 +986,9 @@ export class GeometryBufferRenderer {
         if (this._enableObjectId && value !== 1) {
             throw new Error("GeometryBufferRenderer: object ID textures currently require samples to be 1");
         }
+        if (this._enableMeshBlendTag && value !== 1) {
+            throw new Error("GeometryBufferRenderer: mesh-blending tag textures require samples to be 1");
+        }
         this._multiRenderTarget.samples = value;
     }
     /**
@@ -984,6 +1067,16 @@ export class GeometryBufferRenderer {
                 samplingMode: 1,
             });
         }
+        if (this._enableMeshBlendTag) {
+            this._meshBlendTagIndex = count;
+            count++;
+            textureNames.push("gBuffer_MeshBlendTag");
+            textureTypesAndFormats.push({
+                textureType: 0,
+                textureFormat: 8,
+                samplingMode: 1,
+            });
+        }
         return [count, textureNames, textureTypesAndFormats];
     }
     _createRenderTargets() {
@@ -1000,9 +1093,7 @@ export class GeometryBufferRenderer {
         else if (engine._caps.textureHalfFloat && engine._caps.textureHalfFloatLinearFiltering) {
             type = 2;
         }
-        const dimensions = this._ratioOrDimensions.width !== undefined
-            ? this._ratioOrDimensions
-            : { width: engine.getRenderWidth() * this._ratioOrDimensions, height: engine.getRenderHeight() * this._ratioOrDimensions };
+        const dimensions = this._getRenderTargetDimensions();
         const textureTypes = [];
         const textureFormats = [];
         const samplingModes = [];
@@ -1043,20 +1134,16 @@ export class GeometryBufferRenderer {
         const attachmentsAllButDepth = engine.buildTextureLayout(layoutAttachmentsAllButDepth);
         const attachmentsDepthOnly = engine.buildTextureLayout(layoutAttachmentsDepthOnly);
         this._multiRenderTarget.onClearObservable.add((engine) => {
-            engine.bindAttachments(this.useSpecificClearForDepthTexture ? attachmentsAllButDepth : attachmentsAll);
-            engine.clear(this._clearColor, true, true, true);
+            const colorAttachments = this.useSpecificClearForDepthTexture ? attachmentsAllButDepth : attachmentsAll;
+            engine.clearAttachments(this._clearColor, colorAttachments, true, true, true);
             if (this.useSpecificClearForDepthTexture) {
-                engine.bindAttachments(attachmentsDepthOnly);
-                engine.clear(this._clearDepthColor, true, true, true);
+                engine.clearAttachments(this._clearDepthColor, attachmentsDepthOnly, true, false, false);
             }
             engine.bindAttachments(attachmentsAll);
         });
         this._resizeObserver = engine.onResizeObservable.add(() => {
             if (this._multiRenderTarget) {
-                const dimensions = this._ratioOrDimensions.width !== undefined
-                    ? this._ratioOrDimensions
-                    : { width: engine.getRenderWidth() * this._ratioOrDimensions, height: engine.getRenderHeight() * this._ratioOrDimensions };
-                this._multiRenderTarget.resize(dimensions);
+                this._multiRenderTarget.resize(this._getRenderTargetDimensions());
             }
         });
         // Custom render function
@@ -1126,6 +1213,7 @@ export class GeometryBufferRenderer {
                     if (alphaTexture) {
                         effect.setTexture("diffuseSampler", alphaTexture);
                         effect.setMatrix("diffuseMatrix", alphaTexture.getTextureMatrix());
+                        effect.setFloat("alphaCutOff", material.alphaCutOff ?? 0.4);
                     }
                 }
                 // Bump
@@ -1353,6 +1441,10 @@ export class GeometryBufferRenderer {
                     }
                     effect.setFloat("objectId", objectId);
                 }
+                if (this._enableMeshBlendTag) {
+                    const meshBlendTag = this.meshBlendTagProvider ? _GetGeometryRenderingMeshBlendTag(renderingMesh, this.meshBlendTagProvider) : renderingMesh.meshBlendingTag;
+                    effect.setInt("meshBlendTag", meshBlendTag);
+                }
                 if (hardwareInstancedRendering && renderingMesh.hasThinInstances) {
                     effect.setMatrix("world", world);
                 }
@@ -1420,6 +1512,19 @@ export class GeometryBufferRenderer {
             engine.setDepthWrite(true);
         };
     }
+    _getRenderTargetDimensions() {
+        if (typeof this._ratioOrDimensions === "object") {
+            return {
+                width: Math.max(1, Math.floor(this._ratioOrDimensions.width)),
+                height: Math.max(1, Math.floor(this._ratioOrDimensions.height)),
+            };
+        }
+        const engine = this._scene.getEngine();
+        return {
+            width: Math.max(1, Math.floor(engine.getRenderWidth() * this._ratioOrDimensions)),
+            height: Math.max(1, Math.floor(engine.getRenderHeight() * this._ratioOrDimensions)),
+        };
+    }
     // Copies the bones transformation matrices into the target array and returns the target's reference
     _copyBonesTransformationMatrices(source, target) {
         for (let i = 0; i < source.length; i++) {
@@ -1478,6 +1583,10 @@ GeometryBufferRenderer.IRRADIANCE_TEXTURE_TYPE = 7;
  * Object IDs are stored as 24-bit unsigned integers encoded in the RGB channels.
  */
 GeometryBufferRenderer.OBJECT_ID_TEXTURE_TYPE = 8;
+/**
+ * Constant used to retrieve the packed mesh-blending tag texture index in the G-Buffer textures array.
+ */
+GeometryBufferRenderer.MESH_BLEND_TAG_TEXTURE_TYPE = 9;
 /**
  * @internal
  */