@adobe/data-gpu 0.9.74 → 0.9.76

package/src/graphics/rendering/material-gpu/material-arrays.ts

@@ -1,113 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-/**
- * The shared GPU material set: five `texture_2d_array`s (one per PBR map) plus
- * a palette storage buffer of per-layer factors. Every material occupies one
- * layer across all five arrays; a drawable selects its material with a single
- * per-instance layer index. Built once and grown by layer — materials are
- * added rarely and edited never, so nothing here is rebuilt per frame.
- */
-export interface MaterialArrays {
-    baseColor: GPUTexture;          // rgba8unorm-srgb
-    metallicRoughness: GPUTexture;  // rgba8unorm (G = roughness, B = metalness)
-    normal: GPUTexture;             // rgba8unorm
-    occlusion: GPUTexture;          // rgba8unorm (R = AO)
-    emissive: GPUTexture;           // rgba8unorm-srgb
-}
-
-/** Fixed layer size every material map is resampled to. */
-export const MATERIAL_TEXTURE_SIZE = 512;
-/** Maximum distinct materials (array layers). 16 × 512² × 5 maps ≈ 80 MB. */
-export const MAX_MATERIAL_LAYERS = 16;
-/** Bytes per palette entry: baseColor(vec4) + emissive/metallic(vec4) + rough/normal/occlusion(vec4). */
-export const PALETTE_STRIDE = 48;
-
-export function createMaterialArrays(device: GPUDevice): MaterialArrays {
-    const make = (format: GPUTextureFormat): GPUTexture =>
-        device.createTexture({
-            size: [MATERIAL_TEXTURE_SIZE, MATERIAL_TEXTURE_SIZE, MAX_MATERIAL_LAYERS],
-            dimension: "2d",
-            format,
-            // RENDER_ATTACHMENT is required by copyExternalImageToTexture.
-            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
-        });
-    return {
-        baseColor:         make("rgba8unorm-srgb"),
-        metallicRoughness: make("rgba8unorm"),
-        normal:            make("rgba8unorm"),
-        occlusion:         make("rgba8unorm"),
-        emissive:          make("rgba8unorm-srgb"),
-    };
-}
-
-/** Per-material visible factors written into one palette layer. */
-export interface MaterialFactors {
-    baseColorFactor: readonly number[];
-    emissiveFactor: readonly number[];
-    metallicFactor: number;
-    roughnessFactor: number;
-    normalScale: number;
-    occlusionStrength: number;
-}
-
-const _palette = new Float32Array(PALETTE_STRIDE / 4);
-
-export function writePaletteLayer(device: GPUDevice, palette: GPUBuffer, layer: number, f: MaterialFactors): void {
-    _palette[0] = f.baseColorFactor[0]; _palette[1] = f.baseColorFactor[1]; _palette[2] = f.baseColorFactor[2]; _palette[3] = f.baseColorFactor[3];
-    _palette[4] = f.emissiveFactor[0]; _palette[5] = f.emissiveFactor[1]; _palette[6] = f.emissiveFactor[2]; _palette[7] = f.metallicFactor;
-    _palette[8] = f.roughnessFactor; _palette[9] = f.normalScale; _palette[10] = f.occlusionStrength; _palette[11] = 0;
-    device.queue.writeBuffer(palette, layer * PALETTE_STRIDE, _palette);
-}
-
-/** The five map source URLs for one material ("" = leave the neutral layer). */
-export interface MaterialMapUrls {
-    baseColorUrl: string;
-    metallicRoughnessUrl: string;
-    normalUrl: string;
-    occlusionUrl: string;
-    emissiveUrl: string;
-}
-
-/**
- * Fetches a material's maps and blits them (resampled to the layer size) into
- * its array layer. Fire-and-forget: each map resolves independently, so a body
- * renders (neutral) immediately and sharpens as textures arrive. URLs shared
- * across maps (e.g. an ARM image used for both metallicRoughness and occlusion)
- * are fetched once and copied to each target.
- */
-export function loadMaterialMaps(device: GPUDevice, arrays: MaterialArrays, layer: number, urls: MaterialMapUrls): void {
-    const targets: { url: string; tex: GPUTexture }[] = [
-        { url: urls.baseColorUrl,         tex: arrays.baseColor },
-        { url: urls.metallicRoughnessUrl, tex: arrays.metallicRoughness },
-        { url: urls.normalUrl,            tex: arrays.normal },
-        { url: urls.occlusionUrl,         tex: arrays.occlusion },
-        { url: urls.emissiveUrl,          tex: arrays.emissive },
-    ];
-    const byUrl = new Map<string, GPUTexture[]>();
-    for (const t of targets) {
-        if (!t.url) continue;
-        const list = byUrl.get(t.url);
-        if (list) list.push(t.tex);
-        else byUrl.set(t.url, [t.tex]);
-    }
-    for (const [url, texes] of byUrl) {
-        fetch(url)
-            .then(r => { if (!r.ok) throw new Error(`material map ${r.status}: ${url}`); return r.blob(); })
-            .then(blob => createImageBitmap(blob, {
-                resizeWidth: MATERIAL_TEXTURE_SIZE,
-                resizeHeight: MATERIAL_TEXTURE_SIZE,
-                colorSpaceConversion: "none",
-            }))
-            .then(bitmap => {
-                for (const tex of texes) {
-                    device.queue.copyExternalImageToTexture(
-                        { source: bitmap },
-                        { texture: tex, origin: [0, 0, layer] },
-                        [MATERIAL_TEXTURE_SIZE, MATERIAL_TEXTURE_SIZE, 1],
-                    );
-                }
-                bitmap.close();
-            })
-            .catch(err => console.warn("[materialGpu] map load failed", err));
-    }
-}

package/src/graphics/rendering/material-gpu/material-bind-group.ts

@@ -1,61 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-import type { MaterialArrays } from "./material-arrays.js";
-
-interface DeviceCache {
-    layout: GPUBindGroupLayout;
-    sampler: GPUSampler;
-}
-const cacheByDevice = new WeakMap<GPUDevice, DeviceCache>();
-
-function deviceCache(device: GPUDevice): DeviceCache {
-    let c = cacheByDevice.get(device);
-    if (!c) {
-        const tex = (binding: number): GPUBindGroupLayoutEntry => ({
-            binding, visibility: GPUShaderStage.FRAGMENT,
-            texture: { sampleType: "float", viewDimension: "2d-array" },
-        });
-        c = {
-            layout: device.createBindGroupLayout({
-                entries: [
-                    { binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: "read-only-storage" } },
-                    tex(1), tex(2), tex(3), tex(4), tex(5),
-                    { binding: 6, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "filtering" } },
-                ],
-            }),
-            sampler: device.createSampler({
-                magFilter: "linear", minFilter: "linear", mipmapFilter: "linear",
-                addressModeU: "repeat", addressModeV: "repeat",
-            }),
-        };
-        cacheByDevice.set(device, c);
-    }
-    return c;
-}
-
-/**
- * Bind-group layout for the shared material set: palette storage buffer +
- * five `texture_2d_array`s + a filtering sampler. The renderer's primitive
- * pipeline builds its pipeline layout from this; `createMaterialBindGroup`
- * builds the matching bind group. Cached per device.
- */
-export function createMaterialBindGroupLayout(device: GPUDevice): GPUBindGroupLayout {
-    return deviceCache(device).layout;
-}
-
-export function createMaterialBindGroup(device: GPUDevice, arrays: MaterialArrays, palette: GPUBuffer): GPUBindGroup {
-    const { layout, sampler } = deviceCache(device);
-    const view = (t: GPUTexture): GPUTextureView => t.createView({ dimension: "2d-array" });
-    return device.createBindGroup({
-        layout,
-        entries: [
-            { binding: 0, resource: { buffer: palette } },
-            { binding: 1, resource: view(arrays.baseColor) },
-            { binding: 2, resource: view(arrays.metallicRoughness) },
-            { binding: 3, resource: view(arrays.normal) },
-            { binding: 4, resource: view(arrays.occlusion) },
-            { binding: 5, resource: view(arrays.emissive) },
-            { binding: 6, resource: sampler },
-        ],
-    });
-}

package/src/graphics/rendering/material-gpu/material-gpu-plugin.ts

@@ -1,95 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-import { Database } from "@adobe/data/ecs";
-import { U32 } from "@adobe/data/math";
-import { core } from "../../../core/core-plugin.js";
-import { Material } from "../../../material/material.js";
-import {
-    type MaterialArrays,
-    MAX_MATERIAL_LAYERS, PALETTE_STRIDE,
-    createMaterialArrays, writePaletteLayer, loadMaterialMaps,
-} from "./material-arrays.js";
-import { createMaterialBindGroup } from "./material-bind-group.js";
-
-/** Material rows the builder reads to fill a layer (factors + map URLs). */
-const MATERIAL_COMPONENTS = [
-    "baseColorFactor", "emissiveFactor", "metallicFactor", "roughnessFactor", "normalScale", "occlusionStrength",
-    "baseColorUrl", "metallicRoughnessUrl", "normalUrl", "occlusionUrl", "emissiveUrl",
-] as const;
-
-/**
- * materialGpu — derives the shared GPU material set from the `Material`
- * registry. Each authored material is assigned one array layer; its factors go
- * into the palette buffer and its maps are fetched + blitted into that layer.
- *
- * Incremental and cached: the arrays / palette / bind group are built once, and
- * a layer is assigned only to a material that doesn't have one yet (`_layerIndex`
- * excluded). Materials are added rarely and edited never, so steady state does
- * no work. The renderer (P3) binds `_materialBindGroup` once and selects a
- * material per instance by `_layerIndex`.
- */
-export const materialGpu = Database.Plugin.create({
-    extends: Database.Plugin.combine(Material.plugin, core),
-    components: {
-        _layerIndex: U32.schema,
-    },
-    resources: {
-        _materialArrays:    { default: null as MaterialArrays | null, nonPersistent: true },
-        _materialPalette:   { default: null as GPUBuffer | null, nonPersistent: true },
-        _materialBindGroup: { default: null as GPUBindGroup | null, nonPersistent: true },
-    },
-    systems: {
-        materialGpuBuilder: {
-            schedule: { during: ["preRender"] },
-            create: db => {
-                let arrays: MaterialArrays | null = null;
-                let palette: GPUBuffer | null = null;
-                let nextLayer = 0;
-                return () => {
-                    const { device } = db.store.resources;
-                    if (!device) return;
-
-                    // Assign a layer to each material that lacks one. Tail→head:
-                    // every visited row migrates out (gains _layerIndex), so the
-                    // removal is always from the tail — no hole-fill shift. The GPU
-                    // arrays are created lazily on the first material, so glTF-only
-                    // scenes (no materials) allocate nothing.
-                    for (const arch of db.store.queryArchetypes(["name", ...MATERIAL_COMPONENTS], { exclude: ["_layerIndex"] })) {
-                        const c = arch.columns;
-                        for (let i = arch.rowCount - 1; i >= 0; i--) {
-                            if (nextLayer >= MAX_MATERIAL_LAYERS) break;
-                            if (!arrays || !palette) {
-                                arrays = createMaterialArrays(device);
-                                palette = device.createBuffer({
-                                    size: MAX_MATERIAL_LAYERS * PALETTE_STRIDE,
-                                    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-                                });
-                                db.store.resources._materialArrays = arrays;
-                                db.store.resources._materialPalette = palette;
-                                db.store.resources._materialBindGroup = createMaterialBindGroup(device, arrays, palette);
-                            }
-                            const id = c.id.get(i);
-                            const layer = nextLayer++;
-                            writePaletteLayer(device, palette, layer, {
-                                baseColorFactor: c.baseColorFactor.get(i),
-                                emissiveFactor: c.emissiveFactor.get(i),
-                                metallicFactor: c.metallicFactor.get(i),
-                                roughnessFactor: c.roughnessFactor.get(i),
-                                normalScale: c.normalScale.get(i),
-                                occlusionStrength: c.occlusionStrength.get(i),
-                            });
-                            loadMaterialMaps(device, arrays, layer, {
-                                baseColorUrl: c.baseColorUrl.get(i),
-                                metallicRoughnessUrl: c.metallicRoughnessUrl.get(i),
-                                normalUrl: c.normalUrl.get(i),
-                                occlusionUrl: c.occlusionUrl.get(i),
-                                emissiveUrl: c.emissiveUrl.get(i),
-                            });
-                            db.store.update(id, { _layerIndex: layer });
-                        }
-                    }
-                };
-            },
-        },
-    },
-});

package/src/graphics/scene/model/geometry/geometry.ts

@@ -1,12 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-/**
- * One row of the `Geometry` archetype — an asset identified by URL. The
- * model loader fetches the URL, then writes derived state (`_bounds`,
- * primitive entities, animation clips) onto the same row.
- */
-export interface Geometry {
-    modelUrl: string;
-}
-
-export * as Geometry from "./public.js";