@onerjs/core 8.56.4 → 9.0.1

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,8 +86,12 @@ 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;
+        this._scene._setPreviousWorldMatricesRequired(this, false);
         if (this._multiRenderTarget) {
             // prevents clearing of the RT since it's done by prepass
             this._multiRenderTarget.onClearObservable.clear();
@@ -106,7 +123,9 @@ export class GeometryBufferRenderer {
         this._enableScreenspaceDepth = false;
         this._enableIrradiance = false;
         this._enableObjectId = false;
+        this._enableMeshBlendTag = false;
         this._attachmentsFromPrePass = [];
+        this._scene._setPreviousWorldMatricesRequired(this, false);
     }
     /**
      * @internal
@@ -150,6 +169,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 +234,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;
         }
@@ -282,7 +307,6 @@ export class GeometryBufferRenderer {
             this.dispose();
             this._createRenderTargets();
         }
-        this._scene.needsPreviousWorldMatrices = enable;
     }
     /**
      * @returns a boolean indicating if object's linear velocities are enabled for the G buffer.
@@ -360,7 +384,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 +410,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 +507,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 +523,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 +535,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 +591,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 +893,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,12 +987,16 @@ 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;
     }
     /**
      * Disposes the renderer and frees up associated resources.
      */
     dispose() {
+        this._scene._setPreviousWorldMatricesRequired(this, false);
         if (this._resizeObserver) {
             const engine = this._scene.getEngine();
             engine.onResizeObservable.remove(this._resizeObserver);
@@ -984,6 +1069,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 +1095,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 = [];
@@ -1025,6 +1118,7 @@ export class GeometryBufferRenderer {
         if (!this.isSupported) {
             return;
         }
+        this._scene._setPreviousWorldMatricesRequired(this, !this._linkedWithPrePass && (this._enableVelocity || this._enableVelocityLinear));
         this._multiRenderTarget.wrapU = Texture.CLAMP_ADDRESSMODE;
         this._multiRenderTarget.wrapV = Texture.CLAMP_ADDRESSMODE;
         this._multiRenderTarget.refreshRate = 1;
@@ -1043,20 +1137,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 +1216,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 +1444,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 +1515,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 +1586,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
  */