Aether

// First-person per-object aim markers (OFF by default — opt-in overlay, FPV only).

private val _showAimTracks = MutableStateFlow(prefs.getBoolean("scene_show_aim_tracks", false))

val showAimTracks: StateFlow<Boolean> = _showAimTracks.asStateFlow()

fun setShowAimTracks(on: Boolean) {

_showAimTracks.value = on

prefs.edit { putBoolean("scene_show_aim_tracks", on) }

}

val showAimTracks by app.appSettingsStore.showAimTracks.collectAsState()

aimTracks = showAimTracks,

SceneLayer.AimTracks -> app.appSettingsStore.setShowAimTracks(on)

tracks = { cone -> hud.aimTracks(cone) },

import androidx.compose.runtime.LaunchedEffect

import androidx.compose.runtime.withFrameNanos

import com.aether.mofe.engine.netcode.MeshAimTracker

enum class SceneLayer { Grid, Connections, Nodes, Predicates, Legend, AimTracks }

val aimTracks: Boolean = false,

tracks: (Double) -> List<MeshAimTracker.Track> = { emptyList() },

// First-person per-object aim markers (opt-in layer): every mesh object placed on the

// reticle from its interpolated pose, so the aim reads at a glance. Drawn under the reticle

// so the crosshair stays crisp; (0,0) == on-aim, coinciding with it by construction.

if (firstPerson && layers.aimTracks) {

AimMarkersOverlay(

tracks = tracks,

coneRadians = 3.0 * kotlin.math.PI / 180.0,

modifier = Modifier.fillMaxSize(),

)

}

LayerRow(Icons.Filled.CenterFocusStrong, "Aim tracks", layers.aimTracks) { onToggle(SceneLayer.AimTracks, it) }

/**

* First-person per-object aim markers. Each [MeshAimTracker.Track] carries a reticleOffset

* (right, up) that is (0,0) — the crosshair — exactly when the phone is aimed at that object, and

* grows off-axis. Map it to the screen with the same centre + focal convention as the FPV

* projector, so a marker slides onto [FpvReticle] precisely when its object is on-aim. onReticle

* objects render filled (locked); the rest as a ring (tracking). Repaints on the frame clock so

* markers follow the ~60 Hz hand motion, not the ~10 Hz solve.

*

* NOTE (UI): focal = min(w,h)*0.9 matches the hand-rolled FPV projector (Mesh3DCanvas). For

* pixel-exact OFF-centre alignment with the Filament FPV camera, set focal = (h/2)/tan(vFov/2)

* from that camera; the on-aim (0,0) placement is exact regardless.

*/

@Composable

private fun AimMarkersOverlay(

tracks: (Double) -> List<MeshAimTracker.Track>,

coneRadians: Double,

modifier: Modifier = Modifier,

) {

val frame = remember { mutableStateOf(0L) }

LaunchedEffect(Unit) { while (true) { withFrameNanos { frame.value = it } } }

Canvas(modifier) {

frame.value // frame-clock read → redraw each frame

val cx = size.width / 2f

val cy = size.height / 2f

val focal = kotlin.math.min(size.width, size.height) * 0.9f

for (t in tracks(coneRadians)) {

val off = t.reticleOffset ?: continue // behind the horizon — nothing to place

val x = cx + off.first.toFloat() * focal

val y = cy - off.second.toFloat() * focal // screen-y is down

if (t.onReticle) {

drawCircle(AetherColors.Accent, radius = 7.dp.toPx(), center = Offset(x, y))

} else {

drawCircle(

AetherColors.Accent.copy(alpha = 0.55f), radius = 5.dp.toPx(),

center = Offset(x, y), style = Stroke(width = 2.dp.toPx()),

)

}

}

}

}

import com.aether.mofe.engine.netcode.MeshAimTracker

import com.aether.mofe.engine.netcode.NetcodeSession

import com.aether.mofe.engine.netcode.toTemporalPose

import com.aether.mofe.model.DeviceId

import com.aether.mofe.model.Timestamp

// ── Client-local aim tracker ──────────────────────────────────────────────

// A per-client NetcodeSession fed from the engine's own fused world poses (no peer transport —

// that is the separate mesh-netcode go-live). MeshAimTracker then places every mesh object on

// the reticle from entity-interpolated poses, so the aim reads self-consistent regardless of

// absolute-heading accuracy. Local single-observer ⇒ the mesh clock is identity, so each

// FusedState's own timestamp is its mesh time.

private val netcode = NetcodeSession(baseInterpDelayMicros = 60_000L)

private val aim = MeshAimTracker(netcode)

@Volatile private var latestMeshMicros: Long = 0L

// Feed the aim tracker from the engine's fused world poses (~10 Hz solve).

viewModelScope.launch {

app.mofeEngineHost.fusedStates.collect { states ->

for ((id, state) in states) {

netcode.recordSample(DeviceId(id), state.timestamp, state.toTemporalPose())

val us = state.timestamp.microseconds

if (us > latestMeshMicros) latestMeshMicros = us

}

}

}

/**

* Per-object aim tracks for the first-person reticle: every mesh object placed on the

* observer's facing frame from its entity-interpolated pose ([MeshAimTracker]). Pull-based,

* mirroring [latestFacing]; empty until a self pose + facing exist. Observer position is the

* engine's WORLD-frame self pose (the same frame as the recorded fused poses), so a track's

* (0,0) reticle offset coincides with the crosshair by construction. [coneRadians] is the

* on-reticle "locked" half-angle. Queried at the freshest fused mesh time, so renderPose

* interpolates one interp-delay behind the latest solve.

*/

fun aimTracks(coneRadians: Double): List<MeshAimTracker.Track> {

val observer = app.mofeEngineHost.latestSelfPose()?.position ?: return emptyList()

val facing = latestFacing() ?: return emptyList()

val up = latestTopEdge() ?: Vector3D(0.0, 1.0, 0.0)

return aim.tracks(observer, facing, up, Timestamp(latestMeshMicros), coneRadians)

}