import { GpuComputeNode } from '../contract';

import * as d from 'typegpu/data';
export declare const TRACKER_MAX = 64;
export declare const TRACKER_TRAIL_LEN = 12;
export declare const TRACKER_TRAIL_EVERY = 8;
export declare const TRACKER_AABB_COL: number;
export declare const trackHash: import('typegpu').TgpuFn<(x: d.F32) => d.F32>;
/** Per-detect-mode feature score of one child sample (premultiplied RTT texel). */
export declare function featureScoreFn(mode: string): import('typegpu').TgpuFn<(c: d.Vec4f) => d.F32>;
/**
 * Feature-grid kernel: one thread per grid cell, scoring the child at 4 sub-cell taps. The sim
 * kernel scans this grid so every unlocked tracker always has a concrete target.
 */
export declare function buildFeatureGridKernel(scoreFn: ReturnType<typeof featureScoreFn>): import('typegpu').TgpuFn<(gx: d.U32, gy: d.U32) => d.Void>;
/**
 * Per-tracker pursuit kernel. One thread per tracker.
 *
 * TRACKING is mean-shift: the 7×7 window computes the affinity-weighted CENTROID of the content
 * around the tracker and steps toward it — the tracker converges smoothly onto a feature, sticks
 * to it, and rides it as it moves (argmax hopping jittered along edges and off them).
 *
 * VARIANCE: each tracker owns a preferred brightness BAND (re-rolled per generation). Affinity is
 * closeness of the feature's score to that preference, not raw magnitude — so the population
 * spreads across mid-tones and edges instead of dog-piling the absolute brightest highlight.
 * `threshold` is the floor below which content doesn't count as a feature at all.
 *
 * LIFESPAN: a tracker retires after its (jittered) lifespan and reacquires elsewhere via the
 * feature grid — constant, visible turnover. When unlocked it targets the grid cell that best
 * matches its band (distance-discounted), or roams when the frame is empty.
 *
 * ATOMIC (irreducible): this kernel is a serial per-tracker STATE MACHINE — seed → mean-shift
 * pursuit → global reacquire → crowd-hop → retire — whose stages all read and mutate the same
 * row-state registers in order, then commit them in one trail-ring write pass. There is no
 * shared-intermediate seam to split on without duplicating the state loads/stores; the composed
 * slot is the per-mode `scoreFn` part it shares with the feature-grid kernel.
 */
export declare function buildPursuitKernel(mode: string, scoreFn?: ReturnType<typeof featureScoreFn>): import('typegpu').TgpuFn<(ti: d.U32) => d.Void>;
/**
 * The whole compute half as one part: feature-grid scoring pass → tracker pursuit sim.
 * Both consume the child RTT, which binds LATE (bindInputs — it only exists after boundary
 * allocation). `mode` is the compile-time detect prop value; the scalar slots are per-frame
 * CPU prop names.
 */
export declare function createTrackerPursuitSim(slots: {
    mode: string;
    trackers: string;
    agility: string;
    threshold: string;
    variance: string;
    lifespan: string;
}): GpuComputeNode;
//# sourceMappingURL=trackerSim.d.ts.map