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.

fix(ui): cancel unavailable slider capture and use local track dimensions

yhhe2ed32b0fdb9
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5e9a36840..b23da4a0c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,6 +16,8 @@ published separately; it ships inside the editor.
### Fixed
+- **Slider capture expires with input and target availability.** Disabled, inactive or hidden tracks and lost pointer projections cancel capture before a value update, so restoring the control cannot resume an old drag. A consumed release followed by another press cannot retain capture, and track width is read from the slider's own World instead of shared UI helper bindings.
+
- **Slider visuals follow range and target edits.** Changing min/max or replacing a fill/handle updates the displayed fraction even when the value is unchanged, without emitting a spurious value-change event. Stable frames do not rewrite visuals, cached display state is reused during value changes, and change callbacks may remove later sliders safely.
- **Object drags stop when their input or target becomes unavailable.** Editor-consumed releases, disabled or removed drag components, hidden targets and lost pointer projections clear capture before another position write. Drag callbacks may disable or remove their target safely, and an active gesture emits its end once without resuming later.
diff --git a/sdk/src/ui/behavior/slider.ts b/sdk/src/ui/behavior/slider.ts
index b99b02bea..12f2fd8f3 100644
--- a/sdk/src/ui/behavior/slider.ts
+++ b/sdk/src/ui/behavior/slider.ts
@@ -14,6 +14,8 @@ import { defineComponent } from '../../ecs/component';
import { defineSystem, type SystemDef } from '../../ecs/system';
import { Res } from '../../ecs/resource';
import { Input, type InputState } from '../../input/input';
+import { primaryPointerCancellationVersion } from '../../input/pointerCancellation';
+import { worldEngineApi } from '../../ecs/bridge/engineApi';
import { Transform, type TransformData } from '../../ecs/component';
import type { World } from '../../ecs/world';
import type { Entity } from '../../types';
@@ -27,7 +29,7 @@ import { UIInteraction, type UIInteractionData } from '../input/interactable';
import { Interactable, type InteractableData } from '../input/interactable';
import { Focusable, type FocusableData } from '../input/focusable';
import { UIEventType, type UIEventQueue } from '../core/events';
-import { EntityStateMap, getUINodeWidth } from '../util/helpers';
+import { EntityStateMap } from '../util/helpers';
export interface UISliderData {
min: number;
@@ -75,21 +77,34 @@ function keyStep(d: UISliderData): number {
export function createSliderSystem(world: World, events: UIEventQueue): SystemDef {
// Press on a track captures the drag until release, even off-entity.
let active: Entity | null = null;
+ let lastCancellationVersion = 0;
+ const engine = worldEngineApi(world);
+ const registry = world.getCppRegistry();
+ const receivesInput = (e: Entity): boolean => world.isEntityActive(e)
+ && !world.isDestructionPending(e)
+ && (!world.has(e, Interactable) || (world.get(e, Interactable) as InteractableData).enabled)
+ && (!world.has(e, UINode) || !engine?.getUINodeHiddenInTree?.(registry!, e));
const shown = new EntityStateMap<Pick<UISliderData, 'value' | 'min' | 'max' | 'fill' | 'handle'>>();
return defineSystem(
[Res(Input), Res(UICameraInfo), Res(ScreenOverlay)],
(input: InputState, camera: UICameraData, overlay: ScreenOverlayData) => {
+ const version = primaryPointerCancellationVersion(input);
+ const cancelled = version !== lastCancellationVersion;
+ lastCancellationVersion = version;
+ const pointerAvailable = camera.valid || overlay.active;
+ if (active !== null && (cancelled || !pointerAvailable || !world.valid(active)
+ || !world.has(active, UISlider) || !receivesInput(active)
+ || !world.has(active, Transform) || !input.isMouseButtonDown(0))) active = null;
for (const e of world.getEntitiesWithComponents([UISlider])) {
if (!world.valid(e) || !world.has(e, UISlider)) continue;
const d = world.get(e, UISlider) as UISliderData;
let next = d.value;
- const enabled = !world.has(e, Interactable)
- || (world.get(e, Interactable) as InteractableData).enabled;
+ const enabled = receivesInput(e);
// Pointer: capture on press, track while held.
- if (enabled && world.has(e, UIInteraction)
+ if (enabled && pointerAvailable && input.isMouseButtonDown(0) && world.has(e, UIInteraction)
&& (world.get(e, UIInteraction) as UIInteractionData).justPressed) {
active = e;
}
@@ -98,7 +113,7 @@ export function createSliderSystem(world: World, events: UIEventQueue): SystemDe
active = null;
} else if ((camera.valid || overlay.active) && world.has(e, Transform)) {
const t = world.get(e, Transform) as TransformData;
- const w = getUINodeWidth(e) * t.worldScale.x;
+ const w = (registry ? engine?.getUINodeComputedWidth?.(registry, e) ?? 0 : 0) * t.worldScale.x;
if (w > 0) {
// The pointer in the track's own domain: the fraction
// is a ratio of two positions, so both have to be in
diff --git a/sdk/tests/ui-slider-dropdown.test.ts b/sdk/tests/ui-slider-dropdown.test.ts
index 86c0966c4..012ad82d5 100644
--- a/sdk/tests/ui-slider-dropdown.test.ts
+++ b/sdk/tests/ui-slider-dropdown.test.ts
@@ -32,6 +32,10 @@ interface MockWorld {
insert(e: Entity, c: object, data: unknown): void;
getEntitiesWithComponents(cs: object[]): Entity[];
onDespawn(cb: (e: Entity) => void): () => void;
+ getWasmModule(): null;
+ getCppRegistry(): null;
+ isEntityActive(e: Entity): boolean;
+ isDestructionPending(e: Entity): boolean;
}
function createMockWorld(): MockWorld {
@@ -50,6 +54,8 @@ function createMockWorld(): MockWorld {
w._components.delete(e as number);
},
valid(e) { return w._entities.has(e as number); },
+ getWasmModule() { return null; }, getCppRegistry() { return null; },
+ isEntityActive(e) { return w.valid(e); }, isDestructionPending() { return false; },
setParent() { /* no-op for these tests */ },
has(e, c) { return w._components.get(e as number)?.has(c) ?? false; },
get(e, c) { return w._components.get(e as number)?.get(c); },
@@ -86,7 +92,7 @@ describe('createSlider', () => {
};
const camera = { valid: false };
// eslint-disable-next-line @typescript-eslint/no-explicit-any
- tick = () => (sys as any)._fn(input, camera);
+ tick = () => (sys as any)._fn(input, camera, { active: false });
});
const make = (opts: Record<string, unknown> = {}) =>
diff --git a/sdk/tests/ui-slider-visual-wasm.test.ts b/sdk/tests/ui-slider-visual-wasm.test.ts
index 06b452c85..5722120ed 100644
--- a/sdk/tests/ui-slider-visual-wasm.test.ts
+++ b/sdk/tests/ui-slider-visual-wasm.test.ts
@@ -4,6 +4,14 @@ import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vite
import { App } from '../src/app/app';
import { AppContext, setDefaultContext } from '../src/ecs/context';
import { Schedule } from '../src/ecs/system';
+import { Canvas, Disabled, Transform } from '../src/ecs/component';
+import { Input, InputState, inputEventCallbacks } from '../src/input/input';
+import { inputRouter } from '../src/input/inputRouter';
+import { UICameraInfo } from '../src/ui/core/ui-camera-info';
+import { ScreenOverlay } from '../src/ui/core/screen-overlay';
+import { UIInteraction, Interactable } from '../src/ui/input/interactable';
+import { px } from '../src/ui/core/dimension';
+import { initUIHelpers } from '../src/ui/util/helpers';
import { UIEventQueue } from '../src/ui/core/events';
import { UINode } from '../src/ui/core/ui-node';
import { UIVisual } from '../src/ui/core/ui-visual';
@@ -18,9 +26,10 @@ describe.skipIf(!HAS_WASM)('slider visual reconciliation on real WASM', () => {
beforeEach(() => {
setDefaultContext(new AppContext()); registry = new engine.Registry();
app = App.new(); app.connectCpp(registry, engine); events = new UIEventQueue();
+ initUIHelpers(engine as never, registry);
app.addSystemToSchedule(Schedule.Update, createSliderSystem(app.world, events));
});
- afterEach(() => { app.quit({ keepRenderer: true }); registry.delete(); });
+ afterEach(() => { initUIHelpers(null, registry); app.quit({ keepRenderer: true }); registry.delete(); });
it('range edits repaint fill and thumb without reporting a value change', async () => {
const changed = vi.fn(), slider = createSlider({ world: app.world, events, value: .5, onChange: changed });
await app.tick(1 / 60);
@@ -38,4 +47,70 @@ describe.skipIf(!HAS_WASM)('slider visual reconciliation on real WASM', () => {
expect(app.world.get(fill, UIVisual).fillAmount).toBe(.5);
expect(app.world.get(handle, UINode).insetLeft.value).toBe(50);
});
+
+ async function captureSlider() {
+ const root = app.world.spawn(); app.world.insert(root, Canvas); app.world.insert(root, UINode); app.world.insert(root, Transform);
+ const slider = createSlider({ world: app.world, events, parent: root,
+ node: { width: px(100), height: px(20) }, value: .5 });
+ engine.uiLayout_update(registry, -50, -50, 50, 50, true); app.world.ensureTransformsComposed();
+ const center = app.world.get(slider.entity, Transform).worldPosition.x;
+ const input = new InputState(); input.noteMouseDown(0); app.insertResource(Input, input);
+ app.insertResource(UICameraInfo, { ...UICameraInfo._default, valid: true, worldMouseX: center });
+ app.insertResource(ScreenOverlay, { ...ScreenOverlay._default, pointerX: center });
+ app.world.insert(slider.entity, UIInteraction, { justPressed: true });
+ await app.tick(1 / 60);
+ app.world.update(slider.entity, UIInteraction, ui => { ui.justPressed = false; });
+ const first = slider.getValue();
+ app.getResource(UICameraInfo).worldMouseX = center + 10;
+ app.getResource(ScreenOverlay).pointerX = center + 10;
+ await app.tick(1 / 60);
+ const value = slider.getValue();
+ expect(value).toBeGreaterThan(first);
+ return { slider, center, value, input, root };
+ }
+
+ it.each(['disabled', 'inactive', 'hidden', 'projection'])('%s cancels a captured slider without resuming it', async kind => {
+ const { slider, center, value, root } = await captureSlider();
+ if (kind === 'disabled') app.world.update(slider.entity, Interactable, d => { d.enabled = false; });
+ if (kind === 'inactive') app.world.insert(slider.entity, Disabled);
+ if (kind === 'hidden') {
+ app.world.update(root, UINode, n => { n.display = 1; });
+ engine.uiLayout_update(registry, -50, -50, 50, 50, true);
+ }
+ if (kind === 'projection') app.getResource(UICameraInfo).valid = false;
+ app.getResource(UICameraInfo).worldMouseX = center + 30;
+ app.getResource(ScreenOverlay).pointerX = center + 30;
+ await app.tick(1 / 60);
+ expect(slider.getValue()).toBe(value);
+ if (kind === 'disabled') app.world.update(slider.entity, Interactable, d => { d.enabled = true; });
+ if (kind === 'inactive') app.world.remove(slider.entity, Disabled);
+ if (kind === 'hidden') {
+ app.world.update(root, UINode, n => { n.display = 0; });
+ engine.uiLayout_update(registry, -50, -50, 50, 50, true);
+ }
+ if (kind === 'projection') app.getResource(UICameraInfo).valid = true;
+ await app.tick(1 / 60);
+ expect(slider.getValue()).toBe(value);
+ });
+
+ it('a consumed release followed by an outside press cannot reuse old capture', async () => {
+ const { slider, center, value, input } = await captureSlider();
+ const callbacks = inputEventCallbacks(input);
+ const off = inputRouter.setEditorHandler({ onPointerUp: () => true });
+ try { callbacks.onPointerUp(0); } finally { off(); }
+ callbacks.onPointerDown(0, 500, 500);
+ app.getResource(UICameraInfo).worldMouseX = center + 30;
+ app.getResource(ScreenOverlay).pointerX = center + 30;
+ await app.tick(1 / 60);
+ expect(slider.getValue()).toBe(value);
+ });
+
+ it('rebinding legacy UI helpers cannot change this Worlds track width', async () => {
+ const { slider, center } = await captureSlider();
+ initUIHelpers({ getUINodeComputedWidth: () => 200 } as never, registry);
+ app.getResource(UICameraInfo).worldMouseX = center + 20;
+ app.getResource(ScreenOverlay).pointerX = center + 20;
+ await app.tick(1 / 60);
+ expect(slider.getValue()).toBeCloseTo(.7);
+ });
});
diff --git a/sdk/tests/ui-two-way-binding.test.ts b/sdk/tests/ui-two-way-binding.test.ts
index e5a008be2..67d4823fb 100644
--- a/sdk/tests/ui-two-way-binding.test.ts
+++ b/sdk/tests/ui-two-way-binding.test.ts
@@ -33,6 +33,10 @@ interface MockWorld {
insert(e: Entity, c: object, data: unknown): void;
getEntitiesWithComponents(cs: object[]): Entity[];
onDespawn(cb: (e: Entity) => void): () => void;
+ getWasmModule(): null;
+ getCppRegistry(): null;
+ isEntityActive(e: Entity): boolean;
+ isDestructionPending(e: Entity): boolean;
}
function createMockWorld(): MockWorld {
@@ -53,6 +57,8 @@ function createMockWorld(): MockWorld {
w._components.delete(e as number);
},
valid(e) { return w._entities.has(e as number); },
+ getWasmModule() { return null; }, getCppRegistry() { return null; },
+ isEntityActive(e) { return w.valid(e); }, isDestructionPending() { return false; },
setParent() { /* not needed */ },
has(e, c) { return w._components.get(e as number)?.has(c) ?? false; },
get(e, c) { return w._components.get(e as number)?.get(c); },
@@ -87,7 +93,7 @@ describe('bindWidgetValue', () => {
it('signal → UISlider.value → visuals; input change → signal (round trip settles)', () => {
const sys = createSliderSystem(world as unknown as World, events);
// eslint-disable-next-line @typescript-eslint/no-explicit-any
- const tick = () => (sys as any)._fn(idleInput, noCamera);
+ const tick = () => (sys as any)._fn(idleInput, noCamera, { active: false });
const slider = createSlider({
world: world as unknown as World, events,
diff --git a/tools/releaseNotes.mjs b/tools/releaseNotes.mjs
index 66af6c4ad..054e935fe 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 = {
+ 'fix(ui): cancel unavailable slider capture and use local track dimensions':
+ { note: 'Slider capture expires with input and target availability.' },
'fix(ui): reconcile slider visuals after range and target edits':
{ note: 'Slider visuals follow range and target edits.' },
'fix(ui): retire object drag capture before cancelled movement':