3D engine that AI agents drive
Key the incremental part grouper by compact strings so it keeps about 40x less memory (#779)
Nguyen Xuan An351ff72a0f5c
diff --git a/src/renderer.js b/src/renderer.jsindex ac8dcf36..8513b5c8 100644--- a/src/renderer.js+++ b/src/renderer.js@@ -472,16 +472,24 @@ function validatePartForGrouping(part, morphInfos) {* collects every later part with the same key. Adding parts later gives the batches a single call over all of them would give.*/function createPartGrouper(batching) {- const groups = new Map();+ // One flat map from a compact string key to a batch: a nested map per key value cost about 12 KB for every batch.+ const batchesByKey = new Map();const batches = [];const morphInfos = new Map();const materialKeyValues = new Map();const materialKeyTails = new Map();+ // A key value (a geometry, a material map, a flag) is replaced by a small number, so the key stays a short string.+ const valueNumbers = new Map();+ function numberOf(value) {+ let number = valueNumbers.get(value);+ if (number === undefined) {+ number = valueNumbers.size;+ valueNumbers.set(value, number);+ }+ return number;+ }function addPart(part) {validatePartForGrouping(part, morphInfos);- const key = batching ? part.geometry : part;- if (!groups.has(key)) groups.set(key, new Map());- let maps = groups.get(key);// Thousands of parts share a few materials, so the material half of the key is built once per material.let materialValues = materialKeyValues.get(part.material);if (!materialValues) {@@ -493,16 +501,15 @@ function createPartGrouper(batching) {materialTail = [renderPass(part.material), ...materialAlphaState(part.material), part.material.aovMap ?? null, part.material.transmissionMap ?? null, ...(part.material.aov ?? ZERO_VECTOR)];materialKeyTails.set(part.material, materialTail);}- for (const value of [...materialValues, part.skin ?? null, part.material.snippet, part.crowd ?? null, part.morph ?? null, castsShadow(part), receivesShadow(part), compositeModeOf(part), depthLayerOf(part), flushOrderOf(part), part.lods ?? null, part.shadowLods ?? null, isMirroredMatrix(part.matrix), ...materialTail]) {- if (!maps.has(value)) maps.set(value, new Map());- maps = maps.get(value);- }- if (!maps.has('parts')) {- const batch = [];- maps.set('parts', batch);+ const values = [batching ? part.geometry : part, ...materialValues, part.skin ?? null, part.material.snippet, part.crowd ?? null, part.morph ?? null, castsShadow(part), receivesShadow(part), compositeModeOf(part), depthLayerOf(part), flushOrderOf(part), part.lods ?? null, part.shadowLods ?? null, isMirroredMatrix(part.matrix), ...materialTail];+ const key = values.map(numberOf).join(',');+ let batch = batchesByKey.get(key);+ if (!batch) {+ batch = [];+ batchesByKey.set(key, batch);batches.push(batch);}- maps.get('parts').push(part);+ batch.push(part);}return {batches,diff --git a/tests/incremental-grouping.test.js b/tests/incremental-grouping.test.jsindex c6cf94f4..20c67c85 100644--- a/tests/incremental-grouping.test.js+++ b/tests/incremental-grouping.test.js@@ -150,3 +150,44 @@ test('a slice that shares geometries and keys with earlier parts joins their batassert.equal(next.batches.length, batchCount);assert.equal(next.batches[0].at(-1), joining);});++test('batches a renderer copied earlier stay equal to their prefix grouping after later appends', () => {+ // Renderer67.uploadBatch keeps `[...parts]`; those copies must not change when the grouping grows in place.+ const heldCopies = [];+ let state = null;+ for (let end = 5; end <= worldParts.length; end += 5) {+ const prefix = worldParts.slice(0, end);+ const grouped = groupPartsIncrementally(state, prefix);+ heldCopies.push({ prefix, copies: grouped.batches.map(batch => [...batch]) });+ state = grouped.state;+ }+ for (const { prefix, copies } of heldCopies) {+ assert.ok(sameBatches(copies, groupParts(prefix)), `copies held at ${prefix.length} parts`);+ }+});++test('the parts a state keeps are a copy, so later changes to the caller list do not reach it', () => {+ const list = worldParts.slice(0, 10);+ const grouped = groupPartsIncrementally(null, list);+ list.push(makePart(500, geometries[5]));+ assert.equal(grouped.state.parts.length, 10);+ const next = groupPartsIncrementally(grouped.state, worldParts.slice(0, 10));+ assert.ok(sameBatches(next.batches, groupParts(worldParts.slice(0, 10))));+});++test('a fallback regrouping leaves the batches returned earlier untouched', () => {+ const grouped = groupPartsIncrementally(null, worldParts.slice(0, 15));+ const before = grouped.batches.map(batch => [...batch]);+ const reordered = [worldParts[1], worldParts[0], ...worldParts.slice(2, 20)];+ groupPartsIncrementally(grouped.state, reordered);+ assert.ok(sameBatches(grouped.batches, before));+});++test('parts that differ in one key value never share a batch', () => {+ const geometry = geometries[0];+ const shadowless = { ...makePart(600, geometry), material: materials[0], castShadow: false };+ const shadowing = { ...makePart(601, geometry), material: materials[0] };+ const otherMaterial = { ...makePart(602, geometry), material: { ...materials[1], alphaMode: 'blend', opacity: 0.5 } };+ const grouped = groupPartsIncrementally(null, [shadowing, shadowless, otherMaterial]);+ assert.equal(grouped.batches.length, 3);+});