Skip to content

A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.

perf(ui): search measured list bounds and retry failed syncs

yhh7d27128ba005
diff --git a/CHANGELOG.md b/CHANGELOG.md
index d377375f8..36a12c8b5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,6 +16,8 @@ published separately; it ships inside the editor.
### Fixed
+- **Measured lists locate visible items without scanning every preceding row.** Ordered cached offsets use binary searches for both viewport boundaries. Non-monotone or non-finite offsets retain the existing scan semantics. Failed measurements do not publish a completed cache, and list synchronization stays dirty after errors so a subsequent update can retry.
+
- **Plain-text wrapping avoids repeated whole-line glyph measurements.** The atlas-backed wrap path appends glyph advances in their original order while sharing the greedy wrap decisions with arbitrary string measurement. Long words and wide lines stay linear in glyph queries; spaces, supplementary characters and signed spacing preserve prior line breaks and geometry. Canvas string measurement retains its existing behavior.
- **Long plain-text overflow trims with linear glyph measurement work.** Clip and Ellipsis reuse one pass of prefix advances instead of remeasuring every shorter candidate. Trimming retains whole code points, trailing-whitespace handling and signed letter spacing; matching prefix order preserves the existing glyph geometry.
diff --git a/sdk/src/ui/collection/layout-provider.ts b/sdk/src/ui/collection/layout-provider.ts
index b99cc7015..947bd9ed0 100644
--- a/sdk/src/ui/collection/layout-provider.ts
+++ b/sdk/src/ui/collection/layout-provider.ts
@@ -114,6 +114,7 @@ export class MeasuredLinearLayoutProvider implements LayoutProvider {
/** Prefix offsets: `offsets_[i]` = main-axis start of item `i`; length count+1. */
private offsets_: number[] = [0];
private total_ = 0;
+ private monotone_ = true;
private builtFor_ = -1; // item count the offsets were built for; -1 forces rebuild
constructor(opts: MeasuredLinearLayoutOptions) {
@@ -130,15 +131,18 @@ export class MeasuredLinearLayoutProvider implements LayoutProvider {
private ensure_(count: number): void {
if (this.builtFor_ === count) return;
- this.builtFor_ = count;
const offsets = new Array<number>(count + 1);
offsets[0] = 0;
+ let monotone = true;
for (let i = 0; i < count; i++) {
offsets[i + 1] = offsets[i] + Math.max(0, this.mainSizeOf_(i)) + this.spacing_;
+ if (!Number.isFinite(offsets[i + 1]) || offsets[i + 1] < offsets[i]) monotone = false;
}
this.offsets_ = offsets;
// Drop the trailing gap after the last item.
this.total_ = count > 0 ? offsets[count] - this.spacing_ : 0;
+ this.monotone_ = monotone;
+ this.builtFor_ = count;
}
getContentSize(count: number): Vec2 {
@@ -162,8 +166,23 @@ export class MeasuredLinearLayoutProvider implements LayoutProvider {
if (count <= 0) return [0, 0];
const vStart = this.dir_ === 'column' ? viewport.y : viewport.x;
const vEnd = vStart + (this.dir_ === 'column' ? viewport.height : viewport.width);
- // offsets_ is sorted, so scan for the first item whose end clears vStart and
- // the last whose start is before vEnd (linear — visible spans are short).
+ if (this.monotone_) {
+ let lo = 0, hi = count;
+ while (lo < hi) {
+ const mid = Math.floor((lo + hi) / 2);
+ if (this.offsets_[mid + 1] - this.spacing_ <= vStart) lo = mid + 1;
+ else hi = mid;
+ }
+ const start = lo;
+ hi = count;
+ while (lo < hi) {
+ const mid = Math.floor((lo + hi) / 2);
+ if (this.offsets_[mid] < vEnd) lo = mid + 1;
+ else hi = mid;
+ }
+ return start < lo ? [start, lo] : [0, 0];
+ }
+ // Non-monotone or non-finite offsets retain the existing ordered scan.
let start = 0;
while (start < count && this.offsets_[start + 1] - this.spacing_ <= vStart) start++;
let end = start;
diff --git a/sdk/src/ui/collection/list-view.ts b/sdk/src/ui/collection/list-view.ts
index 3c3e1d94e..925f3b6ed 100644
--- a/sdk/src/ui/collection/list-view.ts
+++ b/sdk/src/ui/collection/list-view.ts
@@ -167,7 +167,15 @@ export class ListView<T = unknown> {
update(): void {
if (this.disposed_ || !this.dirty_) return;
this.dirty_ = false;
+ try {
+ this.sync_();
+ } catch (error) {
+ this.dirty_ = true;
+ throw error;
+ }
+ }
+ private sync_(): void {
const count = this.dataSource_.getCount();
const [visStart, visEnd] = this.layout_.getVisibleRange(this.getViewport(), count);
diff --git a/sdk/tests/ui-layout-provider.test.ts b/sdk/tests/ui-layout-provider.test.ts
index 7ea54f03c..625101b19 100644
--- a/sdk/tests/ui-layout-provider.test.ts
+++ b/sdk/tests/ui-layout-provider.test.ts
@@ -157,3 +157,47 @@ describe('GridLayoutProvider', () => {
expect(p.getVisibleRange(VIEWPORT(0, 0, 100, 100), 0)).toEqual([0, 0]);
});
});
+
+
+it('finds a measured viewport near the end without scanning or remeasuring the entire list', () => {
+ const count = 100000;let measures = 0;
+ const p = new MeasuredLinearLayoutProvider({ crossSize: 200, mainSizeOf: i => { measures++; return 20 + i % 5; } });
+ const total = p.getContentSize(count).y;
+ const state = p as unknown as { offsets_: number[] };
+ let reads = 0;
+ state.offsets_ = new Proxy(state.offsets_, { get(target, key, receiver) {
+ if (typeof key === 'string' && /^\d+$/.test(key)) reads++;
+ return Reflect.get(target, key, receiver);
+ } });
+ const [start, end] = p.getVisibleRange(VIEWPORT(0, total - 240, 200, 240), count);
+ expect(start).toBeGreaterThan(count - 20);expect(end).toBe(count);
+ expect(reads).toBeLessThan(100);
+ expect(measures).toBe(count);
+});
+
+it('retries a failed measurement without publishing partial offsets', () => {
+ let fail = true;
+ const p = new MeasuredLinearLayoutProvider({ crossSize: 200, mainSizeOf: i => {
+ if (fail && i === 2) throw new Error('measure unavailable');return 20;
+ } });
+ expect(() => p.getContentSize(4)).toThrow('measure unavailable');
+ fail = false;
+ expect(p.getContentSize(4)).toEqual({ x: 200, y: 80 });
+ expect(p.getItemRect(3).y).toBe(60);
+});
+
+it.each(['row', 'column'] as const)('preserves measured range boundaries for %s lists', direction => {
+ for (const spacing of [-8, 0, 3]) {
+ const sizes = Array.from({ length: 50 }, (_, i) => i % 7 === 0 ? 0 : 3 + i % 11);
+ const p = new MeasuredLinearLayoutProvider({ direction, crossSize: 200, spacing, mainSizeOf: i => sizes[i] });
+ p.getContentSize(sizes.length);
+ const starts = [0];for (const size of sizes) starts.push(starts[starts.length - 1] + size + spacing);
+ for (let pos = -20; pos <= 500; pos += 2.5) for (const extent of [0, 1, 17, 250]) {
+ let start = 0;while (start < sizes.length && starts[start + 1] - spacing <= pos) start++;
+ let end = start;while (end < sizes.length && starts[end] < pos + extent) end++;
+ const expected = start < end ? [start, end] : [0, 0];
+ const viewport = direction === 'column' ? VIEWPORT(0, pos, 200, extent) : VIEWPORT(pos, 0, extent, 200);
+ expect(p.getVisibleRange(viewport, sizes.length)).toEqual(expected);
+ }
+ }
+});
diff --git a/sdk/tests/ui-list-view.test.ts b/sdk/tests/ui-list-view.test.ts
index 230df4114..b4f7b454b 100644
--- a/sdk/tests/ui-list-view.test.ts
+++ b/sdk/tests/ui-list-view.test.ts
@@ -4,6 +4,7 @@ import { describe, it, expect, beforeEach, vi } from 'vitest';
import {
ListView,
LinearLayoutProvider,
+ MeasuredLinearLayoutProvider,
arrayDataSource,
type DataSource,
} from '../src/ui';
@@ -274,3 +275,18 @@ describe('ListView', () => {
expect(bodyFactory).toHaveBeenCalledTimes(2);
});
});
+
+
+it('retries the mount sync after a transient measured-layout failure', () => {
+ const world = createWorld();const parent = world.spawn();let unavailable = true;
+ const layout = new MeasuredLinearLayoutProvider({ crossSize: 100, mainSizeOf: i => {
+ if (unavailable && i === 2) throw new Error('temporary measurement failure');return 40;
+ } });
+ const list = new ListView({ world: world as unknown as World, parent,
+ dataSource: arrayDataSource(Array.from({ length: 100 }, (_, i) => i)),layout,
+ viewportSize: { x: 100, y: 160 },templates: { default: { factory, binder: () => {} } } });
+ expect(() => list.update()).toThrow('temporary measurement failure');
+ unavailable = false;list.update();
+ expect(list.getMountedCount()).toBe(6);
+ list.dispose();
+});
diff --git a/tools/releaseNotes.mjs b/tools/releaseNotes.mjs
index 86e604b47..3bc1f66b6 100644
--- a/tools/releaseNotes.mjs
+++ b/tools/releaseNotes.mjs
@@ -28,6 +28,8 @@ export const NOTES_FLOOR = 'v0.65.0';
* the reader recognises anyway.
*/
export const NOTED = {
+ 'perf(ui): search measured list bounds and retry failed syncs':
+ { note: 'Measured lists locate visible items without scanning every preceding row.' },
'perf(text): wrap plain text with incremental glyph advances':
{ note: 'Plain-text wrapping avoids repeated whole-line glyph measurements.' },
'perf(text): trim overflowing plain text with prefix advances':