Base fixture for WebGPU tests.

This class is a Fixture + a getter that returns a GPUDevice as well as helpers that use that device.

Hierarchy

Properties

Accessors

Methods

_createComputePipelineDescriptor _createRenderPipelineDescriptor _createRenderPipelineDescriptorWithFragmentShader _getDeviceWithRequestedMaximumLimit _getDeviceWithSpecificLimit _testThenDestroyDevice canCallCopyTextureToBufferWithTextureFormat copy2DTextureToBufferUsingComputePass createBufferTracked createEncoder createPipeline createPipelineAsync createQuerySetTracked createTextureTracked debug eventualExpectOK expect expectGPUBufferRepeatsSingleValue expectGPUBufferValuesEqual expectGPUBufferValuesPassCheck expectGPUError expectGPUErrorAsync expectNoValidationError expectOK expectSingleColor expectSinglePixelBetweenTwoValuesIn2DTexture expectValidationError fail getBindingIndexWGSLForPipelineType getDefaultLimit getDefaultLimits getDefaultOrAdapterLimit getGroupIndexWGSLForPipelineType getModuleForWorkgroupSize hasLanguageFeature info init makeBufferWithContents makeLimitVariant readGPUBufferRangeTyped requestDeviceTracked requestDeviceWithLimits shouldReject shouldRejectConditionally shouldResolve shouldThrow skip skipIf skipIfCopyTextureToTextureNotSupportedForFormat skipIfLanguageFeatureNotSupported skipIfLanguageFeatureSupported skipIfTextureFormatNotSupported skipIfTextureFormatNotUsableAsStorageTexture skipIfTextureViewDimensionNotSupported testCreatePipeline testCreateRenderPipeline testDeviceWithRequestedMaximumLimits testDeviceWithSpecificLimits testForValidationErrorWithPossibleOutOfMemoryError testGPUBindingCommandsMixin testGPURenderAndBindingCommandsMixin testMaxComputeWorkgroupSize trackForCleanup tryTrackForCleanup warn MakeSharedState

Properties

_adapter: null | GPUAdapter = null
_device: undefined | GPUDevice = undefined
adapterLimit: number = 0
defaultLimit: number = 0
limit: keyof GPUSupportedLimits = ...

Accessors

  • get params(): unknown
  • Returns the (case+subcase) parameters for this test function invocation.

    Returns unknown

  • get queue(): GPUQueue
  • GPUQueue for the test to use. (Same as t.device.queue.)

    Returns GPUQueue

  • get sharedState(): S
  • Gets the test fixture's shared state. This object is shared between subcases within the same testcase.

    Returns S

Methods

  • Gets a device with the adapter a requested limit and checks that that limit is correct or that the device failed to create if the requested limit is beyond the maximum supported by the device.

    Parameters

    • limitValueTest: "atDefault" | "underDefault" | "betweenDefaultAndMaximum" | "atMaximum" | "overMaximum"
    • Optional extraLimits: LimitsRequest
    • Optional features: GPUFeatureName[]

    Returns Promise<undefined | DeviceAndLimits>

  • Emulate a texture to buffer copy by using a compute shader to load texture values of a subregion of a 2d texture and write to a storage buffer. For sample count == 1, the buffer contains extent[0] * extent[1] of the sample. For sample count > 1, the buffer contains extent[0] * extent[1] * (N = sampleCount) values sorted in the order of their sample index [0, sampleCount - 1]

    This can be useful when the texture to buffer copy is not available to the texture format e.g. (depth24plus), or when the texture is multisampled.

    MAINTENANCE_TODO: extend texture dimension to 1d and 3d.

    Parameters

    • type: ScalarType
    • componentCount: number
    • textureView: GPUTextureView
    • sampleCount: number = 1
    • extent_: GPUExtent3D = ...
    • origin_: GPUOrigin3D = ...

    Returns GPUBuffer

    storage buffer containing the copied value from the texture.

  • Returns a GPUCommandEncoder, GPUComputePassEncoder, GPURenderPassEncoder, or GPURenderBundleEncoder, and a finish method returning a GPUCommandBuffer. Allows testing methods which have the same signature across multiple encoder interfaces.

    Type Parameters

    • T extends "render pass" | "render bundle" | "compute pass" | "non-pass"

    Parameters

    • encoderType: T
    • __namedParameters: {
          attachmentInfo?: GPURenderBundleEncoderDescriptor;
          occlusionQuerySet?: GPUQuerySet;
      } = {}
      • Optional attachmentInfo?: GPURenderBundleEncoderDescriptor
      • Optional occlusionQuerySet?: GPUQuerySet

    Returns CommandBufferMaker<T>

    Example

    g.test('popDebugGroup')
    .params(u => u.combine('encoderType', kEncoderTypes))
    .fn(t => {
    const { encoder, finish } = t.createEncoder(t.params.encoderType);
    encoder.popDebugGroup();
    });

    g.test('writeTimestamp')
    .params(u => u.combine('encoderType', ['non-pass', 'compute pass', 'render pass'] as const)
    .fn(t => {
    const { encoder, finish } = t.createEncoder(t.params.encoderType);
    // Encoder type is inferred, so `writeTimestamp` can be used even though it doesn't exist
    // on GPURenderBundleEncoder.
    encoder.writeTimestamp(args);
    });
  • Parameters

    • createPipelineType: "createComputePipeline" | "createRenderPipeline" | "createRenderPipelineWithFragmentStage"
    • module: GPUShaderModule

    Returns GPUComputePipeline | GPURenderPipeline

  • Parameters

    • createPipelineType: "createComputePipeline" | "createRenderPipeline" | "createRenderPipelineWithFragmentStage"
    • module: GPUShaderModule

    Returns Promise<GPUComputePipeline> | Promise<GPURenderPipeline>

  • Expect a buffer to consist exclusively of rows of some repeated expected value. The size of expectedValue must be 1, 2, or any multiple of 4 bytes. Rows in the buffer are expected to be zero-padded out to bytesPerRow. minBytesPerRow is the number of bytes per row that contain actual (non-padding) data and must be an exact multiple of the byte-length of expectedValue.

    Parameters

    • buffer: GPUBuffer
    • __namedParameters: {
          bytesPerRow: number;
          expectedValue: ArrayBuffer;
          minBytesPerRow: number;
          numRows: number;
      }
      • bytesPerRow: number
      • expectedValue: ArrayBuffer
      • minBytesPerRow: number
      • numRows: number

    Returns void

  • Expect a GPUBuffer's contents to equal the values in the provided TypedArray.

    Parameters

    • src: GPUBuffer
    • expected: Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float16Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array
    • srcByteOffset: number = 0
    • __namedParameters: {
          method?: "map" | "copy";
          mode?: "fail" | "warn";
      } = {}
      • Optional method?: "map" | "copy"
      • Optional mode?: "fail" | "warn"

    Returns void

  • Expect a GPUBuffer's contents to pass the provided check.

    A library of checks can be found in webgpu/util/check_contents.

    Type Parameters

    • T extends Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float16Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array

    Parameters

    • src: GPUBuffer
    • check: ((actual) => undefined | Error)
        • (actual): undefined | Error
        • Parameters

          • actual: T

          Returns undefined | Error

    • __namedParameters: {
          method?: "map" | "copy";
          mode?: "fail" | "warn";
          srcByteOffset?: number;
          type: TypedArrayBufferViewConstructor<T>;
          typedLength: number;
      }

    Returns void

  • Expect the specified WebGPU error to be generated when running the provided function.

    Type Parameters

    • R

    Parameters

    • filter: GPUErrorFilter
    • fn: (() => R)
        • (): R
        • Returns R

    • shouldError: boolean = true

    Returns R

  • Calls a function that expects a GPU error if shouldError is true

    Type Parameters

    • R

    Parameters

    • filter: GPUErrorFilter
    • fn: (() => R)
        • (): R
        • Returns R

    • shouldError: boolean = true
    • msg: string = ''

    Returns Promise<R>

  • If the argument is an Error, fail (or warn). If it's undefined, no-op. If the argument is an array, apply the above behavior on each of elements.

    Parameters

    • error: undefined | Error | (undefined | Error)[]
    • __namedParameters: {
          mode?: "fail" | "warn";
          niceStack?: Error;
      } = {}
      • Optional mode?: "fail" | "warn"
      • Optional niceStack?: Error

    Returns void

  • Expect an entire GPUTexture to have a single color at the given mip level (defaults to 0). MAINTENANCE_TODO: Remove this and/or replace it with a helper in TextureTestMixin.

    Parameters

    • src: GPUTexture
    • format: GPUTextureFormat
    • __namedParameters: {
          dimension?: GPUTextureDimension;
          exp: PerTexelComponent<number>;
          layout?: LayoutOptions;
          size: [number, number, number];
          slice?: number;
      }
      • Optional dimension?: GPUTextureDimension
      • exp: PerTexelComponent<number>
      • Optional layout?: LayoutOptions
      • size: [number, number, number]
      • Optional slice?: number

    Returns void

  • Take a single pixel of a 2D texture, interpret it using a TypedArray of the expected type, and expect each value in that array to be between the corresponding "expected" values (either a[i] <= actual[i] <= b[i] or a[i] >= actual[i] => b[i]). MAINTENANCE_TODO: Remove this once there is a way to deal with undefined lerp-ed values.

    Parameters

    • src: GPUTexture
    • format: "bgra8unorm" | "rgba8unorm" | "rgba16float" | "r8unorm" | "r8snorm" | "r8uint" | "r8sint" | "r16uint" | "r16sint" | "r16float" | "rg8unorm" | "rg8snorm" | "rg8uint" | "rg8sint" | "r32uint" | "r32sint" | "r32float" | "rg16uint" | "rg16sint" | "rg16float" | "rgba8unorm-srgb" | "rgba8snorm" | "rgba8uint" | "rgba8sint" | "bgra8unorm-srgb" | "rgb9e5ufloat" | "rgb10a2uint" | "rgb10a2unorm" | "rg11b10ufloat" | "rg32uint" | "rg32sint" | "rg32float" | "rgba16uint" | "rgba16sint" | "rgba32uint" | "rgba32sint" | "rgba32float" | "stencil8" | "depth16unorm" | "depth32float" | "bc1-rgba-unorm" | "bc1-rgba-unorm-srgb" | "bc2-rgba-unorm" | "bc2-rgba-unorm-srgb" | "bc3-rgba-unorm" | "bc3-rgba-unorm-srgb" | "bc4-r-unorm" | "bc4-r-snorm" | "bc5-rg-unorm" | "bc5-rg-snorm" | "bc6h-rgb-ufloat" | "bc6h-rgb-float" | "bc7-rgba-unorm" | "bc7-rgba-unorm-srgb" | "etc2-rgb8unorm" | "etc2-rgb8unorm-srgb" | "etc2-rgb8a1unorm" | "etc2-rgb8a1unorm-srgb" | "etc2-rgba8unorm" | "etc2-rgba8unorm-srgb" | "eac-r11unorm" | "eac-r11snorm" | "eac-rg11unorm" | "eac-rg11snorm" | "astc-4x4-unorm" | "astc-4x4-unorm-srgb" | "astc-5x4-unorm" | "astc-5x4-unorm-srgb" | "astc-5x5-unorm" | "astc-5x5-unorm-srgb" | "astc-6x5-unorm" | "astc-6x5-unorm-srgb" | "astc-6x6-unorm" | "astc-6x6-unorm-srgb" | "astc-8x5-unorm" | "astc-8x5-unorm-srgb" | "astc-8x6-unorm" | "astc-8x6-unorm-srgb" | "astc-8x8-unorm" | "astc-8x8-unorm-srgb" | "astc-10x5-unorm" | "astc-10x5-unorm-srgb" | "astc-10x6-unorm" | "astc-10x6-unorm-srgb" | "astc-10x8-unorm" | "astc-10x8-unorm-srgb" | "astc-10x10-unorm" | "astc-10x10-unorm-srgb" | "astc-12x10-unorm" | "astc-12x10-unorm-srgb" | "astc-12x12-unorm" | "astc-12x12-unorm-srgb"
    • __namedParameters: {
          x: number;
          y: number;
      }
      • x: number
      • y: number
    • __namedParameters: {
          checkElementsBetweenFn?: ((actual, expected) => undefined | Error);
          exp: [Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float16Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array, Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float16Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array];
          generateWarningOnly?: boolean;
          layout?: LayoutOptions;
          slice?: number;
      }
      • Optional checkElementsBetweenFn?: ((actual, expected) => undefined | Error)
          • (actual, expected): undefined | Error
          • Parameters

            • actual: Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float16Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array
            • expected: readonly [Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float16Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array, Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float16Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array]

            Returns undefined | Error

      • exp: [Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float16Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array, Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float16Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array]
      • Optional generateWarningOnly?: boolean
      • Optional layout?: LayoutOptions
      • Optional slice?: number

    Returns void

  • Parameters

    • limit: "maxTextureDimension1D" | "maxTextureDimension2D" | "maxTextureDimension3D" | "maxTextureArrayLayers" | "maxBindGroups" | "maxBindGroupsPlusVertexBuffers" | "maxBindingsPerBindGroup" | "maxDynamicUniformBuffersPerPipelineLayout" | "maxDynamicStorageBuffersPerPipelineLayout" | "maxSampledTexturesPerShaderStage" | "maxSamplersPerShaderStage" | "maxStorageBuffersPerShaderStage" | "maxStorageTexturesPerShaderStage" | "maxUniformBuffersPerShaderStage" | "maxUniformBufferBindingSize" | "maxStorageBufferBindingSize" | "minUniformBufferOffsetAlignment" | "minStorageBufferOffsetAlignment" | "maxVertexBuffers" | "maxBufferSize" | "maxVertexAttributes" | "maxVertexBufferArrayStride" | "maxInterStageShaderVariables" | "maxColorAttachments" | "maxColorAttachmentBytesPerSample" | "maxComputeWorkgroupStorageSize" | "maxComputeInvocationsPerWorkgroup" | "maxComputeWorkgroupSizeX" | "maxComputeWorkgroupSizeY" | "maxComputeWorkgroupSizeZ" | "maxComputeWorkgroupsPerDimension"

    Returns 4 | 1000 | 8 | 12 | 16 | 32 | 256 | 64 | 8192 | 2048 | 24 | 65536 | 16384 | 134217728 | 268435456 | 65535

  • Returns {
        maxBindGroups: {
            class: "maximum";
            default: 4;
            maximumValue: 4;
        };
        maxBindGroupsPlusVertexBuffers: {
            class: "maximum";
            default: 24;
            maximumValue: 24;
        };
        maxBindingsPerBindGroup: {
            class: "maximum";
            default: 1000;
            maximumValue: 1000;
        };
        maxBufferSize: {
            class: "maximum";
            default: 268435456;
            maximumValue: 268435456;
        };
        maxColorAttachmentBytesPerSample: {
            class: "maximum";
            default: 32;
            maximumValue: 32;
        };
        maxColorAttachments: {
            class: "maximum";
            default: 8;
            maximumValue: 4;
        };
        maxComputeInvocationsPerWorkgroup: {
            class: "maximum";
            default: 256;
            maximumValue: 128;
        };
        maxComputeWorkgroupSizeX: {
            class: "maximum";
            default: 256;
            maximumValue: 128;
        };
        maxComputeWorkgroupSizeY: {
            class: "maximum";
            default: 256;
            maximumValue: 128;
        };
        maxComputeWorkgroupSizeZ: {
            class: "maximum";
            default: 64;
            maximumValue: 64;
        };
        maxComputeWorkgroupStorageSize: {
            class: "maximum";
            default: 16384;
            maximumValue: 16384;
        };
        maxComputeWorkgroupsPerDimension: {
            class: "maximum";
            default: 65535;
            maximumValue: 65535;
        };
        maxDynamicStorageBuffersPerPipelineLayout: {
            class: "maximum";
            default: 4;
            maximumValue: 4;
        };
        maxDynamicUniformBuffersPerPipelineLayout: {
            class: "maximum";
            default: 8;
            maximumValue: 8;
        };
        maxInterStageShaderVariables: {
            class: "maximum";
            default: 16;
            maximumValue: 15;
        };
        maxSampledTexturesPerShaderStage: {
            class: "maximum";
            default: 16;
            maximumValue: 16;
        };
        maxSamplersPerShaderStage: {
            class: "maximum";
            default: 16;
            maximumValue: 16;
        };
        maxStorageBufferBindingSize: {
            class: "maximum";
            default: 134217728;
            maximumValue: 134217728;
        };
        maxStorageBuffersPerShaderStage: {
            class: "maximum";
            default: 8;
            maximumValue: 4;
        };
        maxStorageTexturesPerShaderStage: {
            class: "maximum";
            default: 4;
            maximumValue: 4;
        };
        maxTextureArrayLayers: {
            class: "maximum";
            default: 256;
            maximumValue: 256;
        };
        maxTextureDimension1D: {
            class: "maximum";
            default: 8192;
            maximumValue: 4096;
        };
        maxTextureDimension2D: {
            class: "maximum";
            default: 8192;
            maximumValue: 4096;
        };
        maxTextureDimension3D: {
            class: "maximum";
            default: 2048;
            maximumValue: 1024;
        };
        maxUniformBufferBindingSize: {
            class: "maximum";
            default: 65536;
            maximumValue: 16384;
        };
        maxUniformBuffersPerShaderStage: {
            class: "maximum";
            default: 12;
            maximumValue: 12;
        };
        maxVertexAttributes: {
            class: "maximum";
            default: 16;
            maximumValue: 16;
        };
        maxVertexBufferArrayStride: {
            class: "maximum";
            default: 2048;
            maximumValue: 2048;
        };
        maxVertexBuffers: {
            class: "maximum";
            default: 8;
            maximumValue: 8;
        };
        minStorageBufferOffsetAlignment: {
            class: "alignment";
            default: 256;
            maximumValue: 256;
        };
        minUniformBufferOffsetAlignment: {
            class: "alignment";
            default: 256;
            maximumValue: 256;
        };
    }

    • Readonly maxBindGroups: {
          class: "maximum";
          default: 4;
          maximumValue: 4;
      }
      • class: "maximum"
      • default: 4
      • maximumValue: 4
    • Readonly maxBindGroupsPlusVertexBuffers: {
          class: "maximum";
          default: 24;
          maximumValue: 24;
      }
      • class: "maximum"
      • default: 24
      • maximumValue: 24
    • Readonly maxBindingsPerBindGroup: {
          class: "maximum";
          default: 1000;
          maximumValue: 1000;
      }
      • class: "maximum"
      • default: 1000
      • maximumValue: 1000
    • Readonly maxBufferSize: {
          class: "maximum";
          default: 268435456;
          maximumValue: 268435456;
      }
      • class: "maximum"
      • default: 268435456
      • maximumValue: 268435456
    • Readonly maxColorAttachmentBytesPerSample: {
          class: "maximum";
          default: 32;
          maximumValue: 32;
      }
      • class: "maximum"
      • default: 32
      • maximumValue: 32
    • Readonly maxColorAttachments: {
          class: "maximum";
          default: 8;
          maximumValue: 4;
      }
      • class: "maximum"
      • default: 8
      • maximumValue: 4
    • Readonly maxComputeInvocationsPerWorkgroup: {
          class: "maximum";
          default: 256;
          maximumValue: 128;
      }
      • class: "maximum"
      • default: 256
      • maximumValue: 128
    • Readonly maxComputeWorkgroupSizeX: {
          class: "maximum";
          default: 256;
          maximumValue: 128;
      }
      • class: "maximum"
      • default: 256
      • maximumValue: 128
    • Readonly maxComputeWorkgroupSizeY: {
          class: "maximum";
          default: 256;
          maximumValue: 128;
      }
      • class: "maximum"
      • default: 256
      • maximumValue: 128
    • Readonly maxComputeWorkgroupSizeZ: {
          class: "maximum";
          default: 64;
          maximumValue: 64;
      }
      • class: "maximum"
      • default: 64
      • maximumValue: 64
    • Readonly maxComputeWorkgroupStorageSize: {
          class: "maximum";
          default: 16384;
          maximumValue: 16384;
      }
      • class: "maximum"
      • default: 16384
      • maximumValue: 16384
    • Readonly maxComputeWorkgroupsPerDimension: {
          class: "maximum";
          default: 65535;
          maximumValue: 65535;
      }
      • class: "maximum"
      • default: 65535
      • maximumValue: 65535
    • Readonly maxDynamicStorageBuffersPerPipelineLayout: {
          class: "maximum";
          default: 4;
          maximumValue: 4;
      }
      • class: "maximum"
      • default: 4
      • maximumValue: 4
    • Readonly maxDynamicUniformBuffersPerPipelineLayout: {
          class: "maximum";
          default: 8;
          maximumValue: 8;
      }
      • class: "maximum"
      • default: 8
      • maximumValue: 8
    • Readonly maxInterStageShaderVariables: {
          class: "maximum";
          default: 16;
          maximumValue: 15;
      }
      • class: "maximum"
      • default: 16
      • maximumValue: 15
    • Readonly maxSampledTexturesPerShaderStage: {
          class: "maximum";
          default: 16;
          maximumValue: 16;
      }
      • class: "maximum"
      • default: 16
      • maximumValue: 16
    • Readonly maxSamplersPerShaderStage: {
          class: "maximum";
          default: 16;
          maximumValue: 16;
      }
      • class: "maximum"
      • default: 16
      • maximumValue: 16
    • Readonly maxStorageBufferBindingSize: {
          class: "maximum";
          default: 134217728;
          maximumValue: 134217728;
      }
      • class: "maximum"
      • default: 134217728
      • maximumValue: 134217728
    • Readonly maxStorageBuffersPerShaderStage: {
          class: "maximum";
          default: 8;
          maximumValue: 4;
      }
      • class: "maximum"
      • default: 8
      • maximumValue: 4
    • Readonly maxStorageTexturesPerShaderStage: {
          class: "maximum";
          default: 4;
          maximumValue: 4;
      }
      • class: "maximum"
      • default: 4
      • maximumValue: 4
    • Readonly maxTextureArrayLayers: {
          class: "maximum";
          default: 256;
          maximumValue: 256;
      }
      • class: "maximum"
      • default: 256
      • maximumValue: 256
    • Readonly maxTextureDimension1D: {
          class: "maximum";
          default: 8192;
          maximumValue: 4096;
      }
      • class: "maximum"
      • default: 8192
      • maximumValue: 4096
    • Readonly maxTextureDimension2D: {
          class: "maximum";
          default: 8192;
          maximumValue: 4096;
      }
      • class: "maximum"
      • default: 8192
      • maximumValue: 4096
    • Readonly maxTextureDimension3D: {
          class: "maximum";
          default: 2048;
          maximumValue: 1024;
      }
      • class: "maximum"
      • default: 2048
      • maximumValue: 1024
    • Readonly maxUniformBufferBindingSize: {
          class: "maximum";
          default: 65536;
          maximumValue: 16384;
      }
      • class: "maximum"
      • default: 65536
      • maximumValue: 16384
    • Readonly maxUniformBuffersPerShaderStage: {
          class: "maximum";
          default: 12;
          maximumValue: 12;
      }
      • class: "maximum"
      • default: 12
      • maximumValue: 12
    • Readonly maxVertexAttributes: {
          class: "maximum";
          default: 16;
          maximumValue: 16;
      }
      • class: "maximum"
      • default: 16
      • maximumValue: 16
    • Readonly maxVertexBufferArrayStride: {
          class: "maximum";
          default: 2048;
          maximumValue: 2048;
      }
      • class: "maximum"
      • default: 2048
      • maximumValue: 2048
    • Readonly maxVertexBuffers: {
          class: "maximum";
          default: 8;
          maximumValue: 8;
      }
      • class: "maximum"
      • default: 8
      • maximumValue: 8
    • Readonly minStorageBufferOffsetAlignment: {
          class: "alignment";
          default: 256;
          maximumValue: 256;
      }
      • class: "alignment"
      • default: 256
      • maximumValue: 256
    • Readonly minUniformBufferOffsetAlignment: {
          class: "alignment";
          default: 256;
          maximumValue: 256;
      }
      • class: "alignment"
      • default: 256
      • maximumValue: 256
  • returns true iff the langFeature is supported

    Parameters

    • langFeature: "readonly_and_readwrite_storage_textures" | "packed_4x8_integer_dot_product" | "unrestricted_pointer_parameters" | "pointer_composite_access"

    Returns boolean

  • Creates a buffer with the contents of some TypedArray. The buffer size will always be aligned to 4 as we set mappedAtCreation === true when creating the buffer.

    MAINTENANCE_TODO: Several call sites would be simplified if this took ArrayBuffer as well.

    Parameters

    • dataArray: Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float16Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array
    • usage: number

    Returns GPUBuffer

  • Parameters

    • limit: "maxTextureDimension1D" | "maxTextureDimension2D" | "maxTextureDimension3D" | "maxTextureArrayLayers" | "maxBindGroups" | "maxBindGroupsPlusVertexBuffers" | "maxBindingsPerBindGroup" | "maxDynamicUniformBuffersPerPipelineLayout" | "maxDynamicStorageBuffersPerPipelineLayout" | "maxSampledTexturesPerShaderStage" | "maxSamplersPerShaderStage" | "maxStorageBuffersPerShaderStage" | "maxStorageTexturesPerShaderStage" | "maxUniformBuffersPerShaderStage" | "maxUniformBufferBindingSize" | "maxStorageBufferBindingSize" | "minUniformBufferOffsetAlignment" | "minStorageBufferOffsetAlignment" | "maxVertexBuffers" | "maxBufferSize" | "maxVertexAttributes" | "maxVertexBufferArrayStride" | "maxInterStageShaderVariables" | "maxColorAttachments" | "maxColorAttachmentBytesPerSample" | "maxComputeWorkgroupStorageSize" | "maxComputeInvocationsPerWorkgroup" | "maxComputeWorkgroupSizeX" | "maxComputeWorkgroupSizeY" | "maxComputeWorkgroupSizeZ" | "maxComputeWorkgroupsPerDimension"
    • variant: ValueTestVariant

    Returns number

  • Snapshot the current contents of a range of a GPUBuffer, and return them as a TypedArray. Also provides a cleanup() function to unmap and destroy the staging buffer.

    Type Parameters

    • T extends Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float16Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array

    Parameters

    Returns Promise<{
        data: T;
        cleanup() => void;
    }>

  • Parameters

    • adapter: GPUAdapter
    • requiredLimits: Record<string, number>
    • shouldReject: boolean
    • Optional requiredFeatures: GPUFeatureName[]

    Returns Promise<undefined | GPUDevice>

  • Expect that the provided promise rejects, with the provided exception name.

    Parameters

    • expectedName: string
    • p: Promise<unknown>
    • shouldReject: boolean
    • Optional message: string

    Returns Promise<void>

  • Expect that the provided function throws (if true or string) or not (if false). If a string is provided, expect that the throw exception has that name.

    MAINTENANCE_TODO: Change to string | false so the exception name is always checked.

    Parameters

    • expectedError: string | boolean
    • fn: (() => void)
        • (): void
        • Returns void

    • __namedParameters: ExceptionCheckOptions = {}

    Returns void

  • Skips this test case if the langFeature is not supported.

    Parameters

    • langFeature: "readonly_and_readwrite_storage_textures" | "packed_4x8_integer_dot_product" | "unrestricted_pointer_parameters" | "pointer_composite_access"

    Returns void

  • Skips this test case if the langFeature is supported.

    Parameters

    • langFeature: "readonly_and_readwrite_storage_textures" | "packed_4x8_integer_dot_product" | "unrestricted_pointer_parameters" | "pointer_composite_access"

    Returns void

  • Parameters

    • createPipelineType: "createComputePipeline" | "createRenderPipeline" | "createRenderPipelineWithFragmentStage"
    • async: boolean
    • module: GPUShaderModule
    • shouldError: boolean
    • msg: string = ''

    Returns Promise<void>

  • Creates a device with the limit defined by LimitValueTest. If the limit of over the maximum we expect an exception If the device is created then we call a test function, checking that the function does not leak any GPU errors.

    Parameters

    • limitTest: "atDefault" | "underDefault" | "betweenDefaultAndMaximum" | "atMaximum" | "overMaximum"
    • testValueName: "atLimit" | "overLimit"
    • fn: ((inputs) => void | Promise<void>)
    • Optional extraLimits: LimitsRequest
    • extraFeatures: GPUFeatureName[] = []

    Returns Promise<void>

  • Creates a device with a specific limit. If the limit of over the maximum we expect an exception If the device is created then we call a test function, checking that the function does not leak any GPU errors.

    Parameters

    • deviceLimitValue: number
    • testValue: number
    • fn: ((inputs) => void | Promise<void>)
    • Optional extraLimits: LimitsRequest
    • Optional features: GPUFeatureName[]

    Returns Promise<void>

  • Calls a function that might expect a validation error. if shouldError is true then expect a validation error, if shouldError is false then ignore out-of-memory errors.

    Type Parameters

    • R

    Parameters

    • fn: (() => R)
        • (): R
        • Returns R

    • shouldError: boolean = true
    • msg: string = ''

    Returns Promise<R>

  • Tests a method on GPUBindingCommandsMixin The function pass will be called with the passEncoder and a bindGroup

    Parameters

    • encoderType: "render" | "compute" | "renderBundle"
    • fn: ((__namedParameters) => void)
        • (__namedParameters): void
        • Parameters

          • __namedParameters: {
                bindGroup: GPUBindGroup;
                passEncoder: GPUBindingCommandsMixin;
            }
            • bindGroup: GPUBindGroup
            • passEncoder: GPUBindingCommandsMixin

          Returns void

    • shouldError: boolean
    • msg: string = ''

    Returns Promise<void>

  • Test a method on GPURenderCommandsMixin or GPUBindingCommandsMixin The function will be called with the passEncoder.

    Parameters

    • encoderType: "render" | "renderBundle"
    • fn: ((__namedParameters) => void)
        • (__namedParameters): void
        • Parameters

          • __namedParameters: {
                bindGroup: GPUBindGroup;
                passEncoder: GPURenderCommandsMixin & GPUBindingCommandsMixin;
            }
            • bindGroup: GPUBindGroup
            • passEncoder: GPURenderCommandsMixin & GPUBindingCommandsMixin

          Returns void

    • shouldError: boolean
    • msg: string = ''

    Returns Promise<void>

  • Parameters

    • limitTest: "atDefault" | "underDefault" | "betweenDefaultAndMaximum" | "atMaximum" | "overMaximum"
    • testValueName: "atLimit" | "overLimit"
    • async: boolean
    • axis: "X" | "Y" | "Z"

    Returns Promise<void>

  • Tracks an object to be cleaned up after the test finishes.

    Usually when creating buffers/textures/query sets, you can use the helpers in GPUTest instead.

    Type Parameters

    • T extends DestroyableObject | Promise<DestroyableObject>

    Parameters

    • o: T

    Returns T

Generated using TypeDoc