Skip to content

armgit / 67.js

Public Imported from GitHub
0

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.js
index 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.js
index 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 bat
assert.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);
+});