@adobe/data-gpu 0.9.69

package/dist/graphics/rendering/model-collider-plugin.js

@@ -0,0 +1,81 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Database, Entity } from "@adobe/data/ecs";
+import { physicsData } from "../../physics/physics-data-plugin.js";
+import { modelLoader } from "../scene/model/model-loader-plugin.js";
+import { hullVertices } from "../scene/model/shape/convex-hull.js";
+/**
+ * modelCollider — lets a rendered model double as a physics body whose collider is
+ * **auto-generated from its mesh**. A `ModelBody` (or `StaticModelCollider`) carries
+ * a `geometry` + a `colliderShape` of `"hull"` or `"mesh"` but *no* collision data;
+ * this fills it once the mesh has loaded:
+ *
+ *   hull → `convexPoints` = the simplified hull vertices of the mesh (the engine
+ *          rebuilds the hull) — a coarse, convex stand-in for a detailed model.
+ *   mesh → `colliderMesh` = the mesh triangles verbatim (static trimesh).
+ *
+ * The source defaults to the body's own `geometry` but can be overridden with
+ * `collisionGeometry` (point it at a low-poly mesh for a cheaper collider). The
+ * model's `scale` is baked into the collision geometry so it matches the render.
+ * Generated data is cached per (source geometry, shape, scale), so many instances
+ * of one model share it. Authoring the collider by hand (supplying `convexPoints`
+ * / `colliderMesh` directly, as `ConvexBody` / `MeshCollider` do) still works and
+ * simply skips generation.
+ *
+ * Because the body already has a `geometry`, the physics render bridge leaves it
+ * alone — it renders as the detailed model and collides as the generated shape.
+ */
+export const modelCollider = Database.Plugin.create({
+    extends: Database.Plugin.combine(physicsData, modelLoader),
+    components: {
+        collisionGeometry: Entity.schema, // optional override: generate the collider from this Geometry instead of `geometry`
+    },
+    archetypes: {
+        // A model that is also a dynamic/kinematic body; collider auto-generated.
+        ModelBody: ["geometry", "scale", "visible", "parent", "bodyType", "colliderShape", "halfExtents", "material", "position", "rotation", "linearVelocity", "angularVelocity"],
+        // A static model collider (immovable level geometry that renders as a model).
+        StaticModelCollider: ["geometry", "scale", "visible", "parent", "colliderShape", "halfExtents", "material", "position", "rotation"],
+    },
+    systems: {
+        generateModelColliders: {
+            schedule: { during: ["postUpdate"] },
+            create: db => {
+                // generated collider data, shared across instances of the same (source mesh, shape, scale)
+                const cache = new Map();
+                return () => {
+                    // model-bodies (geometry + scale) whose collider data isn't generated yet
+                    for (const arch of db.store.queryArchetypes(["colliderShape", "geometry", "scale"], { exclude: ["convexPoints", "colliderMesh"] })) {
+                        const ids = arch.columns.id, css = arch.columns.colliderShape, scl = arch.columns.scale;
+                        // tail→head: filling the data migrates the row out of this archetype
+                        for (let i = arch.rowCount - 1; i >= 0; i--) {
+                            const shape = css.get(i);
+                            if (shape !== "hull" && shape !== "mesh")
+                                continue; // primitive-shaped model-bodies need no generation
+                            const id = ids.get(i);
+                            const src = db.store.read(id).collisionGeometry || arch.columns.geometry.get(i);
+                            const mesh = db.store.read(src);
+                            const positions = mesh?._cpuPositions;
+                            if (!positions)
+                                continue; // source mesh not loaded yet — retry next frame
+                            const s = scl.get(i), key = `${src}:${shape}:${s[0]}:${s[1]}:${s[2]}`;
+                            let data = cache.get(key);
+                            if (!data) {
+                                const scaled = new Float32Array(positions.length);
+                                for (let k = 0; k < positions.length; k += 3) {
+                                    scaled[k] = positions[k] * s[0];
+                                    scaled[k + 1] = positions[k + 1] * s[1];
+                                    scaled[k + 2] = positions[k + 2] * s[2];
+                                }
+                                data = shape === "hull"
+                                    ? { convexPoints: hullVertices(scaled) }
+                                    : { colliderMesh: { positions: scaled, indices: mesh._cpuIndices ?? new Uint32Array(0) } };
+                                cache.set(key, data);
+                            }
+                            db.store.update(id, data);
+                        }
+                    }
+                };
+            },
+        },
+    },
+});
+//# sourceMappingURL=model-collider-plugin.js.map

package/dist/graphics/rendering/model-collider-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-collider-plugin.js","sourceRoot":"","sources":["../../../src/graphics/rendering/model-collider-plugin.ts"],"names":[],"mappings":"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"}

package/dist/graphics/rendering/pbr-core-plugin.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Shape declarations shared between asset producers (model loader, shape
+ * generators) and consumers (renderers). Every component and archetype is
+ * ephemeral — not part of the user's data model. Pair with an asset
+ * producer plus a renderer aggregator (`pbrIblRender`)
+ * to get drawable scenes.
+ */
+export declare const pbrCore: {
+    readonly components: {
+        readonly _vertexBuffer: {
+            readonly default: GPUBuffer | null;
+        };
+        readonly _skinVertexBuffer: {
+            readonly default: GPUBuffer | null;
+        };
+        readonly _indexBuffer: {
+            readonly default: GPUBuffer | null;
+        };
+        readonly _indexCount: {
+            readonly type: "integer";
+            readonly minimum: 0;
+            readonly maximum: 4294967295;
+            readonly default: number;
+        };
+        readonly _indexFormat: {
+            readonly default: GPUIndexFormat;
+        };
+        readonly _materialBindGroup: {
+            readonly default: GPUBindGroup | null;
+        };
+        readonly _geometry: {
+            readonly type: "integer";
+            readonly minimum: -2147483648;
+            readonly maximum: 2147483647;
+            readonly default: number;
+        };
+        readonly _material: {
+            readonly type: "integer";
+            readonly minimum: -2147483648;
+            readonly maximum: 2147483647;
+            readonly default: number;
+        };
+        readonly _nodeLocalMatrix: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "number";
+                readonly precision: 1;
+                readonly default: number;
+            };
+            readonly minItems: 16;
+            readonly maxItems: 16;
+            readonly default: readonly [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+        };
+        readonly _skeletonModelRef: {
+            readonly type: "integer";
+            readonly minimum: -2147483648;
+            readonly maximum: 2147483647;
+            readonly default: number;
+        };
+        readonly _skeletonJointMatrixBindGroup: {
+            readonly default: GPUBindGroup | null;
+        };
+    };
+    readonly resources: {};
+    readonly archetypes: {
+        readonly _VisibleMaterial: readonly ["ephemeral", "_materialBindGroup", "_geometry"];
+        readonly _PbrPrimitive: readonly ["ephemeral", "_vertexBuffer", "_skinVertexBuffer", "_indexBuffer", "_indexCount", "_indexFormat", "_material", "_geometry", "_nodeLocalMatrix"];
+    };
+    readonly transactions: {};
+    readonly systems: import("@adobe/data/ecs").SystemDeclarations<never>;
+    readonly actions: {};
+    readonly services: {};
+    readonly computed: {};
+    readonly indexes: {};
+};

package/dist/graphics/rendering/pbr-core-plugin.js

@@ -0,0 +1,39 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Database, Entity } from "@adobe/data/ecs";
+import { Mat4x4 } from "@adobe/data/math";
+import { U32 } from "@adobe/data/math";
+/**
+ * Shape declarations shared between asset producers (model loader, shape
+ * generators) and consumers (renderers). Every component and archetype is
+ * ephemeral — not part of the user's data model. Pair with an asset
+ * producer plus a renderer aggregator (`pbrIblRender`)
+ * to get drawable scenes.
+ */
+export const pbrCore = Database.Plugin.create({
+    components: {
+        _vertexBuffer: { default: null },
+        /** Secondary VBO with skinning attributes (joints u32×4, weights f32×4),
+         *  null for static primitives. Drives skinned-pipeline dispatch. */
+        _skinVertexBuffer: { default: null },
+        _indexBuffer: { default: null },
+        _indexCount: U32.schema,
+        _indexFormat: { default: "uint16" },
+        _materialBindGroup: { default: null },
+        /** Back-reference from a _PbrPrimitive / _VisibleMaterial to the
+         *  authored Geometry that owns it. */
+        _geometry: Entity.schema,
+        _material: Entity.schema,
+        /** Node-local-to-model-root matrix baked at load time. The renderer
+         *  pre-multiplies it with the per-instance model-root world matrix. */
+        _nodeLocalMatrix: Mat4x4.schema,
+        /** Skeleton-side back-references the renderer reads when dispatching
+         *  the skinned pipeline. Populated by `pbrSkinning`. */
+        _skeletonModelRef: Entity.schema,
+        _skeletonJointMatrixBindGroup: { default: null },
+    },
+    archetypes: {
+        _VisibleMaterial: ["ephemeral", "_materialBindGroup", "_geometry"],
+        _PbrPrimitive: ["ephemeral", "_vertexBuffer", "_skinVertexBuffer", "_indexBuffer", "_indexCount", "_indexFormat", "_material", "_geometry", "_nodeLocalMatrix"],
+    },
+});
+//# sourceMappingURL=pbr-core-plugin.js.map

package/dist/graphics/rendering/pbr-core-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbr-core-plugin.js","sourceRoot":"","sources":["../../../src/graphics/rendering/pbr-core-plugin.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAC;AAEvC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC;IAC1C,UAAU,EAAE;QACR,aAAa,EAAmB,EAAE,OAAO,EAAE,IAAwB,EAAE;QACrE;4EACoE;QACpE,iBAAiB,EAAe,EAAE,OAAO,EAAE,IAAwB,EAAE;QACrE,YAAY,EAAoB,EAAE,OAAO,EAAE,IAAwB,EAAE;QACrE,WAAW,EAAqB,GAAG,CAAC,MAAM;QAC1C,YAAY,EAAoB,EAAE,OAAO,EAAE,QAA0B,EAAE;QACvE,kBAAkB,EAAc,EAAE,OAAO,EAAE,IAA2B,EAAE;QACxE;8CACsC;QACtC,SAAS,EAAuB,MAAM,CAAC,MAAM;QAC7C,SAAS,EAAuB,MAAM,CAAC,MAAM;QAC7C;+EACuE;QACvE,gBAAgB,EAAgB,MAAM,CAAC,MAAM;QAC7C;gEACwD;QACxD,iBAAiB,EAAe,MAAM,CAAC,MAAM;QAC7C,6BAA6B,EAAG,EAAE,OAAO,EAAE,IAA2B,EAAE;KAC3E;IACD,UAAU,EAAE;QACR,gBAAgB,EAAE,CAAC,WAAW,EAAE,oBAAoB,EAAE,WAAW,CAAC;QAClE,aAAa,EAAE,CAAC,WAAW,EAAE,eAAe,EAAE,mBAAmB,EAAE,cAAc,EAAE,aAAa,EAAE,cAAc,EAAE,WAAW,EAAE,WAAW,EAAE,kBAAkB,CAAC;KAClK;CACJ,CAAC,CAAC"}

package/dist/graphics/rendering/pbr-render/pbr-array-shader.wgsl.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Unified PBR shader for instanced primitives (and, after convergence, glTF).
+ * Materials come from the shared `materialGpu` set — five `texture_2d_array`s +
+ * a palette of per-layer factors (group 1) — selected by a per-instance layer
+ * index (group 3, binding 1). Shading is identical Cook-Torrance + split-sum
+ * IBL to the per-material `ibl-shader`; only the material *source* differs.
+ */
+export declare function buildPbrArrayShader(options: {
+    prefilteredMipCount: number;
+}): string;

package/dist/graphics/rendering/pbr-render/pbr-array-shader.wgsl.js

@@ -0,0 +1,145 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { wgslStructFields } from "@adobe/data/typed-buffer";
+import { schema as sceneUniformsSchema } from "../../scene/scene-uniforms/schema.js";
+import brdf from "../ibl-render/brdf.wgsl.js";
+/**
+ * Unified PBR shader for instanced primitives (and, after convergence, glTF).
+ * Materials come from the shared `materialGpu` set — five `texture_2d_array`s +
+ * a palette of per-layer factors (group 1) — selected by a per-instance layer
+ * index (group 3, binding 1). Shading is identical Cook-Torrance + split-sum
+ * IBL to the per-material `ibl-shader`; only the material *source* differs.
+ */
+export function buildPbrArrayShader(options) {
+    return /* wgsl */ `
+struct SceneUniforms {
+${wgslStructFields(sceneUniformsSchema)}
+}
+
+struct MaterialFactors {
+    baseColorFactor: vec4f,
+    emissiveMetallic: vec4f,   // emissive.rgb, metallicFactor
+    roughNormalOcc: vec4f,     // roughnessFactor, normalScale, occlusionStrength, _
+}
+
+@group(0) @binding(0) var<uniform> scene: SceneUniforms;
+
+@group(1) @binding(0) var<storage, read> palette: array<MaterialFactors>;
+@group(1) @binding(1) var baseColorArray: texture_2d_array<f32>;
+@group(1) @binding(2) var metallicRoughnessArray: texture_2d_array<f32>;
+@group(1) @binding(3) var normalArray: texture_2d_array<f32>;
+@group(1) @binding(4) var occlusionArray: texture_2d_array<f32>;
+@group(1) @binding(5) var emissiveArray: texture_2d_array<f32>;
+@group(1) @binding(6) var matSampler: sampler;
+
+@group(2) @binding(0) var iblIrradiance: texture_cube<f32>;
+@group(2) @binding(1) var iblPrefiltered: texture_cube<f32>;
+@group(2) @binding(2) var iblBrdfLut: texture_2d<f32>;
+@group(2) @binding(3) var iblSampler: sampler;
+
+@group(3) @binding(0) var<storage, read> instances: array<mat4x4<f32>>;
+@group(3) @binding(1) var<storage, read> layers: array<u32>;
+
+const PREFILTERED_MIP_COUNT: f32 = ${options.prefilteredMipCount.toFixed(1)};
+
+struct VertexInput {
+    @location(0) position: vec3f,
+    @location(1) normal: vec3f,
+    @location(2) tangent: vec4f,
+    @location(3) uv: vec2f,
+}
+
+struct VertexOutput {
+    @builtin(position) clipPosition: vec4f,
+    @location(0) worldPosition: vec3f,
+    @location(1) normal: vec3f,
+    @location(2) tangent: vec3f,
+    @location(3) bitangent: vec3f,
+    @location(4) uv: vec2f,
+    @location(5) @interpolate(flat) layer: u32,
+}
+
+@vertex
+fn vs_main(@builtin(instance_index) instanceIndex: u32, in: VertexInput) -> VertexOutput {
+    let m = instances[instanceIndex];
+    let m3 = mat3x3<f32>(m[0].xyz, m[1].xyz, m[2].xyz);
+    let normalMat = mat3x3<f32>(
+        cross(m3[1], m3[2]),
+        cross(m3[2], m3[0]),
+        cross(m3[0], m3[1]),
+    );
+    let worldPos = m * vec4f(in.position, 1.0);
+    var out: VertexOutput;
+    out.clipPosition = scene.viewProjectionMatrix * worldPos;
+    out.worldPosition = worldPos.xyz;
+    out.normal = normalize(normalMat * in.normal);
+    out.tangent = normalize(m3 * in.tangent.xyz);
+    out.bitangent = normalize(cross(out.normal, out.tangent) * in.tangent.w);
+    out.uv = in.uv;
+    out.layer = layers[instanceIndex];
+    return out;
+}
+
+${brdf}
+
+@fragment
+fn fs_main(in: VertexOutput) -> @location(0) vec4f {
+    let f = palette[in.layer];
+    let li = i32(in.layer);
+
+    let baseColor = textureSample(baseColorArray, matSampler, in.uv, li) * f.baseColorFactor;
+
+    let mr = textureSample(metallicRoughnessArray, matSampler, in.uv, li);
+    let metallic = mr.b * f.emissiveMetallic.w;
+    var roughness = mr.g * f.roughNormalOcc.x;
+    roughness = max(roughness, MIN_ROUGHNESS);
+    let alpha = roughness * roughness;
+
+    let occlusion = textureSample(occlusionArray, matSampler, in.uv, li).r;
+    let emissive = textureSample(emissiveArray, matSampler, in.uv, li).rgb * f.emissiveMetallic.xyz;
+
+    let nSampled = textureSample(normalArray, matSampler, in.uv, li).rgb * 2.0 - vec3f(1.0);
+    let nScaled = vec3f(nSampled.xy * f.roughNormalOcc.y, nSampled.z);
+    let tbn = mat3x3<f32>(in.tangent, in.bitangent, in.normal);
+    let N = normalize(tbn * nScaled);
+
+    let V = normalize(scene.cameraPosition - in.worldPosition);
+    let nDotV = max(dot(N, V), 0.001);
+    let R = reflect(-V, N);
+
+    let f0 = mix(vec3f(0.04), baseColor.rgb, metallic);
+
+    // --- IBL contribution (split-sum) ---
+    let F_ibl = f_schlick_roughness(nDotV, f0, roughness);
+    let kD_ibl = (vec3f(1.0) - F_ibl) * (1.0 - metallic);
+
+    let irradiance = textureSampleLevel(iblIrradiance, iblSampler, N, 0.0).rgb;
+    let diffuseIbl = kD_ibl * irradiance * baseColor.rgb;
+
+    let mipLevel = roughness * (PREFILTERED_MIP_COUNT - 1.0);
+    let prefiltered = textureSampleLevel(iblPrefiltered, iblSampler, R, mipLevel).rgb;
+    let envBrdf = textureSampleLevel(iblBrdfLut, iblSampler, vec2f(nDotV, roughness), 0.0).rg;
+    let specularIbl = prefiltered * (F_ibl * envBrdf.x + envBrdf.y);
+
+    let ambient = (diffuseIbl + specularIbl) * mix(1.0, occlusion, f.roughNormalOcc.z);
+
+    // --- Direct light (parity with the single scene light) ---
+    let L = normalize(-scene.lightDirection);
+    let H = normalize(V + L);
+    let nDotL = max(dot(N, L), 0.0);
+    let nDotH = max(dot(N, H), 0.0);
+    let vDotH = max(dot(V, H), 0.0);
+    let D_d = d_ggx(nDotH, alpha);
+    let G_d = g_smith(nDotV, nDotL, alpha);
+    let F_d = f_schlick(vDotH, f0);
+    let spec_d = (D_d * G_d * F_d) / (4.0 * nDotV * nDotL + 0.0001);
+    let kD_d = (vec3f(1.0) - F_d) * (1.0 - metallic);
+    let direct = (kD_d * baseColor.rgb / PI + spec_d) * scene.lightColor * nDotL;
+
+    let color = direct + ambient + emissive;
+    let mapped = tone_map_aces(color);
+    let gamma = pow(mapped, vec3f(1.0 / 2.2));
+    return vec4f(gamma, baseColor.a);
+}
+`;
+}
+//# sourceMappingURL=pbr-array-shader.wgsl.js.map

package/dist/graphics/rendering/pbr-render/pbr-array-shader.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbr-array-shader.wgsl.js","sourceRoot":"","sources":["../../../../src/graphics/rendering/pbr-render/pbr-array-shader.wgsl.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAAE,MAAM,IAAI,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AACrF,OAAO,IAAI,MAAM,4BAA4B,CAAC;AAE9C;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB,CAAC,OAAwC;IACxE,OAAO,UAAU,CAAC;;EAEpB,gBAAgB,CAAC,mBAAmB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;qCA2BF,OAAO,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwCzE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6DL,CAAC;AACF,CAAC"}