@aethervtt/shard-render 0.0.1

package/dist/gpu-assets.d.ts

@@ -0,0 +1,114 @@
+import { type World } from '@aethervtt/shard-core';
+import type { GpuContext } from '@aethervtt/shard-gpu';
+import type { Mesh } from '@aethervtt/shard-mesh';
+import { type Texture } from '@aethervtt/shard-texture';
+import { type MaterialAsset } from './assets.js';
+import type { MaterialType } from './materials.js';
+import type { GpuMemoryData } from './stats.js';
+export interface GpuMesh {
+    version: number;
+    generation: number;
+    positions: GPUBuffer;
+    normals: GPUBuffer;
+    uvs: GPUBuffer;
+    uvs1: GPUBuffer;
+    tangents: GPUBuffer;
+    indices: GPUBuffer | undefined;
+    indexFormat: GPUIndexFormat;
+    count: number;
+    /** The index buffer belongs to every GPU mesh sharing its array (`Mesh.gpu`): never destroyed here. */
+    sharedIndices: boolean;
+    /** The vertex buffers belong to another mesh (`Mesh.gpu` with `share`). */
+    sharedVertices: boolean;
+    /** Where this mesh's vertices start in its (shared) vertex buffers. */
+    baseVertex: number;
+}
+export interface GpuMaterial {
+    version: number;
+    generation: number;
+    /** The material type's version the GPU copy was built for. */
+    typeVersion: number;
+    type: MaterialType;
+    buffer: GPUBuffer;
+    textureBuffer: GPUBuffer;
+    /** The type's own uniform, when it has numeric fields. */
+    ownBuffer: GPUBuffer | undefined;
+    bindGroup: GPUBindGroup | undefined;
+    /** What the bind group was built from, to rebuild when a texture changes. */
+    bound: (GpuTexture | undefined)[];
+    ownBound: (GpuTexture | undefined)[];
+}
+export interface GpuTexture {
+    texture: GPUTexture;
+    linear: GPUTextureView;
+    srgb: GPUTextureView;
+    /** 2D-array views (the texture's own for arrays; one layer for plain 2D textures). */
+    arrayLinear: GPUTextureView | undefined;
+    arraySrgb: GPUTextureView | undefined;
+    version: number;
+    generation: number;
+    bytes: number;
+}
+/**
+ * GPU copies of meshes, textures, and materials, shared by every pass that draws them (forward,
+ * shadows, G-buffer, previews). Each is uploaded on first use and again when its version changes,
+ * and rebuilt after a device loss.
+ */
+export declare class GpuAssets {
+    readonly meshes: Map<Mesh, GpuMesh>;
+    readonly materials: Map<MaterialAsset, GpuMaterial>;
+    readonly textures: Map<Texture, GpuTexture>;
+    private defaults;
+    private readonly samplers;
+    /** Textures scratch for the slot lookup (no per-frame allocation). */
+    private readonly slotTextures;
+    /** Guids reloading after device loss, so each is requested once. */
+    private readonly reloading;
+    /** Per frame: whether each material's textures are available. */
+    private readonly ready;
+    private readonly materialBytes;
+    private ownBytes;
+    /** The type's own textures for the material being resolved. */
+    private readonly ownTextures;
+    private readonly textureBytes;
+    private generation;
+    readonly gpu: GpuContext;
+    readonly memory: GpuMemoryData;
+    materialLayout: GPUBindGroupLayout;
+    constructor(gpu: GpuContext, memory: GpuMemoryData);
+    /** Call once per frame before drawing: rebuilds after device loss and resets readiness. */
+    beginFrame(): void;
+    mesh(mesh: Mesh): GpuMesh;
+    private destroyMesh;
+    /** Index buffers shared by GPU meshes, per index array. */
+    private readonly sharedIndexBuffers;
+    /**
+     * A GPU-written mesh (`Mesh.gpu`): storage + vertex buffers compute passes fill (positions,
+     * normals, uvs, uvs1, tangents; f32), and the index buffer every mesh with the same array shares.
+     */
+    private gpuMesh;
+    /** Frees a mesh's GPU buffers now (they're made again if it's drawn later). */
+    releaseMesh(mesh: Mesh): void;
+    /** Uploads a texture (all levels) on first use and when its version changes. */
+    texture(texture: Texture): GpuTexture | undefined;
+    /** 1x1 white and flat-normal textures for empty slots. */
+    defaultTextures(): {
+        white: GpuTexture;
+        normal: GpuTexture;
+    };
+    sampler(wrap: string, filter: string): GPUSampler;
+    /**
+     * Whether a material's textures are available (once per material per frame). False when a
+     * referenced texture is loading or reloading after device loss: its draws wait.
+     */
+    materialReady(world: World, material: MaterialAsset): boolean;
+    private resolveSlots;
+    /** Whether a texture can be uploaded; if its pixels are gone (device loss), reloads it. */
+    private available;
+    /** The group-1 layout of a material type on this device. */
+    layoutOf(type: MaterialType): GPUBindGroupLayout;
+    /** The material's uniforms and bind group, uploaded when its version or textures change. */
+    material(world: World, material: MaterialAsset): GpuMaterial | undefined;
+}
+export declare function createMaterialLayout(gpu: GpuContext): GPUBindGroupLayout;
+export declare const GpuAssetsResource: import("@aethervtt/shard-core").ResourceDef<GpuAssets>;

package/dist/gpu-assets.js

@@ -0,0 +1,494 @@
+import { assetServer } from "@aethervtt/shard-assets";
+import { defineResource } from "@aethervtt/shard-core";
+import { FORMAT_INFO, Textures } from "@aethervtt/shard-texture";
+import { STANDARD_TYPE, TEXTURE_SLOTS } from "./assets.js";
+import { materialLayout } from "./shaders.js";
+const SRGB_SLOT = [true, false, false, false, true];
+class GpuAssets {
+  meshes = /* @__PURE__ */ new Map();
+  materials = /* @__PURE__ */ new Map();
+  textures = /* @__PURE__ */ new Map();
+  defaults;
+  samplers = /* @__PURE__ */ new Map();
+  /** Textures scratch for the slot lookup (no per-frame allocation). */
+  slotTextures = [
+    void 0,
+    void 0,
+    void 0,
+    void 0,
+    void 0
+  ];
+  /** Guids reloading after device loss, so each is requested once. */
+  reloading = /* @__PURE__ */ new Set();
+  /** Per frame: whether each material's textures are available. */
+  ready = /* @__PURE__ */ new Map();
+  materialBytes = new DataView(new ArrayBuffer(materialLayout.size));
+  ownBytes = new DataView(new ArrayBuffer(256));
+  /** The type's own textures for the material being resolved. */
+  ownTextures = [];
+  textureBytes = new Float32Array(40);
+  generation;
+  gpu;
+  memory;
+  materialLayout;
+  constructor(gpu, memory) {
+    this.gpu = gpu;
+    this.memory = memory;
+    this.generation = gpu.generation;
+    this.materialLayout = createMaterialLayout(gpu);
+  }
+  /** Call once per frame before drawing: rebuilds after device loss and resets readiness. */
+  beginFrame() {
+    this.ready.clear();
+    if (this.generation === this.gpu.generation) return;
+    this.generation = this.gpu.generation;
+    this.materialLayout = createMaterialLayout(this.gpu);
+    this.textures.clear();
+    this.memory.textures = 0;
+    this.memory.textureBytes = 0;
+    this.defaults = void 0;
+    this.samplers.clear();
+  }
+  mesh(mesh) {
+    const gpu = this.gpu;
+    let gm = this.meshes.get(mesh);
+    if (gm && gm.version === mesh.version && gm.generation === gpu.generation) {
+      if (mesh.gpu) gm.count = mesh.drawCount;
+      return gm;
+    }
+    if (gm && gm.generation === gpu.generation) this.destroyMesh(gm);
+    if (mesh.gpu) return this.gpuMesh(mesh);
+    const device = gpu.device;
+    const n = mesh.vertexCount;
+    const upload = (data, usage, label) => {
+      const buffer = device.createBuffer({
+        label,
+        size: Math.max(16, data.byteLength + 3 & ~3),
+        usage: usage | GPUBufferUsage.COPY_DST
+      });
+      device.queue.writeBuffer(buffer, 0, data, 0, data.length);
+      return buffer;
+    };
+    const normals = mesh.normals ?? new Float32Array(n * 3).map((_, i) => i % 3 === 1 ? 1 : 0);
+    const uvs = mesh.uvs ?? new Float32Array(n * 2);
+    const uvs1 = mesh.uvs1 ?? uvs;
+    const tangents = mesh.tangents ?? new Float32Array(n * 4);
+    let indices = mesh.indices;
+    if (indices instanceof Uint16Array && indices.length % 2 === 1) {
+      const padded = new Uint16Array(indices.length + 1);
+      padded.set(indices);
+      indices = padded;
+    }
+    gm = {
+      version: mesh.version,
+      generation: gpu.generation,
+      positions: upload(mesh.positions, GPUBufferUsage.VERTEX, "mesh/positions"),
+      normals: upload(normals, GPUBufferUsage.VERTEX, "mesh/normals"),
+      uvs: upload(uvs, GPUBufferUsage.VERTEX, "mesh/uvs"),
+      uvs1: upload(uvs1, GPUBufferUsage.VERTEX, "mesh/uvs1"),
+      tangents: upload(tangents, GPUBufferUsage.VERTEX, "mesh/tangents"),
+      indices: indices ? upload(indices, GPUBufferUsage.INDEX, "mesh/indices") : void 0,
+      indexFormat: mesh.indices instanceof Uint32Array ? "uint32" : "uint16",
+      count: mesh.drawCount,
+      sharedIndices: false,
+      sharedVertices: false,
+      baseVertex: 0
+    };
+    this.meshes.set(mesh, gm);
+    return gm;
+  }
+  destroyMesh(gm) {
+    if (gm.sharedVertices) return;
+    gm.positions.destroy();
+    gm.normals.destroy();
+    gm.uvs.destroy();
+    gm.uvs1.destroy();
+    gm.tangents.destroy();
+    if (!gm.sharedIndices) gm.indices?.destroy();
+  }
+  /** Index buffers shared by GPU meshes, per index array. */
+  sharedIndexBuffers = /* @__PURE__ */ new WeakMap();
+  /**
+   * A GPU-written mesh (`Mesh.gpu`): storage + vertex buffers compute passes fill (positions,
+   * normals, uvs, uvs1, tangents; f32), and the index buffer every mesh with the same array shares.
+   */
+  gpuMesh(mesh) {
+    const gpu = this.gpu;
+    const desc = mesh.gpu;
+    const n = desc.vertexCount;
+    const usage = GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC;
+    const make = (width, label) => gpu.device.createBuffer({ label, size: Math.max(16, n * width * 4), usage });
+    let shared = this.sharedIndexBuffers.get(desc.indices);
+    if (!shared || shared.generation !== gpu.generation) {
+      const data = desc.indices;
+      const bytes = data.byteLength + 3 & ~3;
+      const buffer = gpu.device.createBuffer({
+        label: "mesh/shared-indices",
+        size: Math.max(16, bytes),
+        usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
+      });
+      if (data.byteLength % 4 === 0) gpu.device.queue.writeBuffer(buffer, 0, data, 0, data.length);
+      else {
+        const padded = new Uint16Array(data.length + 1);
+        padded.set(data);
+        gpu.device.queue.writeBuffer(buffer, 0, padded, 0, padded.length);
+      }
+      shared = { generation: gpu.generation, buffer };
+      this.sharedIndexBuffers.set(desc.indices, shared);
+    }
+    const source = desc.share ? this.mesh(desc.share) : void 0;
+    const gm = {
+      version: mesh.version,
+      generation: gpu.generation,
+      positions: source?.positions ?? make(3, "mesh/gpu-positions"),
+      normals: source?.normals ?? make(3, "mesh/gpu-normals"),
+      uvs: source?.uvs ?? make(2, "mesh/gpu-uvs"),
+      uvs1: source?.uvs1 ?? make(2, "mesh/gpu-uvs1"),
+      tangents: source?.tangents ?? make(4, "mesh/gpu-tangents"),
+      indices: shared.buffer,
+      indexFormat: desc.indices instanceof Uint32Array ? "uint32" : "uint16",
+      count: mesh.drawCount,
+      sharedIndices: true,
+      sharedVertices: source !== void 0,
+      baseVertex: mesh.baseVertex
+    };
+    this.meshes.set(mesh, gm);
+    return gm;
+  }
+  /** Frees a mesh's GPU buffers now (they're made again if it's drawn later). */
+  releaseMesh(mesh) {
+    const gm = this.meshes.get(mesh);
+    if (!gm) return;
+    if (gm.generation === this.gpu.generation) this.destroyMesh(gm);
+    this.meshes.delete(mesh);
+  }
+  /** Uploads a texture (all levels) on first use and when its version changes. */
+  texture(texture) {
+    const gpu = this.gpu;
+    const existing = this.textures.get(texture);
+    if (existing && existing.version === texture.version && existing.generation === gpu.generation) {
+      return existing;
+    }
+    if (!texture.levels && !texture.gpuOnly) return void 0;
+    if (existing) {
+      this.memory.textures--;
+      this.memory.textureBytes -= existing.bytes;
+    }
+    existing?.texture.destroy();
+    const info = FORMAT_INFO[texture.format];
+    const srgbView = texture.gpuOnly ? void 0 : info.srgbView;
+    const layers = texture.faces * texture.layers;
+    const handle = gpu.device.createTexture({
+      label: `texture/${texture.format}`,
+      size: { width: texture.width, height: texture.height, depthOrArrayLayers: layers },
+      format: texture.format,
+      mipLevelCount: texture.mipCount,
+      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | (texture.gpuOnly ? GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.COPY_SRC : 0),
+      viewFormats: srgbView ? [srgbView] : []
+    });
+    for (let level = 0; texture.levels && level < texture.mipCount; level++) {
+      const w = Math.max(1, texture.width >> level);
+      const h = Math.max(1, texture.height >> level);
+      const blocksWide = Math.ceil(w / info.block);
+      const blocksHigh = Math.ceil(h / info.block);
+      gpu.device.queue.writeTexture(
+        { texture: handle, mipLevel: level },
+        texture.levels[level],
+        { bytesPerRow: blocksWide * info.bytes, rowsPerImage: blocksHigh },
+        {
+          width: blocksWide * info.block,
+          height: blocksHigh * info.block,
+          depthOrArrayLayers: layers
+        }
+      );
+    }
+    const dimension = texture.faces === 6 ? "cube" : texture.layers > 1 ? "2d-array" : "2d";
+    const linear = handle.createView({ dimension });
+    const srgb = srgbView ? handle.createView({ format: srgbView, dimension }) : linear;
+    const plain = texture.faces === 1;
+    const out = {
+      texture: handle,
+      linear,
+      srgb,
+      arrayLinear: !plain ? void 0 : dimension === "2d-array" ? linear : handle.createView({ dimension: "2d-array" }),
+      arraySrgb: !plain ? void 0 : dimension === "2d-array" ? srgb : srgbView ? handle.createView({
+        format: srgbView,
+        dimension: "2d-array"
+      }) : void 0,
+      version: texture.version,
+      generation: gpu.generation,
+      bytes: texture.byteSize
+    };
+    this.textures.set(texture, out);
+    this.memory.textures++;
+    this.memory.textureBytes += out.bytes;
+    if (!texture.keepCpu) texture.levels = void 0;
+    return out;
+  }
+  /** 1x1 white and flat-normal textures for empty slots. */
+  defaultTextures() {
+    const gpu = this.gpu;
+    if (this.defaults && this.defaults.white.generation === gpu.generation) return this.defaults;
+    const solid = (label, rgba) => {
+      const texture = gpu.device.createTexture({
+        label,
+        size: { width: 1, height: 1 },
+        format: "rgba8unorm",
+        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
+        viewFormats: ["rgba8unorm-srgb"]
+      });
+      gpu.device.queue.writeTexture({ texture }, new Uint8Array(rgba), { bytesPerRow: 4 }, [1, 1]);
+      const linear = texture.createView();
+      return {
+        texture,
+        linear,
+        srgb: texture.createView({ format: "rgba8unorm-srgb" }),
+        arrayLinear: texture.createView({ dimension: "2d-array" }),
+        arraySrgb: texture.createView({ format: "rgba8unorm-srgb", dimension: "2d-array" }),
+        version: 0,
+        generation: gpu.generation,
+        bytes: 4
+      };
+    };
+    this.defaults = {
+      white: solid("texture/white", [255, 255, 255, 255]),
+      normal: solid("texture/flat-normal", [128, 128, 255, 255])
+    };
+    this.samplers.clear();
+    return this.defaults;
+  }
+  sampler(wrap, filter) {
+    const key = `${wrap}|${filter}`;
+    let s = this.samplers.get(key);
+    if (!s) {
+      const address = wrap === "clamp" ? "clamp-to-edge" : wrap === "mirror" ? "mirror-repeat" : "repeat";
+      const linear = filter === "linear";
+      s = this.gpu.device.createSampler({
+        label: `sampler/${key}`,
+        addressModeU: address,
+        addressModeV: address,
+        magFilter: linear ? "linear" : "nearest",
+        minFilter: linear ? "linear" : "nearest",
+        mipmapFilter: linear ? "linear" : "nearest",
+        maxAnisotropy: linear ? 8 : 1
+      });
+      this.samplers.set(key, s);
+    }
+    return s;
+  }
+  /**
+   * Whether a material's textures are available (once per material per frame). False when a
+   * referenced texture is loading or reloading after device loss: its draws wait.
+   */
+  materialReady(world, material) {
+    let ready = this.ready.get(material);
+    if (ready === void 0) {
+      ready = this.resolveSlots(world, material);
+      this.ready.set(material, ready);
+    }
+    return ready;
+  }
+  resolveSlots(world, material) {
+    const store = world.tryResource(Textures);
+    material.sync();
+    const type = material.type;
+    const own = type.textures;
+    this.ownTextures.length = own.length;
+    for (let i = 0; i < own.length; i++) {
+      const ref = material.value[own[i]];
+      if (!ref) {
+        this.ownTextures[i] = void 0;
+        continue;
+      }
+      const texture = store?.get(ref);
+      if (!texture || !this.available(world, texture, ref)) return false;
+      this.ownTextures[i] = texture;
+    }
+    if (!type.standard || !type.standardTextures) return true;
+    const value = material.value;
+    for (let i = 0; i < 5; i++) {
+      const ref = value[TEXTURE_SLOTS[i]].texture;
+      if (!ref) {
+        this.slotTextures[i] = void 0;
+        continue;
+      }
+      const texture = store?.get(ref);
+      if (!texture || !this.available(world, texture, ref)) return false;
+      this.slotTextures[i] = texture;
+    }
+    return true;
+  }
+  /** Whether a texture can be uploaded; if its pixels are gone (device loss), reloads it. */
+  available(world, texture, ref) {
+    if (texture.levels || this.textures.has(texture)) return true;
+    if (ref.guid && !this.reloading.has(ref.guid)) {
+      this.reloading.add(ref.guid);
+      const guid = ref.guid;
+      void assetServer(world).reload(guid).finally(() => this.reloading.delete(guid));
+    }
+    return false;
+  }
+  /** The group-1 layout of a material type on this device. */
+  layoutOf(type) {
+    return type.bindGroupLayout(this.gpu, standardEntries());
+  }
+  /** The material's uniforms and bind group, uploaded when its version or textures change. */
+  material(world, material) {
+    const gpu = this.gpu;
+    if (!this.resolveSlots(world, material)) return void 0;
+    const type = material.type;
+    let gm = this.materials.get(material);
+    if (!gm || gm.generation !== gpu.generation || gm.type !== type || gm.typeVersion !== type.version) {
+      gm = {
+        version: -1,
+        generation: gpu.generation,
+        typeVersion: type.version,
+        type,
+        buffer: gpu.device.createBuffer({
+          label: "material/standard",
+          size: materialLayout.size,
+          usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+        }),
+        textureBuffer: gpu.device.createBuffer({
+          label: "material/textures",
+          size: 160,
+          usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+        }),
+        ownBuffer: type.layout ? gpu.device.createBuffer({
+          label: `material/${type.name}`,
+          size: type.layout.size,
+          usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+        }) : void 0,
+        bindGroup: void 0,
+        bound: [void 0, void 0, void 0, void 0, void 0],
+        ownBound: []
+      };
+      this.materials.set(material, gm);
+    }
+    const defaults = this.defaultTextures();
+    let rebuild = gm.bindGroup === void 0;
+    if (type.standard && type.standardTextures) {
+      for (let i = 0; i < 5; i++) {
+        const texture = this.slotTextures[i];
+        const g = texture ? this.texture(texture) : void 0;
+        if (texture && !g) return void 0;
+        if (gm.bound[i] !== g) {
+          gm.bound[i] = g;
+          rebuild = true;
+        }
+      }
+    }
+    for (let i = 0; i < this.ownTextures.length; i++) {
+      const texture = this.ownTextures[i];
+      const g = texture ? this.texture(texture) : void 0;
+      if (texture && !g) return void 0;
+      if (gm.ownBound[i] !== g) {
+        gm.ownBound[i] = g;
+        rebuild = true;
+      }
+    }
+    if (gm.version !== material.version) {
+      const value = material.value;
+      if (type.standard) {
+        materialLayout.write(this.materialBytes, 0, material.value);
+        gpu.device.queue.writeBuffer(
+          gm.buffer,
+          0,
+          this.materialBytes.buffer,
+          0,
+          materialLayout.size
+        );
+        const t = this.textureBytes;
+        for (let i = 0; i < 5; i++) {
+          const slot = value[TEXTURE_SLOTS[i]];
+          t[i * 8] = slot.offset[0];
+          t[i * 8 + 1] = slot.offset[1];
+          t[i * 8 + 2] = slot.scale[0];
+          t[i * 8 + 3] = slot.scale[1];
+          t[i * 8 + 4] = slot.rotation;
+          t[i * 8 + 5] = slot.uv;
+          t[i * 8 + 6] = slot.texture ? 1 : 0;
+          t[i * 8 + 7] = 0;
+        }
+        gpu.device.queue.writeBuffer(gm.textureBuffer, 0, t.buffer, 0, 160);
+      }
+      if (type.layout && gm.ownBuffer) {
+        if (this.ownBytes.byteLength < type.layout.size)
+          this.ownBytes = new DataView(new ArrayBuffer(type.layout.size));
+        type.layout.write(this.ownBytes, 0, material.value);
+        gpu.device.queue.writeBuffer(gm.ownBuffer, 0, this.ownBytes.buffer, 0, type.layout.size);
+      }
+      gm.version = material.version;
+      rebuild = true;
+    }
+    if (rebuild) {
+      const value = material.value;
+      const entries = [];
+      if (type.standard) {
+        entries.push(
+          { binding: 0, resource: { buffer: gm.buffer } },
+          { binding: 1, resource: { buffer: gm.textureBuffer } }
+        );
+        for (let i = 0; type.standardTextures && i < 5; i++) {
+          const g = gm.bound[i] ?? (i === 2 ? defaults.normal : defaults.white);
+          entries.push({ binding: 2 + i, resource: SRGB_SLOT[i] ? g.srgb : g.linear });
+          const slot = value[TEXTURE_SLOTS[i]];
+          entries.push({ binding: 7 + i, resource: this.sampler(slot.wrap, slot.filter) });
+        }
+      }
+      let binding = type.bindingBase;
+      if (gm.ownBuffer) entries.push({ binding, resource: { buffer: gm.ownBuffer } });
+      binding++;
+      for (let i = 0; i < type.textures.length; i++) {
+        const name = type.textures[i];
+        if (type.arrays.has(name)) {
+          const texture = this.ownTextures[i];
+          const g = gm.ownBound[i] ?? (name.toLowerCase().includes("normal") ? defaults.normal : defaults.white);
+          const color = texture ? texture.usage === "color" : false;
+          entries.push({
+            binding: binding++,
+            resource: (color ? g.arraySrgb ?? g.arrayLinear : g.arrayLinear) ?? g.linear
+          });
+        } else {
+          const g = gm.ownBound[i] ?? defaults.white;
+          entries.push({ binding: binding++, resource: g.linear });
+        }
+        entries.push({ binding: binding++, resource: this.sampler("repeat", "linear") });
+      }
+      gm.bindGroup = gpu.device.createBindGroup({
+        label: `material/${type.name}`,
+        layout: this.layoutOf(type),
+        entries
+      });
+    }
+    return gm;
+  }
+}
+function standardEntries() {
+  const visibility = GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT;
+  return [
+    { binding: 0, visibility, buffer: { type: "uniform" } },
+    { binding: 1, visibility, buffer: { type: "uniform" } },
+    ...[2, 3, 4, 5, 6].map((binding) => ({
+      binding,
+      visibility,
+      texture: { sampleType: "float" }
+    })),
+    ...[7, 8, 9, 10, 11].map((binding) => ({
+      binding,
+      visibility,
+      sampler: { type: "filtering" }
+    }))
+  ];
+}
+function createMaterialLayout(gpu) {
+  return STANDARD_TYPE.bindGroupLayout(gpu, standardEntries());
+}
+const GpuAssetsResource = defineResource("render/GpuAssets", {
+  description: "GPU copies of meshes, textures, and materials."
+});
+export {
+  GpuAssets,
+  GpuAssetsResource,
+  createMaterialLayout
+};