@babylonjs/core 5.52.0 → 5.53.1

package/Engines/webgpuEngine.d.ts

@@ -60,15 +60,31 @@ export interface WebGPUEngineOptions extends ThinEngineOptions, GPURequestAdapte
      */
     powerPreference?: GPUPowerPreference;
     /**
-     * Defines the device descriptor used to create a device.
+     * When set to true, indicates that only a fallback adapter may be returned when requesting an adapter.
+     * If the user agent does not support a fallback adapter, will cause requestAdapter() to resolve to null.
+     * Default: false
+     */
+    forceFallbackAdapter?: boolean;
+    /**
+     * Defines the device descriptor used to create a device once we have retrieved an appropriate adapter
      */
     deviceDescriptor?: GPUDeviceDescriptor;
+    /**
+     * When requesting the device, enable all the features supported by the adapter. Default: false
+     * Note that this setting is ignored if you explicitely set deviceDescriptor.requiredFeatures
+     */
+    enableAllFeatures?: boolean;
+    /**
+     * When requesting the device, set the required limits to the maximum possible values (the ones from adapter.limits). Default: false
+     * Note that this setting is ignored if you explicitely set deviceDescriptor.requiredLimits
+     */
+    setMaximumLimits?: boolean;
     /**
      * Defines the requested Swap Chain Format.
      */
     swapChainFormat?: GPUTextureFormat;
     /**
-     * Defines whether we should generate debug markers in the gpu command lists (can be seen with PIX for eg)
+     * Defines whether we should generate debug markers in the gpu command lists (can be seen with PIX for eg). Default: false
      */
     enableGPUDebugMarkers?: boolean;
     /**
@@ -98,16 +114,18 @@ export declare class WebGPUEngine extends Engine {
     /** @internal */
     readonly _clearStencilValue = 0;
     private readonly _defaultSampleCount;
-    private _canvas;
     /** @internal */
     _options: WebGPUEngineOptions;
     private _glslang;
     private _tintWASM;
     private _adapter;
     private _adapterSupportedExtensions;
+    private _adapterInfo;
+    private _adapterSupportedLimits;
     /** @internal */
     _device: GPUDevice;
     private _deviceEnabledExtensions;
+    private _deviceLimits;
     private _context;
     private _mainPassSampleCount;
     /** @internal */
@@ -250,6 +268,10 @@ export declare class WebGPUEngine extends Engine {
     get supportedExtensions(): Immutable<GPUFeatureName[]>;
     /** Gets the currently enabled extensions on the WebGPU device */
     get enabledExtensions(): Immutable<GPUFeatureName[]>;
+    /** Gets the supported limits by the WebGPU adapter */
+    get supportedLimits(): GPUSupportedLimits;
+    /** Gets the current limits of the WebGPU device */
+    get currentLimits(): GPUSupportedLimits;
     /**
      * Returns a string describing the current engine
      */
@@ -770,11 +792,6 @@ export declare class WebGPUEngine extends Engine {
      * @returns a number defining the current render height
      */
     getRenderHeight(useScreen?: boolean): number;
-    /**
-     * Gets the HTML canvas attached with the current WebGPU context
-     * @returns a HTML canvas
-     */
-    getRenderingCanvas(): Nullable<HTMLCanvasElement>;
     /**
      * Get the current error code of the WebGPU context
      * @returns the error code

package/Engines/webgpuEngine.js

@@ -35,6 +35,21 @@ import { WebGPUTintWASM } from "./WebGPU/webgpuTintWASM.js";
 import { WebGPUShaderProcessor } from "./WebGPU/webgpuShaderProcessor.js";
 import { ShaderLanguage } from "../Materials/shaderLanguage.js";
 import { WebGPUSnapshotRendering } from "./WebGPU/webgpuSnapshotRendering.js";
+const viewDescriptorSwapChainAntialiasing = {
+    label: `TextureView_SwapChain_ResolveTarget`,
+    dimension: WebGPUConstants.TextureDimension.E2d,
+    format: undefined,
+    mipLevelCount: 1,
+    arrayLayerCount: 1,
+};
+const viewDescriptorSwapChain = {
+    label: `TextureView_SwapChain`,
+    dimension: WebGPUConstants.TextureDimension.E2d,
+    format: undefined,
+    mipLevelCount: 1,
+    arrayLayerCount: 1,
+};
+const disableUniformityAnalysisMarker = "/* disable_uniformity_analysis */";
 /**
  * The web GPU engine class provides support for WebGPU version of babylon.js.
  * @since 5.0.0
@@ -130,6 +145,14 @@ export class WebGPUEngine extends Engine {
     get enabledExtensions() {
         return this._deviceEnabledExtensions;
     }
+    /** Gets the supported limits by the WebGPU adapter */
+    get supportedLimits() {
+        return this._adapterSupportedLimits;
+    }
+    /** Gets the current limits of the WebGPU device */
+    get currentLimits() {
+        return this._deviceLimits;
+    }
     /**
      * Returns a string describing the current engine
      */
@@ -149,9 +172,9 @@ export class WebGPUEngine extends Engine {
      */
     getInfo() {
         return {
-            vendor: "unknown vendor",
-            renderer: "unknown renderer",
-            version: "unknown version",
+            vendor: this._adapterInfo.vendor || "unknown vendor",
+            renderer: this._adapterInfo.architecture || "unknown renderer",
+            version: this._adapterInfo.description || "unknown version",
         };
     }
     /**
@@ -202,6 +225,12 @@ export class WebGPUEngine extends Engine {
         this._defaultSampleCount = 4; // Only supported value for now.
         this._glslang = null;
         this._tintWASM = null;
+        this._adapterInfo = {
+            vendor: "",
+            architecture: "",
+            device: "",
+            description: "",
+        };
         /** @internal */
         this._compiledComputeEffects = {};
         /** @internal */
@@ -290,7 +319,7 @@ export class WebGPUEngine extends Engine {
         options.swapChainFormat = options.swapChainFormat || navigator.gpu.getPreferredCanvasFormat();
         this._isWebGPU = true;
         this._shaderPlatformName = "WEBGPU";
-        this._canvas = canvas;
+        this._renderingCanvas = canvas;
         this._options = options;
         this._mainPassSampleCount = options.antialias ? this._defaultSampleCount : 1;
         this._setupMobileChecks();
@@ -329,7 +358,7 @@ export class WebGPUEngine extends Engine {
             throw Error("WebGPU initializations stopped.");
         })
             .then((adapter) => {
-            var _a;
+            var _a, _b, _c;
             if (!adapter) {
                 throw "Could not retrieve a WebGPU adapter (adapter is null).";
             }
@@ -337,9 +366,14 @@ export class WebGPUEngine extends Engine {
                 this._adapter = adapter;
                 this._adapterSupportedExtensions = [];
                 (_a = this._adapter.features) === null || _a === void 0 ? void 0 : _a.forEach((feature) => this._adapterSupportedExtensions.push(feature));
-                const deviceDescriptor = this._options.deviceDescriptor;
-                if (deviceDescriptor === null || deviceDescriptor === void 0 ? void 0 : deviceDescriptor.requiredFeatures) {
-                    const requestedExtensions = deviceDescriptor.requiredFeatures;
+                this._adapterSupportedLimits = this._adapter.limits;
+                this._adapter.requestAdapterInfo().then((adapterInfo) => {
+                    this._adapterInfo = adapterInfo;
+                });
+                const deviceDescriptor = (_b = this._options.deviceDescriptor) !== null && _b !== void 0 ? _b : {};
+                const requiredFeatures = (_c = deviceDescriptor === null || deviceDescriptor === void 0 ? void 0 : deviceDescriptor.requiredFeatures) !== null && _c !== void 0 ? _c : (this._options.enableAllFeatures ? this._adapterSupportedExtensions : undefined);
+                if (requiredFeatures) {
+                    const requestedExtensions = requiredFeatures;
                     const validExtensions = [];
                     for (const extension of requestedExtensions) {
                         if (this._adapterSupportedExtensions.indexOf(extension) !== -1) {
@@ -348,7 +382,13 @@ export class WebGPUEngine extends Engine {
                     }
                     deviceDescriptor.requiredFeatures = validExtensions;
                 }
-                return this._adapter.requestDevice(this._options.deviceDescriptor);
+                if (this._options.setMaximumLimits && !deviceDescriptor.requiredLimits) {
+                    deviceDescriptor.requiredLimits = {};
+                    for (const name in this._adapterSupportedLimits) {
+                        deviceDescriptor.requiredLimits[name] = this._adapterSupportedLimits[name];
+                    }
+                }
+                return this._adapter.requestDevice(deviceDescriptor);
             }
         })
             .then((device) => {
@@ -356,6 +396,7 @@ export class WebGPUEngine extends Engine {
             this._device = device;
             this._deviceEnabledExtensions = [];
             (_a = this._device.features) === null || _a === void 0 ? void 0 : _a.forEach((feature) => this._deviceEnabledExtensions.push(feature));
+            this._deviceLimits = device.limits;
             let numUncapturedErrors = -1;
             this._device.addEventListener("uncapturederror", (event) => {
                 if (++numUncapturedErrors < this.numMaxUncapturedErrors) {
@@ -367,6 +408,9 @@ export class WebGPUEngine extends Engine {
             });
             if (!this._doNotHandleContextLost) {
                 (_b = this._device.lost) === null || _b === void 0 ? void 0 : _b.then((info) => {
+                    if (this._isDisposed) {
+                        return;
+                    }
                     this._contextWasLost = true;
                     Logger.Warn("WebGPU context lost. " + info);
                     this.onContextLostObservable.notifyObservers(this);
@@ -454,16 +498,16 @@ export class WebGPUEngine extends Engine {
         // Init caps
         // TODO WEBGPU Real Capability check once limits will be working.
         this._caps = {
-            maxTexturesImageUnits: 16,
-            maxVertexTextureImageUnits: 16,
-            maxCombinedTexturesImageUnits: 32,
-            maxTextureSize: 8192,
-            maxCubemapTextureSize: 2048,
-            maxRenderTextureSize: 8192,
-            maxVertexAttribs: 16,
-            maxVaryingVectors: 15,
-            maxFragmentUniformVectors: 1024,
-            maxVertexUniformVectors: 1024,
+            maxTexturesImageUnits: this._deviceLimits.maxSampledTexturesPerShaderStage,
+            maxVertexTextureImageUnits: this._deviceLimits.maxSampledTexturesPerShaderStage,
+            maxCombinedTexturesImageUnits: this._deviceLimits.maxSampledTexturesPerShaderStage * 2,
+            maxTextureSize: this._deviceLimits.maxTextureDimension2D,
+            maxCubemapTextureSize: this._deviceLimits.maxTextureDimension2D,
+            maxRenderTextureSize: this._deviceLimits.maxTextureDimension2D,
+            maxVertexAttribs: this._deviceLimits.maxVertexAttributes,
+            maxVaryingVectors: this._deviceLimits.maxInterStageShaderVariables,
+            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),
@@ -471,13 +515,13 @@ export class WebGPUEngine extends Engine {
             etc1: null,
             etc2: (this._deviceEnabledExtensions.indexOf(WebGPUConstants.FeatureName.TextureCompressionETC2) >= 0 ? true : undefined),
             bptc: this._deviceEnabledExtensions.indexOf(WebGPUConstants.FeatureName.TextureCompressionBC) >= 0 ? true : undefined,
-            maxAnisotropy: 4,
+            maxAnisotropy: 16,
             uintIndices: true,
             fragmentDepthSupported: true,
             highPrecisionShaderSupported: true,
             colorBufferFloat: true,
             textureFloat: true,
-            textureFloatLinearFiltering: false,
+            textureFloatLinearFiltering: this._deviceEnabledExtensions.indexOf(WebGPUConstants.FeatureName.Float32Filterable) >= 0,
             textureFloatRender: true,
             textureHalfFloat: true,
             textureHalfFloatLinearFiltering: true,
@@ -488,7 +532,7 @@ export class WebGPUEngine extends Engine {
             depthTextureExtension: true,
             vertexArrayObject: false,
             instancedArrays: true,
-            timerQuery: typeof BigUint64Array !== "undefined" && this.enabledExtensions.indexOf(WebGPUConstants.FeatureName.TimestampQuery) !== -1 ? true : undefined,
+            timerQuery: typeof BigUint64Array !== "undefined" && this._deviceEnabledExtensions.indexOf(WebGPUConstants.FeatureName.TimestampQuery) !== -1 ? true : undefined,
             supportOcclusionQuery: typeof BigUint64Array !== "undefined",
             canUseTimestampForTimerQuery: true,
             multiview: false,
@@ -502,7 +546,7 @@ export class WebGPUEngine extends Engine {
             supportSRGBBuffers: true,
             supportTransformFeedbacks: false,
             textureMaxLevel: true,
-            texture2DArrayMaxLayerCount: 2048,
+            texture2DArrayMaxLayerCount: this._deviceLimits.maxTextureArrayLayers,
         };
         this._caps.parallelShaderCompile = null;
         this._features = {
@@ -533,7 +577,10 @@ export class WebGPUEngine extends Engine {
         };
     }
     _initializeContextAndSwapChain() {
-        this._context = this._canvas.getContext("webgpu");
+        if (!this._renderingCanvas) {
+            throw "The rendering canvas has not been set!";
+        }
+        this._context = this._renderingCanvas.getContext("webgpu");
         this._configureContext();
         this._colorFormat = this._options.swapChainFormat;
         this._mainRenderPassWrapper.colorAttachmentGPUTextures = [new WebGPUHardwareTexture()];
@@ -546,17 +593,17 @@ export class WebGPUEngine extends Engine {
         }
         this.flushFramebuffer(false);
         this._mainTextureExtends = {
-            width: this.getRenderWidth(),
-            height: this.getRenderHeight(),
+            width: this.getRenderWidth(true),
+            height: this.getRenderHeight(true),
             depthOrArrayLayers: 1,
         };
-        const bufferDataUpdate = new Float32Array([this.getRenderHeight()]);
+        const bufferDataUpdate = new Float32Array([this.getRenderHeight(true)]);
         this._bufferManager.setSubData(this._ubInvertY, 4, bufferDataUpdate);
         this._bufferManager.setSubData(this._ubDontInvertY, 4, bufferDataUpdate);
         let mainColorAttachments;
         if (this._options.antialias) {
             const mainTextureDescriptor = {
-                label: "Texture_MainColor_antialiasing",
+                label: `Texture_MainColor_${this._mainTextureExtends.width}x${this._mainTextureExtends.height}_antialiasing`,
                 size: this._mainTextureExtends,
                 mipLevelCount: 1,
                 sampleCount: this._mainPassSampleCount,
@@ -570,7 +617,13 @@ export class WebGPUEngine extends Engine {
             this._mainTexture = this._device.createTexture(mainTextureDescriptor);
             mainColorAttachments = [
                 {
-                    view: this._mainTexture.createView(),
+                    view: this._mainTexture.createView({
+                        label: "TextureView_MainColor_antialiasing",
+                        dimension: 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!
@@ -590,7 +643,7 @@ export class WebGPUEngine extends Engine {
         this._mainRenderPassWrapper.depthTextureFormat = this.isStencilEnable ? WebGPUConstants.TextureFormat.Depth24PlusStencil8 : WebGPUConstants.TextureFormat.Depth32Float;
         this._setDepthTextureFormat(this._mainRenderPassWrapper);
         const depthTextureDescriptor = {
-            label: "Texture_MainDepthStencil",
+            label: `Texture_MainDepthStencil_${this._mainTextureExtends.width}x${this._mainTextureExtends.height}`,
             size: this._mainTextureExtends,
             mipLevelCount: 1,
             sampleCount: this._mainPassSampleCount,
@@ -603,7 +656,13 @@ export class WebGPUEngine extends Engine {
         }
         this._depthTexture = this._device.createTexture(depthTextureDescriptor);
         const mainDepthAttachment = {
-            view: this._depthTexture.createView(),
+            view: this._depthTexture.createView({
+                label: `TextureView_MainDepthStencil_${this._mainTextureExtends.width}x${this._mainTextureExtends.height}`,
+                dimension: WebGPUConstants.TextureDimension.E2d,
+                format: this._depthTexture.format,
+                mipLevelCount: 1,
+                arrayLayerCount: 1,
+            }),
             depthClearValue: this._clearDepthValue,
             depthLoadOp: WebGPUConstants.LoadOp.Clear,
             depthStoreOp: WebGPUConstants.StoreOp.Store,
@@ -746,7 +805,7 @@ export class WebGPUEngine extends Engine {
         let y = Math.floor(this._viewportCached.y);
         const h = Math.floor(this._viewportCached.w);
         if (!this._currentRenderTarget) {
-            y = this.getRenderHeight() - y - h;
+            y = this.getRenderHeight(true) - y - h;
         }
         renderPass.setViewport(Math.floor(this._viewportCached.x), y, Math.floor(this._viewportCached.z), h, 0, 1);
         if (this.dbgVerboseLogsForFirstFrames) {
@@ -1109,10 +1168,10 @@ export class WebGPUEngine extends Engine {
         }
         return defines + source;
     }
-    _createPipelineStageDescriptor(vertexShader, fragmentShader, shaderLanguage) {
+    _createPipelineStageDescriptor(vertexShader, fragmentShader, shaderLanguage, disableUniformityAnalysisInVertex, disableUniformityAnalysisInFragment) {
         if (this._tintWASM && shaderLanguage === ShaderLanguage.GLSL) {
-            vertexShader = this._tintWASM.convertSpirV2WGSL(vertexShader);
-            fragmentShader = this._tintWASM.convertSpirV2WGSL(fragmentShader);
+            vertexShader = this._tintWASM.convertSpirV2WGSL(vertexShader, disableUniformityAnalysisInVertex);
+            fragmentShader = this._tintWASM.convertSpirV2WGSL(fragmentShader, disableUniformityAnalysisInFragment);
         }
         return {
             vertexStage: {
@@ -1130,18 +1189,22 @@ export class WebGPUEngine extends Engine {
         };
     }
     _compileRawPipelineStageDescriptor(vertexCode, fragmentCode, shaderLanguage) {
+        const disableUniformityAnalysisInVertex = vertexCode.indexOf(disableUniformityAnalysisMarker) >= 0;
+        const disableUniformityAnalysisInFragment = fragmentCode.indexOf(disableUniformityAnalysisMarker) >= 0;
         const vertexShader = shaderLanguage === ShaderLanguage.GLSL ? this._compileRawShaderToSpirV(vertexCode, "vertex") : vertexCode;
         const fragmentShader = shaderLanguage === ShaderLanguage.GLSL ? this._compileRawShaderToSpirV(fragmentCode, "fragment") : fragmentCode;
-        return this._createPipelineStageDescriptor(vertexShader, fragmentShader, shaderLanguage);
+        return this._createPipelineStageDescriptor(vertexShader, fragmentShader, shaderLanguage, disableUniformityAnalysisInVertex, disableUniformityAnalysisInFragment);
     }
     _compilePipelineStageDescriptor(vertexCode, fragmentCode, defines, shaderLanguage) {
         this.onBeforeShaderCompilationObservable.notifyObservers(this);
+        const disableUniformityAnalysisInVertex = vertexCode.indexOf(disableUniformityAnalysisMarker) >= 0;
+        const disableUniformityAnalysisInFragment = fragmentCode.indexOf(disableUniformityAnalysisMarker) >= 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
             ? this._compileShaderToSpirV(fragmentCode, "fragment", defines, shaderVersion)
             : this._getWGSLShader(fragmentCode, "fragment", defines);
-        const program = this._createPipelineStageDescriptor(vertexShader, fragmentShader, shaderLanguage);
+        const program = this._createPipelineStageDescriptor(vertexShader, fragmentShader, shaderLanguage, disableUniformityAnalysisInVertex, disableUniformityAnalysisInFragment);
         this.onAfterShaderCompilationObservable.notifyObservers(this);
         return program;
     }
@@ -1364,6 +1427,7 @@ export class WebGPUEngine extends Engine {
             fullOptions.samples = (_a = options.samples) !== null && _a !== void 0 ? _a : 1;
             fullOptions.creationFlags = (_b = options.creationFlags) !== null && _b !== void 0 ? _b : 0;
             fullOptions.useSRGBBuffer = (_c = options.useSRGBBuffer) !== null && _c !== void 0 ? _c : false;
+            fullOptions.label = options.label;
         }
         else {
             fullOptions.generateMipMaps = options;
@@ -1403,6 +1467,7 @@ export class WebGPUEngine extends Engine {
         texture._cachedWrapU = 0;
         texture._cachedWrapV = 0;
         texture._useSRGBBuffer = fullOptions.useSRGBBuffer;
+        texture.label = fullOptions.label;
         this._internalTexturesCache.push(texture);
         if (!delayGPUTextureCreation) {
             this._textureHelper.createGPUTextureForInternalTexture(texture, width, height, layers || 1, fullOptions.creationFlags);
@@ -2104,10 +2169,12 @@ export class WebGPUEngine extends Engine {
         this._mainRenderPassWrapper.colorAttachmentGPUTextures[0].set(swapChainTexture);
         // Resolve in case of MSAA
         if (this._options.antialias) {
-            this._mainRenderPassWrapper.renderPassDescriptor.colorAttachments[0].resolveTarget = swapChainTexture.createView();
+            viewDescriptorSwapChainAntialiasing.format = swapChainTexture.format;
+            this._mainRenderPassWrapper.renderPassDescriptor.colorAttachments[0].resolveTarget = swapChainTexture.createView(viewDescriptorSwapChainAntialiasing);
         }
         else {
-            this._mainRenderPassWrapper.renderPassDescriptor.colorAttachments[0].view = swapChainTexture.createView();
+            viewDescriptorSwapChain.format = swapChainTexture.format;
+            this._mainRenderPassWrapper.renderPassDescriptor.colorAttachments[0].view = swapChainTexture.createView(viewDescriptorSwapChain);
         }
         if (this.dbgVerboseLogsForFirstFrames) {
             if (this._count === undefined) {
@@ -2518,8 +2585,10 @@ export class WebGPUEngine extends Engine {
      */
     dispose() {
         var _a, _b;
+        this._isDisposed = true;
         (_a = this._mainTexture) === null || _a === void 0 ? void 0 : _a.destroy();
         (_b = this._depthTexture) === null || _b === void 0 ? void 0 : _b.destroy();
+        this._device.destroy();
         super.dispose();
     }
     //------------------------------------------------------------------------------
@@ -2531,10 +2600,11 @@ export class WebGPUEngine extends Engine {
      * @returns a number defining the current render width
      */
     getRenderWidth(useScreen = false) {
+        var _a, _b;
         if (!useScreen && this._currentRenderTarget) {
             return this._currentRenderTarget.width;
         }
-        return this._canvas.width;
+        return (_b = (_a = this._renderingCanvas) === null || _a === void 0 ? void 0 : _a.width) !== null && _b !== void 0 ? _b : 0;
     }
     /**
      * Gets the current render height
@@ -2542,17 +2612,11 @@ export class WebGPUEngine extends Engine {
      * @returns a number defining the current render height
      */
     getRenderHeight(useScreen = false) {
+        var _a, _b;
         if (!useScreen && this._currentRenderTarget) {
             return this._currentRenderTarget.height;
         }
-        return this._canvas.height;
-    }
-    /**
-     * Gets the HTML canvas attached with the current WebGPU context
-     * @returns a HTML canvas
-     */
-    getRenderingCanvas() {
-        return this._canvas;
+        return (_b = (_a = this._renderingCanvas) === null || _a === void 0 ? void 0 : _a.height) !== null && _b !== void 0 ? _b : 0;
     }
     //------------------------------------------------------------------------------
     //                              Errors