bind and explicit binding helpers

import { bind, createBindGroup, createBindGroupLayout, createPipelineLayout, createSampler } from "vgpu/core";

import type { Buffer, Device, Texture } from "vgpu/core";
 
type BindVisibility = GPUShaderStageFlags | string | readonly ("vertex" | "fragment" | "compute")[];
type DeviceLike = GPUDevice | Device | { readonly gpu: GPUDevice };
 
interface CreateBindGroupLayoutOptions {
  readonly label?: string;
  readonly entries: readonly GPUBindGroupLayoutEntry[];
}
 
interface CreatePipelineLayoutOptions {
  readonly label?: string;
  readonly bindGroups: readonly GPUBindGroupLayout[];
}
 
interface CreateBindGroupOptions {
  readonly label?: string;
  readonly layout: GPUBindGroupLayout;
  readonly entries: readonly GPUBindGroupEntry[];
}
 
interface SamplerDescriptorWithSugar extends GPUSamplerDescriptor {
  readonly filter?: "linear" | "nearest";
  readonly wrap?: "clamp" | "repeat" | "mirror";
}
 
declare function createBindGroupLayout(device: DeviceLike, opts: CreateBindGroupLayoutOptions): GPUBindGroupLayout;
declare function createPipelineLayout(device: DeviceLike, opts: CreatePipelineLayoutOptions): GPUPipelineLayout;
declare function createBindGroup(device: DeviceLike, opts: CreateBindGroupOptions): GPUBindGroup;
declare function createSampler(device: DeviceLike, descriptor?: SamplerDescriptorWithSugar): GPUSampler;
 
declare const bind: {
  readonly uniform: (binding: number, visibility: BindVisibility, opts?: Omit<GPUBufferBindingLayout, "type">) => GPUBindGroupLayoutEntry;
  readonly storage: (binding: number, visibility: BindVisibility, opts?: Omit<GPUBufferBindingLayout, "type">) => GPUBindGroupLayoutEntry;
  readonly readonlyStorage: (binding: number, visibility: BindVisibility, opts?: Omit<GPUBufferBindingLayout, "type">) => GPUBindGroupLayoutEntry;
  readonly texture: (binding: number, visibility: BindVisibility, opts?: GPUTextureBindingLayout) => GPUBindGroupLayoutEntry;
  readonly storageTexture: (binding: number, visibility: BindVisibility, opts: GPUStorageTextureBindingLayout) => GPUBindGroupLayoutEntry;
  readonly sampler: (binding: number, visibility: BindVisibility, opts?: GPUSamplerBindingLayout) => GPUBindGroupLayoutEntry;
  readonly resource: (binding: number, value: Buffer | Texture | GPUBuffer | GPUBufferBinding | GPUBindingResource | unknown) => GPUBindGroupEntry;
};

import { bind, createBindGroup, createBindGroupLayout, createPipelineLayout, createSampler } from "vgpu/core";
import { createMockAdapter } from "vgpu/mock";
 
const device = await createMockAdapter().requestDevice();
const uniformBuffer = device.createBuffer({ size: 64, usage: ["uniform", "copy_dst"] });
const texture = device.createTexture({
  size: [1, 1],
  format: "rgba8unorm",
  usage: ["texture_binding", "copy_src"],
});
const sampler = createSampler(device, { filter: "linear", wrap: "clamp" });
 
const groupLayout = createBindGroupLayout(device, {
  label: "scene.group0",
  entries: [
    bind.uniform(0, "vertex|fragment"),
    bind.texture(1, "fragment", { sampleType: "float" }),
    bind.sampler(2, ["fragment"], { type: "filtering" }),
  ],
});
 
const pipelineLayout = createPipelineLayout(device, { bindGroups: [groupLayout] });
const group = createBindGroup(device, {
  layout: groupLayout,
  entries: [
    bind.resource(0, uniformBuffer),
    bind.resource(1, texture),
    bind.resource(2, sampler),
  ],
});
 
console.log(pipelineLayout, group);
device.destroy();

import { createSampler } from "vgpu/core";
import { createMockAdapter } from "vgpu/mock";
 
const device = await createMockAdapter().requestDevice();
 
const mixedSampler = createSampler(device, {
  filter: "linear",
  wrap: "repeat",
  magFilter: "nearest", // raw field wins for this key only
});
 
const anisotropicSampler = createSampler(device, {
  filter: "linear",
  mipmapFilter: "linear",
  maxAnisotropy: 16,
});
 
console.log(mixedSampler, anisotropicSampler);
device.destroy();

import { bind, createBindGroupLayout } from "vgpu/core";
import { createMockAdapter } from "vgpu/mock";
 
const device = await createMockAdapter().requestDevice();
const computeLayout = createBindGroupLayout(device, {
  entries: [
    bind.storage(0, "compute", { hasDynamicOffset: true }),
    bind.storageTexture(1, "compute", { access: "write-only", format: "rgba8unorm", viewDimension: "2d" }),
  ],
});
 
console.log(computeLayout);
device.destroy();