@babylonjs/core 5.53.0 → 5.53.1

package/Engines/engine.d.ts

@@ -1109,6 +1109,7 @@ interface WebGLUniformLocation {
     _currentState: any;
 }
 
+/* eslint-disable babylonjs/available */
 /* eslint-disable @typescript-eslint/naming-convention */
 interface GPUObjectBase {
     label: string | undefined;
@@ -1119,37 +1120,50 @@ interface GPUObjectDescriptorBase {
 }
 
 interface GPUSupportedLimits {
-    readonly maxTextureDimension1D: GPUSize32;
-    readonly maxTextureDimension2D: GPUSize32;
-    readonly maxTextureDimension3D: GPUSize32;
-    readonly maxTextureArrayLayers: GPUSize32;
-    readonly maxBindGroups: GPUSize32;
-    readonly maxDynamicUniformBuffersPerPipelineLayout: GPUSize32;
-    readonly maxDynamicStorageBuffersPerPipelineLayout: GPUSize32;
-    readonly maxSampledTexturesPerShaderStage: GPUSize32;
-    readonly maxSamplersPerShaderStage: GPUSize32;
-    readonly maxStorageBuffersPerShaderStage: GPUSize32;
-    readonly maxStorageTexturesPerShaderStage: GPUSize32;
-    readonly maxUniformBuffersPerShaderStage: GPUSize32;
-    readonly maxUniformBufferBindingSize: GPUSize64;
-    readonly maxStorageBufferBindingSize: GPUSize64;
-    readonly minUniformBufferOffsetAlignment: GPUSize32;
-    readonly minStorageBufferOffsetAlignment: GPUSize32;
-    readonly maxVertexBuffers: GPUSize32;
-    readonly maxVertexAttributes: GPUSize32;
-    readonly maxVertexBufferArrayStride: GPUSize32;
-    readonly maxInterStageShaderComponents: GPUSize32;
-    readonly maxComputeWorkgroupStorageSize: GPUSize32;
-    readonly maxComputeInvocationsPerWorkgroup: GPUSize32;
-    readonly maxComputeWorkgroupSizeX: GPUSize32;
-    readonly maxComputeWorkgroupSizeY: GPUSize32;
-    readonly maxComputeWorkgroupSizeZ: GPUSize32;
-    readonly maxComputeWorkgroupsPerDimension: GPUSize32;
+    [name: string]: number;
+
+    readonly maxTextureDimension1D: number;
+    readonly maxTextureDimension2D: number;
+    readonly maxTextureDimension3D: number;
+    readonly maxTextureArrayLayers: number;
+    readonly maxBindGroups: number;
+    readonly maxBindingsPerBindGroup: number;
+    readonly maxDynamicUniformBuffersPerPipelineLayout: number;
+    readonly maxDynamicStorageBuffersPerPipelineLayout: number;
+    readonly maxSampledTexturesPerShaderStage: number;
+    readonly maxSamplersPerShaderStage: number;
+    readonly maxStorageBuffersPerShaderStage: number;
+    readonly maxStorageTexturesPerShaderStage: number;
+    readonly maxUniformBuffersPerShaderStage: number;
+    readonly maxFragmentCombinedOutputResources: number;
+    readonly maxUniformBufferBindingSize: number;
+    readonly maxStorageBufferBindingSize: number;
+    readonly minUniformBufferOffsetAlignment: number;
+    readonly minStorageBufferOffsetAlignment: number;
+    readonly maxVertexBuffers: number;
+    readonly maxBufferSize: number;
+    readonly maxVertexAttributes: number;
+    readonly maxVertexBufferArrayStride: number;
+    readonly maxInterStageShaderComponents: number;
+    readonly maxInterStageShaderVariables: number;
+    readonly maxColorAttachments: number;
+    readonly maxColorAttachmentBytesPerSample: number;
+    readonly maxComputeWorkgroupStorageSize: number;
+    readonly maxComputeInvocationsPerWorkgroup: number;
+    readonly maxComputeWorkgroupSizeX: number;
+    readonly maxComputeWorkgroupSizeY: number;
+    readonly maxComputeWorkgroupSizeZ: number;
+    readonly maxComputeWorkgroupsPerDimension: number;
 }
 
 type GPUSupportedFeatures = ReadonlySet<string>;
 
-type GPUPredefinedColorSpace = "srgb";
+interface GPUAdapterInfo {
+    readonly vendor: string;
+    readonly architecture: string;
+    readonly device: string;
+    readonly description: string;
+}
 
 interface Navigator {
     readonly gpu: GPU | undefined;
@@ -1160,7 +1174,7 @@ interface WorkerNavigator {
 }
 
 class GPU {
-    requestAdapter(options?: GPURequestAdapterOptions): Promise<GPUAdapter | null>;
+    requestAdapter(options?: GPURequestAdapterOptions): Promise<GPUAdapter | undefined>;
     getPreferredCanvasFormat(): GPUTextureFormat;
 }
 
@@ -1179,6 +1193,7 @@ class GPUAdapter {
     readonly isFallbackAdapter: boolean;
 
     requestDevice(descriptor?: GPUDeviceDescriptor): Promise<GPUDevice>;
+    requestAdapterInfo(unmaskHints?: string[]): Promise<GPUAdapterInfo>;
 }
 
 interface GPUDeviceDescriptor extends GPUObjectDescriptorBase {
@@ -1189,7 +1204,6 @@ interface GPUDeviceDescriptor extends GPUObjectDescriptorBase {
 
 type GPUFeatureName =
     | "depth-clip-control"
-    | "depth24unorm-stencil8"
     | "depth32float-stencil8"
     | "texture-compression-bc"
     | "texture-compression-etc2"
@@ -1197,7 +1211,9 @@ type GPUFeatureName =
     | "timestamp-query"
     | "indirect-first-instance"
     | "shader-f16"
-    | "bgra8unorm-storage";
+    | "rg11b10ufloat-renderable"
+    | "bgra8unorm-storage"
+    | "float32-filterable";
 
 class GPUDevice extends EventTarget implements GPUObjectBase {
     label: string | undefined;
@@ -1239,6 +1255,10 @@ class GPUDevice extends EventTarget implements GPUObjectBase {
 class GPUBuffer implements GPUObjectBase {
     label: string | undefined;
 
+    readonly size: GPUSize64;
+    readonly usage: GPUBufferUsageFlags;
+    readonly mapState: GPUBufferMapState;
+
     mapAsync(mode: GPUMapModeFlags, offset?: GPUSize64 /*default=0*/, size?: GPUSize64): Promise<void>;
     getMappedRange(offset?: GPUSize64 /*default=0*/, size?: GPUSize64): ArrayBuffer;
     unmap(): void;
@@ -1246,6 +1266,8 @@ class GPUBuffer implements GPUObjectBase {
     destroy(): void;
 }
 
+type GPUBufferMapState = "unmapped" | "pending" | "mapped";
+
 interface GPUBufferDescriptor extends GPUObjectDescriptorBase {
     size: GPUSize64;
     usage: GPUBufferUsageFlags;
@@ -1261,6 +1283,15 @@ class GPUTexture implements GPUObjectBase {
 
     createView(descriptor?: GPUTextureViewDescriptor): GPUTextureView;
     destroy(): void;
+
+    readonly width: GPUIntegerCoordinate;
+    readonly height: GPUIntegerCoordinate;
+    readonly depthOrArrayLayers: GPUIntegerCoordinate;
+    readonly mipLevelCount: GPUIntegerCoordinate;
+    readonly sampleCount: GPUSize32;
+    readonly dimension: GPUTextureDimension;
+    readonly format: GPUTextureFormat;
+    readonly usage: GPUTextureUsageFlags;
 }
 
 interface GPUTextureDescriptor extends GPUObjectDescriptorBase {
@@ -1423,7 +1454,7 @@ class GPUExternalTexture implements GPUObjectBase {
 
 interface GPUExternalTextureDescriptor extends GPUObjectDescriptorBase {
     source: HTMLVideoElement;
-    colorSpace?: GPUPredefinedColorSpace /* default="srgb" */;
+    colorSpace?: PredefinedColorSpace /* default="srgb" */;
 }
 
 class GPUSampler implements GPUObjectBase {
@@ -1436,7 +1467,7 @@ interface GPUSamplerDescriptor extends GPUObjectDescriptorBase {
     addressModeW?: GPUAddressMode /* default="clamp-to-edge" */;
     magFilter?: GPUFilterMode /* default="nearest" */;
     minFilter?: GPUFilterMode /* default="nearest" */;
-    mipmapFilter?: GPUFilterMode /* default="nearest" */;
+    mipmapFilter?: GPUMipmapFilterMode /* default="nearest" */;
     lodMinClamp?: number /* default=0 */;
     lodMaxClamp?: number /* default=32 */;
     compare?: GPUCompareFunction;
@@ -1447,6 +1478,8 @@ type GPUAddressMode = "clamp-to-edge" | "repeat" | "mirror-repeat";
 
 type GPUFilterMode = "nearest" | "linear";
 
+type GPUMipmapFilterMode = "nearest" | "linear";
+
 type GPUCompareFunction = "never" | "less" | "equal" | "less-equal" | "greater" | "not-equal" | "greater-equal" | "always";
 
 class GPUBindGroupLayout implements GPUObjectBase {
@@ -1535,7 +1568,7 @@ interface GPUPipelineLayoutDescriptor extends GPUObjectDescriptorBase {
 class GPUShaderModule implements GPUObjectBase {
     label: string | undefined;
 
-    compilationInfo(): Promise<GPUCompilationInfo>;
+    getCompilationInfo(): Promise<GPUCompilationInfo>;
 }
 
 interface GPUShaderModuleDescriptor extends GPUObjectDescriptorBase {
@@ -1563,6 +1596,17 @@ interface GPUCompilationInfo {
     readonly messages: readonly GPUCompilationMessage[];
 }
 
+class GPUPipelineError extends DOMException {
+    constructor(message: DOMString | undefined, options: GPUPipelineErrorInit);
+    readonly reason: GPUPipelineErrorReason;
+}
+
+interface GPUPipelineErrorInit {
+    reason: GPUPipelineErrorReason;
+}
+
+type GPUPipelineErrorReason = "validation" | "internal";
+
 type GPUAutoLayoutMode = "auto";
 
 interface GPUPipelineDescriptorBase extends GPUObjectDescriptorBase {
@@ -1746,6 +1790,34 @@ interface GPUVertexAttribute {
     shaderLocation: GPUIndex32;
 }
 
+interface GPUImageDataLayout {
+    offset?: GPUSize64 /* default=0 */;
+    bytesPerRow: GPUSize32;
+    rowsPerImage?: GPUSize32;
+}
+
+interface GPUImageCopyBuffer extends GPUImageDataLayout {
+    buffer: GPUBuffer;
+}
+
+interface GPUImageCopyTexture {
+    texture: GPUTexture;
+    mipLevel?: GPUIntegerCoordinate /* default=0 */;
+    origin?: GPUOrigin3D /* default={} */;
+    aspect?: GPUTextureAspect /* default="all" */;
+}
+
+interface GPUImageCopyTextureTagged extends GPUImageCopyTexture {
+    colorSpace?: PredefinedColorSpace /* default="srgb" */;
+    premultipliedAlpha?: boolean /* default=false */;
+}
+
+interface GPUImageCopyExternalImage {
+    source: ImageBitmap | HTMLVideoElement | HTMLCanvasElement | OffscreenCanvas;
+    origin?: GPUOrigin2D /* default={} */;
+    flipY?: boolean /* default=false */;
+}
+
 class GPUCommandBuffer implements GPUObjectBase {
     label: string | undefined;
 }
@@ -1766,46 +1838,18 @@ class GPUCommandEncoder implements GPUObjectBase, GPUCommandsMixin, GPUDebugComm
     copyTextureToTexture(source: GPUImageCopyTexture, destination: GPUImageCopyTexture, copySize: GPUExtent3D): void;
     clearBuffer(buffer: GPUBuffer, offset?: GPUSize64 /* default=0 */, size?: GPUSize64): void;
 
-    pushDebugGroup(groupLabel: string): void;
-    popDebugGroup(): void;
-    insertDebugMarker(markerLabel: string): void;
-
     writeTimestamp(querySet: GPUQuerySet, queryIndex: GPUSize32): void;
 
     resolveQuerySet(querySet: GPUQuerySet, firstQuery: GPUSize32, queryCount: GPUSize32, destination: GPUBuffer, destinationOffset: GPUSize64): void;
 
     finish(descriptor?: GPUCommandBufferDescriptor): GPUCommandBuffer;
-}
 
-interface GPUCommandEncoderDescriptor extends GPUObjectDescriptorBase {}
-
-interface GPUImageDataLayout {
-    offset?: GPUSize64 /* default=0 */;
-    bytesPerRow: GPUSize32;
-    rowsPerImage?: GPUSize32;
-}
-
-interface GPUImageCopyBuffer extends GPUImageDataLayout {
-    buffer: GPUBuffer;
-}
-
-interface GPUImageCopyTexture {
-    texture: GPUTexture;
-    mipLevel?: GPUIntegerCoordinate /* default=0 */;
-    origin?: GPUOrigin3D /* default={} */;
-    aspect?: GPUTextureAspect /* default="all" */;
-}
-
-interface GPUImageCopyTextureTagged extends GPUImageCopyTexture {
-    colorSpace?: GPUPredefinedColorSpace /* default="srgb" */;
-    premultipliedAlpha?: boolean /* default=false */;
+    pushDebugGroup(groupLabel: string): void;
+    popDebugGroup(): void;
+    insertDebugMarker(markerLabel: string): void;
 }
 
-interface GPUImageCopyExternalImage {
-    source: ImageBitmap | HTMLCanvasElement | OffscreenCanvas;
-    origin?: GPUOrigin2D /* default={} */;
-    flipY?: boolean /* default=false */;
-}
+interface GPUCommandEncoderDescriptor extends GPUObjectDescriptorBase {}
 
 interface GPUBindingCommandsMixin {
     setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup, dynamicOffsets?: GPUBufferDynamicOffset[]): void;
@@ -1905,6 +1949,7 @@ interface GPURenderPassDescriptor extends GPUObjectDescriptorBase {
     depthStencilAttachment?: GPURenderPassDepthStencilAttachment;
     occlusionQuerySet?: GPUQuerySet;
     timestampWrites?: GPURenderPassTimestampWrites /* default=[] */;
+    maxDrawCount?: GPUSize64 /* default=50000000 */;
 }
 
 interface GPURenderPassColorAttachment {
@@ -1944,7 +1989,7 @@ interface GPURenderCommandsMixin {
     setPipeline(pipeline: GPURenderPipeline): void;
 
     setIndexBuffer(buffer: GPUBuffer, indexFormat: GPUIndexFormat, offset?: GPUSize64 /* default=0 */, size?: GPUSize64 /* default=0 */): void;
-    setVertexBuffer(slot: GPUIndex32, buffer: GPUBuffer, offset?: GPUSize64 /* default=0 */, size?: GPUSize64 /* default=0 */): void;
+    setVertexBuffer(slot: GPUIndex32, buffer: GPUBuffer, offset?: GPUSize64 /* default=0 */, size?: GPUSize64): void;
 
     draw(vertexCount: GPUSize32, instanceCount?: GPUSize32 /* default=1 */, firstVertex?: GPUSize32 /* default=0 */, firstInstance?: GPUSize32 /* default=0 */): void;
     drawIndexed(
@@ -2020,6 +2065,9 @@ class GPUQuerySet implements GPUObjectBase {
     label: string | undefined;
 
     destroy(): void;
+
+    readonly type: GPUQueryType;
+    readonly count: GPUSize32;
 }
 
 interface GPUQuerySetDescriptor extends GPUObjectDescriptorBase {
@@ -2045,33 +2093,38 @@ interface GPUCanvasConfiguration extends GPUObjectDescriptorBase {
     format: GPUTextureFormat;
     usage?: GPUTextureUsageFlags /* default=0x10 - GPUTextureUsage.RENDER_ATTACHMENT */;
     viewFormats?: GPUTextureFormat[] /* default=[] */;
-    colorSpace?: GPUPredefinedColorSpace /* default="srgb" */;
+    colorSpace?: PredefinedColorSpace /* default="srgb" */;
     alphaMode?: GPUCanvasAlphaMode /* default="opaque" */;
 }
 
-type GPUDeviceLostReason = "destroyed";
+type GPUDeviceLostReason = "unknown" | "destroyed";
 
 class GPUDeviceLostInfo {
     readonly reason?: GPUDeviceLostReason;
     readonly message: string;
 }
 
-type GPUErrorFilter = "out-of-memory" | "validation";
-
 class GPUError {
     readonly message: string;
 }
 
+class GPUValidationError extends GPUError {
+    constructor(message: string);
+    readonly message: string;
+}
+
 class GPUOutOfMemoryError extends GPUError {
-    constructor();
+    constructor(message: string);
     readonly message: string;
 }
 
-class GPUValidationError extends GPUError {
+class GPUInternalError extends GPUError {
     constructor(message: string);
     readonly message: string;
 }
 
+type GPUErrorFilter = "validation" | "out-of-memory" | "internal";
+
 class GPUUncapturedErrorEvent extends Event {
     constructor(type: string, gpuUncapturedErrorEventInitDict: GPUUncapturedErrorEventInit);
     readonly error: GPUError;
@@ -2085,12 +2138,15 @@ type GPUBufferDynamicOffset = number; /* unsigned long */
 type GPUStencilValue = number; /* unsigned long */
 type GPUSampleMask = number; /* unsigned long */
 type GPUDepthBias = number; /* long */
+
 type GPUSize64 = number; /* unsigned long long */
 type GPUIntegerCoordinate = number; /* unsigned long */
 type GPUIndex32 = number; /* unsigned long */
 type GPUSize32 = number; /* unsigned long */
 type GPUSignedOffset32 = number; /* long */
 
+type GPUFlagsConstant = number; /* unsigned long */
+
 interface GPUColorDict {
     r: number;
     g: number;

package/Engines/nativeEngine.d.ts

@@ -440,6 +440,7 @@ export declare class NativeEngine extends Engine {
         width: number;
         height: number;
     }, options: boolean | RenderTargetCreationOptions): RenderTargetWrapper;
+    updateRenderTargetTextureSampleCount(rtWrapper: RenderTargetWrapper, samples: number): number;
     updateTextureSamplingMode(samplingMode: number, texture: InternalTexture): void;
     bindFramebuffer(texture: RenderTargetWrapper, faceIndex?: number, requiredWidth?: number, requiredHeight?: number, forceFullscreenViewport?: boolean): void;
     unBindFramebuffer(texture: RenderTargetWrapper, disableGenerateMipMaps?: boolean, onBeforeUnbind?: () => void): void;

package/Engines/nativeEngine.js

@@ -1638,6 +1638,7 @@ export class NativeEngine extends Engine {
         let format = 5;
         let useSRGBBuffer = false;
         let samples = 1;
+        let label;
         if (options !== undefined && typeof options === "object") {
             generateMipMaps = !!options.generateMipMaps;
             type = options.type === undefined ? 0 : options.type;
@@ -1645,6 +1646,7 @@ export class NativeEngine extends Engine {
             format = options.format === undefined ? 5 : options.format;
             useSRGBBuffer = options.useSRGBBuffer === undefined ? false : options.useSRGBBuffer;
             samples = (_a = options.samples) !== null && _a !== void 0 ? _a : 1;
+            label = options.label;
         }
         else {
             generateMipMaps = !!options;
@@ -1686,23 +1688,24 @@ export class NativeEngine extends Engine {
         texture.samplingMode = samplingMode;
         texture.type = type;
         texture.format = format;
+        texture.label = label;
         this._internalTexturesCache.push(texture);
         return texture;
     }
     createRenderTargetTexture(size, options) {
-        var _a;
+        var _a, _b;
         const rtWrapper = this._createHardwareRenderTargetWrapper(false, false, size);
         let generateDepthBuffer = true;
         let generateStencilBuffer = false;
         let noColorAttachment = false;
         let colorAttachment = undefined;
-        //let samples = 1;
+        let samples = 1;
         if (options !== undefined && typeof options === "object") {
             generateDepthBuffer = (_a = options.generateDepthBuffer) !== null && _a !== void 0 ? _a : true;
             generateStencilBuffer = !!options.generateStencilBuffer;
             noColorAttachment = !!options.noColorAttachment;
             colorAttachment = options.colorAttachment;
-            //samples = options.samples ?? 1;
+            samples = (_b = options.samples) !== null && _b !== void 0 ? _b : 1;
         }
         const texture = colorAttachment || (noColorAttachment ? null : this._createInternalTexture(size, options, true, InternalTextureSource.RenderTarget));
         const width = size.width || size;
@@ -1712,10 +1715,18 @@ export class NativeEngine extends Engine {
         rtWrapper._generateDepthBuffer = generateDepthBuffer;
         rtWrapper._generateStencilBuffer = generateStencilBuffer;
         rtWrapper.setTextures(texture);
-        // TODO: handle this in native
-        //this.updateRenderTargetTextureSampleCount(rtWrapper, samples);
+        this.updateRenderTargetTextureSampleCount(rtWrapper, samples);
         return rtWrapper;
     }
+    // This function is being added for the sole purpose of overriding the ThinEngine version.  The reason
+    // for this is that the ThinEngine version of this function uses a WebGL2RenderingContext, which is not
+    // available in Babylon Native.  The return value is just a hard-coded value that is not used anywhere
+    // in Babylon Native's code.  This is effectively a hack/workaround so that Babylon Native doesn't crash
+    // This function should be updated once the maxMSAASamples is updated as well.
+    updateRenderTargetTextureSampleCount(rtWrapper, samples) {
+        // TODO: Implement this function once the maxMSAASamples is updated.
+        return 1;
+    }
     updateTextureSamplingMode(samplingMode, texture) {
         if (texture._hardwareTexture) {
             const filter = this._getNativeSamplingMode(samplingMode);