@babylonjs/core 7.11.4 → 7.13.0

package/Engines/webgpuEngine.d.ts

@@ -1032,6 +1032,7 @@ export declare class WebGPUEngine extends AbstractEngine {
      * @param byteLength the byte length of the data
      */
     updateStorageBuffer(buffer: DataBuffer, data: DataArray, byteOffset?: number, byteLength?: number): void;
+    private _readFromGPUBuffer;
     /**
      * Read data from a storage buffer
      * @param storageBuffer The storage buffer to read from
@@ -1042,6 +1043,16 @@ export declare class WebGPUEngine extends AbstractEngine {
      * @returns If not undefined, returns the (promise) buffer (as provided by the 4th parameter) filled with the data, else it returns a (promise) Uint8Array with the data read from the storage buffer
      */
     readFromStorageBuffer(storageBuffer: DataBuffer, offset?: number, size?: number, buffer?: ArrayBufferView, noDelay?: boolean): Promise<ArrayBufferView>;
+    /**
+     * Read data from multiple storage buffers
+     * @param storageBuffers The list of storage buffers to read from
+     * @param offset The offset in the storage buffer to start reading from (default: 0). This is the same offset for all storage buffers!
+     * @param size  The number of bytes to read from each storage buffer (default: capacity of the first buffer)
+     * @param buffer The buffer to write the data we have read from the storage buffers to (optional). If provided, the buffer should be large enough to hold the data from all storage buffers!
+     * @param noDelay If true, a call to flushFramebuffer will be issued so that the data can be read back immediately and not in engine.onEndFrameObservable. This can speed up data retrieval, at the cost of a small perf penalty (default: false).
+     * @returns If not undefined, returns the (promise) buffer (as provided by the 4th parameter) filled with the data, else it returns a (promise) Uint8Array with the data read from the storage buffer
+     */
+    readFromMultipleStorageBuffers(storageBuffers: DataBuffer[], offset?: number, size?: number, buffer?: ArrayBufferView, noDelay?: boolean): Promise<ArrayBufferView>;
     /**
      * Sets a storage buffer in the shader
      * @param name Defines the name of the storage buffer as defined in the shader

package/Engines/webgpuEngine.js

@@ -2,7 +2,7 @@
 import { Logger } from "../Misc/logger.js";
 import { Color4 } from "../Maths/math.js";
 import { Engine } from "../Engines/engine.js";
-import { InternalTexture, InternalTextureSource } from "../Materials/Textures/internalTexture.js";
+import { InternalTexture } from "../Materials/Textures/internalTexture.js";
 import { Effect } from "../Materials/effect.js";
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -33,7 +33,6 @@ import { WebGPUOcclusionQuery } from "./WebGPU/webgpuOcclusionQuery.js";
 import { ShaderCodeInliner } from "./Processors/shaderCodeInliner.js";
 import { WebGPUTintWASM } from "./WebGPU/webgpuTintWASM.js";
 import { WebGPUShaderProcessor } from "./WebGPU/webgpuShaderProcessor.js";
-import { ShaderLanguage } from "../Materials/shaderLanguage.js";
 import { WebGPUSnapshotRendering } from "./WebGPU/webgpuSnapshotRendering.js";
 import "../Buffers/buffer.align.js";
 import "../ShadersWGSL/postprocess.vertex.js";
@@ -52,14 +51,14 @@ import { resetCachedPipeline } from "../Materials/effect.functions.js";
 import { WebGPUExternalTexture } from "./WebGPU/webgpuExternalTexture.js";
 const viewDescriptorSwapChainAntialiasing = {
     label: `TextureView_SwapChain_ResolveTarget`,
-    dimension: WebGPUConstants.TextureDimension.E2d,
+    dimension: "2d" /* WebGPUConstants.TextureDimension.E2d */,
     format: undefined,
     mipLevelCount: 1,
     arrayLayerCount: 1,
 };
 const viewDescriptorSwapChain = {
     label: `TextureView_SwapChain`,
-    dimension: WebGPUConstants.TextureDimension.E2d,
+    dimension: "2d" /* WebGPUConstants.TextureDimension.E2d */,
     format: undefined,
     mipLevelCount: 1,
     arrayLayerCount: 1,
@@ -568,21 +567,21 @@ export class WebGPUEngine extends AbstractEngine {
             maxFragmentUniformVectors: Math.floor(this._deviceLimits.maxUniformBufferBindingSize / 4),
             maxVertexUniformVectors: Math.floor(this._deviceLimits.maxUniformBufferBindingSize / 4),
             standardDerivatives: true,
-            astc: (this._deviceEnabledExtensions.indexOf(WebGPUConstants.FeatureName.TextureCompressionASTC) >= 0 ? true : undefined),
-            s3tc: (this._deviceEnabledExtensions.indexOf(WebGPUConstants.FeatureName.TextureCompressionBC) >= 0 ? true : undefined),
+            astc: (this._deviceEnabledExtensions.indexOf("texture-compression-astc" /* WebGPUConstants.FeatureName.TextureCompressionASTC */) >= 0 ? true : undefined),
+            s3tc: (this._deviceEnabledExtensions.indexOf("texture-compression-bc" /* WebGPUConstants.FeatureName.TextureCompressionBC */) >= 0 ? true : undefined),
             pvrtc: null,
             etc1: null,
-            etc2: (this._deviceEnabledExtensions.indexOf(WebGPUConstants.FeatureName.TextureCompressionETC2) >= 0 ? true : undefined),
-            bptc: this._deviceEnabledExtensions.indexOf(WebGPUConstants.FeatureName.TextureCompressionBC) >= 0 ? true : undefined,
+            etc2: (this._deviceEnabledExtensions.indexOf("texture-compression-etc2" /* WebGPUConstants.FeatureName.TextureCompressionETC2 */) >= 0 ? true : undefined),
+            bptc: this._deviceEnabledExtensions.indexOf("texture-compression-bc" /* WebGPUConstants.FeatureName.TextureCompressionBC */) >= 0 ? true : undefined,
             maxAnisotropy: 16,
             uintIndices: true,
             fragmentDepthSupported: true,
             highPrecisionShaderSupported: true,
             colorBufferFloat: true,
             supportFloatTexturesResolve: false,
-            rg11b10ufColorRenderable: this._deviceEnabledExtensions.indexOf(WebGPUConstants.FeatureName.RG11B10UFloatRenderable) >= 0,
+            rg11b10ufColorRenderable: this._deviceEnabledExtensions.indexOf("rg11b10ufloat-renderable" /* WebGPUConstants.FeatureName.RG11B10UFloatRenderable */) >= 0,
             textureFloat: true,
-            textureFloatLinearFiltering: this._deviceEnabledExtensions.indexOf(WebGPUConstants.FeatureName.Float32Filterable) >= 0,
+            textureFloatLinearFiltering: this._deviceEnabledExtensions.indexOf("float32-filterable" /* WebGPUConstants.FeatureName.Float32Filterable */) >= 0,
             textureFloatRender: true,
             textureHalfFloat: true,
             textureHalfFloatLinearFiltering: true,
@@ -593,7 +592,7 @@ export class WebGPUEngine extends AbstractEngine {
             depthTextureExtension: true,
             vertexArrayObject: false,
             instancedArrays: true,
-            timerQuery: typeof BigUint64Array !== "undefined" && this._deviceEnabledExtensions.indexOf(WebGPUConstants.FeatureName.TimestampQuery) !== -1 ? true : undefined,
+            timerQuery: typeof BigUint64Array !== "undefined" && this._deviceEnabledExtensions.indexOf("timestamp-query" /* WebGPUConstants.FeatureName.TimestampQuery */) !== -1 ? true : undefined,
             supportOcclusionQuery: typeof BigUint64Array !== "undefined",
             canUseTimestampForTimerQuery: true,
             multiview: false,
@@ -672,9 +671,9 @@ export class WebGPUEngine extends AbstractEngine {
                 size: this._mainTextureExtends,
                 mipLevelCount: 1,
                 sampleCount: this._mainPassSampleCount,
-                dimension: WebGPUConstants.TextureDimension.E2d,
+                dimension: "2d" /* WebGPUConstants.TextureDimension.E2d */,
                 format: this._options.swapChainFormat,
-                usage: WebGPUConstants.TextureUsage.RenderAttachment,
+                usage: 16 /* WebGPUConstants.TextureUsage.RenderAttachment */,
             };
             if (this._mainTexture) {
                 this._textureHelper.releaseTexture(this._mainTexture);
@@ -684,14 +683,14 @@ export class WebGPUEngine extends AbstractEngine {
                 {
                     view: this._mainTexture.createView({
                         label: "TextureView_MainColor_antialiasing",
-                        dimension: WebGPUConstants.TextureDimension.E2d,
+                        dimension: "2d" /* WebGPUConstants.TextureDimension.E2d */,
                         format: this._options.swapChainFormat,
                         mipLevelCount: 1,
                         arrayLayerCount: 1,
                     }),
                     clearValue: new Color4(0, 0, 0, 1),
-                    loadOp: WebGPUConstants.LoadOp.Clear,
-                    storeOp: WebGPUConstants.StoreOp.Store, // don't use StoreOp.Discard, else using several cameras with different viewports or using scissors will fail because we call beginRenderPass / endPass several times for the same color attachment!
+                    loadOp: "clear" /* WebGPUConstants.LoadOp.Clear */,
+                    storeOp: "store" /* WebGPUConstants.StoreOp.Store */, // don't use StoreOp.Discard, else using several cameras with different viewports or using scissors will fail because we call beginRenderPass / endPass several times for the same color attachment!
                 },
             ];
         }
@@ -700,12 +699,12 @@ export class WebGPUEngine extends AbstractEngine {
                 {
                     view: undefined,
                     clearValue: new Color4(0, 0, 0, 1),
-                    loadOp: WebGPUConstants.LoadOp.Clear,
-                    storeOp: WebGPUConstants.StoreOp.Store,
+                    loadOp: "clear" /* WebGPUConstants.LoadOp.Clear */,
+                    storeOp: "store" /* WebGPUConstants.StoreOp.Store */,
                 },
             ];
         }
-        this._mainRenderPassWrapper.depthTextureFormat = this.isStencilEnable ? WebGPUConstants.TextureFormat.Depth24PlusStencil8 : WebGPUConstants.TextureFormat.Depth32Float;
+        this._mainRenderPassWrapper.depthTextureFormat = this.isStencilEnable ? "depth24plus-stencil8" /* WebGPUConstants.TextureFormat.Depth24PlusStencil8 */ : "depth32float" /* WebGPUConstants.TextureFormat.Depth32Float */;
         this._setDepthTextureFormat(this._mainRenderPassWrapper);
         this._setColorFormat(this._mainRenderPassWrapper);
         const depthTextureDescriptor = {
@@ -713,9 +712,9 @@ export class WebGPUEngine extends AbstractEngine {
             size: this._mainTextureExtends,
             mipLevelCount: 1,
             sampleCount: this._mainPassSampleCount,
-            dimension: WebGPUConstants.TextureDimension.E2d,
+            dimension: "2d" /* WebGPUConstants.TextureDimension.E2d */,
             format: this._mainRenderPassWrapper.depthTextureFormat,
-            usage: WebGPUConstants.TextureUsage.RenderAttachment,
+            usage: 16 /* WebGPUConstants.TextureUsage.RenderAttachment */,
         };
         if (this._depthTexture) {
             this._textureHelper.releaseTexture(this._depthTexture);
@@ -724,17 +723,17 @@ export class WebGPUEngine extends AbstractEngine {
         const mainDepthAttachment = {
             view: this._depthTexture.createView({
                 label: `TextureView_MainDepthStencil_${this._mainTextureExtends.width}x${this._mainTextureExtends.height}`,
-                dimension: WebGPUConstants.TextureDimension.E2d,
+                dimension: "2d" /* WebGPUConstants.TextureDimension.E2d */,
                 format: this._depthTexture.format,
                 mipLevelCount: 1,
                 arrayLayerCount: 1,
             }),
             depthClearValue: this._clearDepthValue,
-            depthLoadOp: WebGPUConstants.LoadOp.Clear,
-            depthStoreOp: WebGPUConstants.StoreOp.Store,
+            depthLoadOp: "clear" /* WebGPUConstants.LoadOp.Clear */,
+            depthStoreOp: "store" /* WebGPUConstants.StoreOp.Store */,
             stencilClearValue: this._clearStencilValue,
-            stencilLoadOp: !this.isStencilEnable ? undefined : WebGPUConstants.LoadOp.Clear,
-            stencilStoreOp: !this.isStencilEnable ? undefined : WebGPUConstants.StoreOp.Store,
+            stencilLoadOp: !this.isStencilEnable ? undefined : "clear" /* WebGPUConstants.LoadOp.Clear */,
+            stencilStoreOp: !this.isStencilEnable ? undefined : "store" /* WebGPUConstants.StoreOp.Store */,
         };
         this._mainRenderPassWrapper.renderPassDescriptor = {
             label: "MainRenderPass",
@@ -754,8 +753,8 @@ export class WebGPUEngine extends AbstractEngine {
         this._context.configure({
             device: this._device,
             format: this._options.swapChainFormat,
-            usage: WebGPUConstants.TextureUsage.RenderAttachment | WebGPUConstants.TextureUsage.CopySrc,
-            alphaMode: this.premultipliedAlpha ? WebGPUConstants.CanvasAlphaMode.Premultiplied : WebGPUConstants.CanvasAlphaMode.Opaque,
+            usage: 16 /* WebGPUConstants.TextureUsage.RenderAttachment */ | 1 /* WebGPUConstants.TextureUsage.CopySrc */,
+            alphaMode: this.premultipliedAlpha ? "premultiplied" /* WebGPUConstants.CanvasAlphaMode.Premultiplied */ : "opaque" /* WebGPUConstants.CanvasAlphaMode.Opaque */,
         });
     }
     /**
@@ -894,7 +893,7 @@ export class WebGPUEngine extends AbstractEngine {
      * @internal
      */
     _getShaderProcessor(shaderLanguage) {
-        if (shaderLanguage === ShaderLanguage.WGSL) {
+        if (shaderLanguage === 1 /* ShaderLanguage.WGSL */) {
             return this._shaderProcessorWGSL;
         }
         return this._shaderProcessor;
@@ -1472,7 +1471,7 @@ export class WebGPUEngine extends AbstractEngine {
      * @param shaderLanguage the language the shader is written in (default: GLSL)
      * @returns the new Effect
      */
-    createEffect(baseName, attributesNamesOrOptions, uniformsNamesOrEngine, samplers, defines, fallbacks, onCompiled, onError, indexParameters, shaderLanguage = ShaderLanguage.GLSL) {
+    createEffect(baseName, attributesNamesOrOptions, uniformsNamesOrEngine, samplers, defines, fallbacks, onCompiled, onError, indexParameters, shaderLanguage = 0 /* ShaderLanguage.GLSL */) {
         const vertex = typeof baseName === "string" ? baseName : baseName.vertexToken || baseName.vertexSource || baseName.vertexElement || baseName.vertex;
         const fragment = typeof baseName === "string" ? baseName : baseName.fragmentToken || baseName.fragmentSource || baseName.fragmentElement || baseName.fragment;
         const globalDefines = this._getGlobalDefines();
@@ -1508,7 +1507,7 @@ export class WebGPUEngine extends AbstractEngine {
         return defines + source;
     }
     _createPipelineStageDescriptor(vertexShader, fragmentShader, shaderLanguage, disableUniformityAnalysisInVertex, disableUniformityAnalysisInFragment) {
-        if (this._tintWASM && shaderLanguage === ShaderLanguage.GLSL) {
+        if (this._tintWASM && shaderLanguage === 0 /* ShaderLanguage.GLSL */) {
             vertexShader = this._tintWASM.convertSpirV2WGSL(vertexShader, disableUniformityAnalysisInVertex);
             fragmentShader = this._tintWASM.convertSpirV2WGSL(fragmentShader, disableUniformityAnalysisInFragment);
         }
@@ -1530,8 +1529,8 @@ export class WebGPUEngine extends AbstractEngine {
     _compileRawPipelineStageDescriptor(vertexCode, fragmentCode, shaderLanguage) {
         const disableUniformityAnalysisInVertex = vertexCode.indexOf(`#define DISABLE_UNIFORMITY_ANALYSIS`) >= 0;
         const disableUniformityAnalysisInFragment = fragmentCode.indexOf(`#define DISABLE_UNIFORMITY_ANALYSIS`) >= 0;
-        const vertexShader = shaderLanguage === ShaderLanguage.GLSL ? this._compileRawShaderToSpirV(vertexCode, "vertex") : vertexCode;
-        const fragmentShader = shaderLanguage === ShaderLanguage.GLSL ? this._compileRawShaderToSpirV(fragmentCode, "fragment") : fragmentCode;
+        const vertexShader = shaderLanguage === 0 /* ShaderLanguage.GLSL */ ? this._compileRawShaderToSpirV(vertexCode, "vertex") : vertexCode;
+        const fragmentShader = shaderLanguage === 0 /* ShaderLanguage.GLSL */ ? this._compileRawShaderToSpirV(fragmentCode, "fragment") : fragmentCode;
         return this._createPipelineStageDescriptor(vertexShader, fragmentShader, shaderLanguage, disableUniformityAnalysisInVertex, disableUniformityAnalysisInFragment);
     }
     _compilePipelineStageDescriptor(vertexCode, fragmentCode, defines, shaderLanguage) {
@@ -1539,8 +1538,8 @@ export class WebGPUEngine extends AbstractEngine {
         const disableUniformityAnalysisInVertex = vertexCode.indexOf(`#define DISABLE_UNIFORMITY_ANALYSIS`) >= 0;
         const disableUniformityAnalysisInFragment = fragmentCode.indexOf(`#define DISABLE_UNIFORMITY_ANALYSIS`) >= 0;
         const shaderVersion = "#version 450\n";
-        const vertexShader = shaderLanguage === ShaderLanguage.GLSL ? this._compileShaderToSpirV(vertexCode, "vertex", defines, shaderVersion) : this._getWGSLShader(vertexCode, "vertex", defines);
-        const fragmentShader = shaderLanguage === ShaderLanguage.GLSL
+        const vertexShader = shaderLanguage === 0 /* ShaderLanguage.GLSL */ ? this._compileShaderToSpirV(vertexCode, "vertex", defines, shaderVersion) : this._getWGSLShader(vertexCode, "vertex", defines);
+        const fragmentShader = shaderLanguage === 0 /* ShaderLanguage.GLSL */
             ? this._compileShaderToSpirV(fragmentCode, "fragment", defines, shaderVersion)
             : this._getWGSLShader(fragmentCode, "fragment", defines);
         const program = this._createPipelineStageDescriptor(vertexShader, fragmentShader, shaderLanguage, disableUniformityAnalysisInVertex, disableUniformityAnalysisInFragment);
@@ -1754,7 +1753,7 @@ export class WebGPUEngine extends AbstractEngine {
      * @param source source type of the texture
      * @returns a new internal texture
      */
-    _createInternalTexture(size, options, delayGPUTextureCreation = true, source = InternalTextureSource.Unknown) {
+    _createInternalTexture(size, options, delayGPUTextureCreation = true, source = 0 /* InternalTextureSource.Unknown */) {
         const fullOptions = {};
         if (options !== undefined && typeof options === "object") {
             fullOptions.generateMipMaps = options.generateMipMaps;
@@ -1875,7 +1874,7 @@ export class WebGPUEngine extends AbstractEngine {
      */
     wrapWebGPUTexture(texture) {
         const hardwareTexture = new WebGPUHardwareTexture(texture);
-        const internalTexture = new InternalTexture(this, InternalTextureSource.Unknown, true);
+        const internalTexture = new InternalTexture(this, 0 /* InternalTextureSource.Unknown */, true);
         internalTexture._hardwareTexture = hardwareTexture;
         internalTexture.isReady = true;
         return internalTexture;
@@ -1991,7 +1990,7 @@ export class WebGPUEngine extends AbstractEngine {
             else if (loadData.info.sphericalPolynomial) {
                 texture._sphericalPolynomial = loadData.info.sphericalPolynomial;
             }
-            texture._source = InternalTextureSource.CubePrefiltered;
+            texture._source = 9 /* InternalTextureSource.CubePrefiltered */;
             if (onLoad) {
                 onLoad(texture);
             }
@@ -2401,13 +2400,13 @@ export class WebGPUEngine extends AbstractEngine {
                     const faceIndex = rtWrapper.faceIndices?.[i] ?? 0;
                     const viewDescriptor = {
                         ...this._rttRenderPassWrapper.colorAttachmentViewDescriptor,
-                        dimension: mrtTexture.is3D ? WebGPUConstants.TextureViewDimension.E3d : WebGPUConstants.TextureViewDimension.E2d,
+                        dimension: mrtTexture.is3D ? "3d" /* WebGPUConstants.TextureViewDimension.E3d */ : "2d" /* WebGPUConstants.TextureViewDimension.E2d */,
                         format: gpuMRTWrapper.format,
                         baseArrayLayer: mrtTexture.isCube ? layerIndex * 6 + faceIndex : mrtTexture.is3D ? 0 : layerIndex,
                     };
                     const msaaViewDescriptor = {
                         ...this._rttRenderPassWrapper.colorAttachmentViewDescriptor,
-                        dimension: mrtTexture.is3D ? WebGPUConstants.TextureViewDimension.E3d : WebGPUConstants.TextureViewDimension.E2d,
+                        dimension: mrtTexture.is3D ? "3d" /* WebGPUConstants.TextureViewDimension.E3d */ : "2d" /* WebGPUConstants.TextureViewDimension.E2d */,
                         format: gpuMRTWrapper.format,
                         baseArrayLayer: 0,
                     };
@@ -2419,8 +2418,8 @@ export class WebGPUEngine extends AbstractEngine {
                         resolveTarget: gpuMSAATexture ? colorTextureView : undefined,
                         depthSlice: mrtTexture.is3D ? layerIndex : undefined,
                         clearValue: index !== 0 && mustClearColor ? (isRTInteger ? clearColorForIntegerRT : clearColor) : undefined,
-                        loadOp: index !== 0 && mustClearColor ? WebGPUConstants.LoadOp.Clear : WebGPUConstants.LoadOp.Load,
-                        storeOp: WebGPUConstants.StoreOp.Store,
+                        loadOp: index !== 0 && mustClearColor ? "clear" /* WebGPUConstants.LoadOp.Clear */ : "load" /* WebGPUConstants.LoadOp.Load */,
+                        storeOp: "store" /* WebGPUConstants.StoreOp.Store */,
                     });
                 }
             }
@@ -2447,8 +2446,8 @@ export class WebGPUEngine extends AbstractEngine {
                     resolveTarget: gpuMSAATexture ? colorTextureView : undefined,
                     depthSlice,
                     clearValue: mustClearColor ? (isRTInteger ? clearColorForIntegerRT : clearColor) : undefined,
-                    loadOp: mustClearColor ? WebGPUConstants.LoadOp.Clear : WebGPUConstants.LoadOp.Load,
-                    storeOp: WebGPUConstants.StoreOp.Store,
+                    loadOp: mustClearColor ? "clear" /* WebGPUConstants.LoadOp.Clear */ : "load" /* WebGPUConstants.LoadOp.Load */,
+                    storeOp: "store" /* WebGPUConstants.StoreOp.Store */,
                 });
             }
             else {
@@ -2463,15 +2462,15 @@ export class WebGPUEngine extends AbstractEngine {
                 ? {
                     view: depthMSAATextureView ? depthMSAATextureView : depthTextureView,
                     depthClearValue: mustClearDepth ? (this.useReverseDepthBuffer ? this._clearReverseDepthValue : this._clearDepthValue) : undefined,
-                    depthLoadOp: mustClearDepth ? WebGPUConstants.LoadOp.Clear : WebGPUConstants.LoadOp.Load,
-                    depthStoreOp: WebGPUConstants.StoreOp.Store,
+                    depthLoadOp: mustClearDepth ? "clear" /* WebGPUConstants.LoadOp.Clear */ : "load" /* WebGPUConstants.LoadOp.Load */,
+                    depthStoreOp: "store" /* WebGPUConstants.StoreOp.Store */,
                     stencilClearValue: rtWrapper._depthStencilTextureWithStencil && mustClearStencil ? this._clearStencilValue : undefined,
                     stencilLoadOp: !depthTextureHasStencil
                         ? undefined
                         : rtWrapper._depthStencilTextureWithStencil && mustClearStencil
-                            ? WebGPUConstants.LoadOp.Clear
-                            : WebGPUConstants.LoadOp.Load,
-                    stencilStoreOp: !depthTextureHasStencil ? undefined : WebGPUConstants.StoreOp.Store,
+                            ? "clear" /* WebGPUConstants.LoadOp.Clear */
+                            : "load" /* WebGPUConstants.LoadOp.Load */,
+                    stencilStoreOp: !depthTextureHasStencil ? undefined : "store" /* WebGPUConstants.StoreOp.Store */,
                 }
                 : undefined,
             occlusionQuerySet: this._occlusionQuery?.hasQueries ? this._occlusionQuery.querySet : undefined,
@@ -2517,19 +2516,19 @@ export class WebGPUEngine extends AbstractEngine {
         const mustClearDepth = setClearStates && clearDepth;
         const mustClearStencil = setClearStates && clearStencil;
         this._mainRenderPassWrapper.renderPassDescriptor.colorAttachments[0].clearValue = mustClearColor ? clearColor : undefined;
-        this._mainRenderPassWrapper.renderPassDescriptor.colorAttachments[0].loadOp = mustClearColor ? WebGPUConstants.LoadOp.Clear : WebGPUConstants.LoadOp.Load;
+        this._mainRenderPassWrapper.renderPassDescriptor.colorAttachments[0].loadOp = mustClearColor ? "clear" /* WebGPUConstants.LoadOp.Clear */ : "load" /* WebGPUConstants.LoadOp.Load */;
         this._mainRenderPassWrapper.renderPassDescriptor.depthStencilAttachment.depthClearValue = mustClearDepth
             ? this.useReverseDepthBuffer
                 ? this._clearReverseDepthValue
                 : this._clearDepthValue
             : undefined;
-        this._mainRenderPassWrapper.renderPassDescriptor.depthStencilAttachment.depthLoadOp = mustClearDepth ? WebGPUConstants.LoadOp.Clear : WebGPUConstants.LoadOp.Load;
+        this._mainRenderPassWrapper.renderPassDescriptor.depthStencilAttachment.depthLoadOp = mustClearDepth ? "clear" /* WebGPUConstants.LoadOp.Clear */ : "load" /* WebGPUConstants.LoadOp.Load */;
         this._mainRenderPassWrapper.renderPassDescriptor.depthStencilAttachment.stencilClearValue = mustClearStencil ? this._clearStencilValue : undefined;
         this._mainRenderPassWrapper.renderPassDescriptor.depthStencilAttachment.stencilLoadOp = !this.isStencilEnable
             ? undefined
             : mustClearStencil
-                ? WebGPUConstants.LoadOp.Clear
-                : WebGPUConstants.LoadOp.Load;
+                ? "clear" /* WebGPUConstants.LoadOp.Clear */
+                : "load" /* WebGPUConstants.LoadOp.Load */;
         this._mainRenderPassWrapper.renderPassDescriptor.occlusionQuerySet = this._occlusionQuery?.hasQueries ? this._occlusionQuery.querySet : undefined;
         const swapChainTexture = this._context.getCurrentTexture();
         this._mainRenderPassWrapper.colorAttachmentGPUTextures[0].set(swapChainTexture);
@@ -2624,21 +2623,21 @@ export class WebGPUEngine extends AbstractEngine {
         this._setColorFormat(this._rttRenderPassWrapper);
         this._rttRenderPassWrapper.colorAttachmentViewDescriptor = {
             format: this._colorFormat,
-            dimension: texture.is3D ? WebGPUConstants.TextureViewDimension.E3d : WebGPUConstants.TextureViewDimension.E2d,
+            dimension: texture.is3D ? "3d" /* WebGPUConstants.TextureViewDimension.E3d */ : "2d" /* WebGPUConstants.TextureViewDimension.E2d */,
             mipLevelCount: 1,
             baseArrayLayer: texture.isCube ? layer * 6 + faceIndex : layer,
             baseMipLevel: lodLevel,
             arrayLayerCount: 1,
-            aspect: WebGPUConstants.TextureAspect.All,
+            aspect: "all" /* WebGPUConstants.TextureAspect.All */,
         };
         this._rttRenderPassWrapper.depthAttachmentViewDescriptor = {
             format: this._depthTextureFormat,
-            dimension: depthStencilTexture && depthStencilTexture.is3D ? WebGPUConstants.TextureViewDimension.E3d : WebGPUConstants.TextureViewDimension.E2d,
+            dimension: depthStencilTexture && depthStencilTexture.is3D ? "3d" /* WebGPUConstants.TextureViewDimension.E3d */ : "2d" /* WebGPUConstants.TextureViewDimension.E2d */,
             mipLevelCount: 1,
             baseArrayLayer: depthStencilTexture ? (depthStencilTexture.isCube ? layer * 6 + faceIndex : layer) : 0,
             baseMipLevel: 0,
             arrayLayerCount: 1,
-            aspect: WebGPUConstants.TextureAspect.All,
+            aspect: "all" /* WebGPUConstants.TextureAspect.All */,
         };
         if (this.dbgVerboseLogsForFirstFrames) {
             if (this._count === undefined) {
@@ -2894,7 +2893,7 @@ export class WebGPUEngine extends AbstractEngine {
         renderPass2.setPipeline(pipeline);
         // bind index/vertex buffers
         if (this._currentIndexBuffer) {
-            renderPass2.setIndexBuffer(this._currentIndexBuffer.underlyingResource, this._currentIndexBuffer.is32Bits ? WebGPUConstants.IndexFormat.Uint32 : WebGPUConstants.IndexFormat.Uint16, 0);
+            renderPass2.setIndexBuffer(this._currentIndexBuffer.underlyingResource, this._currentIndexBuffer.is32Bits ? "uint32" /* WebGPUConstants.IndexFormat.Uint32 */ : "uint16" /* WebGPUConstants.IndexFormat.Uint16 */, 0);
         }
         const vertexBuffers = this._cacheRenderPipeline.vertexBuffers;
         for (let index = 0; index < vertexBuffers.length; index++) {
@@ -3092,22 +3091,10 @@ export class WebGPUEngine extends AbstractEngine {
         }
         this._bufferManager.setSubData(dataBuffer, byteOffset, view, 0, byteLength);
     }
-    /**
-     * Read data from a storage buffer
-     * @param storageBuffer The storage buffer to read from
-     * @param offset The offset in the storage buffer to start reading from (default: 0)
-     * @param size  The number of bytes to read from the storage buffer (default: capacity of the buffer)
-     * @param buffer The buffer to write the data we have read from the storage buffer to (optional)
-     * @param noDelay If true, a call to flushFramebuffer will be issued so that the data can be read back immediately and not in engine.onEndFrameObservable. This can speed up data retrieval, at the cost of a small perf penalty (default: false).
-     * @returns If not undefined, returns the (promise) buffer (as provided by the 4th parameter) filled with the data, else it returns a (promise) Uint8Array with the data read from the storage buffer
-     */
-    readFromStorageBuffer(storageBuffer, offset, size, buffer, noDelay) {
-        size = size || storageBuffer.capacity;
-        const gpuBuffer = this._bufferManager.createRawBuffer(size, WebGPUConstants.BufferUsage.MapRead | WebGPUConstants.BufferUsage.CopyDst, undefined, "TempReadFromStorageBuffer");
-        this._renderEncoder.copyBufferToBuffer(storageBuffer.underlyingResource, offset ?? 0, gpuBuffer, 0, size);
+    _readFromGPUBuffer(gpuBuffer, size, buffer, noDelay) {
         return new Promise((resolve, reject) => {
             const readFromBuffer = () => {
-                gpuBuffer.mapAsync(WebGPUConstants.MapMode.Read, 0, size).then(() => {
+                gpuBuffer.mapAsync(1 /* WebGPUConstants.MapMode.Read */, 0, size).then(() => {
                     const copyArrayBuffer = gpuBuffer.getMappedRange(0, size);
                     let data = buffer;
                     if (data === undefined) {
@@ -3144,6 +3131,38 @@ export class WebGPUEngine extends AbstractEngine {
             }
         });
     }
+    /**
+     * Read data from a storage buffer
+     * @param storageBuffer The storage buffer to read from
+     * @param offset The offset in the storage buffer to start reading from (default: 0)
+     * @param size  The number of bytes to read from the storage buffer (default: capacity of the buffer)
+     * @param buffer The buffer to write the data we have read from the storage buffer to (optional)
+     * @param noDelay If true, a call to flushFramebuffer will be issued so that the data can be read back immediately and not in engine.onEndFrameObservable. This can speed up data retrieval, at the cost of a small perf penalty (default: false).
+     * @returns If not undefined, returns the (promise) buffer (as provided by the 4th parameter) filled with the data, else it returns a (promise) Uint8Array with the data read from the storage buffer
+     */
+    readFromStorageBuffer(storageBuffer, offset, size, buffer, noDelay) {
+        size = size || storageBuffer.capacity;
+        const gpuBuffer = this._bufferManager.createRawBuffer(size, WebGPUConstants.BufferUsage.MapRead | WebGPUConstants.BufferUsage.CopyDst, undefined, "TempReadFromStorageBuffer");
+        this._renderEncoder.copyBufferToBuffer(storageBuffer.underlyingResource, offset ?? 0, gpuBuffer, 0, size);
+        return this._readFromGPUBuffer(gpuBuffer, size, buffer, noDelay);
+    }
+    /**
+     * Read data from multiple storage buffers
+     * @param storageBuffers The list of storage buffers to read from
+     * @param offset The offset in the storage buffer to start reading from (default: 0). This is the same offset for all storage buffers!
+     * @param size  The number of bytes to read from each storage buffer (default: capacity of the first buffer)
+     * @param buffer The buffer to write the data we have read from the storage buffers to (optional). If provided, the buffer should be large enough to hold the data from all storage buffers!
+     * @param noDelay If true, a call to flushFramebuffer will be issued so that the data can be read back immediately and not in engine.onEndFrameObservable. This can speed up data retrieval, at the cost of a small perf penalty (default: false).
+     * @returns If not undefined, returns the (promise) buffer (as provided by the 4th parameter) filled with the data, else it returns a (promise) Uint8Array with the data read from the storage buffer
+     */
+    readFromMultipleStorageBuffers(storageBuffers, offset, size, buffer, noDelay) {
+        size = size || storageBuffers[0].capacity;
+        const gpuBuffer = this._bufferManager.createRawBuffer(size * storageBuffers.length, WebGPUConstants.BufferUsage.MapRead | WebGPUConstants.BufferUsage.CopyDst, undefined, "TempReadFromMultipleStorageBuffers");
+        for (let i = 0; i < storageBuffers.length; i++) {
+            this._renderEncoder.copyBufferToBuffer(storageBuffers[i].underlyingResource, offset ?? 0, gpuBuffer, i * size, size);
+        }
+        return this._readFromGPUBuffer(gpuBuffer, size * storageBuffers.length, buffer, noDelay);
+    }
     /**
      * Sets a storage buffer in the shader
      * @param name Defines the name of the storage buffer as defined in the shader