typegpu 0.5.3 → 0.5.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typegpu",
   "private": false,
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "A thin layer between JS and WebGPU/WGSL that improves development experience and allows for faster iteration.",
   "license": "MIT",
   "type": "module",
@@ -49,7 +49,7 @@
   },
   "homepage": "https://typegpu.com",
   "dependencies": {
-    "tinyest": "~0.1.0-alpha.6",
+    "tinyest": "~0.1.0-alpha.7",
     "typed-binary": "^4.3.1"
   },
   "main": "./index.js",

package/sampler-CPNwYXSH.d.ts

@@ -0,0 +1,369 @@
+import { F as F32, U as U32, b as I32, d as Vec4f, m as Vec4u, j as Vec4i, C as Default, T as TgpuNamable, x as UnionToIntersection } from './dataTypes-ts2Ccted.js';
+
+interface StorageFlag {
+    usableAsStorage: true;
+}
+/**
+ * @deprecated Use StorageFlag instead.
+ */
+type Storage = StorageFlag;
+declare function isUsableAsStorage<T>(value: T): value is T & StorageFlag;
+
+type TextureProps = {
+    size: readonly number[];
+    format: GPUTextureFormat;
+    viewFormats?: GPUTextureFormat[] | undefined;
+    dimension?: GPUTextureDimension | undefined;
+    mipLevelCount?: number | undefined;
+    sampleCount?: number | undefined;
+};
+
+declare const texelFormatToChannelType: {
+    r8unorm: F32;
+    r8snorm: F32;
+    r8uint: U32;
+    r8sint: I32;
+    r16uint: U32;
+    r16sint: I32;
+    r16float: F32;
+    rg8unorm: F32;
+    rg8snorm: F32;
+    rg8uint: U32;
+    rg8sint: I32;
+    r32uint: U32;
+    r32sint: I32;
+    r32float: F32;
+    rg16uint: U32;
+    rg16sint: I32;
+    rg16float: F32;
+    rgba8unorm: F32;
+    'rgba8unorm-srgb': F32;
+    rgba8snorm: F32;
+    rgba8uint: U32;
+    rgba8sint: I32;
+    bgra8unorm: F32;
+    'bgra8unorm-srgb': F32;
+    rgb9e5ufloat: F32;
+    rgb10a2uint: U32;
+    rgb10a2unorm: F32;
+    rg11b10ufloat: F32;
+    rg32uint: U32;
+    rg32sint: I32;
+    rg32float: F32;
+    rgba16uint: U32;
+    rgba16sint: I32;
+    rgba16float: F32;
+    rgba32uint: U32;
+    rgba32sint: I32;
+    rgba32float: F32;
+    stencil8: F32;
+    depth16unorm: F32;
+    depth24plus: F32;
+    'depth24plus-stencil8': F32;
+    depth32float: F32;
+    'depth32float-stencil8': F32;
+    'bc1-rgba-unorm': F32;
+    'bc1-rgba-unorm-srgb': F32;
+    'bc2-rgba-unorm': F32;
+    'bc2-rgba-unorm-srgb': F32;
+    'bc3-rgba-unorm': F32;
+    'bc3-rgba-unorm-srgb': F32;
+    'bc4-r-unorm': F32;
+    'bc4-r-snorm': F32;
+    'bc5-rg-unorm': F32;
+    'bc5-rg-snorm': F32;
+    'bc6h-rgb-ufloat': F32;
+    'bc6h-rgb-float': F32;
+    'bc7-rgba-unorm': F32;
+    'bc7-rgba-unorm-srgb': F32;
+    'etc2-rgb8unorm': F32;
+    'etc2-rgb8unorm-srgb': F32;
+    'etc2-rgb8a1unorm': F32;
+    'etc2-rgb8a1unorm-srgb': F32;
+    'etc2-rgba8unorm': F32;
+    'etc2-rgba8unorm-srgb': F32;
+    'eac-r11unorm': F32;
+    'eac-r11snorm': F32;
+    'eac-rg11unorm': F32;
+    'eac-rg11snorm': F32;
+    'astc-4x4-unorm': F32;
+    'astc-4x4-unorm-srgb': F32;
+    'astc-5x4-unorm': F32;
+    'astc-5x4-unorm-srgb': F32;
+    'astc-5x5-unorm': F32;
+    'astc-5x5-unorm-srgb': F32;
+    'astc-6x5-unorm': F32;
+    'astc-6x5-unorm-srgb': F32;
+    'astc-6x6-unorm': F32;
+    'astc-6x6-unorm-srgb': F32;
+    'astc-8x5-unorm': F32;
+    'astc-8x5-unorm-srgb': F32;
+    'astc-8x6-unorm': F32;
+    'astc-8x6-unorm-srgb': F32;
+    'astc-8x8-unorm': F32;
+    'astc-8x8-unorm-srgb': F32;
+    'astc-10x5-unorm': F32;
+    'astc-10x5-unorm-srgb': F32;
+    'astc-10x6-unorm': F32;
+    'astc-10x6-unorm-srgb': F32;
+    'astc-10x8-unorm': F32;
+    'astc-10x8-unorm-srgb': F32;
+    'astc-10x10-unorm': F32;
+    'astc-10x10-unorm-srgb': F32;
+    'astc-12x10-unorm': F32;
+    'astc-12x10-unorm-srgb': F32;
+    'astc-12x12-unorm': F32;
+    'astc-12x12-unorm-srgb': F32;
+};
+type TexelFormatToChannelType = typeof texelFormatToChannelType;
+type TexelFormatToStringChannels = {
+    [Key in keyof TexelFormatToChannelType]: TexelFormatToChannelType[Key]['type'];
+};
+type KeysWithValue<T extends Record<string, unknown>, TValue> = keyof {
+    [Key in keyof T as T[Key] extends TValue ? Key : never]: Key;
+};
+type ChannelTypeToLegalFormats = {
+    [Key in TexelFormatToChannelType[keyof TexelFormatToChannelType]['type']]: KeysWithValue<TexelFormatToStringChannels, Key>;
+};
+type SampleTypeToStringChannelType = {
+    float: 'f32';
+    'unfilterable-float': 'f32';
+    depth: 'f32';
+    sint: 'i32';
+    uint: 'u32';
+};
+type ViewDimensionToDimension = {
+    '1d': '1d';
+    '2d': '2d';
+    '2d-array': '2d';
+    '3d': '3d';
+    cube: '2d';
+    'cube-array': '2d';
+};
+/**
+ * https://www.w3.org/TR/WGSL/#storage-texel-formats
+ */
+type StorageTextureTexelFormat = 'rgba8unorm' | 'rgba8snorm' | 'rgba8uint' | 'rgba8sint' | 'rgba16uint' | 'rgba16sint' | 'rgba16float' | 'r32uint' | 'r32sint' | 'r32float' | 'rg32uint' | 'rg32sint' | 'rg32float' | 'rgba32uint' | 'rgba32sint' | 'rgba32float' | 'bgra8unorm';
+declare const texelFormatToDataType: {
+    readonly rgba8unorm: Vec4f;
+    readonly rgba8snorm: Vec4f;
+    readonly rgba8uint: Vec4u;
+    readonly rgba8sint: Vec4i;
+    readonly rgba16uint: Vec4u;
+    readonly rgba16sint: Vec4i;
+    readonly rgba16float: Vec4f;
+    readonly r32uint: Vec4u;
+    readonly r32sint: Vec4i;
+    readonly r32float: Vec4f;
+    readonly rg32uint: Vec4u;
+    readonly rg32sint: Vec4i;
+    readonly rg32float: Vec4f;
+    readonly rgba32uint: Vec4u;
+    readonly rgba32sint: Vec4i;
+    readonly rgba32float: Vec4f;
+    readonly bgra8unorm: Vec4f;
+};
+declare const channelFormatToSchema: {
+    float: F32;
+    'unfilterable-float': F32;
+    uint: U32;
+    sint: I32;
+    depth: F32;
+};
+type ChannelFormatToSchema = typeof channelFormatToSchema;
+type TexelFormatToDataType = typeof texelFormatToDataType;
+type TexelFormatToDataTypeOrNever<T> = T extends keyof TexelFormatToDataType ? TexelFormatToDataType[T] : never;
+/**
+ * Represents what formats a storage view can choose from based on its owner texture's props.
+ */
+type StorageFormatOptions<TProps extends TextureProps> = Extract<TProps['format'] | Default<TProps['viewFormats'], []>[number], StorageTextureTexelFormat>;
+/**
+ * Represents what formats a sampled view can choose from based on its owner texture's props.
+ */
+type SampledFormatOptions<TProps extends TextureProps> = TProps['format'] | Default<TProps['viewFormats'], []>[number];
+
+interface Sampled {
+    usableAsSampled: true;
+}
+interface Render {
+    usableAsRender: true;
+}
+type LiteralToExtensionMap = {
+    storage: StorageFlag;
+    sampled: Sampled;
+    render: Render;
+};
+type AllowedUsages<TProps extends TextureProps> = 'sampled' | 'render' | (TProps['format'] extends StorageTextureTexelFormat ? 'storage' : never);
+declare function isUsableAsSampled<T>(value: T): value is T & Sampled;
+declare function isUsableAsRender<T>(value: T): value is T & Render;
+
+type ResolveStorageDimension<TDimension extends GPUTextureViewDimension, TProps extends TextureProps> = StorageTextureDimension extends TDimension ? Default<TProps['dimension'], '2d'> : TDimension extends StorageTextureDimension ? TDimension : '2d';
+type ViewUsages<TProps extends TextureProps, TTexture extends TgpuTexture<TProps>> = boolean extends TTexture['usableAsSampled'] ? boolean extends TTexture['usableAsStorage'] ? never : 'readonly' | 'writeonly' | 'mutable' : boolean extends TTexture['usableAsStorage'] ? 'sampled' : 'readonly' | 'writeonly' | 'mutable' | 'sampled';
+type ChannelData = U32 | I32 | F32;
+type TexelData = Vec4u | Vec4i | Vec4f;
+/**
+ * @param TProps all properties that distinguish this texture apart from other textures on the type level.
+ */
+interface TgpuTexture<TProps extends TextureProps = TextureProps> extends TgpuNamable {
+    readonly resourceType: 'texture';
+    readonly props: TProps;
+    readonly label: string | undefined;
+    readonly usableAsStorage: boolean;
+    readonly usableAsSampled: boolean;
+    readonly usableAsRender: boolean;
+    $usage<T extends AllowedUsages<TProps>[]>(...usages: T): this & UnionToIntersection<LiteralToExtensionMap[T[number]]>;
+    createView<TUsage extends ViewUsages<TProps, this>, TDimension extends 'sampled' extends TUsage ? GPUTextureViewDimension : StorageTextureDimension, TFormat extends 'sampled' extends TUsage ? SampledFormatOptions<TProps> : StorageFormatOptions<TProps>>(access: TUsage, params?: TextureViewParams<TDimension, TFormat>): {
+        mutable: TgpuMutableTexture<ResolveStorageDimension<TDimension, TProps>, TexelFormatToDataTypeOrNever<StorageFormatOptions<TProps> extends TFormat ? TProps['format'] : TFormat>>;
+        readonly: TgpuReadonlyTexture<ResolveStorageDimension<TDimension, TProps>, TexelFormatToDataTypeOrNever<StorageFormatOptions<TProps> extends TFormat ? TProps['format'] : TFormat>>;
+        writeonly: TgpuWriteonlyTexture<ResolveStorageDimension<TDimension, TProps>, TexelFormatToDataTypeOrNever<StorageFormatOptions<TProps> extends TFormat ? TProps['format'] : TFormat>>;
+        sampled: TgpuSampledTexture<GPUTextureViewDimension extends TDimension ? Default<TProps['dimension'], '2d'> : TDimension, TexelFormatToChannelType[SampledFormatOptions<TProps> extends TFormat ? TProps['format'] : TFormat]>;
+    }[TUsage];
+    destroy(): void;
+}
+type StorageTextureAccess = 'readonly' | 'writeonly' | 'mutable';
+/**
+ * Based on @see GPUTextureViewDimension
+ * https://www.w3.org/TR/WGSL/#texture-depth
+ */
+type StorageTextureDimension = '1d' | '2d' | '2d-array' | '3d';
+type TextureViewParams<TDimension extends GPUTextureViewDimension | undefined, TFormat extends GPUTextureFormat | undefined> = {
+    format?: TFormat;
+    dimension?: TDimension;
+    aspect?: GPUTextureAspect;
+    baseMipLevel?: number;
+    mipLevelCount?: number;
+    baseArrayLayout?: number;
+    arrayLayerCount?: number;
+};
+interface TgpuStorageTexture<TDimension extends StorageTextureDimension = StorageTextureDimension, TData extends TexelData = TexelData> {
+    readonly resourceType: 'texture-storage-view';
+    readonly dimension: TDimension;
+    readonly texelDataType: TData;
+    readonly access: StorageTextureAccess;
+}
+/**
+ * A texture accessed as "readonly" storage on the GPU.
+ */
+interface TgpuReadonlyTexture<TDimension extends StorageTextureDimension = StorageTextureDimension, TData extends TexelData = TexelData> extends TgpuStorageTexture<TDimension, TData> {
+    readonly access: 'readonly';
+}
+/**
+ * A texture accessed as "writeonly" storage on the GPU.
+ */
+interface TgpuWriteonlyTexture<TDimension extends StorageTextureDimension = StorageTextureDimension, TData extends TexelData = TexelData> extends TgpuStorageTexture<TDimension, TData> {
+    readonly access: 'writeonly';
+}
+/**
+ * A texture accessed as "mutable" (or read_write) storage on the GPU.
+ */
+interface TgpuMutableTexture<TDimension extends StorageTextureDimension = StorageTextureDimension, TData extends TexelData = TexelData> extends TgpuStorageTexture<TDimension, TData> {
+    readonly access: 'mutable';
+}
+/**
+ * A texture accessed as sampled on the GPU.
+ */
+interface TgpuSampledTexture<TDimension extends GPUTextureViewDimension = GPUTextureViewDimension, TData extends ChannelData = ChannelData> {
+    readonly resourceType: 'texture-sampled-view';
+    readonly dimension: TDimension;
+    readonly channelDataType: TData;
+}
+declare function isTexture<T extends TgpuTexture>(value: unknown | T): value is T;
+declare function isStorageTextureView<T extends TgpuReadonlyTexture | TgpuWriteonlyTexture | TgpuMutableTexture>(value: unknown | T): value is T;
+declare function isSampledTextureView<T extends TgpuSampledTexture>(value: unknown | T): value is T;
+type TgpuAnyTextureView = TgpuReadonlyTexture | TgpuWriteonlyTexture | TgpuMutableTexture | TgpuSampledTexture;
+
+interface SamplerProps {
+    addressModeU?: GPUAddressMode;
+    addressModeV?: GPUAddressMode;
+    /**
+     * Specifies the address modes for the texture width, height, and depth
+     * coordinates, respectively.
+     */
+    addressModeW?: GPUAddressMode;
+    /**
+     * Specifies the sampling behavior when the sample footprint is smaller than or equal to one
+     * texel.
+     */
+    magFilter?: GPUFilterMode;
+    /**
+     * Specifies the sampling behavior when the sample footprint is larger than one texel.
+     */
+    minFilter?: GPUFilterMode;
+    /**
+     * Specifies behavior for sampling between mipmap levels.
+     */
+    mipmapFilter?: GPUMipmapFilterMode;
+    lodMinClamp?: number;
+    /**
+     * Specifies the minimum and maximum levels of detail, respectively, used internally when
+     * sampling a texture.
+     */
+    lodMaxClamp?: number;
+    /**
+     * Specifies the maximum anisotropy value clamp used by the sampler. Anisotropic filtering is
+     * enabled when {@link GPUSamplerDescriptor.maxAnisotropy} is > 1 and the implementation supports it.
+     * Anisotropic filtering improves the image quality of textures sampled at oblique viewing
+     * angles. Higher {@link GPUSamplerDescriptor.maxAnisotropy} values indicate the maximum ratio of
+     * anisotropy supported when filtering.
+     *
+     * Most implementations support {@link GPUSamplerDescriptor.maxAnisotropy} values in range
+     * between 1 and 16, inclusive. The used value of {@link GPUSamplerDescriptor.maxAnisotropy}
+     * will be clamped to the maximum value that the platform supports.
+     * The precise filtering behavior is implementation-dependent.
+     */
+    maxAnisotropy?: number;
+}
+interface ComparisonSamplerProps {
+    compare: GPUCompareFunction;
+    addressModeU?: GPUAddressMode;
+    addressModeV?: GPUAddressMode;
+    /**
+     * Specifies the address modes for the texture width, height, and depth
+     * coordinates, respectively.
+     */
+    addressModeW?: GPUAddressMode;
+    /**
+     * Specifies the sampling behavior when the sample footprint is smaller than or equal to one
+     * texel.
+     */
+    magFilter?: GPUFilterMode;
+    /**
+     * Specifies the sampling behavior when the sample footprint is larger than one texel.
+     */
+    minFilter?: GPUFilterMode;
+    /**
+     * Specifies behavior for sampling between mipmap levels.
+     */
+    mipmapFilter?: GPUMipmapFilterMode;
+    lodMinClamp?: number;
+    /**
+     * Specifies the minimum and maximum levels of detail, respectively, used internally when
+     * sampling a texture.
+     */
+    lodMaxClamp?: number;
+    /**
+     * Specifies the maximum anisotropy value clamp used by the sampler. Anisotropic filtering is
+     * enabled when {@link GPUSamplerDescriptor.maxAnisotropy} is > 1 and the implementation supports it.
+     * Anisotropic filtering improves the image quality of textures sampled at oblique viewing
+     * angles. Higher {@link GPUSamplerDescriptor.maxAnisotropy} values indicate the maximum ratio of
+     * anisotropy supported when filtering.
+     *
+     * Most implementations support {@link GPUSamplerDescriptor.maxAnisotropy} values in range
+     * between 1 and 16, inclusive. The used value of {@link GPUSamplerDescriptor.maxAnisotropy}
+     * will be clamped to the maximum value that the platform supports.
+     * The precise filtering behavior is implementation-dependent.
+     */
+    maxAnisotropy?: number;
+}
+interface TgpuSampler {
+    readonly resourceType: 'sampler';
+}
+interface TgpuComparisonSampler {
+    readonly resourceType: 'sampler-comparison';
+}
+declare function sampler(props: SamplerProps): TgpuSampler;
+declare function comparisonSampler(props: ComparisonSamplerProps): TgpuComparisonSampler;
+declare function isSampler(resource: unknown): resource is TgpuSampler;
+declare function isComparisonSampler(resource: unknown): resource is TgpuComparisonSampler;
+
+export { type ChannelFormatToSchema as C, type Render as R, type StorageFlag as S, type TgpuTexture as T, type ViewDimensionToDimension as V, type TgpuReadonlyTexture as a, type TgpuWriteonlyTexture as b, type TgpuMutableTexture as c, type TgpuSampledTexture as d, type TgpuSampler as e, type TgpuComparisonSampler as f, type StorageTextureTexelFormat as g, type StorageTextureDimension as h, type TexelFormatToDataType as i, type Sampled as j, type TextureProps as k, type ChannelTypeToLegalFormats as l, type SampleTypeToStringChannelType as m, type TgpuAnyTextureView as n, comparisonSampler as o, isSampler as p, isComparisonSampler as q, isSampledTextureView as r, sampler as s, isStorageTextureView as t, isTexture as u, isUsableAsRender as v, isUsableAsSampled as w, isUsableAsStorage as x, type Storage as y };