ris-framework 0.1.0 → 0.2.0-dev.12

package/src/webgpu/texture/WebGpuTexture2D.ts

@@ -0,0 +1,197 @@
+import {
+    type IFramework,
+    State,
+    TextureDescriptor,
+    TextureUsage,
+    TextureUtilities,
+    type ITextureView,
+    TextureViewDescriptor,
+    TextureViewDimension,
+} from "../../api/index.ts";
+import {ATexture2D} from "../../core/rendering/texture/texture.ts";
+import type {WebGpuGraphicsDevice} from "../WebGpuGraphicsDevice.ts";
+import {GpuTextureUsage, type GpuTexture, type GpuTextureView} from "../WebGpuTypes.ts";
+import {WebGpuConverter} from "../utilities/WebGpuConverter.ts";
+import {WebGpuTextureView} from "./WebGpuTextureView.ts";
+
+/**
+ * The WebGPU 2D texture.
+ *
+ * Supports uncompressed formats with `Uint8Array` mip levels or an `HTMLImageElement`.
+ * Mipmap generation and compressed (KTX2) formats are not implemented for WebGPU yet.
+ * @internal
+ */
+export class WebGpuTexture2D extends ATexture2D {
+
+    private readonly _graphicsDevice: WebGpuGraphicsDevice;
+    private readonly _image?: HTMLImageElement;
+    private _gpuTexture: GpuTexture | null = null;
+    private _gpuDefaultView: GpuTextureView | null = null;
+
+    /**
+     * The constructor.
+     * @param framework The framework.
+     * @param descriptor The texture descriptor.
+     * @param image An optional image to upload instead of `descriptor.data`.
+     */
+    public constructor(framework: IFramework, descriptor: TextureDescriptor, image?: HTMLImageElement) {
+        super(descriptor);
+        this._graphicsDevice = framework.renderer.graphicsDevice as WebGpuGraphicsDevice;
+        this._image = image;
+    }
+
+    /** The WebGPU texture. */
+    public get gpuTexture(): GpuTexture {
+        if (!this._gpuTexture) {
+            throw new Error("WebGpuTexture2D: the texture is not initialized or is disposed.");
+        }
+        return this._gpuTexture;
+    }
+
+    /** The default WebGPU view of the whole texture. */
+    public get gpuDefaultView(): GpuTextureView {
+        if (!this._gpuDefaultView) {
+            throw new Error("WebGpuTexture2D: the texture is not initialized or is disposed.");
+        }
+        return this._gpuDefaultView;
+    }
+
+    /** @inheritDoc */
+    public initialize(): void {
+        if (this._state == State.INITIALIZED) {
+            throw new Error("Texture is already initialized.");
+        } else if (this._state == State.DISPOSED) {
+            throw new Error("Texture is already disposed.");
+        }
+
+        if (TextureUtilities.isCompressedTextureFormat(this.textureFormat)) {
+            throw new Error("Compressed textures are not implemented for WebGPU.");
+        }
+        if (this._generateMipMaps) {
+            console.warn("WebGpuTexture2D: mipmap generation is not implemented for WebGPU; only the base level is used.");
+            this._generateMipMaps = false;
+        }
+
+        const hasData = !!this._data && this._data.length > 0;
+        let usage = WebGpuConverter.convertTextureUsage(this.textureUsage);
+        // Uploading needs COPY_DST; copyExternalImageToTexture also needs RENDER_ATTACHMENT.
+        if (hasData || this._image) {
+            usage |= GpuTextureUsage.COPY_DST;
+        }
+        if (this._image) {
+            usage |= GpuTextureUsage.RENDER_ATTACHMENT;
+        }
+
+        const device = this._graphicsDevice.device;
+        this._gpuTexture = device.createTexture({
+            label: this.label ?? `WebGpuTexture2D ${this.id}`,
+            size: {width: this.width, height: this.height, depthOrArrayLayers: 1},
+            mipLevelCount: this._mipLevels,
+            format: WebGpuConverter.convertTextureFormat(this.textureFormat),
+            usage,
+        });
+
+        if (this._image) {
+            device.queue.copyExternalImageToTexture(
+                {source: this._image},
+                {texture: this._gpuTexture},
+                {width: this.width, height: this.height});
+        } else if (hasData) {
+            let width = this.width;
+            let height = this.height;
+            for (let level = 0; level < this._data!.length; level++) {
+                const levelData = this._data![level];
+                const bytesPerPixel = TextureUtilities.getVRamSize(this.textureFormat, 1, 1);
+                device.queue.writeTexture(
+                    {texture: this._gpuTexture, mipLevel: level},
+                    levelData,
+                    {bytesPerRow: width * bytesPerPixel, rowsPerImage: height},
+                    {width, height});
+                width = Math.max(1, Math.floor(width / 2));
+                height = Math.max(1, Math.floor(height / 2));
+            }
+        }
+
+        this._gpuDefaultView = this._gpuTexture.createView({label: `${this.label ?? "WebGpuTexture2D"} default view`});
+        // ATexture2D declares the default view readonly and sets it to null; fill it in here.
+        (this as { defaultTextureView: ITextureView }).defaultTextureView =
+            new WebGpuTextureView(this._gpuDefaultView, this.textureFormat);
+        this._handle = this._gpuTexture;
+
+        this._state = State.INITIALIZED;
+
+        let width = this.width;
+        let height = this.height;
+        this._size = 0;
+        for (let i = 0; i < this.mipLevels; i++) {
+            this._size += TextureUtilities.getVRamSize(this.textureFormat, width, height);
+            width = Math.max(1, Math.floor(width / 2));
+            height = Math.max(1, Math.floor(height / 2));
+        }
+    }
+
+    /** @inheritDoc */
+    public createView(descriptor?: TextureViewDescriptor): ITextureView {
+        descriptor = descriptor ?? new TextureViewDescriptor();
+        if (descriptor.dimension !== TextureViewDimension.DIMENSION_2D) {
+            throw new Error("Only 2D texture views are implemented for WebGPU.");
+        }
+        const view = this.gpuTexture.createView({
+            label: descriptor.label,
+            format: WebGpuConverter.convertTextureFormat(descriptor.textureFormat),
+            dimension: "2d",
+        });
+        return new WebGpuTextureView(view, descriptor.textureFormat, descriptor.dimension);
+    }
+
+    /** @inheritDoc */
+    public dispose(): void {
+        if (this._state == State.DISPOSING || this._state == State.DISPOSED) {
+            return;
+        }
+        this._gpuTexture?.destroy();
+        this._gpuTexture = null;
+        this._gpuDefaultView = null;
+        this.defaultTextureView?.dispose();
+        this._state = State.DISPOSED;
+
+        for (const listener of this._disposedListeners.slice()) {
+            listener(this);
+        }
+    }
+
+    /** One default texture per framework. */
+    private static readonly _defaultFilled = new WeakMap<IFramework, WebGpuTexture2D>();
+
+    /**
+     * Returns the framework's 1x1 white texture, creating it on first use.
+     * Used when a pipeline has no texture set.
+     * @param framework The framework.
+     */
+    public static getOrCreateDefault(framework: IFramework): WebGpuTexture2D {
+        let texture = WebGpuTexture2D._defaultFilled.get(framework);
+        if (!texture || texture.state === State.DISPOSED) {
+            const desc = new TextureDescriptor();
+            desc.width = 1;
+            desc.height = 1;
+            desc.data = [new Uint8Array([255, 255, 255, 255])];
+            desc.textureFormat = framework.renderer.preferredTextureFormat;
+            desc.textureUsage = TextureUsage.TEXTURE_BINDING | TextureUsage.COPY_DST;
+            desc.label = "RisDefaultFilledTexture";
+            texture = new WebGpuTexture2D(framework, desc);
+            texture.initialize();
+            WebGpuTexture2D._defaultFilled.set(framework, texture);
+        }
+        return texture;
+    }
+
+    /**
+     * Disposes and forgets the framework's default texture. Called from `Framework.dispose()`.
+     * @param framework The framework.
+     */
+    public static disposeDefault(framework: IFramework): void {
+        const texture = WebGpuTexture2D._defaultFilled.get(framework);
+        WebGpuTexture2D._defaultFilled.delete(framework);
+        texture?.dispose();
+    }
+}

package/src/webgpu/texture/WebGpuTextureFactory.ts

@@ -0,0 +1,118 @@
+import {
+    Color,
+    type IFramework,
+    type ITexture2D,
+    type ITextureFactory,
+    TextureDescriptor,
+    TextureFormat,
+    TextureUsage,
+} from "../../api/index.ts";
+import type {IKtx2Texture} from "ris-ktx2";
+import {WebGpuTexture2D} from "./WebGpuTexture2D.ts";
+
+/**
+ * The WebGPU texture factory.
+ * @internal
+ */
+export class WebGpuTextureFactory implements ITextureFactory {
+
+    /**
+     * The constructor.
+     * @param _framework The framework.
+     */
+    public constructor(private readonly _framework: IFramework) {
+    }
+
+    /** @inheritDoc */
+    public createFromKtx2(_ktxTexture: IKtx2Texture, _descriptor?: TextureDescriptor): ITexture2D {
+        throw new Error("createFromKtx2 is not implemented for WebGPU.");
+    }
+
+    /** @inheritDoc */
+    public create(
+        width: number, height: number,
+        data?: number[] | HTMLImageElement | ArrayBufferView,
+        channels: number = 4,
+        label: string | null | undefined = null,
+        textureUsage = TextureUsage.COPY_DST | TextureUsage.TEXTURE_BINDING,
+        textureFormat = TextureFormat.RGBA_8_UNORM,
+        useMipMaps = false): ITexture2D {
+
+        if (!data) {
+            throw new Error("Data must not be null.");
+        }
+        if (width == 0 || height == 0) {
+            throw new Error("width and height must be greater than 0.");
+        }
+        if (channels == 0) {
+            throw new Error("channels must be greater than 0.");
+        }
+        if (textureFormat == TextureFormat.UNDEFINED) {
+            textureFormat = this._framework.renderer.preferredTextureFormat;
+        }
+
+        const desc = new TextureDescriptor();
+        desc.width = width;
+        desc.height = height;
+        desc.textureFormat = textureFormat;
+        desc.textureUsage = textureUsage;
+        desc.generateMipmaps = useMipMaps;
+        desc.label = label ?? null;
+
+        let image: HTMLImageElement | undefined;
+        if (typeof HTMLImageElement !== "undefined" && data instanceof HTMLImageElement) {
+            image = data;
+        } else if (Array.isArray(data)) {
+            desc.data = [new Uint8Array(data)];
+        } else {
+            const view = data as ArrayBufferView;
+            desc.data = [new Uint8Array(view.buffer, view.byteOffset, view.byteLength)];
+        }
+
+        const texture = new WebGpuTexture2D(this._framework, desc, image);
+        texture.initialize();
+        return texture;
+    }
+
+    /** @inheritDoc */
+    public createEmpty(
+        width: number, height: number,
+        color: Color | null = null,
+        textureUsage = TextureUsage.COPY_DST | TextureUsage.TEXTURE_BINDING,
+        textureFormat = TextureFormat.UNDEFINED,
+        label: string | null = null,
+        useMipmap = false): ITexture2D {
+
+        if (width == 0 || height == 0) {
+            throw new Error("Width and height must be greater than 0.");
+        }
+        if (textureFormat == TextureFormat.UNDEFINED) {
+            textureFormat = this._framework.renderer.preferredTextureFormat;
+        }
+
+        const desc = new TextureDescriptor();
+        desc.width = width;
+        desc.height = height;
+        desc.textureUsage = textureUsage;
+        desc.textureFormat = textureFormat;
+        desc.label = label;
+        desc.generateMipmaps = useMipmap;
+
+        // WebGPU zero-initializes textures, so transparent black needs no upload; neither do depth textures.
+        if (!color || (color.r === 0 && color.g === 0 && color.b === 0 && color.a === 0)) {
+            const texture = new WebGpuTexture2D(this._framework, desc);
+            texture.initialize();
+            return texture;
+        }
+
+        const byteSize = width * height * 4;
+        const bytes = new Uint8Array(byteSize);
+        for (let i = 0; i < byteSize; i += 4) {
+            bytes[i] = color.r * 255;
+            bytes[i + 1] = color.g * 255;
+            bytes[i + 2] = color.b * 255;
+            bytes[i + 3] = color.a * 255;
+        }
+        return this.create(width, height, bytes, 4, label, textureUsage, textureFormat, useMipmap);
+    }
+}

package/src/webgpu/texture/WebGpuTextureView.ts

@@ -0,0 +1,43 @@
+import {type ITextureView, TextureFormat, TextureViewDimension} from "../../api/index.ts";
+import type {GpuTextureView} from "../WebGpuTypes.ts";
+
+/**
+ * The WebGPU texture view.
+ * @internal
+ */
+export class WebGpuTextureView implements ITextureView {
+
+    private _gpuTextureView: GpuTextureView | null;
+
+    /**
+     * The constructor.
+     * @param gpuTextureView The WebGPU view.
+     * @param textureFormat The view format.
+     * @param dimension The view dimension.
+     */
+    public constructor(gpuTextureView: GpuTextureView, textureFormat: TextureFormat, dimension = TextureViewDimension.DIMENSION_2D) {
+        this._gpuTextureView = gpuTextureView;
+        this.textureFormat = textureFormat;
+        this.dimension = dimension;
+    }
+
+    /** @inheritDoc */
+    public readonly textureFormat: TextureFormat;
+
+    /** @inheritDoc */
+    public readonly dimension: TextureViewDimension;
+
+    /** The WebGPU view. */
+    public get gpuTextureView(): GpuTextureView {
+        if (!this._gpuTextureView) {
+            throw new Error("WebGpuTextureView: the view is disposed.");
+        }
+        return this._gpuTextureView;
+    }
+
+    /** @inheritDoc */
+    public dispose(): void {
+        // Views have no destroy() in WebGPU; dropping the reference is enough.
+        this._gpuTextureView = null;
+    }
+}

package/src/webgpu/utilities/WebGpuConverter.ts

@@ -0,0 +1,299 @@
+import {
+    BufferUsage,
+    CullMode,
+    FrontFace,
+    LoadAction,
+    MipMapSamplerFilter,
+    PrimitiveTopology,
+    SamplerAddressMode,
+    SamplerFilter,
+    StoreAction,
+    TextureFormat,
+    TextureUsage,
+    VertexStepMode,
+    type IVertexBufferLayout,
+} from "../../api/index.ts";
+import {VertexFormat} from "../../api/geometry/VertexFormat.ts";
+import {BlendFactor, BlendOperation} from "../../core/rendering/blending/enums.ts";
+import {
+    GpuBufferUsage,
+    GpuTextureUsage,
+    type GpuAddressMode,
+    type GpuBlendFactor,
+    type GpuBlendOperation,
+    type GpuCullMode,
+    type GpuFilterMode,
+    type GpuFrontFace,
+    type GpuLoadOp,
+    type GpuPrimitiveTopology,
+    type GpuStoreOp,
+    type GpuTextureFormat,
+    type GpuVertexBufferLayout,
+    type GpuVertexFormat,
+} from "../WebGpuTypes.ts";
+
+/**
+ * Converts framework enums to WebGPU values.
+ * @internal
+ */
+export class WebGpuConverter {
+
+    /** Converts buffer usage flags. */
+    public static convertBufferUsage(usage: BufferUsage): number {
+        let result = 0;
+        if (usage & BufferUsage.VERTEX) result |= GpuBufferUsage.VERTEX;
+        if (usage & BufferUsage.INDEX) result |= GpuBufferUsage.INDEX;
+        if (usage & BufferUsage.UNIFORM) result |= GpuBufferUsage.UNIFORM;
+        if (usage & BufferUsage.STORAGE) result |= GpuBufferUsage.STORAGE;
+        if (usage & BufferUsage.MAP_READ) result |= GpuBufferUsage.MAP_READ;
+        if (usage & BufferUsage.COPY_DST) result |= GpuBufferUsage.COPY_DST;
+        return result;
+    }
+
+    /** Converts texture usage flags. `TextureUsage.NONE` maps to 0. */
+    public static convertTextureUsage(usage: TextureUsage): number {
+        let result = 0;
+        if (usage & TextureUsage.COPY_SRC) result |= GpuTextureUsage.COPY_SRC;
+        if (usage & TextureUsage.COPY_DST) result |= GpuTextureUsage.COPY_DST;
+        if (usage & TextureUsage.TEXTURE_BINDING) result |= GpuTextureUsage.TEXTURE_BINDING;
+        if (usage & TextureUsage.STORAGE_BINDING) result |= GpuTextureUsage.STORAGE_BINDING;
+        if (usage & TextureUsage.RENDER_ATTACHMENT) result |= GpuTextureUsage.RENDER_ATTACHMENT;
+        return result;
+    }
+
+    /** Converts a texture format. Throws for formats the WebGPU backend does not support yet. */
+    public static convertTextureFormat(format: TextureFormat): GpuTextureFormat {
+        switch (format) {
+            case TextureFormat.RGBA_8_UNORM:
+                return "rgba8unorm";
+            case TextureFormat.RGBA_8_UNORM_SRGB:
+                return "rgba8unorm-srgb";
+            case TextureFormat.DEPTH_24_STENCIL_8:
+                return "depth24plus-stencil8";
+            case TextureFormat.DEPTH_32_FLOAT:
+                return "depth32float";
+            case TextureFormat.RED_32_FLOAT:
+                return "r32float";
+
+            // BC (texture-compression-bc). WebGPU has no BC1 RGB, the RGBA variant decodes the same blocks.
+            case TextureFormat.BC1_RGB_UNORM:
+                return "bc1-rgba-unorm";
+            case TextureFormat.BC1_RGB_SRGB:
+                return "bc1-rgba-unorm-srgb";
+            case TextureFormat.BC3_RGBA_UNORM:
+                return "bc3-rgba-unorm";
+            case TextureFormat.BC3_RGBA_SRGB:
+                return "bc3-rgba-unorm-srgb";
+            case TextureFormat.BC7_RGBA_UNORM:
+                return "bc7-rgba-unorm";
+            case TextureFormat.BC7_RGBA_SRGB:
+                return "bc7-rgba-unorm-srgb";
+
+            // ETC2 (texture-compression-etc2)
+            case TextureFormat.ETC2_RGB8_UNORM:
+                return "etc2-rgb8unorm";
+            case TextureFormat.ETC2_RGB8_SRGB:
+                return "etc2-rgb8unorm-srgb";
+            case TextureFormat.ETC2_RGBA8_UNORM:
+                return "etc2-rgba8unorm";
+            case TextureFormat.ETC2_RGBA8_SRGB:
+                return "etc2-rgba8unorm-srgb";
+
+            // ASTC (texture-compression-astc)
+            case TextureFormat.ASTC_4X4_RGBA_UNORM:
+                return "astc-4x4-unorm";
+            case TextureFormat.ASTC_4X4_RGBA_SRGB:
+                return "astc-4x4-unorm-srgb";
+            case TextureFormat.ASTC_5X4_RGBA_UNORM:
+                return "astc-5x4-unorm";
+            case TextureFormat.ASTC_5X4_RGBA_SRGB:
+                return "astc-5x4-unorm-srgb";
+            case TextureFormat.ASTC_5X5_RGBA_UNORM:
+                return "astc-5x5-unorm";
+            case TextureFormat.ASTC_5X5_RGBA_SRGB:
+                return "astc-5x5-unorm-srgb";
+            case TextureFormat.ASTC_6X5_RGBA_UNORM:
+                return "astc-6x5-unorm";
+            case TextureFormat.ASTC_6X5_RGBA_SRGB:
+                return "astc-6x5-unorm-srgb";
+            case TextureFormat.ASTC_6X6_RGBA_UNORM:
+                return "astc-6x6-unorm";
+            case TextureFormat.ASTC_6X6_RGBA_SRGB:
+                return "astc-6x6-unorm-srgb";
+            case TextureFormat.ASTC_8X5_RGBA_UNORM:
+                return "astc-8x5-unorm";
+            case TextureFormat.ASTC_8X5_RGBA_SRGB:
+                return "astc-8x5-unorm-srgb";
+            case TextureFormat.ASTC_8X6_RGBA_UNORM:
+                return "astc-8x6-unorm";
+            case TextureFormat.ASTC_8X6_RGBA_SRGB:
+                return "astc-8x6-unorm-srgb";
+            case TextureFormat.ASTC_8X8_RGBA_UNORM:
+                return "astc-8x8-unorm";
+            case TextureFormat.ASTC_8X8_RGBA_SRGB:
+                return "astc-8x8-unorm-srgb";
+            case TextureFormat.ASTC_10X5_RGBA_UNORM:
+                return "astc-10x5-unorm";
+            case TextureFormat.ASTC_10X5_RGBA_SRGB:
+                return "astc-10x5-unorm-srgb";
+            case TextureFormat.ASTC_10X6_RGBA_UNORM:
+                return "astc-10x6-unorm";
+            case TextureFormat.ASTC_10X6_RGBA_SRGB:
+                return "astc-10x6-unorm-srgb";
+            case TextureFormat.ASTC_10X8_RGBA_UNORM:
+                return "astc-10x8-unorm";
+            case TextureFormat.ASTC_10X8_RGBA_SRGB:
+                return "astc-10x8-unorm-srgb";
+            case TextureFormat.ASTC_10X10_RGBA_UNORM:
+                return "astc-10x10-unorm";
+            case TextureFormat.ASTC_10X10_RGBA_SRGB:
+                return "astc-10x10-unorm-srgb";
+            case TextureFormat.ASTC_12X10_RGBA_UNORM:
+                return "astc-12x10-unorm";
+            case TextureFormat.ASTC_12X10_RGBA_SRGB:
+                return "astc-12x10-unorm-srgb";
+            case TextureFormat.ASTC_12X12_RGBA_UNORM:
+                return "astc-12x12-unorm";
+            case TextureFormat.ASTC_12X12_RGBA_SRGB:
+                return "astc-12x12-unorm-srgb";
+            default:
+                throw new Error(`Texture format ${format} is not implemented for WebGPU.`);
+        }
+    }
+
+    /** Whether the format has a stencil aspect. */
+    public static hasStencil(format: TextureFormat): boolean {
+        return format === TextureFormat.DEPTH_24_STENCIL_8;
+    }
+
+    /** Whether the format is a depth (or depth-stencil) format. */
+    public static isDepthFormat(format: TextureFormat): boolean {
+        return format === TextureFormat.DEPTH_24_STENCIL_8 || format === TextureFormat.DEPTH_32_FLOAT;
+    }
+
+    /** Converts a load action. WebGPU has no "don't care", so `UNDEFINED` clears. */
+    public static convertLoadAction(action: LoadAction): GpuLoadOp {
+        return action === LoadAction.LOAD ? "load" : "clear";
+    }
+
+    /** Converts a store action. */
+    public static convertStoreAction(action: StoreAction): GpuStoreOp {
+        return action === StoreAction.DISCARD ? "discard" : "store";
+    }
+
+    /** Converts a sampler address mode. WebGPU has no border clamp, so it falls back to clamp to edge. */
+    public static convertAddressMode(mode: SamplerAddressMode): GpuAddressMode {
+        switch (mode) {
+            case SamplerAddressMode.REPEAT:
+                return "repeat";
+            case SamplerAddressMode.MIRROR_REPEAT:
+                return "mirror-repeat";
+            default:
+                return "clamp-to-edge";
+        }
+    }
+
+    /** Converts a sampler filter. */
+    public static convertFilter(filter: SamplerFilter): GpuFilterMode {
+        return filter === SamplerFilter.LINEAR ? "linear" : "nearest";
+    }
+
+    /** Converts a mip map filter. `NONE` maps to nearest; the sampler then clamps to mip 0. */
+    public static convertMipMapFilter(filter: MipMapSamplerFilter): GpuFilterMode {
+        return filter === MipMapSamplerFilter.LINEAR ? "linear" : "nearest";
+    }
+
+    /** Converts a blend factor. */
+    public static convertBlendFactor(factor: BlendFactor): GpuBlendFactor {
+        switch (factor) {
+            case BlendFactor.ONE:
+                return "one";
+            case BlendFactor.SRC_ALPHA:
+                return "src-alpha";
+            case BlendFactor.ONE_MINUS_SRC_ALPHA:
+                return "one-minus-src-alpha";
+            default:
+                throw new Error(`Blend factor ${factor} is not implemented for WebGPU.`);
+        }
+    }
+
+    /** Converts a blend operation. */
+    public static convertBlendOperation(operation: BlendOperation): GpuBlendOperation {
+        switch (operation) {
+            case BlendOperation.ADD:
+                return "add";
+            case BlendOperation.SUBTRACT:
+                return "subtract";
+            case BlendOperation.REVERSE_SUBTRACT:
+                return "reverse-subtract";
+            case BlendOperation.MIN:
+                return "min";
+            case BlendOperation.MAX:
+                return "max";
+            default:
+                throw new Error(`Blend operation ${operation} is not implemented for WebGPU.`);
+        }
+    }
+
+    /** Converts a primitive topology. */
+    public static convertTopology(topology: PrimitiveTopology): GpuPrimitiveTopology {
+        switch (topology) {
+            case PrimitiveTopology.LINE_LIST:
+                return "line-list";
+            case PrimitiveTopology.LINE_STRIP:
+                return "line-strip";
+            case PrimitiveTopology.POINT_LIST:
+                return "point-list";
+            case PrimitiveTopology.TRIANGLE_STRIP:
+                return "triangle-strip";
+            default:
+                return "triangle-list";
+        }
+    }
+
+    /** Converts a cull mode. */
+    public static convertCullMode(mode: CullMode): GpuCullMode {
+        switch (mode) {
+            case CullMode.BACK:
+                return "back";
+            case CullMode.FRONT:
+                return "front";
+            default:
+                return "none";
+        }
+    }
+
+    /** Converts a front face. */
+    public static convertFrontFace(face: FrontFace): GpuFrontFace {
+        return face === FrontFace.CW ? "cw" : "ccw";
+    }
+
+    /** Converts a vertex format. */
+    public static convertVertexFormat(format: VertexFormat): GpuVertexFormat {
+        switch (format) {
+            case VertexFormat.FLOAT_32:
+                return "float32";
+            case VertexFormat.FLOAT_32X2:
+                return "float32x2";
+            case VertexFormat.FLOAT_32X3:
+                return "float32x3";
+            case VertexFormat.FLOAT_32X4:
+                return "float32x4";
+            default:
+                throw new Error(`Vertex format ${VertexFormat[format]} is not implemented for WebGPU.`);
+        }
+    }
+
+    /** Converts a vertex buffer layout. */
+    public static convertVertexBufferLayout(layout: IVertexBufferLayout): GpuVertexBufferLayout {
+        return {
+            arrayStride: layout.arrayStride,
+            stepMode: layout.stepMode === VertexStepMode.INSTANCE ? "instance" : "vertex",
+            attributes: layout.attributes.map(attribute => ({
+                format: WebGpuConverter.convertVertexFormat(attribute.format),
+                offset: attribute.offset,
+                shaderLocation: attribute.shaderLocation,
+            })),
+        };
+    }
+}

package/src/wgsl-raw.d.ts

@@ -0,0 +1,4 @@
+declare module "*.wgsl?raw" {
+    const source: string;
+    export default source;
+}

package/dist/api/FrameworkConfiguration.d.ts

@@ -1,23 +0,0 @@
-import { TextureSamplerFilteringPreset } from "../core/rendering/enums.js";
-import { vec2 } from "gl-matrix";
-import type { IFrameworkConfiguration } from "./IFrameworkConfiguration.js";
-import { PowerPreferenceType } from "./rendering/PowerPreference.js";
-/**
- * The options for configuring the Framework.
- * @public
- */
-export declare class FrameworkConfiguration implements IFrameworkConfiguration {
-    /** @inheritDoc */
-    useKtx2: boolean;
-    /** @inheritDoc */
-    canvas?: HTMLCanvasElement;
-    /** @inheritDoc */
-    backBufferSize?: vec2;
-    /** @inheritDoc */
-    textureFiltering?: TextureSamplerFilteringPreset | undefined;
-    /** @inheritDoc */
-    alpha: boolean;
-    /** @inheritDoc */
-    powerPreference: PowerPreferenceType;
-}
-//# sourceMappingURL=FrameworkConfiguration.d.ts.map

package/dist/api/FrameworkConfiguration.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FrameworkConfiguration.d.ts","sourceRoot":"","sources":["../../src/api/FrameworkConfiguration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAC3E,OAAO,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AAC/B,OAAO,KAAK,EAAC,uBAAuB,EAAC,MAAM,8BAA8B,CAAC;AAC1E,OAAO,EAAC,mBAAmB,EAAC,MAAM,gCAAgC,CAAC;AAEnE;;;GAGG;AACH,qBAAa,sBAAuB,YAAW,uBAAuB;IAElE,kBAAkB;IAClB,OAAO,UAAS;IAEhB,kBAAkB;IAClB,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAE3B,kBAAkB;IAClB,cAAc,CAAC,EAAE,IAAI,CAAC;IAEtB,kBAAkB;IAClB,gBAAgB,CAAC,4CAA0C;IAE3D,kBAAkB;IAClB,KAAK,UAAS;IAEd,kBAAkB;IAClB,eAAe,sBAA+B;CACjD"}