ris-framework 0.2.0-dev.11 → 0.2.0-dev.12

package/src/webgpu/WebGpuGraphicsDevice.ts

@@ -0,0 +1,199 @@
+import {AGraphicsDevice, type IGraphicsDeviceDescriptor} from "../core/rendering/AGraphicsDevice.ts";
+import type {BlendStateDescriptor} from "../core/rendering/blending/blend-state-descriptor.ts";
+import type {SamplerDescriptor} from "../core/rendering/sampler/sampler-descriptor.ts";
+import {
+    type IBlendState,
+    type IGPUInfo,
+    type IPrimitiveState,
+    type IRenderPass,
+    type ISampler,
+    type ISwapChain,
+    type IWindowManager,
+    PrimitiveStateDescriptor,
+    RenderPassDescriptor,
+    SwapChainDescriptor,
+} from "../api/index.ts";
+import {getNavigatorGpu, type GpuAdapter, type GpuDevice, type GpuRenderPassEncoder} from "./WebGpuTypes.ts";
+import {PowerPreferenceType} from "../api/rendering/PowerPreference.ts";
+import {WebGpuGraphicsDeviceFeatures} from "./WebGpuGraphicsDeviceFeatures.ts";
+import {WebGpuGpuInfo} from "./WebGpuGpuInfo.ts";
+import {WebGpuSwapChain} from "./swap-chain/WebGpuSwapChain.ts";
+import {WebGpuSampler} from "./sampler/WebGpuSampler.ts";
+import {WebGpuRenderPass} from "./render-pass/WebGpuRenderPass.ts";
+import {WebGpuBlendState} from "./blending/WebGpuBlendState.ts";
+import {WebGpuPrimitiveState} from "./primitive/WebGpuPrimitiveState.ts";
+
+/**
+ * The WebGPU graphics device. It requests its own adapter and device in {@link createAsync},
+ * so everything after creation is synchronous like WebGL.
+ * @internal
+ */
+export class WebGpuGraphicsDevice extends AGraphicsDevice {
+
+    private readonly _windowManager: IWindowManager;
+    private readonly _adapter: GpuAdapter;
+    private readonly _device: GpuDevice;
+    private _features: WebGpuGraphicsDeviceFeatures = null!;
+    private _gpuInfo: WebGpuGpuInfo = null!;
+    private _swapChain: WebGpuSwapChain | null = null;
+
+    /**
+     * The render pass encoder of the pass that is currently open, or null between passes.
+     * Set by {@link WebGpuRenderPass.beginPass}, like `currentRenderPassEncoder` in the C# device.
+     */
+    public currentRenderPassEncoder: GpuRenderPassEncoder | null = null;
+
+    /**
+     * Creates the graphics device: requests the WebGPU adapter and device.
+     * Throws when WebGPU is unavailable or no adapter is found.
+     * @param windowManager The window manager.
+     * @param descriptor The device descriptor.
+     * @returns The created graphics device.
+     */
+    public static async createAsync(windowManager: IWindowManager, descriptor: IGraphicsDeviceDescriptor): Promise<WebGpuGraphicsDevice> {
+        const gpu = getNavigatorGpu();
+        if (!gpu) {
+            throw new Error("WebGPU is not supported: navigator.gpu is missing.");
+        }
+        const preference = descriptor.powerPreference;
+        const adapter = await gpu.requestAdapter(
+            preference && preference !== PowerPreferenceType.DEFAULT
+                ? {powerPreference: preference as unknown as "low-power" | "high-performance"}
+                : undefined);
+        if (!adapter) {
+            throw new Error("WebGPU is not supported: no adapter was found.");
+        }
+        // WebGPU only enables the features that are requested, so ask for every compression family the adapter has.
+        const requiredFeatures = ["texture-compression-bc", "texture-compression-etc2", "texture-compression-astc"]
+            .filter(feature => adapter.features.has(feature));
+        const device = await adapter.requestDevice({label: "RisFramework WebGPU device", requiredFeatures});
+        return new WebGpuGraphicsDevice(windowManager, descriptor, adapter, device);
+    }
+
+    /**
+     * The constructor. Use {@link createAsync} to create the device.
+     * @param windowManager The window manager.
+     * @param descriptor The device descriptor.
+     * @param adapter The WebGPU adapter.
+     * @param device The WebGPU device.
+     */
+    private constructor(windowManager: IWindowManager, descriptor: IGraphicsDeviceDescriptor, adapter: GpuAdapter, device: GpuDevice) {
+        super(descriptor);
+        this._windowManager = windowManager;
+        this._adapter = adapter;
+        this._device = device;
+    }
+
+    /** The WebGPU device. */
+    public get device(): GpuDevice {
+        return this._device;
+    }
+
+    /** The WebGPU adapter. */
+    public get adapter(): GpuAdapter {
+        return this._adapter;
+    }
+
+    /** Whether the canvas should keep its alpha channel. */
+    public get alpha(): boolean {
+        return this._descriptor.alpha;
+    }
+
+    /** The swap chain, once created. */
+    public get swapChain(): WebGpuSwapChain | null {
+        return this._swapChain;
+    }
+
+    /** The window manager. */
+    public get windowManager(): IWindowManager {
+        return this._windowManager;
+    }
+
+    /** @inheritDoc */
+    public get features(): WebGpuGraphicsDeviceFeatures {
+        return this._features;
+    }
+
+    /** @inheritDoc */
+    public get gpuInfo(): IGPUInfo {
+        return this._gpuInfo;
+    }
+
+    /** The current render pass encoder. Throws when no pass is open. */
+    public get renderPassEncoder(): GpuRenderPassEncoder {
+        if (!this.currentRenderPassEncoder) {
+            throw new Error("WebGpuGraphicsDevice: no render pass is open. Draw calls must happen between beginRenderPass and endRenderPass.");
+        }
+        return this.currentRenderPassEncoder;
+    }
+
+    /** @inheritDoc */
+    public initialize(): void {
+        this._features = new WebGpuGraphicsDeviceFeatures(this._device.features);
+        this._gpuInfo = new WebGpuGpuInfo(this._adapter, this._features);
+        this.setupDebugCallback();
+        super.initialize();
+    }
+
+    /** @inheritDoc */
+    public createSwapChain(canvas: HTMLCanvasElement, descriptor: SwapChainDescriptor): ISwapChain {
+        this._swapChain?.dispose();
+        this._swapChain = new WebGpuSwapChain(canvas, this, descriptor);
+        return this._swapChain;
+    }
+
+    /** @inheritDoc */
+    public createSampler(descriptor?: SamplerDescriptor): ISampler {
+        return new WebGpuSampler(this, descriptor);
+    }
+
+    /** @inheritDoc */
+    public createRenderPass(descriptor: RenderPassDescriptor): IRenderPass {
+        return new WebGpuRenderPass(this, descriptor);
+    }
+
+    /** @inheritDoc */
+    public createBlendState(descriptor: BlendStateDescriptor): IBlendState {
+        return new WebGpuBlendState(descriptor);
+    }
+
+    /** @inheritDoc */
+    public createPrimitiveState(descriptor?: PrimitiveStateDescriptor): IPrimitiveState {
+        return new WebGpuPrimitiveState(descriptor ?? new PrimitiveStateDescriptor());
+    }
+
+    /** @inheritDoc */
+    public setupDebugCallback(): void {
+        this._device.addEventListener("uncapturederror", event => {
+            console.error(`WebGPU error: ${event.error.message}`);
+        });
+        this._device.lost.then(info => {
+            if (info.reason !== "destroyed") {
+                console.error(`WebGPU device lost (${info.reason}): ${info.message}`);
+            }
+        }).catch(() => { /* ignore */ });
+    }
+
+    /** @inheritDoc */
+    public frameEnd(): void {
+        // Command buffers are submitted at the end of every render pass, so nothing is pending here.
+    }
+
+    /** @inheritDoc */
+    public pushDebugGroup(groupName: string): void {
+        this.currentRenderPassEncoder?.pushDebugGroup(groupName);
+    }
+
+    /** @inheritDoc */
+    public popDebugGroup(): void {
+        this.currentRenderPassEncoder?.popDebugGroup();
+    }
+
+    /** @inheritDoc */
+    public dispose(): void {
+        super.dispose();
+        this._swapChain?.dispose();
+        this._swapChain = null;
+        this._device.destroy();
+    }
+}

package/src/webgpu/WebGpuGraphicsDeviceFeatures.ts

@@ -0,0 +1,41 @@
+import type {IGraphicsDeviceFeatures} from "../api/index.ts";
+import type {GpuSupportedFeatures} from "./WebGpuTypes.ts";
+
+/**
+ * The WebGPU graphics device features, read from the device's enabled features.
+ * @internal
+ */
+export class WebGpuGraphicsDeviceFeatures implements IGraphicsDeviceFeatures {
+
+    /**
+     * The constructor.
+     * @param features The device's enabled features.
+     */
+    public constructor(features: GpuSupportedFeatures) {
+        this.supportsTextureCompressionBC = features.has("texture-compression-bc");
+        // S3TC (BC1-BC3) is part of the WebGPU BC feature.
+        this.supportsTextureCompressionS3TC = this.supportsTextureCompressionBC;
+        this.supportsTextureCompressionS3TCSrgb = this.supportsTextureCompressionBC;
+        this.supportsTextureCompressionETC2 = features.has("texture-compression-etc2");
+        this.supportsTextureCompressionASTC = features.has("texture-compression-astc");
+        this.supportsTextureCompressionPVRTC = false;
+    }
+
+    /** @inheritDoc */
+    public readonly supportsTextureCompressionS3TC: boolean;
+
+    /** @inheritDoc */
+    public readonly supportsTextureCompressionS3TCSrgb: boolean;
+
+    /** @inheritDoc */
+    public readonly supportsTextureCompressionBC: boolean;
+
+    /** @inheritDoc */
+    public readonly supportsTextureCompressionETC2: boolean;
+
+    /** @inheritDoc */
+    public readonly supportsTextureCompressionASTC: boolean;
+
+    /** @inheritDoc */
+    public readonly supportsTextureCompressionPVRTC: boolean;
+}

package/src/webgpu/WebGpuRenderer.ts

@@ -0,0 +1,49 @@
+import {ARenderer} from "../core/rendering/ARenderer.ts";
+import {type IFramework, type IGraphicsDevice, type IRendererConfiguration, RenderingBackend} from "../api/index.ts";
+import {WebGpuGraphicsDevice} from "./WebGpuGraphicsDevice.ts";
+import {getNavigatorGpu} from "./WebGpuTypes.ts";
+
+/**
+ * The WebGPU renderer. WebGPU hands out the adapter and device asynchronously, so call
+ * {@link acquireDeviceAsync} (done by `Framework.initializeAsync()`) before {@link initialize}.
+ * @internal
+ */
+export class WebGpuRenderer extends ARenderer {
+
+    private _createdDevice: WebGpuGraphicsDevice | null = null;
+
+    /**
+     * The constructor.
+     * @param framework The framework.
+     * @param renderConfiguration The renderer configuration.
+     */
+    public constructor(framework: IFramework, renderConfiguration: IRendererConfiguration) {
+        super(framework, renderConfiguration);
+        this.backend = RenderingBackend.WEB_GPU;
+    }
+
+    /** Whether the browser exposes `navigator.gpu`. */
+    public static isSupported(): boolean {
+        return getNavigatorGpu() !== undefined;
+    }
+
+    /**
+     * Creates the graphics device, which requests its own adapter and device.
+     * Throws when WebGPU is unavailable or no adapter is found.
+     */
+    public async acquireDeviceAsync(): Promise<void> {
+        this._createdDevice = await WebGpuGraphicsDevice.createAsync(this._framework.windowManager, {
+            samplerFilteringPreset: this._renderConfiguration.textureFiltering,
+            alpha: this._renderConfiguration.alpha,
+            powerPreference: this._renderConfiguration.powerPreference,
+        });
+    }
+
+    /** @inheritDoc */
+    protected createGraphicsDevice(): IGraphicsDevice {
+        if (!this._createdDevice) {
+            throw new Error("WebGpuRenderer: the device is not created. Use Framework.initializeAsync() for WebGPU.");
+        }
+        return this._createdDevice;
+    }
+}

package/src/webgpu/WebGpuTypes.ts

@@ -0,0 +1,288 @@
+/**
+ * Minimal hand-written WebGPU type declarations used by the WebGPU backend.
+ *
+ * TypeScript 5.9's `lib.dom` does not ship the WebGPU API, and the project avoids adding `@webgpu/types`.
+ * The types are module-scoped (prefixed with `Gpu`) instead of global, so they never clash with `@webgpu/types`
+ * in a consumer's project. Only what the backend uses is declared.
+ * @internal
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/** `GPUBufferUsage` flags. */
+export const GpuBufferUsage = {
+    MAP_READ: 0x0001,
+    MAP_WRITE: 0x0002,
+    COPY_SRC: 0x0004,
+    COPY_DST: 0x0008,
+    INDEX: 0x0010,
+    VERTEX: 0x0020,
+    UNIFORM: 0x0040,
+    STORAGE: 0x0080,
+    INDIRECT: 0x0100,
+    QUERY_RESOLVE: 0x0200,
+} as const;
+
+/** `GPUTextureUsage` flags. */
+export const GpuTextureUsage = {
+    COPY_SRC: 0x01,
+    COPY_DST: 0x02,
+    TEXTURE_BINDING: 0x04,
+    STORAGE_BINDING: 0x08,
+    RENDER_ATTACHMENT: 0x10,
+} as const;
+
+/** `GPUShaderStage` flags. */
+export const GpuShaderStage = {
+    VERTEX: 0x1,
+    FRAGMENT: 0x2,
+    COMPUTE: 0x4,
+} as const;
+
+export type GpuTextureFormat = string;
+export type GpuPowerPreference = "low-power" | "high-performance";
+export type GpuLoadOp = "load" | "clear";
+export type GpuStoreOp = "store" | "discard";
+export type GpuIndexFormat = "uint16" | "uint32";
+export type GpuPrimitiveTopology = "point-list" | "line-list" | "line-strip" | "triangle-list" | "triangle-strip";
+export type GpuCullMode = "none" | "front" | "back";
+export type GpuFrontFace = "ccw" | "cw";
+export type GpuBlendFactor = "zero" | "one" | "src-alpha" | "one-minus-src-alpha" | string;
+export type GpuBlendOperation = "add" | "subtract" | "reverse-subtract" | "min" | "max";
+export type GpuAddressMode = "clamp-to-edge" | "repeat" | "mirror-repeat";
+export type GpuFilterMode = "nearest" | "linear";
+export type GpuCompareFunction = "never" | "less" | "equal" | "less-equal" | "greater" | "not-equal" | "greater-equal" | "always";
+export type GpuVertexFormat = "float32" | "float32x2" | "float32x3" | "float32x4" | string;
+export type GpuVertexStepMode = "vertex" | "instance";
+
+export interface GpuObjectBase {
+    label: string;
+}
+
+export interface GpuAdapterInfo {
+    readonly vendor: string;
+    readonly architecture: string;
+    readonly device: string;
+    readonly description: string;
+}
+
+export interface GpuSupportedFeatures {
+    has(feature: string): boolean;
+}
+
+export interface Gpu {
+    requestAdapter(options?: { powerPreference?: GpuPowerPreference }): Promise<GpuAdapter | null>;
+    getPreferredCanvasFormat(): GpuTextureFormat;
+}
+
+export interface GpuAdapter {
+    readonly features: GpuSupportedFeatures;
+    readonly info?: GpuAdapterInfo;
+    requestDevice(descriptor?: { label?: string; requiredFeatures?: string[] }): Promise<GpuDevice>;
+}
+
+export interface GpuError {
+    readonly message: string;
+}
+
+export interface GpuDevice extends GpuObjectBase {
+    readonly features: GpuSupportedFeatures;
+    readonly queue: GpuQueue;
+    readonly lost: Promise<{ reason: string; message: string }>;
+    createBuffer(descriptor: { label?: string; size: number; usage: number; mappedAtCreation?: boolean }): GpuBuffer;
+    createTexture(descriptor: {
+        label?: string;
+        size: [number, number, number?] | { width: number; height?: number; depthOrArrayLayers?: number };
+        mipLevelCount?: number;
+        sampleCount?: number;
+        dimension?: "1d" | "2d" | "3d";
+        format: GpuTextureFormat;
+        usage: number;
+    }): GpuTexture;
+    createSampler(descriptor?: {
+        label?: string;
+        addressModeU?: GpuAddressMode;
+        addressModeV?: GpuAddressMode;
+        addressModeW?: GpuAddressMode;
+        magFilter?: GpuFilterMode;
+        minFilter?: GpuFilterMode;
+        mipmapFilter?: GpuFilterMode;
+        lodMinClamp?: number;
+        lodMaxClamp?: number;
+        compare?: GpuCompareFunction;
+        maxAnisotropy?: number;
+    }): GpuSampler;
+    createBindGroupLayout(descriptor: { label?: string; entries: GpuBindGroupLayoutEntry[] }): GpuBindGroupLayout;
+    createPipelineLayout(descriptor: { label?: string; bindGroupLayouts: GpuBindGroupLayout[] }): GpuPipelineLayout;
+    createBindGroup(descriptor: { label?: string; layout: GpuBindGroupLayout; entries: GpuBindGroupEntry[] }): GpuBindGroup;
+    createShaderModule(descriptor: { label?: string; code: string }): GpuShaderModule;
+    createRenderPipeline(descriptor: GpuRenderPipelineDescriptor): GpuRenderPipeline;
+    createCommandEncoder(descriptor?: { label?: string }): GpuCommandEncoder;
+    pushErrorScope(filter: "validation" | "out-of-memory" | "internal"): void;
+    popErrorScope(): Promise<GpuError | null>;
+    addEventListener(type: "uncapturederror", listener: (event: { error: GpuError }) => void): void;
+    destroy(): void;
+}
+
+export interface GpuQueue {
+    submit(commandBuffers: GpuCommandBuffer[]): void;
+    writeBuffer(buffer: GpuBuffer, bufferOffset: number, data: ArrayBufferLike | ArrayBufferView, dataOffset?: number, size?: number): void;
+    writeTexture(
+        destination: { texture: GpuTexture; mipLevel?: number; origin?: [number, number, number?] },
+        data: ArrayBufferView | ArrayBufferLike,
+        dataLayout: { offset?: number; bytesPerRow?: number; rowsPerImage?: number },
+        size: [number, number, number?] | { width: number; height?: number; depthOrArrayLayers?: number }): void;
+    copyExternalImageToTexture(
+        source: { source: any; flipY?: boolean },
+        destination: { texture: GpuTexture; mipLevel?: number; premultipliedAlpha?: boolean },
+        copySize: [number, number, number?] | { width: number; height?: number; depthOrArrayLayers?: number }): void;
+}
+
+export interface GpuBuffer extends GpuObjectBase {
+    readonly size: number;
+    destroy(): void;
+}
+
+export interface GpuTexture extends GpuObjectBase {
+    readonly width: number;
+    readonly height: number;
+    readonly format: GpuTextureFormat;
+    createView(descriptor?: { label?: string; format?: GpuTextureFormat; dimension?: string }): GpuTextureView;
+    destroy(): void;
+}
+
+export interface GpuTextureView extends GpuObjectBase {
+    readonly __brand?: "GPUTextureView";
+}
+
+export interface GpuSampler extends GpuObjectBase {
+    readonly __brand?: "GPUSampler";
+}
+
+export interface GpuBindGroupLayout extends GpuObjectBase {
+    readonly __brand?: "GPUBindGroupLayout";
+}
+
+export interface GpuPipelineLayout extends GpuObjectBase {
+    readonly __brand?: "GPUPipelineLayout";
+}
+
+export interface GpuBindGroup extends GpuObjectBase {
+    readonly __brand?: "GPUBindGroup";
+}
+
+export interface GpuShaderModule extends GpuObjectBase {
+    getCompilationInfo?(): Promise<{ messages: readonly { type: string; message: string; lineNum: number; linePos: number }[] }>;
+}
+
+export interface GpuRenderPipeline extends GpuObjectBase {
+    readonly __brand?: "GPURenderPipeline";
+}
+
+export interface GpuCommandBuffer extends GpuObjectBase {
+    readonly __brand?: "GPUCommandBuffer";
+}
+
+export interface GpuBindGroupLayoutEntry {
+    binding: number;
+    visibility: number;
+    buffer?: { type?: "uniform" | "storage" | "read-only-storage"; hasDynamicOffset?: boolean; minBindingSize?: number };
+    sampler?: { type?: "filtering" | "non-filtering" | "comparison" };
+    texture?: { sampleType?: "float" | "unfilterable-float" | "depth" | "sint" | "uint"; viewDimension?: string; multisampled?: boolean };
+}
+
+export interface GpuBindGroupEntry {
+    binding: number;
+    resource: GpuSampler | GpuTextureView | { buffer: GpuBuffer; offset?: number; size?: number };
+}
+
+export interface GpuVertexBufferLayout {
+    arrayStride: number;
+    stepMode?: GpuVertexStepMode;
+    attributes: { format: GpuVertexFormat; offset: number; shaderLocation: number }[];
+}
+
+export interface GpuBlendComponent {
+    operation?: GpuBlendOperation;
+    srcFactor?: GpuBlendFactor;
+    dstFactor?: GpuBlendFactor;
+}
+
+export interface GpuColorTargetState {
+    format: GpuTextureFormat;
+    blend?: { color: GpuBlendComponent; alpha: GpuBlendComponent };
+    writeMask?: number;
+}
+
+export interface GpuDepthStencilState {
+    format: GpuTextureFormat;
+    depthWriteEnabled?: boolean;
+    depthCompare?: GpuCompareFunction;
+}
+
+export interface GpuRenderPipelineDescriptor {
+    label?: string;
+    layout: GpuPipelineLayout | "auto";
+    vertex: { module: GpuShaderModule; entryPoint?: string; buffers?: GpuVertexBufferLayout[] };
+    fragment?: { module: GpuShaderModule; entryPoint?: string; targets: GpuColorTargetState[] };
+    primitive?: { topology?: GpuPrimitiveTopology; cullMode?: GpuCullMode; frontFace?: GpuFrontFace; stripIndexFormat?: GpuIndexFormat };
+    depthStencil?: GpuDepthStencilState;
+    multisample?: { count?: number };
+}
+
+export interface GpuRenderPassColorAttachment {
+    view: GpuTextureView;
+    resolveTarget?: GpuTextureView;
+    clearValue?: { r: number; g: number; b: number; a: number };
+    loadOp: GpuLoadOp;
+    storeOp: GpuStoreOp;
+}
+
+export interface GpuRenderPassDepthStencilAttachment {
+    view: GpuTextureView;
+    depthClearValue?: number;
+    depthLoadOp?: GpuLoadOp;
+    depthStoreOp?: GpuStoreOp;
+    stencilClearValue?: number;
+    stencilLoadOp?: GpuLoadOp;
+    stencilStoreOp?: GpuStoreOp;
+}
+
+export interface GpuRenderPassDescriptor {
+    label?: string;
+    colorAttachments: GpuRenderPassColorAttachment[];
+    depthStencilAttachment?: GpuRenderPassDepthStencilAttachment;
+}
+
+export interface GpuCommandEncoder extends GpuObjectBase {
+    beginRenderPass(descriptor: GpuRenderPassDescriptor): GpuRenderPassEncoder;
+    finish(descriptor?: { label?: string }): GpuCommandBuffer;
+}
+
+export interface GpuRenderPassEncoder extends GpuObjectBase {
+    setPipeline(pipeline: GpuRenderPipeline): void;
+    setVertexBuffer(slot: number, buffer: GpuBuffer, offset?: number, size?: number): void;
+    setIndexBuffer(buffer: GpuBuffer, format: GpuIndexFormat, offset?: number, size?: number): void;
+    setBindGroup(index: number, bindGroup: GpuBindGroup): void;
+    drawIndexed(indexCount: number, instanceCount?: number, firstIndex?: number, baseVertex?: number, firstInstance?: number): void;
+    draw(vertexCount: number, instanceCount?: number, firstVertex?: number, firstInstance?: number): void;
+    pushDebugGroup(label: string): void;
+    popDebugGroup(): void;
+    end(): void;
+}
+
+export interface GpuCanvasContext {
+    configure(configuration: { device: GpuDevice; format: GpuTextureFormat; usage?: number; alphaMode?: "opaque" | "premultiplied" }): void;
+    unconfigure(): void;
+    getCurrentTexture(): GpuTexture;
+}
+
+/**
+ * Returns `navigator.gpu`, or undefined when the browser has no WebGPU.
+ */
+export function getNavigatorGpu(): Gpu | undefined {
+    if (typeof navigator === "undefined") {
+        return undefined;
+    }
+    return (navigator as unknown as { gpu?: Gpu }).gpu ?? undefined;
+}

package/src/webgpu/blending/WebGpuBlendState.ts

@@ -0,0 +1,53 @@
+import type {BlendStateDescriptor} from "../../core/rendering/blending/blend-state-descriptor.ts";
+import type {IBlendState} from "../../api/index.ts";
+import type {GpuBlendComponent} from "../WebGpuTypes.ts";
+import {WebGpuConverter} from "../utilities/WebGpuConverter.ts";
+
+/**
+ * The WebGPU blend state. WebGPU bakes blending into the render pipeline, so this only holds the converted values.
+ * @internal
+ */
+export class WebGpuBlendState implements IBlendState {
+
+    /**
+     * The constructor.
+     * @param descriptor The blend state descriptor.
+     */
+    public constructor(descriptor: BlendStateDescriptor) {
+        this.blendingEnabled = descriptor.blendingEnabled;
+        this.color = {
+            srcFactor: WebGpuConverter.convertBlendFactor(descriptor.color.srcFactor),
+            dstFactor: WebGpuConverter.convertBlendFactor(descriptor.color.dstFactor),
+            operation: WebGpuConverter.convertBlendOperation(descriptor.color.operation),
+        };
+        this.alpha = {
+            srcFactor: WebGpuConverter.convertBlendFactor(descriptor.alpha.srcFactor),
+            dstFactor: WebGpuConverter.convertBlendFactor(descriptor.alpha.dstFactor),
+            operation: WebGpuConverter.convertBlendOperation(descriptor.alpha.operation),
+        };
+    }
+
+    /** Whether blending is enabled. */
+    public readonly blendingEnabled: boolean;
+
+    /** The color blend component. */
+    public readonly color: GpuBlendComponent;
+
+    /** The alpha blend component. */
+    public readonly alpha: GpuBlendComponent;
+
+    /** The `GPUBlendState` for a color target, or undefined when blending is disabled. */
+    public get gpuBlendState(): { color: GpuBlendComponent; alpha: GpuBlendComponent } | undefined {
+        return this.blendingEnabled ? {color: this.color, alpha: this.alpha} : undefined;
+    }
+
+    /** @inheritDoc */
+    public get nativePtr(): any {
+        return this.gpuBlendState;
+    }
+
+    /** @inheritDoc */
+    public dispose(): void {
+        // Nothing to release.
+    }
+}

package/src/webgpu/buffers/WebGpuBuffersFactory.ts

@@ -0,0 +1,46 @@
+import {
+    BufferUsage,
+    type IBufferFactory,
+    type IFramework,
+    type IIndexBuffer,
+    type IUniformBuffer,
+    type IVertexBuffer,
+} from "../../api/index.ts";
+import {WebGpuVertexBuffer} from "./WebGpuVertexBuffer.ts";
+import {WebGpuIndexBuffer} from "./WebGpuIndexBuffer.ts";
+import {WebGpuUniformBuffer} from "./WebGpuUniformBuffer.ts";
+
+/**
+ * The WebGPU buffers factory.
+ * @internal
+ */
+export class WebGpuBuffersFactory implements IBufferFactory {
+
+    /**
+     * The constructor.
+     * @param _framework The framework.
+     */
+    public constructor(private readonly _framework: IFramework) {
+    }
+
+    /** @inheritDoc */
+    public createVertexBuffer(data: ArrayLike<number>, vertexStride: number, usage: BufferUsage = BufferUsage.VERTEX | BufferUsage.COPY_DST, label?: string): IVertexBuffer {
+        const buffer = new WebGpuVertexBuffer(this._framework, data, vertexStride, usage, label);
+        buffer.initialize();
+        return buffer;
+    }
+
+    /** @inheritDoc */
+    public createUniformBuffer(data: ArrayLike<number>, usage: BufferUsage = BufferUsage.UNIFORM | BufferUsage.COPY_DST, label?: string): IUniformBuffer {
+        const buffer = new WebGpuUniformBuffer(this._framework, data, usage, label);
+        buffer.initialize();
+        return buffer;
+    }
+
+    /** @inheritDoc */
+    public createIndexBuffer(data: ArrayLike<number>, label?: string): IIndexBuffer {
+        const buffer = new WebGpuIndexBuffer(this._framework, label);
+        buffer.initialize(data);
+        return buffer;
+    }
+}