@derschmale/tiny-helix 0.1.0 → 0.2.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025 David Lenaerts
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2025 David Lenaerts
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,95 +1,95 @@
-# tiny-helix
-
-A lightweight TypeScript library for WebGPU, built as an ES6 module.
-
-## Quickstart
-
-Install:
-
-```bash
-npm install tiny-helix
-```
-
-Or for development from source:
-
-```bash
-git clone https://github.com/DerSchmale/tiny-helix.git
-cd tiny-helix
-npm install
-npm run build:debug   # builds non-minified debug bundles with source maps
-```
-
-## Usage (browser)
-
-Basic example showing initialization and a simple render loop:
-
-```ts
-import TinyHelix from 'tiny-helix';
-
-const app = new TinyHelix();
-await app.initialize({ canvas: document.querySelector('canvas')! });
-
-function frame() {
-  app.startFrame();
-  const encoder = app.createCommandEncoder('frame-encoder');
-
-  // Simple clear pass: create a render pass, set the clear color and end the pass.
-  // This uses the backbuffer as the default target.
-  const clearPass = encoder.createRenderPass()
-    .withLabel('clear-pass')
-    .withClearColor(0.1, 0.12, 0.15, 1.0) // r,g,b,a
-    .build();
-
-  clearPass.end();
-
-  encoder.submit();
-  requestAnimationFrame(frame);
-}
-
-frame();
-```
-
-## Debug build and source maps
-
-A development-friendly debug build is included. It produces readable, non-minified bundles with full source maps. The debug builds output the following files into `dist/`:
-
-- `tiny-helix.debug.js` + `tiny-helix.debug.js.map` (UMD / CommonJS-like build)
-- `tiny-helix.esm.debug.js` + `tiny-helix.esm.debug.js.map` (ESM build)
-
-To create the debug bundles run:
-
-```bash
-npm run build:debug
-```
-
-The webpack configuration is set up so source maps use `file:///...` absolute file URLs instead of the `webpack://` scheme. This prevents browsers from attempting to resolve `webpack://` sources when consuming the package as a module.
-
-## API overview
-
-This project exposes a small set of helpers and wrappers for working with WebGPU in TypeScript. The main entry points are:
-
-- `TinyHelix` (default export): High-level manager for a WebGPU context, backbuffer and helpers for creating render targets, shaders, meshes and render pipelines.
-- `WebGPUContext`: Low-level context manager that handles adapter/device initialization and canvas configuration.
-- `CommandEncoder`: Helper for recording and submitting GPU commands per-frame.
-- `RenderPass`, `RenderPipeline`, `RenderTarget`, `Shader`, `Mesh`, `Texture`, and buffer helpers.
-
-See the inline JSDoc comments in `src/` for detailed method and type information. TypeScript consumers will get typings from the `dist/index.d.ts` entry.
-
-## Development notes
-
-- Use `npm run build` to produce production bundles (minified, optimized).
-- Use `npm run build:debug` to produce debug bundles with full source maps.
-- For TypeScript projects, install `@webgpu/types` for better type completion:
-
-```bash
-npm install --save-dev @webgpu/types
-```
-
-## Requirements
-
-- A browser with WebGPU support
-- For TypeScript projects, you may want to install `@webgpu/types` for full type definitions
-
-## License
-
-MIT License - see [LICENSE](./LICENSE) for details.
+# tiny-helix
+
+A lightweight TypeScript library for WebGPU, built as an ES6 module.
+
+## Quickstart
+
+Install:
+
+```bash
+npm install tiny-helix
+```
+
+Or for development from source:
+
+```bash
+git clone https://github.com/DerSchmale/tiny-helix.git
+cd tiny-helix
+npm install
+npm run build:debug   # builds non-minified debug bundles with source maps
+```
+
+## Usage (browser)
+
+Basic example showing initialization and a simple render loop:
+
+```ts
+import TinyHelix from 'tiny-helix';
+
+const app = new TinyHelix();
+await app.initialize({ canvas: document.querySelector('canvas')! });
+
+function frame() {
+  app.startFrame();
+  const encoder = app.createCommandEncoder('frame-encoder');
+
+  // Simple clear pass: create a render pass, set the clear color and end the pass.
+  // This uses the backbuffer as the default target.
+  const clearPass = encoder.createRenderPass()
+    .withLabel('clear-pass')
+    .withClearColor(0.1, 0.12, 0.15, 1.0) // r,g,b,a
+    .build();
+
+  clearPass.end();
+
+  encoder.submit();
+  requestAnimationFrame(frame);
+}
+
+frame();
+```
+
+## Debug build and source maps
+
+A development-friendly debug build is included. It produces readable, non-minified bundles with full source maps. The debug builds output the following files into `dist/`:
+
+- `tiny-helix.debug.js` + `tiny-helix.debug.js.map` (UMD / CommonJS-like build)
+- `tiny-helix.esm.debug.js` + `tiny-helix.esm.debug.js.map` (ESM build)
+
+To create the debug bundles run:
+
+```bash
+npm run build:debug
+```
+
+The webpack configuration is set up so source maps use `file:///...` absolute file URLs instead of the `webpack://` scheme. This prevents browsers from attempting to resolve `webpack://` sources when consuming the package as a module.
+
+## API overview
+
+This project exposes a small set of helpers and wrappers for working with WebGPU in TypeScript. The main entry points are:
+
+- `TinyHelix` (default export): High-level manager for a WebGPU context, backbuffer and helpers for creating render targets, shaders, meshes and render pipelines.
+- `WebGPUContext`: Low-level context manager that handles adapter/device initialization and canvas configuration.
+- `CommandEncoder`: Helper for recording and submitting GPU commands per-frame.
+- `RenderPass`, `RenderPipeline`, `RenderTarget`, `Shader`, `Mesh`, `Texture`, and buffer helpers.
+
+See the inline JSDoc comments in `src/` for detailed method and type information. TypeScript consumers will get typings from the `dist/index.d.ts` entry.
+
+## Development notes
+
+- Use `npm run build` to produce production bundles (minified, optimized).
+- Use `npm run build:debug` to produce debug bundles with full source maps.
+- For TypeScript projects, install `@webgpu/types` for better type completion:
+
+```bash
+npm install --save-dev @webgpu/types
+```
+
+## Requirements
+
+- A browser with WebGPU support
+- For TypeScript projects, you may want to install `@webgpu/types` for full type definitions
+
+## License
+
+MIT License - see [LICENSE](./LICENSE) for details.

package/dist/BindGroup.d.ts

@@ -2,10 +2,10 @@
 import { WebGPUContext } from "./WebGPUContext";
 import { UniformBuffer, UniformBufferLayout } from "./buffers/UniformBuffer";
 import { IBuffer } from "./buffers/IBuffer";
-import { Texture, TextureView } from "./Texture";
+import { TextureView } from "./Texture";
 import { Sampler } from "./Sampler";
 import { TextureFormat } from "../dist";
-import { StorageAccess } from "./enums";
+import { SamplerType, StorageAccess, TextureSampleType, TextureViewDimension } from "./enums";
 /**
  * Lightweight wrapper around a GPUBindGroup.
  * Use {@link TinyHelix.createBindGroup} to create instances.
@@ -43,7 +43,7 @@ export declare class BindGroupBuilder {
      */
     withBuffer(fieldName: string, buffer: IBuffer): this;
     /** Attach a texture to the bind group. */
-    withTexture(fieldName: string, texture: Texture | TextureView): this;
+    withTexture(fieldName: string, texture: TextureView): this;
     /** Attach a sampler to the bind group at the given binding index. */
     withSampler(fieldName: string, sampler: Sampler): this;
     /**
@@ -96,23 +96,24 @@ declare class BindGroupLayoutBuilder {
     /**
      * Add a storage buffer binding at the given index and record its layout.
      * @param index - binding index
-     * @param field_name - a name used to reference the layout later
-     * @param access_mode - Defines whether the storage buffer is read-only or not.
+     * @param fieldName - a name used to reference the layout later
+     * @param accessMode - Defines whether the storage buffer is read-only or not.
      * @param visibility - shader stage visibility flags (defaults to FRAGMENT|COMPUTE)
      */
-    withStorageBuffer(index: number, field_name: string, access_mode: StorageAccess, visibility?: GPUShaderStageFlags): this;
+    withStorageBuffer(index: number, fieldName: string, accessMode: StorageAccess, minBindingSize?: number, visibility?: GPUShaderStageFlags): this;
     /**
      * Add a storage texture binding at the given index. The texture will be
      * write-only and use RGBA8Unorm format.
      * @param index
-     * @param field_name
+     * @param fieldName
      * @param format
-     * @param access_mode
+     * @param accessMode
      * @param visibility
+     * @param viewDimension
      */
-    withStorageTexture(index: number, field_name: string, format: TextureFormat, access_mode: StorageAccess, visibility?: GPUShaderStageFlags): this;
-    withTexture(index: number, field_name: string, visibility?: GPUShaderStageFlags): this;
-    withSampler(index: number, field_name: string, visibility?: GPUShaderStageFlags): this;
+    withStorageTexture(index: number, fieldName: string, format: TextureFormat, accessMode: StorageAccess, visibility?: GPUShaderStageFlags, viewDimension?: TextureViewDimension): this;
+    withTexture(index: number, fieldName: string, visibility?: GPUShaderStageFlags, viewDimension?: TextureViewDimension, sampleType?: TextureSampleType): this;
+    withSampler(index: number, fieldName: string, samplerType?: SamplerType, visibility?: GPUShaderStageFlags): this;
     /**
      * Create the underlying GPUBindGroupLayout and return a wrapped `BindGroupLayout`.
      */

package/dist/ComputePipeline.d.ts

@@ -10,8 +10,10 @@ export declare class ComputePipelineBuilder {
     private _label?;
     private _shader;
     private _entry;
+    private _overrideConstants;
     constructor(ctx: WebGPUContext);
     withLabel(label: string): this;
+    withOverrideConstant(id: string, value: number): this;
     /** Select the shader entry point for the fragment stage. */
     withShader(shader: Shader, entry: string): this;
     build(): ComputePipeline;

package/dist/Mesh.d.ts

@@ -144,7 +144,7 @@ export declare class StreamBuilder {
      * Upload vertex data for this stream. `keepOnCPU` controls whether the
      * source ArrayBuffer is retained in memory for readback.
      */
-    withData(data: ArrayBufferLike, keepOnCPU?: boolean): void;
+    withData(data: ArrayBufferLike, byteOffset?: number, byteLength?: number, keepOnCPU?: boolean): void;
 }
 /**
  * Fluent builder for creating a Mesh. Use `pushStream()` to describe vertex

package/dist/RenderPass.d.ts

@@ -4,6 +4,8 @@ import { RenderPipeline } from "./RenderPipeline";
 import { Mesh } from "./Mesh";
 import { BindGroup } from "./BindGroup";
 import { IndexedCollection } from "./utils/IndexedCollection";
+import { StoreOp } from "./enums";
+import { Buffer } from "./buffers/Buffer";
 /**
  * Lightweight wrapper around GPURenderPassEncoder. Provides a minimal API
  * for ending the pass; higher-level helpers may be added later.
@@ -37,7 +39,13 @@ export declare class RenderPass {
     /**
      * Issue a draw call using the currently set pipeline and mesh.
      */
-    draw(): this;
+    draw(numInstances?: number): this;
+    /**
+     * Issue an indirect draw call using the currently set pipeline and mesh.
+     * @param indirectBuffer A Buffer containing the draw parameters. The buffer must have been created with the `Indirect` usage flag.
+     * @param indirectOffset The offset in bytes into the indirectBuffer where the draw parameters are stored. Must be a multiple of 4.
+     */
+    drawIndirect(indirectBuffer: Buffer, indirectOffset?: number): this;
     /**
      * End the render pass. After calling end(), the underlying encoder may
      * continue recording other passes or be finished/submitted.
@@ -61,6 +69,7 @@ export declare class RenderPassBuilder {
     private _clearDepth?;
     private _clearStencil?;
     private _globalBindGroups;
+    private _storeOps;
     /**
      * Create a new builder instance. This should only be called from the CommandEncoder
      * instance (see {@link CommandEncoder.createRenderPass}).
@@ -80,11 +89,17 @@ export declare class RenderPassBuilder {
     /**
      * Set the clear color for the most recently added color target.
      * Overloads allow passing an array or individual color components.
+     * Be sure to call this unless you really want to load the existing contents of the target.
      */
     withClearColor(): this;
     withClearColor(r: number[] | IndexedCollection): this;
     withClearColor(r: number, g: number, b: number): this;
     withClearColor(r: number, g: number, b: number, a: number): this;
+    /**
+     * Set the store operation for the most recently added color target. Defaults to 'store' if not specified.
+     * @param storeOp
+     */
+    withStoreOp(storeOp: StoreOp): this;
     /**
      * Set the clear stencil value
      */

package/dist/RenderPipeline.d.ts

@@ -59,15 +59,27 @@ export declare class RenderPipelineBuilder {
      * @param compare
      */
     withDepthCompare(compare: CompareFunction): this;
+    /**
+     * Sets the depth bias for each triangle.
+     * @param depthBias Constant depth bias added to each triangle fragment.
+     * @param slopeScale Depth bias that scales with the triangle fragment’s slope.
+     * @param max The maximum depth bias of a triangle fragment.
+     */
+    withDepthBias(depthBias: number, slopeScale?: number, max?: number): this;
     /**
      * Enable or disable depth writes. Default is `true`.
      * @param enabled
      */
     withDepthWrite(enabled: boolean): this;
-    /** Override a shader constant for specialization. */
-    withOverrideConstant(id: string, value: number): this;
+    /**
+     * Override a shader constant for specialization. We do NOT use `ShaderStage.Vertex | ShaderStage.Fragment` as
+     * default because some browser implementations (as of early 2026) have bugs when a non-existent constant is defined
+     */
+    withOverrideConstant(id: string, value: number, pipeline: GPUShaderStageFlags): this;
     /** Set the blend mode for the last assigned (or default) color target. */
     withBlendMode(blendMode: BlendMode): this;
+    /** Set the color write mask for the last assigned (or default) color target. */
+    withColorWrite(r: boolean, g?: boolean, b?: boolean, a?: boolean): this;
     /**
      * Build and create the `RenderPipeline`. Throws if required pieces (shader/vertices)
      * are missing.

package/dist/Sampler.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="@webgpu/types" />
 import { WebGPUContext } from "./WebGPUContext";
-import { AddressMode, FilterMode } from "./enums";
+import { AddressMode, CompareFunction, FilterMode } from "./enums";
 export declare class Sampler {
     readonly _inner: GPUSampler;
     private static DEFAULT_TRILINEAR;
@@ -8,17 +8,9 @@ export declare class Sampler {
 }
 export declare class SamplerBuilder {
     private _ctx;
-    private _addressModeU?;
-    private _addressModeV?;
-    private _addressModeW?;
-    private _minFilter?;
-    private _magFilter?;
-    private _mipmapFilter?;
-    private _minMipLevel?;
-    private _maxMipLevel?;
-    private _maxAnisotropy?;
-    private _compare?;
+    private _desc;
     constructor(ctx: WebGPUContext);
+    withLabel(label: string): this;
     withAddressMode(u: AddressMode, v?: AddressMode, w?: AddressMode): this;
     withFiltering(minFilter: FilterMode, magFilter?: FilterMode, mipmapFilter?: FilterMode): this;
     withTrilinearFiltering(): this;
@@ -26,6 +18,6 @@ export declare class SamplerBuilder {
     withAnisotropicFiltering(maxAnisotropy: number): this;
     withMinMipLevel(level: number): this;
     withMaxMipLevel(level: number): this;
-    withCompareFunction(compare: GPUCompareFunction): this;
+    withCompareFunction(compare: CompareFunction): this;
     build(): Sampler;
 }

package/dist/Shader.d.ts

@@ -17,6 +17,7 @@ export declare class Shader {
      * @internal
      */
     constructor(inner: GPUShaderModule, ctx: WebGPUContext, vertexAttributes: AttributeMap, bindGroupLayouts?: BindGroupLayout[]);
+    getCompilationInfo(): Promise<GPUCompilationInfo>;
     /**
      * Get the shader location for a named vertex attribute. Returns undefined if the attribute
      * is not declared by the shader.
@@ -64,7 +65,7 @@ export declare class ShaderBuilder {
      */
     withInclude(name: string, code: string): this;
     /** Declare a named vertex attribute and the location it maps to in the shader. */
-    withVertexAttribute(name: string, location: number): this;
+    withVertexAttribute(location: number, name: string): this;
     /**
      * Declare a bind group layout used by this shader. The provided builder
      * callback is used to construct the layout description.

package/dist/Texture.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="@webgpu/types" />
 import { WebGPUContext } from "./WebGPUContext";
-import { TextureFormat } from "./enums";
+import { TextureDimension, TextureFormat, TextureViewDimension } from "./enums";
 import { IBuffer } from "./buffers/IBuffer";
 import { TextureUsage } from "./buffers/Buffer";
 /**
@@ -11,27 +11,43 @@ export declare class Texture implements IBuffer {
     /** @internal */
     readonly _inner: GPUTexture;
     private _format;
+    private _ctx;
+    private _mipper?;
     /**
-     * Create a Texture wrapper from an existing GPUTexture.
-     * @param texture - The underlying GPUTexture
+     * @internal
      */
-    static from_webgpu(texture: GPUTexture, format: TextureFormat): Texture;
-    constructor(inner: GPUTexture, format: TextureFormat);
+    static from_webgpu(texture: GPUTexture, format: TextureFormat, ctx: WebGPUContext, mipShader?: GPUShaderModule): Texture;
+    constructor(inner: GPUTexture, format: TextureFormat, ctx: WebGPUContext, mipShader?: GPUShaderModule);
     createView(): TextureViewBuilder;
     get format(): TextureFormat;
+    get mipLevelCount(): number;
+    get width(): number;
+    get height(): number;
+    get depthOrArrayLayers(): number;
     _getBufferResource(): GPUBindingResource;
+    uploadImage(data: ImageBitmap, mipLevel?: number): void;
+    uploadData(data: GPUAllowSharedBufferSource, mipLevel?: number): void;
+    generateMipmaps(): void;
+    dimension(): TextureDimension;
 }
 export declare class TextureBuilder {
     private _ctx;
     private _size;
-    private _data;
+    private _data?;
     private _format;
     private _usage;
-    constructor(ctx: WebGPUContext);
+    private _dimension;
+    private _mipLevelCount;
+    private _generateMips;
+    private _mipShader;
+    constructor(ctx: WebGPUContext, mipShader: GPUShaderModule);
     withSize(width: number, height: number, depthOrArrayLayers?: number): this;
-    withData(data: GPUAllowSharedBufferSource): this;
+    withDimension(dim: TextureDimension): this;
+    withMipLevels(count?: number): this;
     withFormat(format: TextureFormat): this;
-    withImage(data: ImageBitmap): this;
+    withData(data: GPUAllowSharedBufferSource, mipLevel?: number): this;
+    withImage(data: ImageBitmap, mipLevel?: number): this;
+    withGeneratedMipmaps(): this;
     withUsage(usage: TextureUsage): this;
     build(): Texture;
 }
@@ -47,9 +63,22 @@ export declare class TextureViewBuilder {
      * @internal
      */
     constructor(texture: Texture);
+    withUsage(usage: TextureUsage): this;
     withSingleMip(level: number): this;
     withMipRange(start: number, end: number): this;
     withSingleLayer(layer: number): this;
     withLayerRange(start: number, end: number): this;
+    withDimension(dim: TextureViewDimension): this;
     build(): TextureView;
 }
+export declare class TextureUtils {
+    static isBc(format: TextureFormat): boolean;
+    static isEtc(format: TextureFormat): boolean;
+    static getBlockWidth(format: TextureFormat): number;
+    /**
+     * Returns the number of bytes in a compressed or uncompressed block for the
+     * given texture format. Matches the mapping from the Rust implementation and
+     * throws for unsupported formats.
+     */
+    static bytesPerBlock(format: TextureFormat): number;
+}

package/dist/TinyHelix.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="@webgpu/types" />
 import { WebGPUContextOptions } from './WebGPUContext';
 import { CommandEncoder } from "./CommandEncoder";
 import { Texture, TextureBuilder } from "./Texture";
@@ -23,6 +24,7 @@ export interface TinyHelixOptions extends WebGPUContextOptions {
  * backbuffer and provides helpers to create render targets and command encoders.
  */
 export declare class TinyHelix {
+    private _parent;
     private _context;
     private _options;
     private _backbuffer?;
@@ -31,12 +33,30 @@ export declare class TinyHelix {
     private _depthStencilTarget?;
     private _shaderIncludes;
     private _canvas;
-    private _globalBindBufferLayouts;
-    private _globalBindBuffers;
-    /**
-     * Create a new TinyHelix instance. Call `initialize()` before rendering.
-     */
-    constructor(canvas: HTMLCanvasElement);
+    private _globalBindGroupLayouts;
+    private _globalBindGroups;
+    private _mipShader;
+    /**
+      * Create a new TinyHelix instance from a HTMLCanvasElement or an existing TinyHelix instance.
+     *  When creating from a Canvas, call `initialize()` before rendering to initialize the WebGPU context. When
+     *  using an existing TinyHelix instance, the new instance will share the same WebGPU context and resources.
+      */
+    constructor(canvasOrHX: HTMLCanvasElement | TinyHelix);
+    get shaderF16Supported(): boolean;
+    get floatFilteringSupported(): boolean;
+    get adapter(): GPUAdapter;
+    get device(): GPUDevice;
+    get context(): GPUCanvasContext;
+    /**
+     * Copies all shader includes from another TinyHelix instance.
+     * @param hx - The TinyHelix instance to copy includes from.
+     */
+    copyIncludesFrom(hx: TinyHelix): this;
+    /**
+     * Copies all global bind groups from another TinyHelix instance.
+     * @param hx - The TinyHelix instance to copy global bind groups from.
+     */
+    copyGlobalBindGroupsFrom(hx: TinyHelix): this;
     /**
      * Initializes the underlying WebGPU context and prepares resources.
      * @param options - Configuration options forwarded to the WebGPU context

package/dist/WebGPUContext.d.ts

@@ -24,6 +24,8 @@ export declare class WebGPUContext {
     private _format;
     private _canvas;
     private _colorSpace;
+    private _shaderF16Supported;
+    private _floatFilteringSupported;
     /**
      * Gets the WebGPU adapter. Throws if not initialized.
      */
@@ -58,6 +60,15 @@ export declare class WebGPUContext {
      * @throws Error if WebGPU is not supported or initialization fails
      */
     initialize(options?: WebGPUContextOptions): Promise<void>;
+    /**
+     * Indicates whether the shaders support the f16 format. Use the type `half`, `vec2h`, `vec3h`, `vec4h`, etc. to
+     * provide f32 fallbacks if f16 is not supported.
+     */
+    get shaderF16Supported(): boolean;
+    /**
+     * Indicates whether the device supports filtering on float32 textures.
+     */
+    get floatFilteringSupported(): boolean;
     /**
      * Internal helper to fetch the current swapchain texture.
      * @internal

package/dist/buffers/Buffer.d.ts

@@ -39,6 +39,7 @@ export declare class BufferBuilder {
     private _size;
     private _keepData;
     private _usage;
+    private _dataOffset;
     constructor(ctx: WebGPUContext);
     /**
      * Add usage flags for the GPU buffer.
@@ -49,7 +50,7 @@ export declare class BufferBuilder {
      * ArrayBuffer is stored in the resulting `Buffer.data` field for readback or
      * reuse.
      */
-    withData(data: ArrayBufferLike, keepOnCPU?: boolean): this;
+    withData(data: ArrayBufferLike, keepOnCPU?: boolean, offset?: number, length?: number): this;
     /**
      * Specify a size for the buffer, used when not providing data.
      */

package/dist/enums.d.ts

@@ -156,3 +156,42 @@ export declare enum StorageAccess {
     Read = "read-only",
     Write = "write-only"
 }
+export declare enum TextureSampleType {
+    Float = "float",
+    Sint = "sint",
+    Uint = "uint",
+    UnfilterableFloat = "unfilterable-float",
+    Depth = "depth"
+}
+export declare enum SamplerType {
+    Filtering = "filtering",
+    NonFiltering = "non-filtering",
+    Comparison = "comparison"
+}
+export declare enum ColorChannel {
+    Red,
+    Green,
+    Blue
+}
+export declare enum TextureDimension {
+    D1 = "1d",
+    D2 = "2d",
+    D3 = "3d"
+}
+export declare enum TextureViewDimension {
+    D1 = "1d",
+    D2 = "2d",
+    D2Array = "2d-array",
+    Cube = "cube",
+    CubeArray = "cube-array",
+    D3 = "3d"
+}
+export declare enum ShaderStage {
+    Vertex,
+    Fragment,
+    Compute
+}
+export declare enum StoreOp {
+    Store = "store",
+    Discard = "discard"
+}