@onerjs/core 8.56.1 → 8.56.3

package/Rendering/geometryBufferRenderer.pure.d.ts

@@ -8,6 +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";
 /** @internal */
 interface ISavedTransformationMatrix {
     world: Matrix;
@@ -76,6 +77,11 @@ export declare class GeometryBufferRenderer {
      * using getIndex(GeometryBufferRenderer.IRRADIANCE_TEXTURE_TYPE)
      */
     static readonly IRRADIANCE_TEXTURE_TYPE = 7;
+    /**
+     * Constant used to retrieve the object ID texture index in the G-Buffer textures array.
+     * Object IDs are stored as 24-bit unsigned integers encoded in the RGB channels.
+     */
+    static readonly OBJECT_ID_TEXTURE_TYPE = 8;
     /**
      * Dictionary used to store the previous transformation matrices of each rendered mesh
      * in order to compute objects velocities when enableVelocity is set to "true"
@@ -99,6 +105,16 @@ export declare class GeometryBufferRenderer {
     excludedSkinnedMeshesFromVelocity: AbstractMesh[];
     /** Gets or sets a boolean indicating if transparent meshes should be rendered */
     renderTransparentMeshes: boolean;
+    /**
+     * Provides the object ID written for each rendered mesh.
+     *
+     * IDs must be integers between 0 and 0xFFFFFF. ID 0 is reserved for background or excluded meshes.
+     * 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
+     */
+    objectIdProvider?: GeometryRenderingObjectIdProvider;
     /**
      * Gets or sets a boolean indicating if normals should be generated in world space (default: false, meaning normals are generated in view space)
      */
@@ -121,6 +137,7 @@ export declare class GeometryBufferRenderer {
     private _enableReflectivity;
     private _enableScreenspaceDepth;
     private _enableIrradiance;
+    private _enableObjectId;
     private _depthFormat;
     private _clearColor;
     private _clearDepthColor;
@@ -132,6 +149,7 @@ export declare class GeometryBufferRenderer {
     private _normalIndex;
     private _screenspaceDepthIndex;
     private _irradianceIndex;
+    private _objectIdIndex;
     private _linkedWithPrePass;
     private _prePassRenderer;
     private _attachmentsFromPrePass;
@@ -256,6 +274,18 @@ export declare class GeometryBufferRenderer {
      * Sets whether or not objects irradiance are enabled for the G buffer.
      */
     set enableIrradiance(enable: boolean);
+    /**
+     * Gets whether object IDs are enabled for the G buffer.
+     */
+    get enableObjectId(): boolean;
+    /**
+     * Sets whether object IDs are enabled for the G buffer.
+     *
+     * 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
+     */
+    set enableObjectId(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.

package/Rendering/geometryBufferRenderer.pure.js

@@ -12,6 +12,7 @@ import { BindClipPlane, PrepareStringDefinesForClipPlanes, AddClipPlaneUniforms
 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";
 export const Samplers = [
     "diffuseSampler",
     "bumpSampler",
@@ -54,6 +55,7 @@ export const Uniforms = [
     "morphTargetTextureInfo",
     "morphTargetTextureIndices",
     "boneTextureInfo",
+    "objectId",
 ];
 /**
  * This renderer is helpful to fill one of the render target with a geometry buffer.
@@ -103,6 +105,7 @@ export class GeometryBufferRenderer {
         this._enableVelocityLinear = false;
         this._enableScreenspaceDepth = false;
         this._enableIrradiance = false;
+        this._enableObjectId = false;
         this._attachmentsFromPrePass = [];
     }
     /**
@@ -143,6 +146,10 @@ export class GeometryBufferRenderer {
             this._irradianceIndex = index;
             this._enableIrradiance = true;
         }
+        else if (geometryBufferType === GeometryBufferRenderer.OBJECT_ID_TEXTURE_TYPE) {
+            this._objectIdIndex = index;
+            this._enableObjectId = true;
+        }
     }
     /**
      * @internal
@@ -202,6 +209,8 @@ export class GeometryBufferRenderer {
                 return this._screenspaceDepthIndex;
             case GeometryBufferRenderer.IRRADIANCE_TEXTURE_TYPE:
                 return this._irradianceIndex;
+            case GeometryBufferRenderer.OBJECT_ID_TEXTURE_TYPE:
+                return this._objectIdIndex;
             default:
                 return -1;
         }
@@ -340,6 +349,43 @@ export class GeometryBufferRenderer {
             this._createRenderTargets();
         }
     }
+    /**
+     * Gets whether object IDs are enabled for the G buffer.
+     */
+    get enableObjectId() {
+        return this._enableObjectId;
+    }
+    /**
+     * Sets whether object IDs are enabled for the G buffer.
+     *
+     * 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
+     */
+    set enableObjectId(enable) {
+        if (enable && this._linkedWithPrePass) {
+            throw new Error("GeometryBufferRenderer: object ID textures are not supported when linked to the PrePassRenderer");
+        }
+        if (enable && this.samples !== 1) {
+            throw new Error("GeometryBufferRenderer: object ID textures currently require samples to be 1");
+        }
+        if (enable && !this._enableObjectId && !this._linkedWithPrePass) {
+            const engine = this._scene.getEngine();
+            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._enableObjectId = enable;
+        if (!enable) {
+            this._objectIdIndex = -1;
+        }
+        if (!this._linkedWithPrePass) {
+            this.dispose();
+            this._createRenderTargets();
+        }
+    }
     /**
      * Gets the scene associated with the buffer.
      */
@@ -401,6 +447,7 @@ export class GeometryBufferRenderer {
         this._enableReflectivity = false;
         this._enableScreenspaceDepth = false;
         this._enableIrradiance = false;
+        this._enableObjectId = 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;
@@ -411,6 +458,7 @@ export class GeometryBufferRenderer {
         this._normalIndex = -1;
         this._screenspaceDepthIndex = -1;
         this._irradianceIndex = -1;
+        this._objectIdIndex = -1;
         this._linkedWithPrePass = false;
         /**
          * This will store a mask in the alpha channel of the irradiance texture to indicate which pixels have
@@ -764,6 +812,10 @@ export class GeometryBufferRenderer {
                 }
             }
         }
+        if (this._enableObjectId) {
+            defines.push("#define OBJECT_ID");
+            defines.push("#define OBJECT_ID_INDEX " + this._objectIdIndex);
+        }
         if (this.generateNormalsInWorldSpace) {
             defines.push("#define NORMAL_WORLDSPACE");
         }
@@ -851,6 +903,9 @@ export class GeometryBufferRenderer {
      * Sets the number of samples used to render the buffer (anti aliasing).
      */
     set samples(value) {
+        if (this._enableObjectId && value !== 1) {
+            throw new Error("GeometryBufferRenderer: object ID textures currently require samples to be 1");
+        }
         this._multiRenderTarget.samples = value;
     }
     /**
@@ -919,11 +974,25 @@ export class GeometryBufferRenderer {
             textureNames.push("gBuffer_Irradiance");
             textureTypesAndFormats.push(this._textureTypesAndFormats[GeometryBufferRenderer.IRRADIANCE_TEXTURE_TYPE]);
         }
+        if (this._enableObjectId) {
+            this._objectIdIndex = count;
+            count++;
+            textureNames.push("gBuffer_ObjectId");
+            textureTypesAndFormats.push({
+                textureType: 0,
+                textureFormat: 5,
+                samplingMode: 1,
+            });
+        }
         return [count, textureNames, textureTypesAndFormats];
     }
     _createRenderTargets() {
         const engine = this._scene.getEngine();
         const [count, textureNames, textureTypesAndFormat] = this._assignRenderTargetIndices();
+        const maxDrawBuffers = Math.min(engine.getCaps().maxDrawBuffers ?? 1, 8);
+        if (engine.getCaps().drawBuffersExtension && count > maxDrawBuffers) {
+            throw new Error(`GeometryBufferRenderer: ${count} color attachments were requested, but this engine supports at most ${maxDrawBuffers}`);
+        }
         let type = 0;
         if (engine._caps.textureFloat && engine._caps.textureFloatLinearFiltering) {
             type = 1;
@@ -1274,6 +1343,16 @@ export class GeometryBufferRenderer {
                     effect.setMatrix("previousWorld", this._previousTransformationMatrices[effectiveMesh.uniqueId].world);
                     effect.setMatrix("previousViewProjection", this._previousTransformationMatrices[effectiveMesh.uniqueId].viewProjection);
                 }
+                if (this._enableObjectId) {
+                    let objectId = renderingMesh.uniqueId;
+                    if (this.objectIdProvider) {
+                        objectId = _GetGeometryRenderingObjectId(renderingMesh, this.objectIdProvider);
+                    }
+                    else if (objectId > 0xffffff) {
+                        throw new Error(`Invalid geometry object ID ${objectId} for mesh "${renderingMesh.name}". Object IDs must be integers between 0 and 0xFFFFFF.`);
+                    }
+                    effect.setFloat("objectId", objectId);
+                }
                 if (hardwareInstancedRendering && renderingMesh.hasThinInstances) {
                     effect.setMatrix("world", world);
                 }
@@ -1394,6 +1473,11 @@ GeometryBufferRenderer.VELOCITY_LINEAR_TEXTURE_TYPE = 6;
  * using getIndex(GeometryBufferRenderer.IRRADIANCE_TEXTURE_TYPE)
  */
 GeometryBufferRenderer.IRRADIANCE_TEXTURE_TYPE = 7;
+/**
+ * Constant used to retrieve the object ID texture index in the G-Buffer textures array.
+ * Object IDs are stored as 24-bit unsigned integers encoded in the RGB channels.
+ */
+GeometryBufferRenderer.OBJECT_ID_TEXTURE_TYPE = 8;
 /**
  * @internal
  */