@haiyue/native 0.1.0

package/bridge/input/native-touch.android.ts

@@ -0,0 +1,55 @@
+import { Screen, View, Application, type EventData } from '@nativescript/core';
+import { type TouchGestureEventData } from '@nativescript/core/ui/gestures';
+import type { Canvas } from '@nativescript/canvas';
+import { nativeViewRect } from '../render/view-rect.android';
+import { OrbitPointerTarget, type TouchAction } from './pointer-target';
+export interface NativeTouchSample {
+  action: TouchAction | 'suspend' | 'unloaded' | 'dispose';
+  points: { id: number; x: number; y: number; nativeHash: number }[];
+  input: ReturnType<OrbitPointerTarget['snapshot']>;
+}
+export class NativeTouchInput {
+  readonly target: OrbitPointerTarget;
+  readonly orbitTarget: OrbitPointerTarget | null;
+  private readonly ids = new Set<number>();
+  private pinching = false;
+  private disposed = false;
+  private paused = false;
+  get isPinching(): boolean { return this.pinching; }
+  constructor(private readonly view: Canvas, private readonly sample: (event: NativeTouchSample) => void, options: { pinchZoom?: boolean } = {}) {
+    if (!view.ignoreTouchEvents) throw new Error('Disable Canvas pointer synthesis before attaching Core touch.');
+    this.target = new OrbitPointerTarget(() => nativeViewRect(view));
+    this.orbitTarget = options.pinchZoom ? new OrbitPointerTarget(() => nativeViewRect(view), 'all') : null;
+    // Android dispatches only observers registered on Core's View. A standalone
+    // GesturesObserver is never included in that dispatch list. Bypass Canvas's
+    // DOM addEventListener override while keeping its synthetic touch disabled.
+    View.prototype.addEventListener.call(view, 'touch', this.onTouch);
+    view.on('unloaded', this.unloaded);
+    view.on('loaded', this.loaded);
+  }
+  snapshot() { return { pinching: this.pinching, rect: nativeViewRect(this.view), measured: { width: this.view.clientWidth, height: this.view.clientHeight }, ...this.target.snapshot(), nativeIdentities: this.ids.size, nativeObserverCount: this.disposed ? 0 : 1, nativeRecognizerCount: this.disposed ? 0 : 1 }; }
+  private touch(event: TouchGestureEventData): void {
+    if (this.disposed || this.paused) return;
+    const action = event.action as TouchAction, motion = event.android as android.view.MotionEvent;
+    if (!['down','move','up','cancel'].includes(action)) return;
+    const indices = action === 'move' || action === 'cancel' ? Array.from({length:motion.getPointerCount()},(_,i)=>i) : [motion.getActionIndex()];
+    const points = indices.map(i => ({ id: motion.getPointerId(i), nativeHash: motion.getPointerId(i), x: motion.getX(i) / Screen.mainScreen.scale, y: motion.getY(i) / Screen.mainScreen.scale }));
+    if (action === 'down') for (const point of points) this.ids.add(point.id);
+    if (this.orbitTarget && !this.pinching && this.ids.size >= 2) { this.pinching = true; this.target.suspend(); }
+    this.target.handle(action, points); this.orbitTarget?.handle(action, points);
+    if (action === 'up' || action === 'cancel') for (const point of points) this.ids.delete(point.id);
+    this.sample({ action, points, input: this.target.snapshot() });
+    if (this.pinching && this.ids.size !== 2) this.orbitTarget?.suspend();
+    if (this.pinching && !this.ids.size) { this.pinching = false; this.target.resume(); this.orbitTarget?.resume(); }
+  }
+  private readonly onTouch = (event: EventData): void => this.touch(event as TouchGestureEventData);
+  private readonly loaded = (): void => { if (!Application.inBackground && !Application.suspended) this.resume(); };
+  private cancel(action: 'suspend' | 'unloaded' | 'dispose'): void {
+    this.target.suspend(); this.orbitTarget?.suspend(); this.ids.clear(); this.pinching = false; this.paused = true;
+    this.sample({ action, points: [], input: this.target.snapshot() });
+  }
+  private readonly unloaded = (): void => this.cancel('unloaded');
+  suspend(): void { if (!this.disposed) this.cancel('suspend'); }
+  resume(): void { if (!this.disposed) { this.paused = false; this.target.resume(); this.orbitTarget?.resume(); } }
+  dispose(): void { if (this.disposed) return; this.cancel('dispose'); View.prototype.removeEventListener.call(this.view,'touch',this.onTouch); this.view.off('unloaded',this.unloaded); this.view.off('loaded',this.loaded); this.target.dispose(); this.orbitTarget?.dispose(); this.disposed=true; }
+}

package/bridge/input/native-touch.ios.ts

@@ -0,0 +1,91 @@
+import { nativeViewRect } from '../render/view-rect.ios';
+import type { Canvas } from '@nativescript/canvas';
+import { GesturesObserver, GestureTypes, type TouchGestureEventData } from '@nativescript/core/ui/gestures';
+import { OrbitPointerTarget, type TouchAction } from './pointer-target';
+import { TouchIdentity } from './touch-identity';
+
+export interface NativeTouchSample {
+  action: TouchAction | 'suspend' | 'unloaded' | 'dispose';
+  points: { id: number; x: number; y: number; nativeHash: number }[];
+  input: ReturnType<OrbitPointerTarget['snapshot']>;
+}
+
+export class NativeTouchInput {
+  readonly target: OrbitPointerTarget;
+  readonly orbitTarget: OrbitPointerTarget | null;
+  private pinching = false;
+  get isPinching(): boolean { return this.pinching; }
+  private readonly identity = new TouchIdentity<UITouch>((a, b) => a === b || a.isEqual(b));
+  private readonly observer: GesturesObserver;
+  private readonly previousMultipleTouch: boolean;
+  private disposed = false;
+  private paused = false;
+
+  constructor(private readonly view: Canvas, private readonly sample: (event: NativeTouchSample) => void, options: { pinchZoom?: boolean } = {}) {
+    if (!view.ignoreTouchEvents) throw new Error('Disable Canvas pointer synthesis before attaching Core touch.');
+    const native = view.nativeViewProtected as UIView;
+    this.previousMultipleTouch = native.multipleTouchEnabled;
+    native.multipleTouchEnabled = true;
+    this.target = new OrbitPointerTarget(() => nativeViewRect(view));
+    this.orbitTarget = options.pinchZoom ? new OrbitPointerTarget(() => nativeViewRect(view), 'all') : null;
+    this.observer = new GesturesObserver(view, event => this.touch(event as TouchGestureEventData), this);
+    this.observer.observe(GestureTypes.touch);
+    view.on('unloaded', this.unloaded);
+  }
+
+  snapshot() { return { pinching: this.pinching, rect: nativeViewRect(this.view), measured: { width: this.view.clientWidth, height: this.view.clientHeight }, ...this.target.snapshot(), nativeIdentities: this.identity.count, nativeObserverCount: this.disposed ? 0 : 1, nativeRecognizerCount: (this.view.nativeViewProtected as UIView | undefined)?.gestureRecognizers?.count ?? 0 }; }
+
+  private touch(event: TouchGestureEventData): void {
+    if (this.disposed || this.paused) return;
+    const action = event.action as TouchAction;
+    if (!['down', 'move', 'up', 'cancel'].includes(action)) return;
+    const pointers = event.getActivePointers();
+    // NSSet iteration has no chronology; earliest timestamp wins simultaneous downs.
+    if (action === 'down') pointers.sort((a, b) => (a.ios as UITouch).timestamp - (b.ios as UITouch).timestamp);
+    const points: NativeTouchSample['points'] = [];
+    for (const pointer of pointers) {
+      const touch = pointer.ios as UITouch;
+      const id = action === 'down' ? this.identity.begin(touch) : this.identity.find(touch);
+      if (id === undefined) continue;
+      points.push({ id, x: pointer.getX() - (this.view.nativeViewProtected as UIView).bounds.origin.x, y: pointer.getY() - (this.view.nativeViewProtected as UIView).bounds.origin.y, nativeHash: touch.hash });
+    }
+    if (this.orbitTarget && !this.pinching && this.identity.count >= 2) {
+      this.pinching = true;
+      this.target.suspend();
+    }
+    this.target.handle(action, points);
+    this.orbitTarget?.handle(action, points);
+    if (action === 'up' || action === 'cancel') for (const point of points) this.identity.end(point.id);
+    this.sample({ action, points, input: this.target.snapshot() });
+    if (this.pinching && this.identity.count !== 2) this.orbitTarget?.suspend();
+    if (this.pinching && this.identity.count === 0) {
+      this.pinching = false;
+      this.target.resume();
+      this.orbitTarget?.resume();
+    }
+  }
+
+  private cancel(action: 'suspend' | 'unloaded' | 'dispose'): void {
+    this.target.suspend();
+    this.orbitTarget?.suspend();
+    this.pinching = false;
+    this.identity.clear();
+    this.paused = true;
+    this.sample({ action, points: [], input: this.target.snapshot() });
+  }
+
+  private readonly unloaded = (): void => this.cancel('unloaded');
+  suspend(): void { if (!this.disposed) this.cancel('suspend'); }
+  resume(): void { if (!this.disposed) { this.paused = false; this.target.resume(); this.orbitTarget?.resume(); } }
+  dispose(): void {
+    if (this.disposed) return;
+    this.cancel('dispose');
+    this.observer.disconnect();
+    this.view.off('unloaded', this.unloaded);
+    const native = this.view.nativeViewProtected as UIView | undefined;
+    if (native) native.multipleTouchEnabled = this.previousMultipleTouch;
+    this.target.dispose();
+    this.orbitTarget?.dispose();
+    this.disposed = true;
+  }
+}

package/bridge/input/native-touch.ts

@@ -0,0 +1,2 @@
+// TypeScript fallback; NativeScript resolves the platform suffix at bundle time.
+export * from './native-touch.ios';

package/bridge/input/pointer-target.ts

@@ -0,0 +1,106 @@
+export interface LogicalRect { x: number; y: number; width: number; height: number }
+export interface TouchPoint { id: number; x: number; y: number }
+export type TouchAction = 'down' | 'move' | 'up' | 'cancel';
+export interface OrbitPointer {
+  pointerId: number; pointerType: 'touch'; button: 0;
+  clientX: number; clientY: number; defaultPrevented: boolean;
+  preventDefault(): void;
+}
+type Listener = (event: OrbitPointer) => void;
+
+/** A single-pointer event target. Coordinates and bounds are both UIKit points. */
+export class OrbitPointerTarget {
+  private readonly listeners = new Map<string, Set<Listener>>();
+  private readonly touches = new Map<number, TouchPoint>();
+  private primary: number | null = null;
+  private captured: number | null = null;
+  private paused = false;
+  private disposed = false;
+
+  constructor(private readonly rect: () => LogicalRect, private readonly mode: 'primary' | 'all' = 'primary') {}
+
+  getBoundingClientRect() {
+    const r = this.rect();
+    return { ...r, left: r.x, top: r.y, right: r.x + r.width, bottom: r.y + r.height };
+  }
+
+  addEventListener(type: string, listener: Listener): void {
+    if (this.disposed) return;
+    let entries = this.listeners.get(type);
+    if (!entries) this.listeners.set(type, entries = new Set());
+    entries.add(listener);
+  }
+
+  removeEventListener(type: string, listener: Listener): void {
+    this.listeners.get(type)?.delete(listener);
+  }
+
+  setPointerCapture(id: number): void {
+    if ((this.mode === 'primary' && id !== this.primary) || !this.touches.has(id)) throw new Error('Cannot capture an inactive native touch.');
+    // UIKit's recognizer owns this UITouch through end/cancel even outside its view.
+    this.captured = id;
+  }
+
+  releasePointerCapture(id: number): void {
+    if (this.captured === id) this.captured = null;
+  }
+
+  handle(action: TouchAction, points: readonly TouchPoint[]): void {
+    if (this.disposed || this.paused) return;
+    for (const point of points) {
+      if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) continue;
+      if (action === 'down') {
+        if (this.touches.has(point.id)) continue;
+        this.touches.set(point.id, point);
+        if (this.primary !== null && this.mode === 'primary') continue;
+        if (this.primary === null) this.primary = point.id;
+        this.emit('pointerdown', point);
+      } else {
+        if (!this.touches.has(point.id)) continue;
+        this.touches.set(point.id, point);
+        if (this.mode === 'all' || point.id === this.primary) this.emit(`pointer${action}`, point);
+        if (action === 'up' || action === 'cancel') {
+          this.touches.delete(point.id);
+          if (point.id === this.primary) { this.primary = null; this.captured = null; }
+        }
+      }
+    }
+  }
+
+  cancel(): void {
+    const point = this.primary === null ? undefined : this.touches.get(this.primary);
+    if (this.mode === 'all') { for (const touch of this.touches.values()) this.emit('pointercancel', touch); }
+    else if (point) this.emit('pointercancel', point);
+    this.touches.clear();
+    this.primary = null;
+    this.captured = null;
+  }
+
+  suspend(): void { this.cancel(); this.paused = true; }
+  resume(): void { if (!this.disposed) this.paused = false; }
+  dispose(): void {
+    if (this.disposed) return;
+    this.suspend();
+    this.listeners.clear();
+    this.disposed = true;
+  }
+
+  snapshot() {
+    return { primary: this.primary, captured: this.captured, trackedTouches: this.touches.size,
+      listenerCount: [...this.listeners.values()].reduce((sum, entries) => sum + entries.size, 0),
+      paused: this.paused, disposed: this.disposed };
+  }
+
+  private emit(type: string, point: TouchPoint): void {
+    const rect = this.rect();
+    const event: OrbitPointer = {
+      pointerId: point.id, pointerType: 'touch', button: 0,
+      clientX: rect.x + point.x, clientY: rect.y + point.y,
+      defaultPrevented: false,
+      preventDefault() { this.defaultPrevented = true; },
+    };
+    // Native view input has no DOM wheel/scroll default. Canvas's own pointer
+    // synthesis is disabled by the native adapter, and system cancellation wins.
+    for (const listener of this.listeners.get(type) ?? []) listener(event);
+  }
+}

package/bridge/input/touch-identity.ts

@@ -0,0 +1,20 @@
+/** Native wrappers may differ between callbacks; compare the underlying touch identity. */
+export class TouchIdentity<T> {
+  private next = 1;
+  private readonly entries: { touch: T; id: number }[] = [];
+  constructor(private readonly equal: (a: T, b: T) => boolean) {}
+  find(touch: T): number | undefined { return this.entries.find(entry => this.equal(entry.touch, touch))?.id; }
+  begin(touch: T): number {
+    const found = this.find(touch);
+    if (found !== undefined) return found;
+    const id = this.next++;
+    this.entries.push({ touch, id });
+    return id;
+  }
+  end(id: number): void {
+    const index = this.entries.findIndex(entry => entry.id === id);
+    if (index >= 0) this.entries.splice(index, 1);
+  }
+  clear(): void { this.entries.length = 0; }
+  get count(): number { return this.entries.length; }
+}

package/bridge/lifecycle/demand-frames.ts

@@ -0,0 +1,51 @@
+export interface DemandFrameDriver {
+  start(): void;
+  stop(): void;
+  defer(callback: () => void): void;
+}
+
+/** Event-driven ownership of Engine.run/stop. No polling timer or idle RAF.
+ * Two frames cover GUI callbacks that mutate a scene after its 3D pass. */
+export class NativeDemandFrames {
+  private readonly driver: DemandFrameDriver;
+  private remaining = 0;
+  private active = false;
+  private running = false;
+  private queued = false;
+  private disposed = false;
+  constructor(driver: DemandFrameDriver) { this.driver = driver; }
+
+  request(): void {
+    if (this.disposed) return;
+    this.remaining = 2;
+    if (!this.active || this.running || this.queued) return;
+    this.queued = true;
+    // Never restart synchronously inside after-update: FrameLoop's current tick
+    // would otherwise schedule a second RAF after start() scheduled the first.
+    this.driver.defer(() => {
+      this.queued = false;
+      if (!this.active || this.disposed || this.running) return;
+      this.running = true;
+      this.driver.start();
+    });
+  }
+  resume(): void { if (!this.disposed) { this.active = true; this.request(); } }
+  suspend(): void {
+    this.active = false;
+    this.running = false;
+    this.remaining = 0;
+    this.driver.stop();
+  }
+  afterFrame(animating: boolean): void {
+    if (!this.active || this.disposed) return;
+    // Render a settling frame even if a deadline expires between update and
+    // presentation; final static colors/poses must reach the surface.
+    this.remaining = animating ? 2 : Math.max(0, this.remaining - 1);
+    if (!animating && this.remaining === 0) {
+      this.running = false;
+      this.driver.stop();
+    }
+  }
+  snapshot() { return { active: this.active, running: this.running, queued: this.queued, remaining: this.remaining }; }
+  dispose(): void { this.disposed = true; this.suspend(); }
+}

package/bridge/lifecycle/frame-performance.ts

@@ -0,0 +1,20 @@
+/** Bounded CPU/frame-interval samples. CPU includes command encoding and present,
+ * not GPU execution; frame intervals include scheduling and GPU back-pressure. */
+export class FramePerformance {
+  private readonly maxSamples=600;
+  private cpu:number[]=[];
+  private intervals:number[]=[];
+  private lastStart:number|null=null;
+  private started=0;
+  begin(now:number):void {
+    if(this.lastStart!==null && this.intervals.length<this.maxSamples)this.intervals.push(now-this.lastStart);
+    this.lastStart=now;this.started=now;
+  }
+  end(now:number):void {if(this.cpu.length<this.maxSamples)this.cpu.push(now-this.started);}
+  reset():void {this.cpu=[];this.intervals=[];this.lastStart=null;}
+  take() {
+    const stats=(a:number[])=>{const sorted=[...a].sort((a,b)=>a-b);return {samples:a.length,meanMs:a.reduce((s,v)=>s+v,0)/Math.max(1,a.length),p95Ms:sorted[Math.max(0,Math.ceil(sorted.length*.95)-1)]??0};};
+    const result={cpu:stats(this.cpu),interval:stats(this.intervals)};
+    this.cpu=[];this.intervals=[];return result;
+  }
+}

package/bridge/lifecycle/frame-scheduler.ts

@@ -0,0 +1,33 @@
+export interface NativeFrameDriver {
+  request(callback: (time: number) => void): number;
+  cancel(handle: number): void;
+  now(): number;
+}
+
+/** Adapts native handle 0 and native timestamps to Engine's frame contract. */
+export function createFrameScheduler(driver: NativeFrameDriver, onError: (error: unknown) => void) {
+  let next = 1;
+  const pending = new Map<number, number>();
+  return {
+    request(callback: (time: number) => void): number {
+      const id = next++;
+      const nativeId = driver.request(() => {
+        if (!pending.delete(id)) return;
+        try { callback(driver.now()); } catch (error) { onError(error); }
+      });
+      pending.set(id, nativeId);
+      return id;
+    },
+    cancel(id: number): void {
+      const nativeId = pending.get(id);
+      if (nativeId === undefined) return;
+      pending.delete(id);
+      driver.cancel(nativeId);
+    },
+    cancelAll(): void {
+      for (const id of pending.values()) driver.cancel(id);
+      pending.clear();
+    },
+    get pendingCount(): number { return pending.size; },
+  };
+}