@babylonjs/core 8.50.5 → 8.51.1

package/Instrumentation/engineInstrumentation.js

@@ -53,7 +53,8 @@ export class EngineInstrumentation {
                 this._shaderCompilationTime.beginMonitoring();
             });
             this._onAfterShaderCompilationObserver = this.engine.onAfterShaderCompilationObservable.add(() => {
-                this._shaderCompilationTime.endMonitoring();
+                this._shaderCompilationTime.endMonitoring(false);
+                this._shaderCompilationTime.endFrame();
             });
         }
         else {

package/Instrumentation/engineInstrumentation.js.map

@@ -1 +1 @@
-{"version":3,"file":"engineInstrumentation.js","sourceRoot":"","sources":["../../../../dev/core/src/Instrumentation/engineInstrumentation.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Observer } from \"../Misc/observable\";\r\nimport { PerfCounter } from \"../Misc/perfCounter\";\r\nimport type { Nullable } from \"../types\";\r\nimport type { IDisposable } from \"../scene\";\r\nimport type { AbstractEngine } from \"../Engines/abstractEngine\";\r\n/**\r\n * This class can be used to get instrumentation data from a Babylon engine\r\n * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/optimize_your_scene#engineinstrumentation\r\n */\r\nexport class EngineInstrumentation implements IDisposable {\r\n    private _captureGPUFrameTime = false;\r\n\r\n    private _captureShaderCompilationTime = false;\r\n    private _shaderCompilationTime = new PerfCounter();\r\n\r\n    // Observers\r\n    private _onBeginFrameObserver: Nullable<Observer<AbstractEngine>> = null;\r\n    private _onEndFrameObserver: Nullable<Observer<AbstractEngine>> = null;\r\n    private _onBeforeShaderCompilationObserver: Nullable<Observer<AbstractEngine>> = null;\r\n    private _onAfterShaderCompilationObserver: Nullable<Observer<AbstractEngine>> = null;\r\n\r\n    private _disposed = false;\r\n\r\n    // Properties\r\n    /**\r\n     * Gets the perf counter used for GPU frame time\r\n     */\r\n    public get gpuFrameTimeCounter(): PerfCounter {\r\n        return this.engine.getGPUFrameTimeCounter();\r\n    }\r\n\r\n    /**\r\n     * Gets the GPU frame time capture status\r\n     */\r\n    public get captureGPUFrameTime(): boolean {\r\n        return this._captureGPUFrameTime;\r\n    }\r\n\r\n    /**\r\n     * Enable or disable the GPU frame time capture\r\n     */\r\n    public set captureGPUFrameTime(value: boolean) {\r\n        if (value === this._captureGPUFrameTime) {\r\n            return;\r\n        }\r\n\r\n        this._captureGPUFrameTime = value;\r\n        this.engine.captureGPUFrameTime(value);\r\n    }\r\n\r\n    /**\r\n     * Gets the perf counter used for shader compilation time\r\n     */\r\n    public get shaderCompilationTimeCounter(): PerfCounter {\r\n        return this._shaderCompilationTime;\r\n    }\r\n\r\n    /**\r\n     * Gets the shader compilation time capture status\r\n     */\r\n    public get captureShaderCompilationTime(): boolean {\r\n        return this._captureShaderCompilationTime;\r\n    }\r\n\r\n    /**\r\n     * Enable or disable the shader compilation time capture\r\n     */\r\n    public set captureShaderCompilationTime(value: boolean) {\r\n        if (value === this._captureShaderCompilationTime) {\r\n            return;\r\n        }\r\n\r\n        this._captureShaderCompilationTime = value;\r\n\r\n        if (value) {\r\n            this._onBeforeShaderCompilationObserver = this.engine.onBeforeShaderCompilationObservable.add(() => {\r\n                this._shaderCompilationTime.fetchNewFrame();\r\n                this._shaderCompilationTime.beginMonitoring();\r\n            });\r\n\r\n            this._onAfterShaderCompilationObserver = this.engine.onAfterShaderCompilationObservable.add(() => {\r\n                this._shaderCompilationTime.endMonitoring();\r\n            });\r\n        } else {\r\n            this.engine.onBeforeShaderCompilationObservable.remove(this._onBeforeShaderCompilationObserver);\r\n            this._onBeforeShaderCompilationObserver = null;\r\n            this.engine.onAfterShaderCompilationObservable.remove(this._onAfterShaderCompilationObserver);\r\n            this._onAfterShaderCompilationObserver = null;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Instantiates a new engine instrumentation.\r\n     * This class can be used to get instrumentation data from a Babylon engine\r\n     * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/optimize_your_scene#engineinstrumentation\r\n     * @param engine Defines the engine to instrument\r\n     */\r\n    public constructor(\r\n        /**\r\n         * Define the instrumented engine.\r\n         */\r\n        public engine: AbstractEngine\r\n    ) {}\r\n\r\n    /**\r\n     * Dispose and release associated resources.\r\n     */\r\n    public dispose() {\r\n        if (this._disposed) {\r\n            return;\r\n        }\r\n\r\n        this.engine.onBeginFrameObservable.remove(this._onBeginFrameObserver);\r\n        this._onBeginFrameObserver = null;\r\n\r\n        this.engine.onEndFrameObservable.remove(this._onEndFrameObserver);\r\n        this._onEndFrameObserver = null;\r\n\r\n        this.engine.onBeforeShaderCompilationObservable.remove(this._onBeforeShaderCompilationObserver);\r\n        this._onBeforeShaderCompilationObserver = null;\r\n\r\n        this.engine.onAfterShaderCompilationObservable.remove(this._onAfterShaderCompilationObserver);\r\n        this._onAfterShaderCompilationObserver = null;\r\n\r\n        (<any>this.engine) = null;\r\n        this._disposed = true;\r\n    }\r\n}\r\n"]}
+{"version":3,"file":"engineInstrumentation.js","sourceRoot":"","sources":["../../../../dev/core/src/Instrumentation/engineInstrumentation.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Observer } from \"../Misc/observable\";\r\nimport { PerfCounter } from \"../Misc/perfCounter\";\r\nimport type { Nullable } from \"../types\";\r\nimport type { IDisposable } from \"../scene\";\r\nimport type { AbstractEngine } from \"../Engines/abstractEngine\";\r\n/**\r\n * This class can be used to get instrumentation data from a Babylon engine\r\n * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/optimize_your_scene#engineinstrumentation\r\n */\r\nexport class EngineInstrumentation implements IDisposable {\r\n    private _captureGPUFrameTime = false;\r\n\r\n    private _captureShaderCompilationTime = false;\r\n    private _shaderCompilationTime = new PerfCounter();\r\n\r\n    // Observers\r\n    private _onBeginFrameObserver: Nullable<Observer<AbstractEngine>> = null;\r\n    private _onEndFrameObserver: Nullable<Observer<AbstractEngine>> = null;\r\n    private _onBeforeShaderCompilationObserver: Nullable<Observer<AbstractEngine>> = null;\r\n    private _onAfterShaderCompilationObserver: Nullable<Observer<AbstractEngine>> = null;\r\n\r\n    private _disposed = false;\r\n\r\n    // Properties\r\n    /**\r\n     * Gets the perf counter used for GPU frame time\r\n     */\r\n    public get gpuFrameTimeCounter(): PerfCounter {\r\n        return this.engine.getGPUFrameTimeCounter();\r\n    }\r\n\r\n    /**\r\n     * Gets the GPU frame time capture status\r\n     */\r\n    public get captureGPUFrameTime(): boolean {\r\n        return this._captureGPUFrameTime;\r\n    }\r\n\r\n    /**\r\n     * Enable or disable the GPU frame time capture\r\n     */\r\n    public set captureGPUFrameTime(value: boolean) {\r\n        if (value === this._captureGPUFrameTime) {\r\n            return;\r\n        }\r\n\r\n        this._captureGPUFrameTime = value;\r\n        this.engine.captureGPUFrameTime(value);\r\n    }\r\n\r\n    /**\r\n     * Gets the perf counter used for shader compilation time\r\n     */\r\n    public get shaderCompilationTimeCounter(): PerfCounter {\r\n        return this._shaderCompilationTime;\r\n    }\r\n\r\n    /**\r\n     * Gets the shader compilation time capture status\r\n     */\r\n    public get captureShaderCompilationTime(): boolean {\r\n        return this._captureShaderCompilationTime;\r\n    }\r\n\r\n    /**\r\n     * Enable or disable the shader compilation time capture\r\n     */\r\n    public set captureShaderCompilationTime(value: boolean) {\r\n        if (value === this._captureShaderCompilationTime) {\r\n            return;\r\n        }\r\n\r\n        this._captureShaderCompilationTime = value;\r\n\r\n        if (value) {\r\n            this._onBeforeShaderCompilationObserver = this.engine.onBeforeShaderCompilationObservable.add(() => {\r\n                this._shaderCompilationTime.fetchNewFrame();\r\n                this._shaderCompilationTime.beginMonitoring();\r\n            });\r\n\r\n            this._onAfterShaderCompilationObserver = this.engine.onAfterShaderCompilationObservable.add(() => {\r\n                this._shaderCompilationTime.endMonitoring(false);\r\n                this._shaderCompilationTime.endFrame();\r\n            });\r\n        } else {\r\n            this.engine.onBeforeShaderCompilationObservable.remove(this._onBeforeShaderCompilationObserver);\r\n            this._onBeforeShaderCompilationObserver = null;\r\n            this.engine.onAfterShaderCompilationObservable.remove(this._onAfterShaderCompilationObserver);\r\n            this._onAfterShaderCompilationObserver = null;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Instantiates a new engine instrumentation.\r\n     * This class can be used to get instrumentation data from a Babylon engine\r\n     * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/optimize_your_scene#engineinstrumentation\r\n     * @param engine Defines the engine to instrument\r\n     */\r\n    public constructor(\r\n        /**\r\n         * Define the instrumented engine.\r\n         */\r\n        public engine: AbstractEngine\r\n    ) {}\r\n\r\n    /**\r\n     * Dispose and release associated resources.\r\n     */\r\n    public dispose() {\r\n        if (this._disposed) {\r\n            return;\r\n        }\r\n\r\n        this.engine.onBeginFrameObservable.remove(this._onBeginFrameObserver);\r\n        this._onBeginFrameObserver = null;\r\n\r\n        this.engine.onEndFrameObservable.remove(this._onEndFrameObserver);\r\n        this._onEndFrameObserver = null;\r\n\r\n        this.engine.onBeforeShaderCompilationObservable.remove(this._onBeforeShaderCompilationObserver);\r\n        this._onBeforeShaderCompilationObserver = null;\r\n\r\n        this.engine.onAfterShaderCompilationObservable.remove(this._onAfterShaderCompilationObserver);\r\n        this._onAfterShaderCompilationObserver = null;\r\n\r\n        (<any>this.engine) = null;\r\n        this._disposed = true;\r\n    }\r\n}\r\n"]}

package/Materials/GaussianSplatting/gaussianSplattingGpuPickingMaterialPlugin.d.ts

@@ -0,0 +1,109 @@
+import type { Nullable } from "../../types.js";
+import type { Scene } from "../../scene.js";
+import type { AbstractEngine } from "../../Engines/abstractEngine.js";
+import type { SubMesh } from "../../Meshes/subMesh.js";
+import type { UniformBuffer } from "../uniformBuffer.js";
+import type { MaterialDefines } from "../materialDefines.js";
+import { MaterialPluginBase } from "../materialPluginBase.js";
+import { ShaderLanguage } from "../shaderLanguage.js";
+import type { GaussianSplattingMaterial } from "./gaussianSplattingMaterial.js";
+/**
+ * Plugin for GaussianSplattingMaterial that replaces per-splat color output with
+ * a pre-computed picking color for GPU-based hit testing.
+ *
+ * The picking color is computed on the CPU by encoding a 24-bit picking ID as RGB
+ * (matching the readback decoding in GPUPicker).
+ * @experimental
+ */
+export declare class GaussianSplattingGpuPickingMaterialPlugin extends MaterialPluginBase {
+    private _pickingColor;
+    private _isCompound;
+    private _partPickingColors;
+    private _maxPartCount;
+    /**
+     * Creates a new GaussianSplattingGpuPickingMaterialPlugin.
+     * @param material The GaussianSplattingMaterial to attach the plugin to.
+     * @param maxPartCount The maximum number of parts supported for compound meshes.
+     */
+    constructor(material: GaussianSplattingMaterial, maxPartCount?: number);
+    /**
+     * Encodes a 24-bit picking ID into normalized RGB components.
+     * @param id The picking ID to encode
+     * @returns A tuple [r, g, b] with values in [0, 1]
+     */
+    static EncodeIdToColor(id: number): [number, number, number];
+    /**
+     * Sets the picking color for a non-compound mesh from a picking ID.
+     * The ID is encoded into an RGB color on the CPU.
+     * @param id The 24-bit picking ID.
+     */
+    set meshId(id: number);
+    /**
+     * Sets whether this material is for a compound mesh with per-part picking.
+     */
+    set isCompound(value: boolean);
+    /**
+     * Gets whether this material is for a compound mesh with per-part picking.
+     */
+    get isCompound(): boolean;
+    /**
+     * Sets the per-part picking colors from an array of picking IDs.
+     * Each ID is encoded into an RGB color on the CPU.
+     * @param ids Array mapping part index to picking ID.
+     */
+    set partMeshIds(ids: number[]);
+    /**
+     * @returns the class name
+     */
+    getClassName(): string;
+    /**
+     * Indicates this plugin supports both GLSL and WGSL.
+     * @param shaderLanguage the shader language to check
+     * @returns true for GLSL and WGSL
+     */
+    isCompatible(shaderLanguage: ShaderLanguage): boolean;
+    /**
+     * Always ready — no textures or async resources to wait on.
+     * @param _defines the defines
+     * @param _scene the scene
+     * @param _engine the engine
+     * @param _subMesh the submesh
+     * @returns true
+     */
+    isReadyForSubMesh(_defines: MaterialDefines, _scene: Scene, _engine: AbstractEngine, _subMesh: SubMesh): boolean;
+    /**
+     * Returns custom shader code to inject GPU picking color output.
+     *
+     * @param shaderType "vertex" or "fragment"
+     * @param shaderLanguage the shader language to use (default: GLSL)
+     * @returns null or a map of injection point names to code strings
+     */
+    getCustomCode(shaderType: string, shaderLanguage?: ShaderLanguage): Nullable<{
+        [pointName: string]: string;
+    }>;
+    private _getCustomCodeGLSL;
+    private _getCustomCodeWGSL;
+    /**
+     * Registers the picking uniforms with the engine.
+     * @returns uniform descriptions
+     */
+    getUniforms(): {
+        ubo?: Array<{
+            name: string;
+            size?: number;
+            type?: string;
+            arraySize?: number;
+        }>;
+        vertex?: string;
+        fragment?: string;
+        externalUniforms?: string[];
+    };
+    /**
+     * Binds the picking color uniform(s) each frame.
+     * @param _uniformBuffer the uniform buffer (unused — we bind directly on the effect)
+     * @param _scene the current scene
+     * @param _engine the current engine
+     * @param subMesh the submesh being rendered
+     */
+    bindForSubMesh(_uniformBuffer: UniformBuffer, _scene: Scene, _engine: AbstractEngine, subMesh: SubMesh): void;
+}

package/Materials/GaussianSplatting/gaussianSplattingGpuPickingMaterialPlugin.js

@@ -0,0 +1,210 @@
+import { MaterialPluginBase } from "../materialPluginBase.js";
+import { RegisterClass } from "../../Misc/typeStore.js";
+import { GaussianSplattingMaxPartCount } from "./gaussianSplattingMaterial.js";
+/**
+ * Plugin for GaussianSplattingMaterial that replaces per-splat color output with
+ * a pre-computed picking color for GPU-based hit testing.
+ *
+ * The picking color is computed on the CPU by encoding a 24-bit picking ID as RGB
+ * (matching the readback decoding in GPUPicker).
+ * @experimental
+ */
+export class GaussianSplattingGpuPickingMaterialPlugin extends MaterialPluginBase {
+    /**
+     * Creates a new GaussianSplattingGpuPickingMaterialPlugin.
+     * @param material The GaussianSplattingMaterial to attach the plugin to.
+     * @param maxPartCount The maximum number of parts supported for compound meshes.
+     */
+    constructor(material, maxPartCount = GaussianSplattingMaxPartCount) {
+        super(material, "GaussianSplatGpuPicking", 200);
+        this._pickingColor = [0, 0, 0];
+        this._isCompound = false;
+        this._partPickingColors = [];
+        this._maxPartCount = maxPartCount;
+        this._enable(true);
+    }
+    /**
+     * Encodes a 24-bit picking ID into normalized RGB components.
+     * @param id The picking ID to encode
+     * @returns A tuple [r, g, b] with values in [0, 1]
+     */
+    static EncodeIdToColor(id) {
+        return [((id >> 16) & 0xff) / 255, ((id >> 8) & 0xff) / 255, (id & 0xff) / 255];
+    }
+    /**
+     * Sets the picking color for a non-compound mesh from a picking ID.
+     * The ID is encoded into an RGB color on the CPU.
+     * @param id The 24-bit picking ID.
+     */
+    set meshId(id) {
+        this._pickingColor = GaussianSplattingGpuPickingMaterialPlugin.EncodeIdToColor(id);
+    }
+    /**
+     * Sets whether this material is for a compound mesh with per-part picking.
+     */
+    set isCompound(value) {
+        this._isCompound = value;
+        this.markAllDefinesAsDirty();
+    }
+    /**
+     * Gets whether this material is for a compound mesh with per-part picking.
+     */
+    get isCompound() {
+        return this._isCompound;
+    }
+    /**
+     * Sets the per-part picking colors from an array of picking IDs.
+     * Each ID is encoded into an RGB color on the CPU.
+     * @param ids Array mapping part index to picking ID.
+     */
+    set partMeshIds(ids) {
+        const colors = [];
+        for (let i = 0; i < this._maxPartCount; i++) {
+            const c = i < ids.length ? GaussianSplattingGpuPickingMaterialPlugin.EncodeIdToColor(ids[i]) : [0, 0, 0];
+            colors.push(c[0], c[1], c[2]);
+        }
+        this._partPickingColors = colors;
+    }
+    /**
+     * @returns the class name
+     */
+    getClassName() {
+        return "GaussianSplattingGpuPickingMaterialPlugin";
+    }
+    /**
+     * Indicates this plugin supports both GLSL and WGSL.
+     * @param shaderLanguage the shader language to check
+     * @returns true for GLSL and WGSL
+     */
+    isCompatible(shaderLanguage) {
+        switch (shaderLanguage) {
+            case 0 /* ShaderLanguage.GLSL */:
+            case 1 /* ShaderLanguage.WGSL */:
+                return true;
+            default:
+                return false;
+        }
+    }
+    /**
+     * Always ready — no textures or async resources to wait on.
+     * @param _defines the defines
+     * @param _scene the scene
+     * @param _engine the engine
+     * @param _subMesh the submesh
+     * @returns true
+     */
+    isReadyForSubMesh(_defines, _scene, _engine, _subMesh) {
+        return true;
+    }
+    /**
+     * Returns custom shader code to inject GPU picking color output.
+     *
+     * @param shaderType "vertex" or "fragment"
+     * @param shaderLanguage the shader language to use (default: GLSL)
+     * @returns null or a map of injection point names to code strings
+     */
+    getCustomCode(shaderType, shaderLanguage = 0 /* ShaderLanguage.GLSL */) {
+        if (shaderLanguage === 1 /* ShaderLanguage.WGSL */) {
+            return this._getCustomCodeWGSL(shaderType);
+        }
+        return this._getCustomCodeGLSL(shaderType);
+    }
+    _getCustomCodeGLSL(shaderType) {
+        if (shaderType === "vertex") {
+            return {
+                CUSTOM_VERTEX_DEFINITIONS: `varying float vPartIndex;`,
+                CUSTOM_VERTEX_UPDATE: `
+#if IS_COMPOUND
+    vPartIndex = float(splat.partIndex);
+#else
+    vPartIndex = 0.0;
+#endif
+                `,
+            };
+        }
+        else if (shaderType === "fragment") {
+            return {
+                CUSTOM_FRAGMENT_DEFINITIONS: `
+varying float vPartIndex;
+#if IS_COMPOUND
+uniform vec3 partPickingColors[${this._maxPartCount}];
+#else
+uniform vec3 pickingColor;
+#endif
+                `,
+                CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR: `
+#if IS_COMPOUND
+    finalColor = vec4(partPickingColors[int(vPartIndex + 0.5)], 1.0);
+#else
+    finalColor = vec4(pickingColor, 1.0);
+#endif
+                `,
+            };
+        }
+        return null;
+    }
+    _getCustomCodeWGSL(shaderType) {
+        if (shaderType === "vertex") {
+            return {
+                CUSTOM_VERTEX_DEFINITIONS: `varying vPartIndex: f32;`,
+                CUSTOM_VERTEX_UPDATE: `
+#if IS_COMPOUND
+    vertexOutputs.vPartIndex = f32(splat.partIndex);
+#else
+    vertexOutputs.vPartIndex = 0.0;
+#endif
+                `,
+            };
+        }
+        else if (shaderType === "fragment") {
+            return {
+                CUSTOM_FRAGMENT_DEFINITIONS: `
+varying vPartIndex: f32;
+#if IS_COMPOUND
+uniform partPickingColors: array<vec3f, ${this._maxPartCount}>;
+#else
+uniform pickingColor: vec3f;
+#endif
+                `,
+                CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR: `
+#if IS_COMPOUND
+    finalColor = vec4f(uniforms.partPickingColors[i32(fragmentInputs.vPartIndex + 0.5)], 1.0);
+#else
+    finalColor = vec4f(uniforms.pickingColor, 1.0);
+#endif
+                `,
+            };
+        }
+        return null;
+    }
+    /**
+     * Registers the picking uniforms with the engine.
+     * @returns uniform descriptions
+     */
+    getUniforms() {
+        return {
+            externalUniforms: ["pickingColor", "partPickingColors"],
+        };
+    }
+    /**
+     * Binds the picking color uniform(s) each frame.
+     * @param _uniformBuffer the uniform buffer (unused — we bind directly on the effect)
+     * @param _scene the current scene
+     * @param _engine the current engine
+     * @param subMesh the submesh being rendered
+     */
+    bindForSubMesh(_uniformBuffer, _scene, _engine, subMesh) {
+        const effect = subMesh.effect;
+        if (!effect) {
+            return;
+        }
+        if (this._isCompound) {
+            effect.setArray3("partPickingColors", this._partPickingColors);
+        }
+        else {
+            effect.setFloat3("pickingColor", this._pickingColor[0], this._pickingColor[1], this._pickingColor[2]);
+        }
+    }
+}
+RegisterClass("BABYLON.GaussianSplattingGpuPickingMaterialPlugin", GaussianSplattingGpuPickingMaterialPlugin);
+//# sourceMappingURL=gaussianSplattingGpuPickingMaterialPlugin.js.map

package/Materials/GaussianSplatting/gaussianSplattingGpuPickingMaterialPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gaussianSplattingGpuPickingMaterialPlugin.js","sourceRoot":"","sources":["../../../../../dev/core/src/Materials/GaussianSplatting/gaussianSplattingGpuPickingMaterialPlugin.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Nullable } from \"../../types\";\r\nimport type { Scene } from \"../../scene\";\r\nimport type { AbstractEngine } from \"../../Engines/abstractEngine\";\r\nimport type { SubMesh } from \"../../Meshes/subMesh\";\r\nimport type { UniformBuffer } from \"../uniformBuffer\";\r\nimport type { MaterialDefines } from \"../materialDefines\";\r\nimport { MaterialPluginBase } from \"../materialPluginBase\";\r\nimport { ShaderLanguage } from \"../shaderLanguage\";\r\nimport { RegisterClass } from \"../../Misc/typeStore\";\r\nimport { GaussianSplattingMaxPartCount } from \"./gaussianSplattingMaterial\";\r\nimport type { GaussianSplattingMaterial } from \"./gaussianSplattingMaterial\";\r\n\r\n/**\r\n * Plugin for GaussianSplattingMaterial that replaces per-splat color output with\r\n * a pre-computed picking color for GPU-based hit testing.\r\n *\r\n * The picking color is computed on the CPU by encoding a 24-bit picking ID as RGB\r\n * (matching the readback decoding in GPUPicker).\r\n * @experimental\r\n */\r\nexport class GaussianSplattingGpuPickingMaterialPlugin extends MaterialPluginBase {\r\n    private _pickingColor: [number, number, number] = [0, 0, 0];\r\n    private _isCompound: boolean = false;\r\n    private _partPickingColors: number[] = [];\r\n    private _maxPartCount: number;\r\n\r\n    /**\r\n     * Creates a new GaussianSplattingGpuPickingMaterialPlugin.\r\n     * @param material The GaussianSplattingMaterial to attach the plugin to.\r\n     * @param maxPartCount The maximum number of parts supported for compound meshes.\r\n     */\r\n    constructor(material: GaussianSplattingMaterial, maxPartCount = GaussianSplattingMaxPartCount) {\r\n        super(material, \"GaussianSplatGpuPicking\", 200);\r\n\r\n        this._maxPartCount = maxPartCount;\r\n        this._enable(true);\r\n    }\r\n\r\n    /**\r\n     * Encodes a 24-bit picking ID into normalized RGB components.\r\n     * @param id The picking ID to encode\r\n     * @returns A tuple [r, g, b] with values in [0, 1]\r\n     */\r\n    public static EncodeIdToColor(id: number): [number, number, number] {\r\n        return [((id >> 16) & 0xff) / 255, ((id >> 8) & 0xff) / 255, (id & 0xff) / 255];\r\n    }\r\n\r\n    /**\r\n     * Sets the picking color for a non-compound mesh from a picking ID.\r\n     * The ID is encoded into an RGB color on the CPU.\r\n     * @param id The 24-bit picking ID.\r\n     */\r\n    public set meshId(id: number) {\r\n        this._pickingColor = GaussianSplattingGpuPickingMaterialPlugin.EncodeIdToColor(id);\r\n    }\r\n\r\n    /**\r\n     * Sets whether this material is for a compound mesh with per-part picking.\r\n     */\r\n    public set isCompound(value: boolean) {\r\n        this._isCompound = value;\r\n        this.markAllDefinesAsDirty();\r\n    }\r\n\r\n    /**\r\n     * Gets whether this material is for a compound mesh with per-part picking.\r\n     */\r\n    public get isCompound(): boolean {\r\n        return this._isCompound;\r\n    }\r\n\r\n    /**\r\n     * Sets the per-part picking colors from an array of picking IDs.\r\n     * Each ID is encoded into an RGB color on the CPU.\r\n     * @param ids Array mapping part index to picking ID.\r\n     */\r\n    public set partMeshIds(ids: number[]) {\r\n        const colors: number[] = [];\r\n        for (let i = 0; i < this._maxPartCount; i++) {\r\n            const c = i < ids.length ? GaussianSplattingGpuPickingMaterialPlugin.EncodeIdToColor(ids[i]) : ([0, 0, 0] as [number, number, number]);\r\n            colors.push(c[0], c[1], c[2]);\r\n        }\r\n        this._partPickingColors = colors;\r\n    }\r\n\r\n    /**\r\n     * @returns the class name\r\n     */\r\n    public override getClassName(): string {\r\n        return \"GaussianSplattingGpuPickingMaterialPlugin\";\r\n    }\r\n\r\n    /**\r\n     * Indicates this plugin supports both GLSL and WGSL.\r\n     * @param shaderLanguage the shader language to check\r\n     * @returns true for GLSL and WGSL\r\n     */\r\n    public override isCompatible(shaderLanguage: ShaderLanguage): boolean {\r\n        switch (shaderLanguage) {\r\n            case ShaderLanguage.GLSL:\r\n            case ShaderLanguage.WGSL:\r\n                return true;\r\n            default:\r\n                return false;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Always ready — no textures or async resources to wait on.\r\n     * @param _defines the defines\r\n     * @param _scene the scene\r\n     * @param _engine the engine\r\n     * @param _subMesh the submesh\r\n     * @returns true\r\n     */\r\n    public override isReadyForSubMesh(_defines: MaterialDefines, _scene: Scene, _engine: AbstractEngine, _subMesh: SubMesh): boolean {\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * Returns custom shader code to inject GPU picking color output.\r\n     *\r\n     * @param shaderType \"vertex\" or \"fragment\"\r\n     * @param shaderLanguage the shader language to use (default: GLSL)\r\n     * @returns null or a map of injection point names to code strings\r\n     */\r\n    public override getCustomCode(shaderType: string, shaderLanguage = ShaderLanguage.GLSL): Nullable<{ [pointName: string]: string }> {\r\n        if (shaderLanguage === ShaderLanguage.WGSL) {\r\n            return this._getCustomCodeWGSL(shaderType);\r\n        }\r\n        return this._getCustomCodeGLSL(shaderType);\r\n    }\r\n\r\n    private _getCustomCodeGLSL(shaderType: string): Nullable<{ [pointName: string]: string }> {\r\n        if (shaderType === \"vertex\") {\r\n            return {\r\n                CUSTOM_VERTEX_DEFINITIONS: `varying float vPartIndex;`,\r\n                CUSTOM_VERTEX_UPDATE: `\r\n#if IS_COMPOUND\r\n    vPartIndex = float(splat.partIndex);\r\n#else\r\n    vPartIndex = 0.0;\r\n#endif\r\n                `,\r\n            };\r\n        } else if (shaderType === \"fragment\") {\r\n            return {\r\n                CUSTOM_FRAGMENT_DEFINITIONS: `\r\nvarying float vPartIndex;\r\n#if IS_COMPOUND\r\nuniform vec3 partPickingColors[${this._maxPartCount}];\r\n#else\r\nuniform vec3 pickingColor;\r\n#endif\r\n                `,\r\n                CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR: `\r\n#if IS_COMPOUND\r\n    finalColor = vec4(partPickingColors[int(vPartIndex + 0.5)], 1.0);\r\n#else\r\n    finalColor = vec4(pickingColor, 1.0);\r\n#endif\r\n                `,\r\n            };\r\n        }\r\n        return null;\r\n    }\r\n\r\n    private _getCustomCodeWGSL(shaderType: string): Nullable<{ [pointName: string]: string }> {\r\n        if (shaderType === \"vertex\") {\r\n            return {\r\n                CUSTOM_VERTEX_DEFINITIONS: `varying vPartIndex: f32;`,\r\n                CUSTOM_VERTEX_UPDATE: `\r\n#if IS_COMPOUND\r\n    vertexOutputs.vPartIndex = f32(splat.partIndex);\r\n#else\r\n    vertexOutputs.vPartIndex = 0.0;\r\n#endif\r\n                `,\r\n            };\r\n        } else if (shaderType === \"fragment\") {\r\n            return {\r\n                CUSTOM_FRAGMENT_DEFINITIONS: `\r\nvarying vPartIndex: f32;\r\n#if IS_COMPOUND\r\nuniform partPickingColors: array<vec3f, ${this._maxPartCount}>;\r\n#else\r\nuniform pickingColor: vec3f;\r\n#endif\r\n                `,\r\n                CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR: `\r\n#if IS_COMPOUND\r\n    finalColor = vec4f(uniforms.partPickingColors[i32(fragmentInputs.vPartIndex + 0.5)], 1.0);\r\n#else\r\n    finalColor = vec4f(uniforms.pickingColor, 1.0);\r\n#endif\r\n                `,\r\n            };\r\n        }\r\n        return null;\r\n    }\r\n\r\n    /**\r\n     * Registers the picking uniforms with the engine.\r\n     * @returns uniform descriptions\r\n     */\r\n    public override getUniforms(): {\r\n        ubo?: Array<{ name: string; size?: number; type?: string; arraySize?: number }>;\r\n        vertex?: string;\r\n        fragment?: string;\r\n        externalUniforms?: string[];\r\n    } {\r\n        return {\r\n            externalUniforms: [\"pickingColor\", \"partPickingColors\"],\r\n        };\r\n    }\r\n\r\n    /**\r\n     * Binds the picking color uniform(s) each frame.\r\n     * @param _uniformBuffer the uniform buffer (unused — we bind directly on the effect)\r\n     * @param _scene the current scene\r\n     * @param _engine the current engine\r\n     * @param subMesh the submesh being rendered\r\n     */\r\n    public override bindForSubMesh(_uniformBuffer: UniformBuffer, _scene: Scene, _engine: AbstractEngine, subMesh: SubMesh): void {\r\n        const effect = subMesh.effect;\r\n        if (!effect) {\r\n            return;\r\n        }\r\n\r\n        if (this._isCompound) {\r\n            effect.setArray3(\"partPickingColors\", this._partPickingColors);\r\n        } else {\r\n            effect.setFloat3(\"pickingColor\", this._pickingColor[0], this._pickingColor[1], this._pickingColor[2]);\r\n        }\r\n    }\r\n}\r\n\r\nRegisterClass(\"BABYLON.GaussianSplattingGpuPickingMaterialPlugin\", GaussianSplattingGpuPickingMaterialPlugin);\r\n"]}

package/Materials/GaussianSplatting/gaussianSplattingMaterial.d.ts

@@ -17,6 +17,7 @@ import "../../Shaders/gaussianSplattingDepth.vertex.js";
 import "../../ShadersWGSL/gaussianSplattingDepth.fragment.js";
 import "../../ShadersWGSL/gaussianSplattingDepth.vertex.js";
 import { ShaderLanguage } from "../shaderLanguage.js";
+export declare const GaussianSplattingMaxPartCount = 256;
 /**
  * GaussianSplattingMaterial material used to render Gaussian Splatting
  * @experimental

package/Materials/GaussianSplatting/gaussianSplattingMaterial.js

@@ -7,6 +7,7 @@ import { AddClipPlaneUniforms, BindClipPlane } from "../clipPlaneMaterialHelper.
 import { Camera } from "../../Cameras/camera.js";
 import { ShadowDepthWrapper } from "../../Materials/shadowDepthWrapper.js";
 import { ShaderMaterial } from "../../Materials/shaderMaterial.js";
+import { Material } from "../material.js";
 import "../../Shaders/gaussianSplatting.fragment.js";
 import "../../Shaders/gaussianSplatting.vertex.js";
 import "../../ShadersWGSL/gaussianSplatting.fragment.js";
@@ -16,15 +17,18 @@ import "../../Shaders/gaussianSplattingDepth.vertex.js";
 import "../../ShadersWGSL/gaussianSplattingDepth.fragment.js";
 import "../../ShadersWGSL/gaussianSplattingDepth.vertex.js";
 import { BindFogParameters, BindLogDepth, PrepareAttributesForInstances, PrepareDefinesForAttributes, PrepareDefinesForFrameBoundValues, PrepareDefinesForMisc, PrepareUniformsAndSamplersList, } from "../materialHelper.functions.js";
+// Can be up to 256, then we'll need to change the partIndices texture format to uint16
+export const GaussianSplattingMaxPartCount = 256;
 /**
  * @internal
  */
 class GaussianSplattingMaterialDefines extends MaterialDefines {
     /**
      * Constructor of the defines.
+     * @param externalProperties External properties (e.g. from material plugins) to add to the defines.
      */
-    constructor() {
-        super();
+    constructor(externalProperties) {
+        super(externalProperties);
         this.FOG = false;
         this.THIN_INSTANCES = true;
         this.LOGARITHMICDEPTH = false;
@@ -37,7 +41,7 @@ class GaussianSplattingMaterialDefines extends MaterialDefines {
         this.SH_DEGREE = 0;
         this.COMPENSATION = false;
         this.IS_COMPOUND = false;
-        this.MAX_PART_COUNT = 16; // Can be up to 256, then we'll need to change the partIndices texture format to uint16
+        this.MAX_PART_COUNT = GaussianSplattingMaxPartCount;
         this.rebuild();
     }
 }
@@ -116,12 +120,21 @@ export class GaussianSplattingMaterial extends PushMaterial {
             }
         }
         if (!subMesh.materialDefines) {
-            defines = subMesh.materialDefines = new GaussianSplattingMaterialDefines();
+            this._callbackPluginEventGeneric(4 /* MaterialPluginEvent.GetDefineNames */, this._eventInfo);
+            defines = subMesh.materialDefines = new GaussianSplattingMaterialDefines(this._eventInfo.defineNames);
         }
         const scene = this.getScene();
         if (this._isReadyForSubMesh(subMesh)) {
             return true;
         }
+        // Check plugin readiness
+        this._eventInfo.isReadyForSubMesh = true;
+        this._eventInfo.defines = defines;
+        this._eventInfo.subMesh = subMesh;
+        this._callbackPluginEventIsReadyForSubMesh(this._eventInfo);
+        if (!this._eventInfo.isReadyForSubMesh) {
+            return false;
+        }
         if (!this._sourceMesh) {
             return false;
         }
@@ -147,23 +160,42 @@ export class GaussianSplattingMaterial extends PushMaterial {
             scene.resetCachedMaterial();
             //Attributes
             PrepareAttributesForInstances(GaussianSplattingMaterial._Attribs, defines);
+            const attribs = GaussianSplattingMaterial._Attribs.slice();
+            const uniforms = GaussianSplattingMaterial._Uniforms.slice();
+            const samplers = GaussianSplattingMaterial._Samplers.slice();
+            const uniformBuffers = GaussianSplattingMaterial._UniformBuffers.slice();
             PrepareUniformsAndSamplersList({
-                uniformsNames: GaussianSplattingMaterial._Uniforms,
-                uniformBuffersNames: GaussianSplattingMaterial._UniformBuffers,
-                samplers: GaussianSplattingMaterial._Samplers,
+                uniformsNames: uniforms,
+                uniformBuffersNames: uniformBuffers,
+                samplers: samplers,
                 defines: defines,
             });
-            AddClipPlaneUniforms(GaussianSplattingMaterial._Uniforms);
+            AddClipPlaneUniforms(uniforms);
+            // Let plugin manager prepare its uniform/sampler/ubo lists
+            if (!this._uniformBufferLayoutBuilt) {
+                this.buildUniformLayout();
+            }
+            // Prepare plugin effect
+            this._eventInfo.fallbackRank = 0;
+            this._eventInfo.defines = defines;
+            this._eventInfo.attributes = attribs;
+            this._eventInfo.uniforms = uniforms;
+            this._eventInfo.samplers = samplers;
+            this._eventInfo.uniformBuffersNames = uniformBuffers;
+            this._eventInfo.customCode = undefined;
+            this._eventInfo.mesh = mesh;
+            this._callbackPluginEventGeneric(128 /* MaterialPluginEvent.PrepareEffect */, this._eventInfo);
             const join = defines.toString();
             const effect = scene.getEngine().createEffect("gaussianSplatting", {
-                attributes: GaussianSplattingMaterial._Attribs,
-                uniformsNames: GaussianSplattingMaterial._Uniforms,
-                uniformBuffersNames: GaussianSplattingMaterial._UniformBuffers,
-                samplers: GaussianSplattingMaterial._Samplers,
+                attributes: attribs,
+                uniformsNames: uniforms,
+                uniformBuffersNames: uniformBuffers,
+                samplers: samplers,
                 defines: join,
                 onCompiled: this.onCompiled,
                 onError: this.onError,
                 indexParameters: {},
+                processCodeAfterIncludes: this._eventInfo.customCode,
                 shaderLanguage: this._shaderLanguage,
                 extraInitializationsAsync: async () => {
                     if (this._shaderLanguage === 1 /* ShaderLanguage.WGSL */) {
@@ -300,6 +332,9 @@ export class GaussianSplattingMaterial extends PushMaterial {
         if (this.useLogarithmicDepth) {
             BindLogDepth(defines, effect, scene);
         }
+        // Bind plugins
+        this._eventInfo.subMesh = subMesh;
+        this._callbackPluginEventBindForSubMesh(this._eventInfo);
         this._afterBind(mesh, this._activeEffect, subMesh);
     }
     static _BindEffectUniforms(gsMesh, gsMaterial, shaderMaterial, scene) {
@@ -383,7 +418,7 @@ export class GaussianSplattingMaterial extends PushMaterial {
         }
         if (compoundMesh) {
             defines.push("#define IS_COMPOUND");
-            defines.push("#define MAX_PART_COUNT 16");
+            defines.push(`#define MAX_PART_COUNT ${GaussianSplattingMaxPartCount}`);
         }
         const shaderMaterial = new ShaderMaterial("gaussianSplattingDepthRender", scene, {
             vertex: "gaussianSplattingDepth",
@@ -431,7 +466,11 @@ export class GaussianSplattingMaterial extends PushMaterial {
      * @returns The cloned material.
      */
     clone(name) {
-        return SerializationHelper.Clone(() => new GaussianSplattingMaterial(name, this.getScene()), this);
+        const clone = SerializationHelper.Clone(() => new GaussianSplattingMaterial(name, this.getScene()), this);
+        clone.id = name;
+        clone.name = name;
+        this._clonePlugins(clone, "");
+        return clone;
     }
     /**
      * Serializes the current material to its JSON representation.
@@ -457,7 +496,9 @@ export class GaussianSplattingMaterial extends PushMaterial {
      * @returns the instantiated GaussianSplattingMaterial.
      */
     static Parse(source, scene, rootUrl) {
-        return SerializationHelper.Parse(() => new GaussianSplattingMaterial(source.name, scene), source, scene, rootUrl);
+        const material = SerializationHelper.Parse(() => new GaussianSplattingMaterial(source.name, scene), source, scene, rootUrl);
+        Material._ParsePlugins(source, material, scene, rootUrl);
+        return material;
     }
 }
 /**