@onerjs/core 9.0.2 → 9.0.3

package/Meshes/Compression/meshoptCompression.js.map

@@ -1 +1 @@
-{"version":3,"file":"meshoptCompression.js","sourceRoot":"","sources":["../../../../../dev/core/src/Meshes/Compression/meshoptCompression.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAM9C,IAAI,eAAe,GAAG,CAAC,CAAC;AACxB,IAAI,aAAa,GAA4C,IAAI,CAAC;AAiBlE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,OAAO,kBAAkB;IAmB3B;;OAEG;IACI,MAAM,KAAK,OAAO;QACrB,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,CAAC;YAC/B,kBAAkB,CAAC,QAAQ,GAAG,IAAI,kBAAkB,EAAE,CAAC;QAC3D,CAAC;QAED,OAAO,kBAAkB,CAAC,QAAQ,CAAC;IACvC,CAAC;IAED;;OAEG;IACH;QACI,MAAM,OAAO,GAAG,kBAAkB,CAAC,aAAa,CAAC,OAAO,CAAC;QAEzD,0CAA0C;QAC1C,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC,sBAAsB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;YAC7E,4DAA4D;YAC5D,OAAO,cAAc,CAAC,KAAK,CAAC;QAChC,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;OAEG;IACI,OAAO;QACV,OAAO,IAAI,CAAC,qBAAqB,CAAC;IACtC,CAAC;IAED;;;;;;;;;OASG;IACI,KAAK,CAAC,qBAAqB,CAAC,MAAkB,EAAE,KAAa,EAAE,MAAc,EAAE,IAA4C,EAAE,MAAe;QAC/I,MAAM,IAAI,CAAC,qBAAsB,CAAC;QAClC,IAAI,eAAe,KAAK,CAAC,EAAE,CAAC;YACxB,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YAC7B,eAAe,GAAG,CAAC,CAAC;QACxB,CAAC;QACD,MAAM,MAAM,GAAG,MAAM,cAAc,CAAC,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;QAC/F,oGAAoG;QACpG,IAAI,aAAa,KAAK,IAAI,EAAE,CAAC;YACzB,YAAY,CAAC,aAAa,CAAC,CAAC;QAChC,CAAC;QACD,aAAa,GAAG,UAAU,CAAC,GAAG,EAAE;YAC5B,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YAC7B,eAAe,GAAG,CAAC,CAAC;YACpB,aAAa,GAAG,IAAI,CAAC;QACzB,CAAC,EAAE,IAAI,CAAC,CAAC;QACT,OAAO,MAAM,CAAC;IAClB,CAAC;;AA1ED;;;;;;;GAOG;AACW,gCAAa,GAAqC;IAC5D,OAAO,EAAE;QACL,GAAG,EAAE,GAAG,KAAK,CAAC,cAAc,qBAAqB;KACpD;CACJ,CAAC;AAEa,2BAAQ,GAAiC,IAAI,CAAC","sourcesContent":["import { Tools } from \"../../Misc/tools.pure\";\r\nimport { type IDisposable } from \"../../scene\";\r\nimport { type Nullable } from \"../../types\";\r\n\r\ndeclare let MeshoptDecoder: any;\r\n\r\nlet NumberOfWorkers = 0;\r\nlet WorkerTimeout: Nullable<ReturnType<typeof setTimeout>> = null;\r\n\r\n/**\r\n * Configuration for meshoptimizer compression\r\n */\r\nexport interface IMeshoptCompressionConfiguration {\r\n    /**\r\n     * Configuration for the decoder.\r\n     */\r\n    decoder: {\r\n        /**\r\n         * The url to the meshopt decoder library.\r\n         */\r\n        url: string;\r\n    };\r\n}\r\n\r\n/**\r\n * Meshopt compression (https://github.com/zeux/meshoptimizer)\r\n *\r\n * This class wraps the meshopt library from https://github.com/zeux/meshoptimizer/tree/master/js.\r\n *\r\n * **Encoder**\r\n *\r\n * The encoder is not currently implemented.\r\n *\r\n * **Decoder**\r\n *\r\n * By default, the configuration points to a copy of the meshopt files on the Babylon.js preview CDN (e.g. https://preview.babylonjs.com/meshopt_decoder.js).\r\n *\r\n * To update the configuration, use the following code:\r\n * ```javascript\r\n *     MeshoptCompression.Configuration = {\r\n *         decoder: {\r\n *             url: \"<url to the meshopt decoder library>\"\r\n *         }\r\n *     };\r\n * ```\r\n */\r\nexport class MeshoptCompression implements IDisposable {\r\n    private _decoderModulePromise?: Promise<any>;\r\n\r\n    /**\r\n     * The configuration. Defaults to the following:\r\n     * ```javascript\r\n     * decoder: {\r\n     *   url: \"https://cdn.babylonjs.com/meshopt_decoder.js\"\r\n     * }\r\n     * ```\r\n     */\r\n    public static Configuration: IMeshoptCompressionConfiguration = {\r\n        decoder: {\r\n            url: `${Tools._DefaultCdnUrl}/meshopt_decoder.js`,\r\n        },\r\n    };\r\n\r\n    private static _Default: Nullable<MeshoptCompression> = null;\r\n\r\n    /**\r\n     * Default instance for the meshoptimizer object.\r\n     */\r\n    public static get Default(): MeshoptCompression {\r\n        if (!MeshoptCompression._Default) {\r\n            MeshoptCompression._Default = new MeshoptCompression();\r\n        }\r\n\r\n        return MeshoptCompression._Default;\r\n    }\r\n\r\n    /**\r\n     * Constructor\r\n     */\r\n    constructor() {\r\n        const decoder = MeshoptCompression.Configuration.decoder;\r\n\r\n        // eslint-disable-next-line github/no-then\r\n        this._decoderModulePromise = Tools.LoadBabylonScriptAsync(decoder.url).then(() => {\r\n            // Wait for WebAssembly compilation before resolving promise\r\n            return MeshoptDecoder.ready;\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Stop all async operations and release resources.\r\n     */\r\n    public dispose(): void {\r\n        delete this._decoderModulePromise;\r\n    }\r\n\r\n    /**\r\n     * Decode meshopt data.\r\n     * @see https://github.com/zeux/meshoptimizer/tree/master/js#decoder\r\n     * @param source The input data.\r\n     * @param count The number of elements.\r\n     * @param stride The stride in bytes.\r\n     * @param mode The compression mode.\r\n     * @param filter The compression filter.\r\n     * @returns a Promise<Uint8Array> that resolves to the decoded data\r\n     */\r\n    public async decodeGltfBufferAsync(source: Uint8Array, count: number, stride: number, mode: \"ATTRIBUTES\" | \"TRIANGLES\" | \"INDICES\", filter?: string): Promise<Uint8Array> {\r\n        await this._decoderModulePromise!;\r\n        if (NumberOfWorkers === 0) {\r\n            MeshoptDecoder.useWorkers(1);\r\n            NumberOfWorkers = 1;\r\n        }\r\n        const result = await MeshoptDecoder.decodeGltfBufferAsync(count, stride, source, mode, filter);\r\n        // a simple debounce to avoid switching back and forth between workers and no workers while decoding\r\n        if (WorkerTimeout !== null) {\r\n            clearTimeout(WorkerTimeout);\r\n        }\r\n        WorkerTimeout = setTimeout(() => {\r\n            MeshoptDecoder.useWorkers(0);\r\n            NumberOfWorkers = 0;\r\n            WorkerTimeout = null;\r\n        }, 1000);\r\n        return result;\r\n    }\r\n}\r\n"]}
+{"version":3,"file":"meshoptCompression.js","sourceRoot":"","sources":["../../../../../dev/core/src/Meshes/Compression/meshoptCompression.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAS9C,IAAI,eAAe,GAAG,CAAC,CAAC;AACxB,IAAI,aAAa,GAA4C,IAAI,CAAC;AAiBlE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,OAAO,kBAAkB;IAoB3B;;OAEG;IACI,MAAM,KAAK,OAAO;QACrB,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,CAAC;YAC/B,kBAAkB,CAAC,QAAQ,GAAG,IAAI,kBAAkB,EAAE,CAAC;QAC3D,CAAC;QAED,OAAO,kBAAkB,CAAC,QAAQ,CAAC;IACvC,CAAC;IAED;;OAEG;IACH;QAhCiB,sBAAiB,GAAY,OAAO,OAAO,KAAK,WAAW,IAAI,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC;QAiCpG,sEAAsE;QACtE,oEAAoE;QACpE,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACzB,OAAO;QACX,CAAC;QAED,MAAM,OAAO,GAAG,kBAAkB,CAAC,aAAa,CAAC,OAAO,CAAC;QAEzD,0CAA0C;QAC1C,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC,sBAAsB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;YAC7E,4DAA4D;YAC5D,OAAO,cAAc,CAAC,KAAK,CAAC;QAChC,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;OAEG;IACI,OAAO;QACV,OAAO,IAAI,CAAC,qBAAqB,CAAC;IACtC,CAAC;IAED;;;;;;;;;OASG;IACI,KAAK,CAAC,qBAAqB,CAAC,MAAkB,EAAE,KAAa,EAAE,MAAc,EAAE,IAA4C,EAAE,MAAe;QAC/I,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACzB,OAAO,OAAO,CAAC,aAAc,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;QACvE,CAAC;QACD,MAAM,IAAI,CAAC,qBAAsB,CAAC;QAClC,IAAI,eAAe,KAAK,CAAC,EAAE,CAAC;YACxB,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YAC7B,eAAe,GAAG,CAAC,CAAC;QACxB,CAAC;QACD,MAAM,MAAM,GAAG,MAAM,cAAc,CAAC,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;QAC/F,oGAAoG;QACpG,IAAI,aAAa,KAAK,IAAI,EAAE,CAAC;YACzB,YAAY,CAAC,aAAa,CAAC,CAAC;QAChC,CAAC;QACD,aAAa,GAAG,UAAU,CAAC,GAAG,EAAE;YAC5B,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YAC7B,eAAe,GAAG,CAAC,CAAC;YACpB,aAAa,GAAG,IAAI,CAAC;QACzB,CAAC,EAAE,IAAI,CAAC,CAAC;QACT,OAAO,MAAM,CAAC;IAClB,CAAC;;AAnFD;;;;;;;GAOG;AACW,gCAAa,GAAqC;IAC5D,OAAO,EAAE;QACL,GAAG,EAAE,GAAG,KAAK,CAAC,cAAc,qBAAqB;KACpD;CACJ,AAJ0B,CAIzB;AAEa,2BAAQ,GAAiC,IAAI,AAArC,CAAsC","sourcesContent":["import { Tools } from \"../../Misc/tools.pure\";\r\nimport { type IDisposable } from \"../../scene\";\r\nimport { type Nullable } from \"../../types\";\r\nimport { type INative } from \"../../Engines/Native/nativeInterfaces\";\r\n\r\ndeclare let MeshoptDecoder: any;\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\ndeclare const _native: INative;\r\n\r\nlet NumberOfWorkers = 0;\r\nlet WorkerTimeout: Nullable<ReturnType<typeof setTimeout>> = null;\r\n\r\n/**\r\n * Configuration for meshoptimizer compression\r\n */\r\nexport interface IMeshoptCompressionConfiguration {\r\n    /**\r\n     * Configuration for the decoder.\r\n     */\r\n    decoder: {\r\n        /**\r\n         * The url to the meshopt decoder library.\r\n         */\r\n        url: string;\r\n    };\r\n}\r\n\r\n/**\r\n * Meshopt compression (https://github.com/zeux/meshoptimizer)\r\n *\r\n * This class wraps the meshopt library from https://github.com/zeux/meshoptimizer/tree/master/js.\r\n *\r\n * **Encoder**\r\n *\r\n * The encoder is not currently implemented.\r\n *\r\n * **Decoder**\r\n *\r\n * By default, the configuration points to a copy of the meshopt files on the Babylon.js preview CDN (e.g. https://preview.babylonjs.com/meshopt_decoder.js).\r\n *\r\n * To update the configuration, use the following code:\r\n * ```javascript\r\n *     MeshoptCompression.Configuration = {\r\n *         decoder: {\r\n *             url: \"<url to the meshopt decoder library>\"\r\n *         }\r\n *     };\r\n * ```\r\n */\r\nexport class MeshoptCompression implements IDisposable {\r\n    private _decoderModulePromise?: Promise<any>;\r\n    private readonly _useNativeDecoder: boolean = typeof _native !== \"undefined\" && !!_native.decodeMeshopt;\r\n\r\n    /**\r\n     * The configuration. Defaults to the following:\r\n     * ```javascript\r\n     * decoder: {\r\n     *   url: \"https://cdn.babylonjs.com/meshopt_decoder.js\"\r\n     * }\r\n     * ```\r\n     */\r\n    public static Configuration: IMeshoptCompressionConfiguration = {\r\n        decoder: {\r\n            url: `${Tools._DefaultCdnUrl}/meshopt_decoder.js`,\r\n        },\r\n    };\r\n\r\n    private static _Default: Nullable<MeshoptCompression> = null;\r\n\r\n    /**\r\n     * Default instance for the meshoptimizer object.\r\n     */\r\n    public static get Default(): MeshoptCompression {\r\n        if (!MeshoptCompression._Default) {\r\n            MeshoptCompression._Default = new MeshoptCompression();\r\n        }\r\n\r\n        return MeshoptCompression._Default;\r\n    }\r\n\r\n    /**\r\n     * Constructor\r\n     */\r\n    constructor() {\r\n        // When the native meshopt decoder is available (Babylon Native), skip\r\n        // loading the WebAssembly module entirely and decode synchronously.\r\n        if (this._useNativeDecoder) {\r\n            return;\r\n        }\r\n\r\n        const decoder = MeshoptCompression.Configuration.decoder;\r\n\r\n        // eslint-disable-next-line github/no-then\r\n        this._decoderModulePromise = Tools.LoadBabylonScriptAsync(decoder.url).then(() => {\r\n            // Wait for WebAssembly compilation before resolving promise\r\n            return MeshoptDecoder.ready;\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Stop all async operations and release resources.\r\n     */\r\n    public dispose(): void {\r\n        delete this._decoderModulePromise;\r\n    }\r\n\r\n    /**\r\n     * Decode meshopt data.\r\n     * @see https://github.com/zeux/meshoptimizer/tree/master/js#decoder\r\n     * @param source The input data.\r\n     * @param count The number of elements.\r\n     * @param stride The stride in bytes.\r\n     * @param mode The compression mode.\r\n     * @param filter The compression filter.\r\n     * @returns a Promise<Uint8Array> that resolves to the decoded data\r\n     */\r\n    public async decodeGltfBufferAsync(source: Uint8Array, count: number, stride: number, mode: \"ATTRIBUTES\" | \"TRIANGLES\" | \"INDICES\", filter?: string): Promise<Uint8Array> {\r\n        if (this._useNativeDecoder) {\r\n            return _native.decodeMeshopt!(source, count, stride, mode, filter);\r\n        }\r\n        await this._decoderModulePromise!;\r\n        if (NumberOfWorkers === 0) {\r\n            MeshoptDecoder.useWorkers(1);\r\n            NumberOfWorkers = 1;\r\n        }\r\n        const result = await MeshoptDecoder.decodeGltfBufferAsync(count, stride, source, mode, filter);\r\n        // a simple debounce to avoid switching back and forth between workers and no workers while decoding\r\n        if (WorkerTimeout !== null) {\r\n            clearTimeout(WorkerTimeout);\r\n        }\r\n        WorkerTimeout = setTimeout(() => {\r\n            MeshoptDecoder.useWorkers(0);\r\n            NumberOfWorkers = 0;\r\n            WorkerTimeout = null;\r\n        }, 1000);\r\n        return result;\r\n    }\r\n}\r\n"]}

package/Meshes/GaussianSplatting/gaussianSplattingGpuSorter.d.ts

@@ -0,0 +1,415 @@
+import { type Nullable } from "../../types.js";
+import { type AbstractEngine } from "../../Engines/abstractEngine.pure.js";
+import { type WebGPUEngine } from "../../Engines/webgpuEngine.pure.js";
+import { type Matrix } from "../../Maths/math.vector.pure.js";
+import { type BaseTexture } from "../../Materials/Textures/baseTexture.pure.js";
+import { ComputeShader } from "../../Compute/computeShader.pure.js";
+import { StorageBuffer } from "../../Buffers/storageBuffer.js";
+import { type VertexBuffer } from "../../Buffers/buffer.pure.js";
+/**
+ * Anything exposing a Babylon.js column-major 4x4 matrix array (a Matrix, for instance).
+ */
+export type GaussianSplattingGpuSortMatrix = Pick<Matrix, "m">;
+/**
+ * Inputs describing the splat data the GPU sorter reads. The sorter only reads textures: it never owns them.
+ */
+export interface IGaussianSplattingGpuSortSource {
+    /**
+     * Number of splats in the mesh (the value used as the "empty splat" index padding the sorted output).
+     */
+    vertexCount: number;
+    /**
+     * Width in texels of the data textures (splat index i lives at texel (i % width, floor(i / width))).
+     */
+    textureWidth: number;
+    /**
+     * RGBA32F texture whose xyz hold the splat centers. For SOG data, the RGBA8 "means low" texture.
+     */
+    centersTexture: BaseTexture;
+    /**
+     * SOG (quantized means) inputs. When set, centers are decoded like the Gaussian Splatting vertex shader does.
+     */
+    sog?: {
+        /**
+         * RGBA8 "means high" texture.
+         */
+        meansHighTexture: BaseTexture;
+        /**
+         * Quantization range minimum (xyz) of the log-encoded means.
+         */
+        meansMin: ArrayLike<number>;
+        /**
+         * Quantization range maximum (xyz) of the log-encoded means.
+         */
+        meansMax: ArrayLike<number>;
+    };
+    /**
+     * Compound meshes: R8 texture (same layout as the centers) holding each splat's part index. Used together with {@link GaussianSplattingGpuSorter.setPartMatrices}.
+     */
+    partIndicesTexture?: BaseTexture;
+    /**
+     * Optional local-space bounding box minimum of the splat centers, used to derive the depth range when none is given to {@link GaussianSplattingGpuSorter.sort}.
+     * Not needed for SOG data (derived from the means range).
+     */
+    boundsMin?: ArrayLike<number>;
+    /**
+     * Optional local-space bounding box maximum of the splat centers.
+     */
+    boundsMax?: ArrayLike<number>;
+}
+/**
+ * Options of {@link GaussianSplattingGpuSorter.sort}.
+ */
+export interface IGaussianSplattingGpuSortOptions {
+    /**
+     * Whether the scene is right-handed. Matches the CPU sort worker: the depth is negated so larger always means farther.
+     */
+    rightHanded?: boolean;
+    /**
+     * World position of the camera. When omitted, the translation of the view matrix is used, which is equivalent.
+     */
+    cameraPosition?: ArrayLike<number>;
+    /**
+     * Depth interval covering every active splat, in the sign-adjusted depth space (larger = farther). The 2^keyBits sort keys span this interval,
+     * so a tight interval improves the precision. When omitted, it is derived from the source bounds.
+     */
+    depthRange?: {
+        min: number;
+        max: number;
+    };
+}
+/**
+ * Number of keys bits clamped to the supported range.
+ * @param keyBits requested number of sort key bits
+ * @returns the clamped, integral number of key bits
+ * @internal
+ */
+export declare function _ClampGpuSortKeyBits(keyBits: number): number;
+/**
+ * Number of radix passes needed to sort keys of a given size.
+ * @param keyBits number of bits of the sort keys
+ * @returns the number of 4-bit radix passes
+ * @internal
+ */
+export declare function _GetGpuSortPassCount(keyBits: number): number;
+/**
+ * Count of output slots: the active count rounded up to a multiple of 16 (16 splats per instance), at least 16.
+ * @param activeCount number of splats to render
+ * @returns the padded count
+ * @internal
+ */
+export declare function _GetGpuSortPaddedCount(activeCount: number): number;
+/**
+ * Packs flat `[start0, count0, start1, count1, ...]` splat intervals for the key shader. Each GPU entry is `(exclusive prefix of the counts, start)`.
+ * Empty intervals are dropped and intervals are clamped to `[0, vertexCount)`.
+ * @param intervals flat source-splat intervals (start, count pairs)
+ * @param vertexCount number of splats in the mesh
+ * @returns the packed entries, the number of entries and the total number of active splats
+ * @internal
+ */
+export declare function _PackGpuSortIntervals(intervals: ArrayLike<number>, vertexCount: number): {
+    data: Uint32Array;
+    count: number;
+    total: number;
+};
+/**
+ * Computes the coefficients of the depth of a splat center: `depth = dot(coef.xyz, center) + coef.w`, in the same space and sign convention as the CPU sort worker
+ * (the signed distance along the camera forward axis, negated in right-handed scenes, so a larger value is farther).
+ * @param world world matrix (array of 16 numbers) transforming the splat center
+ * @param view view matrix (array of 16 numbers)
+ * @param depthSign 1 for left-handed scenes, -1 for right-handed scenes
+ * @param cameraPosition world camera position, or null to use the view matrix translation
+ * @param out receives the 4 coefficients
+ * @param offset index of the first coefficient in out
+ * @param worldOffset index of the first element of the world matrix in world (defaults to 0), so a matrix can be read from a flat array without creating a view
+ * @internal
+ */
+export declare function _ComputeGpuSortDepthCoefficients(world: ArrayLike<number>, view: ArrayLike<number>, depthSign: number, cameraPosition: Nullable<ArrayLike<number>>, out: Float32Array, offset: number, worldOffset?: number): void;
+/**
+ * Computes the interval of depths reached by the points of a box, for one or several sets of depth coefficients.
+ * @param coefficients depth coefficients (4 per set)
+ * @param setCount number of coefficient sets
+ * @param boundsMin box minimum (xyz)
+ * @param boundsMax box maximum (xyz)
+ * @param result optional object receiving the interval, to avoid an allocation when called every frame
+ * @returns the min and max depths (the result object when provided)
+ * @internal
+ */
+export declare function _ComputeGpuSortDepthRange(coefficients: ArrayLike<number>, setCount: number, boundsMin: ArrayLike<number>, boundsMax: ArrayLike<number>, result?: {
+    min: number;
+    max: number;
+}): {
+    min: number;
+    max: number;
+};
+/**
+ * Scale converting a depth distance to a sort key: `key = (depthMax - depth) * scale`, so the farthest splat gets key 0 (sorted first).
+ * @param depthMin smallest depth
+ * @param depthMax largest depth
+ * @param keyBits number of bits of the sort keys
+ * @returns the scale, 0 when the depth range is degenerate (all keys are 0, like the CPU worker)
+ * @internal
+ */
+export declare function _ComputeGpuSortKeyScale(depthMin: number, depthMax: number, keyBits: number): number;
+/**
+ * Inverse of the SOG means log-transform, applied to a quantization range bound.
+ * @param value log-encoded value
+ * @returns the decoded value
+ * @internal
+ */
+export declare function _DecodeGpuSortSogMean(value: number): number;
+/**
+ * Gets the number of splats a GPU sorter can handle on an engine: limited by the maximum storage buffer binding size (4 bytes per splat),
+ * and by 2^24 so that source indices are exactly representable as float32 in the instanced vertex buffer.
+ * @param engine the engine
+ * @returns the maximum number of splats (a multiple of 16)
+ */
+export declare function GetGaussianSplattingGpuSorterMaxSplatCount(engine: AbstractEngine): number;
+/**
+ * Per-view GPU buffer receiving a sorted splat index list. It can be bound as the four instanced `splatIndex0` ... `splatIndex3` vertex attributes
+ * of the Gaussian Splatting vertex shader (16 splats per instance), in place of the CPU-uploaded index buffer.
+ *
+ * Create it with {@link GaussianSplattingGpuSorter.createOutput}. After each successful sort, if {@link buffersVersion} changed,
+ * the vertex buffers were recreated (the output grew) and must be bound again.
+ */
+export declare class GaussianSplattingGpuSortOutput {
+    private _engine;
+    private _label;
+    private _storageBuffer;
+    private _vertexBuffers;
+    private _wrapper;
+    private _capacity;
+    private _buffersVersion;
+    /** @internal */
+    _sortedPaddedCount: number;
+    /** @internal */
+    _paramsBuffer: StorageBuffer;
+    /** @internal */
+    _coefsBuffer: Nullable<StorageBuffer>;
+    /** @internal */
+    _coefsCapacity: number;
+    /** @internal */
+    _keysCs: Nullable<ComputeShader>;
+    /** @internal */
+    _keysCsSog: boolean;
+    /** @internal */
+    _keysCsCompound: boolean;
+    /** @internal Texture views used by the keys context, which may change without replacing their BaseTexture objects. */
+    _keysCsCentersView: Nullable<GPUTextureView>;
+    /** @internal */
+    _keysCsMeansHighView: Nullable<GPUTextureView>;
+    /** @internal */
+    _keysCsPartIndicesView: Nullable<GPUTextureView>;
+    /** @internal */
+    _outputCs: ComputeShader;
+    /** @internal Sorter binding version the compute shaders of this output were last bound with. */
+    _boundSorterVersion: number;
+    /** @internal Buffers version of the output storage buffer the output shader was last bound with. */
+    _boundBuffersVersion: number;
+    /** @internal */
+    _boundCoefsBuffer: Nullable<StorageBuffer>;
+    /** @internal */
+    _boundKeysCs: Nullable<ComputeShader>;
+    /** @internal */
+    _lastSortError: boolean;
+    /** @internal */
+    _onDisposed: Nullable<() => void>;
+    private _disposed;
+    /**
+     * @param engine the WebGPU engine
+     * @param label debug label
+     * @internal
+     */
+    constructor(engine: WebGPUEngine, label: string);
+    /**
+     * The buffer holding the sorted splat indices as float32 (back-to-front), padded to a multiple of 16 with the empty splat index.
+     */
+    get buffer(): Nullable<StorageBuffer>;
+    /**
+     * The 4 instanced vertex buffers `splatIndex0` ... `splatIndex3` (vec4 each, stride 16 floats) viewing {@link buffer}.
+     */
+    get vertexBuffers(): readonly VertexBuffer[];
+    /**
+     * Number of output slots written by the last successful sort: a multiple of 16 (0 before the first successful sort).
+     */
+    get paddedCount(): number;
+    /**
+     * Number of instances to draw (16 splats per instance) after the last successful sort.
+     */
+    get instanceCount(): number;
+    /**
+     * Incremented each time the underlying buffer and vertex buffers are recreated.
+     */
+    get buffersVersion(): number;
+    /**
+     * Creates (or grows) the GPU buffer so it can hold the given number of slots.
+     * @param paddedCount number of slots
+     * @param maxCapacity maximum capacity allowed by the device limits
+     * @internal
+     */
+    _ensureCapacity(paddedCount: number, maxCapacity: number): void;
+    /**
+     * Releases the GPU resources.
+     */
+    dispose(): void;
+    private _releaseBuffers;
+}
+/**
+ * WebGPU compute depth sorter for Gaussian Splatting. It reproduces the ordering of the CPU sort worker (back-to-front counting sort) entirely on the GPU,
+ * and writes the sorted splat indices in a vertex buffer ready to be used as the instanced `splatIndex` attributes ({@link GaussianSplattingGpuSortOutput}).
+ *
+ * Pipeline of a sort (all dispatches are enqueued on the engine's command encoder, without any CPU readback):
+ *   1. keys: for each active splat, compute the view depth and quantize it to a `keyBits`-bit key (farthest = smallest). Supports splat intervals,
+ *      compound parts (per-part matrices) and SOG decoded means.
+ *   2. a stable LSD radix sort with 4-bit digits, `ceil(keyBits / 4)` passes of count, scan (2 levels) and scatter. No subgroup operation is required.
+ *   3. output: writes the sorted indices as float32, padding to a multiple of 16 with `vertexCount`.
+ *
+ * Usage constraints:
+ * - {@link sort} ends the current render pass: call it outside of any render pass (e.g. in `onBeforeRenderObservable` / `onBeforeCameraRenderObservable`).
+ * - Uniform-like data is written with queue writes, which take effect before the whole frame's commands. So call {@link sort} at most once per output and per frame, and do not
+ *   change the source, the intervals or the part matrices between two sorts of the same frame.
+ * - If the textures given to {@link setSource} are recreated, call {@link setSource} again.
+ * - The compute shaders and the WebGPU compute engine extension are loaded by {@link GaussianSplattingGpuSorter.LoadDependenciesAsync}: await it before the first {@link sort}.
+ * Until it has completed, {@link sort} returns false without enqueuing anything.
+ * @experimental
+ */
+export declare class GaussianSplattingGpuSorter {
+    private static _DependenciesReady;
+    private static _DependenciesPromise;
+    private readonly _engine;
+    private readonly _name;
+    private readonly _keyBits;
+    private readonly _passCount;
+    private readonly _maxSplatCount;
+    private readonly _maxIntervalCount;
+    private _vertexCount;
+    private _textureWidth;
+    private _centersTexture;
+    private _meansHighTexture;
+    private _partIndicesTexture;
+    private readonly _meansMin;
+    private readonly _meansMax;
+    private _boundsMin;
+    private _boundsMax;
+    private _partMatrices;
+    private _partCount;
+    private _rawIntervals;
+    private _packedIntervals;
+    private _intervalCount;
+    private _intervalsDirty;
+    private _intervalsValid;
+    private _activeCount;
+    private _bindingsVersion;
+    private _sortShadersBoundVersion;
+    private _capacity;
+    private _keysA;
+    private _keysB;
+    private _valsA;
+    private _valsB;
+    private _sumTable;
+    private _intervalsBuffer;
+    private _intervalsCapacity;
+    private readonly _chunkSums;
+    private readonly _passParams;
+    private _passParamsActiveCount;
+    private readonly _passData;
+    private readonly _countCs;
+    private readonly _scatterCs;
+    private readonly _scanLocalCs;
+    private readonly _scanSumsCs;
+    private readonly _paramsData;
+    private readonly _paramsU32;
+    private readonly _paramsF32;
+    private _coefs;
+    private readonly _depthRange;
+    private readonly _outputs;
+    private _disposed;
+    /**
+     * Whether GPU sorting is available on an engine: a WebGPU engine with compute shader support.
+     * @param engine the engine
+     * @returns true if a {@link GaussianSplattingGpuSorter} can be created
+     */
+    static IsSupported(engine: AbstractEngine): boolean;
+    /**
+     * Gets the maximum number of splats the sorter can sort on an engine.
+     * @param engine the engine
+     * @returns the maximum splat count
+     */
+    static GetMaxSupportedSplatCount(engine: AbstractEngine): number;
+    /**
+     * Registers the WebGPU compute engine extension and loads the compute shaders of the sorter. The result is cached: calling it again returns the same promise.
+     * It must have completed before the first {@link sort} (which returns false until then). If loading fails, the promise rejects and the next call retries.
+     * @returns a promise resolved when the dependencies are ready
+     */
+    static LoadDependenciesAsync(): Promise<void>;
+    /**
+     * Creates a GPU sorter. Shaders are compiled asynchronously: {@link sort} returns false until they are ready.
+     * Await {@link GaussianSplattingGpuSorter.LoadDependenciesAsync} before the first {@link sort}.
+     * @param engine the WebGPU engine
+     * @param name debug name
+     * @param keyBits number of bits of the depth sort keys (8 to 24, default 16). Each 4 bits cost one radix pass; 16 bits is enough for most scenes.
+     */
+    constructor(engine: AbstractEngine, name?: string, keyBits?: number);
+    /**
+     * Number of splats rendered after applying the intervals (the number of keys sorted).
+     */
+    get activeCount(): number;
+    /**
+     * Number of output slots (activeCount rounded up to a multiple of 16).
+     */
+    get paddedCount(): number;
+    /**
+     * Number of bits of the depth sort keys.
+     */
+    get keyBits(): number;
+    /**
+     * Sets the splat data to sort.
+     * @param source the source textures and layout
+     * @returns false (and logs an error) if the source or active interval count exceeds {@link GaussianSplattingGpuSorter.GetMaxSupportedSplatCount}
+     */
+    setSource(source: IGaussianSplattingGpuSortSource): boolean;
+    /**
+     * Sets the transform of each part of a compound mesh. Used instead of the world matrix given to {@link sort} when a part indices texture was set in {@link setSource}.
+     * The matrices are copied: call this again when they change.
+     * @param matrices one matrix per part, or a flat array of 16 floats per part, or null for a non-compound mesh
+     */
+    setPartMatrices(matrices: Nullable<ReadonlyArray<GaussianSplattingGpuSortMatrix> | ArrayLike<number>>): void;
+    /**
+     * Restricts the sort to ranges of source splats, like the CPU worker's `intervals` message.
+     * @param intervals flat `[start0, count0, start1, count1, ...]` (start, COUNT pairs), or null to sort every splat
+     * @returns false (and logs an error) if the packed intervals or padded active count exceed the scan or device storage-buffer limits.
+     * Overlapping intervals count each occurrence. Sorting is disabled until valid intervals or a valid source are set.
+     */
+    setIntervals(intervals: Nullable<ArrayLike<number>>): boolean;
+    /**
+     * Creates an output receiving the sorted indices of one view. Use one output per camera that is sorted independently.
+     * @returns the new output
+     */
+    createOutput(): GaussianSplattingGpuSortOutput;
+    /**
+     * Enqueues the sort of the active splats for a view. Call it outside of any render pass, once per output and per frame.
+     * @param output the output receiving the sorted indices
+     * @param worldMatrix world matrix of the mesh (ignored for compound meshes, which use the part matrices)
+     * @param viewMatrix view matrix of the camera
+     * @param options handedness, camera position and depth range
+     * @returns false if nothing was enqueued (unsupported active intervals, shaders still compiling, no source, or no depth range), true otherwise
+     */
+    sort(output: GaussianSplattingGpuSortOutput, worldMatrix: GaussianSplattingGpuSortMatrix, viewMatrix: GaussianSplattingGpuSortMatrix, options?: IGaussianSplattingGpuSortOptions): boolean;
+    /**
+     * Releases all the GPU resources, including the outputs created by {@link createOutput}.
+     */
+    dispose(): void;
+    private _refreshIntervals;
+    private _releaseSortBuffers;
+    private _ensureCapacity;
+    private _ensureIntervalsBuffer;
+    private _ensureCoefsBuffer;
+    private _getKeysComputeShader;
+    private _bindResources;
+    private _bindSortShaders;
+    private _isReady;
+    private _writeParams;
+    private _writeIntervals;
+    private _writePassParams;
+    private _dispatchSort;
+}