perf(slint): immersive Coverflow - persistent elements + animated scroll (CSS/iPhone model)

Rebuild that finally kills the per-click CPU spike, using the classic
coverflow architecture (the owner's reference: Addy Osmani / iPhone-2007).

Root cause of the spike (now removed): every navigation re-ran refresh_async
which REPLACED the coverflow VecModels, so Slint dropped + rebuilt all 7 bound
Image elements and re-uploaded/re-decoded every cover on each click.

New architecture:
- A single STABLE flat cover model, QueueState.coverflow-tracks =
  [history oldest..newest, NOW, upcoming...], + an int coverflow-index. An
  order-sensitive id-sequence hash gates the model setter: a pure track advance
  (same sequence, pointer moves) does NOT rebuild the model - only the index
  updates. So the Repeater is never rebuilt and visible covers never re-decode.
  Rebuild happens only on a real content change (new queue / shuffle / add /
  remove).
- CoverflowPanel: a Repeater over coverflow-tracks; each card's transform is a
  pure function of offset = index - scroll. `scroll` is a float bound to
  coverflow-index with `animate scroll { 320ms }` - GPU-composited slide that
  repaints only during the transition then idles (no animation-tick / Timer, so
  idle = no continuous render). Flat scaled cards (no rotateY/skew/reflection),
  per-depth black-overlay dim, center painted last + non-interactive, ~7 visible.
- Windowed lazy decode (+-4) reusing the DECODED_PIXEL_CACHE; at most the one
  newly-entering cover decodes per advance.
- Side cards navigate via queue-wide play_history / play_coverflow_upcoming.
- Bonus: atmosphere bg de-dupes by URL (ATMOSPHERE_LAST_URL) so a track change
  no longer re-blurs the same cover. [coverflow-perf] debug timers added.

cc
This commit is contained in:
vicrodh committed 2026-06-13 21:34:30 -06:00
1 parent 763df2eab5
commit 5ded7b1610
4 files changed
+389 -263

No files matched your search

+56 -7
View File
@@ -1177,6 +1177,33 @@ fn load_now_playing_artwork(weak: slint::Weak<AppWindow>, art: qbz_models::Artwo
/// the 160px bar art. Mirrors [`load_now_playing_artwork`] but decodes larger
/// and writes the separate `artwork-large` slot. Source-aware via the SAME
/// `ArtworkRef` funnel (the caller passes a `Some(300)` ref).
/// Last resolved art URL the atmosphere (bg blur / glow / spectrum) was
/// generated for. The 300px decode + `generate_atmosphere` blur is the CPU cost
/// on every track change; this dedupe skips the regen when the SAME cover is
/// re-centered (e.g. a re-play of the current track, a QConnect echo). `None` =
/// nothing generated yet. Reset on track-clear (see `refresh_now_playing_meta`).
static ATMOSPHERE_LAST_URL: std::sync::Mutex<Option<String>> = std::sync::Mutex::new(None);
/// Compare-and-record the atmosphere art-URL dedupe key. Returns `true` when it
/// differs from the last generated value (caller regenerates), recording it. A
/// `None`/empty url, or a poisoned lock, always regenerates (conservative).
fn atmosphere_url_changed(url: Option<&str>) -> bool {
let Some(u) = url.filter(|s| !s.is_empty()) else {
return true;
};
match ATMOSPHERE_LAST_URL.lock() {
Ok(mut last) => {
if last.as_deref() == Some(u) {
false
} else {
*last = Some(u.to_string());
true
}
}
Err(_) => true,
}
}
fn load_now_playing_artwork_large(weak: slint::Weak<AppWindow>, art: qbz_models::ArtworkRef) {
if art.is_empty() {
return;
@@ -1184,6 +1211,8 @@ fn load_now_playing_artwork_large(weak: slint::Weak<AppWindow>, art: qbz_models:
let Some(cache) = crate::artwork::shared_cache() else {
return;
};
// Art-URL dedupe key for the atmosphere regen (bg/glow/spectrum).
let art_url = art.to_mpris_url();
tokio::spawn(async move {
let Some((pixels, w, h)) =
crate::artwork::fetch_and_decode_ref(&art, &cache, 300).await
@@ -1192,19 +1221,34 @@ fn load_now_playing_artwork_large(weak: slint::Weak<AppWindow>, art: qbz_models:
};
let _ = weak.upgrade_in_event_loop(move |win| {
let img = crate::artwork::pixels_to_image(&pixels, w, h);
// The hover-preview cover is ALWAYS needed (independent of the
// immersive overlay), so set it unconditionally first.
win.global::<NowPlayingState>().set_artwork_large(img);
// The atmosphere (bg blur / glow / spectrum colors) regen is the CPU
// cost on every track change. Skip the expensive generate_atmosphere
// blur when the SAME cover is already centered (art-URL dedupe) — the
// bg/glow/spectrum already reflect it. This is the compounding
// per-click cost the rebuild flagged (a re-play / QConnect echo of the
// current track no longer re-blurs). We deliberately do NOT gate on
// `ImmersiveState.open`: opening the overlay does not re-fire this
// path, so a closed-overlay skip would leave a stale bg on open; the
// overlay is conditionally mounted, so generating while closed is
// cheap insurance and the dedupe still prevents repeats.
let imm = win.global::<ImmersiveState>();
if !atmosphere_url_changed(art_url.as_deref()) {
return;
}
if let Some((bg_pixels, bg_w, bg_h)) = crate::immersive::generate_atmosphere(&pixels, w, h)
{
let bg = crate::artwork::pixels_to_image(&bg_pixels, bg_w, bg_h);
win.global::<ImmersiveState>().set_bg_image(bg);
imm.set_bg_image(bg);
}
win.global::<ImmersiveState>()
.set_glow_color(crate::immersive::glow_color(&pixels, w, h));
imm.set_glow_color(crate::immersive::glow_color(&pixels, w, h));
let (spec_primary, spec_secondary) =
crate::immersive::spectrum_colors(&pixels, w, h);
win.global::<ImmersiveState>().set_spectrum_primary(spec_primary);
win.global::<ImmersiveState>()
.set_spectrum_secondary(spec_secondary);
win.global::<NowPlayingState>().set_artwork_large(img);
imm.set_spectrum_primary(spec_primary);
imm.set_spectrum_secondary(spec_secondary);
});
});
}
@@ -1276,6 +1320,11 @@ pub(crate) async fn refresh_now_playing_meta(runtime: &Runtime, weak: &slint::We
if let Ok(mut last) = MPRIS_LAST_META.lock() {
*last = None;
}
// Reset the atmosphere art-URL dedupe so replaying the same track after a
// stop regenerates the immersive bg/glow/spectrum.
if let Ok(mut last) = ATMOSPHERE_LAST_URL.lock() {
*last = None;
}
if let Some(t) = crate::tray::handle() {
t.clear_track();
}
+186 -78
View File
@@ -46,6 +46,14 @@ pub struct QueueController {
handle: tokio::runtime::Handle,
playback: qbz_app::settings::playback::PlaybackPreferencesState,
view: Arc<Mutex<ViewState>>,
/// Last coverflow flat id-sequence fingerprint pushed to `QueueState`.
/// `refresh_async` compares the freshly-computed hash to this: equal means a
/// PURE ADVANCE/JUMP (same id-sequence, only the current pointer moved) — the
/// flat model setter is SKIPPED and only `coverflow-index` is updated, so the
/// Repeater never rebuilds and visible covers never re-decode. A different
/// hash (new queue / shuffle / add / remove) triggers the one-time rebuild.
/// `None` = nothing pushed yet (first refresh always rebuilds).
last_coverflow_seq: Arc<Mutex<Option<u64>>>,
}
// `PlaybackPreferencesState` is not `Clone`, but its sole field is an
@@ -61,6 +69,7 @@ impl Clone for QueueController {
store: Arc::clone(&self.playback.store),
},
view: Arc::clone(&self.view),
last_coverflow_seq: Arc::clone(&self.last_coverflow_seq),
}
}
}
@@ -148,6 +157,7 @@ impl QueueController {
handle,
playback,
view: Arc::new(Mutex::new(ViewState::default())),
last_coverflow_seq: Arc::new(Mutex::new(None)),
}
}
@@ -200,6 +210,7 @@ impl QueueController {
}
async fn refresh_async(&self) {
let perf_start = std::time::Instant::now();
let state = self.runtime.core().get_queue_state_full().await;
// --- NOW PLAYING --------------------------------------------------
@@ -261,21 +272,60 @@ impl QueueController {
let history_rows: Vec<RowData> =
state.history.iter().map(|t| row_from(t, false)).collect();
// --- COVERFLOW (unfiltered next-3 / prev-3) -----------------------
// Built from the UNFILTERED queue so the immersive pyramid is correct
// regardless of sidebar page/search. Index 0 = next / most-recent.
let coverflow_up_rows: Vec<RowData> = state
.upcoming
.iter()
.take(3)
.map(|t| row_from(t, false))
.collect();
let coverflow_hist_rows: Vec<RowData> = state
.history
.iter()
.take(3)
.map(|t| row_from(t, false))
.collect();
// --- COVERFLOW (ONE stable flat model) ----------------------------
// Built from the UNFILTERED queue, oldest-first:
// [history.reversed (oldest..newest), NOW-PLAYING, upcoming...]
// `QueueStateFull.history` is most-recent-first, so reverse it for the
// oldest-first flat order. The flat index of NOW = number of history
// entries (it sits right after the reversed history). On a PURE ADVANCE
// the id-sequence is unchanged and only `coverflow_index` moves -> the
// .slint `scroll` float animates, no model rebuild, no re-decode.
let mut coverflow_rows: Vec<RowData> = Vec::with_capacity(
state.history.len() + 1 + state.upcoming.len(),
);
for t in state.history.iter().rev() {
coverflow_rows.push(row_from(t, false));
}
let coverflow_index: usize = if let Some(t) = state.current_track.as_ref() {
let idx = coverflow_rows.len();
coverflow_rows.push(row_from(t, true));
idx
} else {
// No current track: index points at the first upcoming (or 0 when
// the whole queue is empty). The flat list is history ++ upcoming.
coverflow_rows.len()
};
for t in state.upcoming.iter() {
coverflow_rows.push(row_from(t, false));
}
// Order-sensitive rolling fingerprint over the flat id-sequence. Used to
// gate the model rebuild: equal hash => same membership+order => pure
// advance/jump => skip set_coverflow_tracks. Hashing the ordered ids
// (not a set) catches shuffle/reorder; folding the index-free id list
// keeps a same-sequence-different-pointer advance hashing identical.
let coverflow_seq_hash: u64 = {
use std::hash::{Hash, Hasher};
let mut h = std::collections::hash_map::DefaultHasher::new();
coverflow_rows.len().hash(&mut h);
for r in &coverflow_rows {
r.id.hash(&mut h);
}
h.finish()
};
// Decide rebuild-vs-index-only BEFORE the event loop so the art-job set
// can be narrowed to the ±4 window. `seq_changed` true => rebuild path.
let seq_changed = {
let mut last = self.last_coverflow_seq.lock().ok();
let changed = match last.as_deref() {
Some(Some(prev)) => *prev != coverflow_seq_hash,
_ => true, // None lock or first push -> rebuild
};
if let Some(slot) = last.as_deref_mut() {
*slot = Some(coverflow_seq_hash);
}
changed
};
// --- Infinite-play flag ------------------------------------------
let infinite = self
@@ -302,49 +352,70 @@ impl QueueController {
art_jobs.push((ArtTarget::History(idx), row.artwork_url.clone()));
}
}
for (idx, row) in coverflow_up_rows.iter().enumerate() {
// Coverflow art jobs are WINDOWED to ±4 around the current flat index
// (only ~9 rows can be near the visible ±3 fan), not the whole queue.
// The set is narrowed further on the event loop (skip rows that already
// carry a decoded handle) so a pure advance decodes AT MOST the one
// cover that just entered the window — see the closure below.
const CF_WINDOW: usize = 4;
let cf_lo = coverflow_index.saturating_sub(CF_WINDOW);
let cf_hi = (coverflow_index + CF_WINDOW).min(coverflow_rows.len().saturating_sub(1));
let mut coverflow_art_jobs: Vec<(ArtTarget, String)> = Vec::new();
if !coverflow_rows.is_empty() {
for flat_idx in cf_lo..=cf_hi {
let row = &coverflow_rows[flat_idx];
if !row.artwork_url.is_empty() {
art_jobs.push((ArtTarget::CoverflowUpcoming(idx), row.artwork_url.clone()));
coverflow_art_jobs
.push((ArtTarget::CoverflowFlat(flat_idx), row.artwork_url.clone()));
}
}
for (idx, row) in coverflow_hist_rows.iter().enumerate() {
if !row.artwork_url.is_empty() {
art_jobs.push((ArtTarget::CoverflowHistory(idx), row.artwork_url.clone()));
}
}
let weak = self.weak.clone();
let _ = weak.upgrade_in_event_loop(move |w| {
let qs = w.global::<QueueState>();
// Snapshot prior decoded handles per list BEFORE replacing the
// models, so unchanged tracks keep their decoded artwork instead of
// blanking to the default (which forced a full re-decode + blink on
// every click). Diffed per-list so a track present in both history
// and upcoming can't cross-map.
let prior_page = prior_art_map(&qs.get_upcoming_page());
let prior_history = prior_art_map(&qs.get_history());
let prior_cf_up = prior_art_map(&qs.get_coverflow_upcoming());
let prior_cf_hist = prior_art_map(&qs.get_coverflow_history());
// Snapshot prior decoded handles into ONE GLOBAL id -> artwork map
// covering EVERY prior list (now-playing + upcoming + history +
// both coverflow lists) BEFORE replacing the models. Coverflow
// navigation shifts a cover ACROSS lists every click (now-playing ->
// history, upcoming -> now-playing, ...), so a per-list diff misses
// the moved covers -> they blank to default -> full re-decode ->
// flicker + CPU spike. A global map reuses a cover's decoded handle
// no matter which list it sat in before; net per click only the one
// genuinely new track decodes.
let mut prior_all: std::collections::HashMap<slint::SharedString, slint::Image> =
std::collections::HashMap::new();
{
let np = qs.get_now_playing();
if np.artwork.size().width > 0 {
prior_all.insert(np.id.clone(), np.artwork.clone());
}
for m in [
qs.get_upcoming_page(),
qs.get_history(),
qs.get_coverflow_tracks(),
] {
for i in 0..m.row_count() {
if let Some(it) = m.row_data(i) {
if it.artwork.size().width > 0 {
prior_all.entry(it.id.clone()).or_insert(it.artwork.clone());
}
}
}
}
}
let np_item = now_playing
.as_ref()
.map(|r| {
// Reuse the prior now-playing cover only if the same track.
let prior = qs.get_now_playing();
let mut map = std::collections::HashMap::new();
if prior.artwork.size().width > 0 {
map.insert(prior.id.clone(), prior.artwork.clone());
}
to_item_reuse(r, &map)
})
.map(|r| to_item_reuse(r, &prior_all))
.unwrap_or_default();
qs.set_has_current(now_playing.is_some());
qs.set_now_playing(np_item);
qs.set_now_playing_favorite(now_playing_favorite);
let page_items: Vec<QueueItem> =
page_rows.iter().map(|r| to_item_reuse(r, &prior_page)).collect();
page_rows.iter().map(|r| to_item_reuse(r, &prior_all)).collect();
qs.set_upcoming_page(slint::ModelRc::new(slint::VecModel::from(page_items)));
qs.set_upcoming_total(upcoming_total as i32);
qs.set_upcoming_remaining(remaining as i32);
@@ -354,25 +425,68 @@ impl QueueController {
qs.set_page_end(page_end as i32);
let history_items: Vec<QueueItem> =
history_rows.iter().map(|r| to_item_reuse(r, &prior_history)).collect();
history_rows.iter().map(|r| to_item_reuse(r, &prior_all)).collect();
qs.set_history(slint::ModelRc::new(slint::VecModel::from(history_items)));
// Coverflow lists (unfiltered next-3 / prev-3), reusing handles.
let cf_up_items: Vec<QueueItem> = coverflow_up_rows
// --- COVERFLOW: gated flat-model update -----------------------
// KEY INVARIANT. On a PURE ADVANCE/JUMP the id-sequence is unchanged
// (`!seq_changed`) so we DO NOT call set_coverflow_tracks: the
// Repeater model is untouched, every visible cover keeps its decoded
// `slint::Image` handle (no source reassignment, no re-decode), and
// only the int `coverflow-index` moves -> the .slint `scroll` float
// animates the fan to the new position. The model is rebuilt ONLY
// when the contents actually change (new queue / shuffle / add /
// remove), reusing the global id->handle map so even then only the
// genuinely-new covers decode.
if seq_changed {
let cf_items: Vec<QueueItem> = coverflow_rows
.iter()
.map(|r| to_item_reuse(r, &prior_cf_up))
.map(|r| to_item_reuse(r, &prior_all))
.collect();
qs.set_coverflow_upcoming(slint::ModelRc::new(slint::VecModel::from(cf_up_items)));
let cf_hist_items: Vec<QueueItem> = coverflow_hist_rows
.iter()
.map(|r| to_item_reuse(r, &prior_cf_hist))
.collect();
qs.set_coverflow_history(slint::ModelRc::new(slint::VecModel::from(cf_hist_items)));
qs.set_coverflow_tracks(slint::ModelRc::new(slint::VecModel::from(cf_items)));
qs.set_coverflow_seq_hash(coverflow_seq_hash as i32);
log::debug!(
"[coverflow-perf] rebuild seq={coverflow_seq_hash} len={} idx={coverflow_index}",
coverflow_rows.len()
);
} else {
log::debug!(
"[coverflow-perf] index-only idx={coverflow_index} (seq unchanged)"
);
}
qs.set_coverflow_index(coverflow_index as i32);
qs.set_infinite_play(infinite);
// Keep the Slint tab property in sync with the view state so the
// Queue/History body always matches the selected tab.
qs.set_tab(tab);
// --- COVERFLOW windowed lazy decode (inside the event loop so it
// can read the live model and SKIP rows that already carry a decoded
// handle). After a rebuild the to_item_reuse map already filled most
// window covers; after an index-only update the model is the prior
// one with handles intact. Either way we emit a decode job ONLY for a
// window row whose model cell is still a default (0-width) image ->
// at most ONE decode per advance (the cover that just entered ±4),
// often zero. Visible covers are NEVER re-decoded (the invariant).
let cf_model = qs.get_coverflow_tracks();
let mut windowed_jobs: Vec<(ArtTarget, String)> = Vec::new();
for (target, url) in coverflow_art_jobs.into_iter() {
let ArtTarget::CoverflowFlat(flat_idx) = target else {
continue;
};
let needs = cf_model
.row_data(flat_idx)
.map(|it| it.artwork.size().width == 0)
.unwrap_or(false);
if needs {
windowed_jobs.push((target, url));
}
}
if !windowed_jobs.is_empty() {
let plex = crate::plex_settings::get();
load_artwork(w.as_weak(), windowed_jobs, plex.base_url, plex.token);
}
});
// Plex creds for source-aware art: a Plex queue row carries a raw
@@ -380,6 +494,11 @@ impl QueueController {
// not a local-file read miss. Non-Plex paths ignore these.
let plex = crate::plex_settings::get();
load_artwork(self.weak.clone(), art_jobs, plex.base_url, plex.token);
log::debug!(
"[coverflow-perf] refresh_async total={}ms",
perf_start.elapsed().as_millis()
);
}
// --- Callbacks --------------------------------------------------------
@@ -710,8 +829,8 @@ enum ArtTarget {
NowPlaying,
Upcoming(usize),
History(usize),
CoverflowUpcoming(usize),
CoverflowHistory(usize),
/// A row in the single stable flat coverflow model, by flat index.
CoverflowFlat(usize),
}
/// Build a `QueueItem` from plain row data, REUSING a prior decoded artwork
@@ -741,23 +860,6 @@ fn to_item_reuse(
}
}
/// Snapshot the current id -> decoded-artwork map for a Slint model, so the
/// rebuilt rows can reuse handles for tracks that did not change. Only rows
/// whose artwork is actually resolved (`width > 0`) are recorded.
fn prior_art_map(
model: &slint::ModelRc<QueueItem>,
) -> std::collections::HashMap<slint::SharedString, slint::Image> {
let mut map = std::collections::HashMap::new();
for i in 0..model.row_count() {
if let Some(item) = model.row_data(i) {
if item.artwork.size().width > 0 {
map.insert(item.id.clone(), item.artwork.clone());
}
}
}
map
}
#[cfg(test)]
mod tests {
use super::*;
@@ -914,6 +1016,9 @@ fn load_artwork(
};
if let Some(key) = cache_key.as_deref() {
if let Some((pixels, w, h)) = crate::artwork::decoded_pixels(key, QUEUE_DECODE) {
if let ArtTarget::CoverflowFlat(i) = target {
log::debug!("[coverflow-perf] cache-hit flat_idx={i}");
}
let weak = weak.clone();
let _ = weak.upgrade_in_event_loop(move |win| {
let img = crate::artwork::pixels_to_image(&pixels, w, h);
@@ -923,7 +1028,14 @@ fn load_artwork(
}
}
let perf_url = match target {
ArtTarget::CoverflowFlat(i) => Some((i, cache_key.clone().unwrap_or_default())),
_ => None,
};
tokio::spawn(async move {
if let Some((i, u)) = perf_url.as_ref() {
log::debug!("[coverflow-perf] decode flat_idx={i} url={u}");
}
let Some((pixels, w, h)) =
crate::artwork::fetch_and_decode_ref(&art, &cache, QUEUE_DECODE).await
else {
@@ -960,17 +1072,13 @@ fn apply_queue_art(win: &AppWindow, target: ArtTarget, img: slint::Image) {
items.set_row_data(idx, item);
}
}
ArtTarget::CoverflowUpcoming(idx) => {
let items = qs.get_coverflow_upcoming();
if let Some(mut item) = items.row_data(idx) {
item.artwork = img;
items.set_row_data(idx, item);
}
}
ArtTarget::CoverflowHistory(idx) => {
let items = qs.get_coverflow_history();
ArtTarget::CoverflowFlat(idx) => {
let items = qs.get_coverflow_tracks();
if let Some(mut item) = items.row_data(idx) {
item.artwork = img;
// set_row_data on a SINGLE flat row — does NOT replace the
// VecModel, so the Repeater is not rebuilt and the other covers'
// sources are untouched. Only this one cell's image changes.
items.set_row_data(idx, item);
}
}
+125 -169
View File
@@ -1,40 +1,39 @@
// Coverflow foreground (Immersive mode 2) — a CHEAP "rocola" (jukebox)
// PYRAMID of flat scaled cards.
// Coverflow foreground (Immersive mode 2) — a CHEAP classic-CSS / iPhone-2007
// coverflow built on the PERSISTENT-ELEMENT + ANIMATED-SCROLL architecture.
//
// OWNER DECISION (binding, REPLACES the old true-3D-aspiring fan): NO rotateY /
// skew / perspective / reflection, NO far-edge shade gradient, NO transparency
// on the card root. Just flat scaled cards. Depth reads from (a) a step-down
// SCALE so the silhouette is a pyramid (center tallest) and (b) a per-depth
// semi-transparent BLACK overlay on an INNER rectangle (attenuation, darker
// the further out). A real blur is too expensive and is NOT used — the owner
// said "un blur o atenuación... basta", so attenuation + scale is the depth cue.
// ARCHITECTURE (binding — replaces the old 7 fixed-slot design):
// 1. PERSISTENT covers. The covers are a SINGLE stable, ordered list of the
// whole queue — `QueueState.coverflow-tracks` = [history oldest..newest,
// NOW-PLAYING, upcoming...]. This list + its decoded cover images do NOT
// change on a pure track advance/navigation; only the int
// `QueueState.coverflow-index` (the flat position of NOW) moves. The Rust
// controller rebuilds the model ONLY when the queue CONTENTS change
// (id-sequence diff). So a track advance NEVER rebuilds this Repeater and
// NEVER re-decodes a visible cover.
// 2. ANIMATED SCROLL. A single float `scroll` is bound to `coverflow-index`
// with `animate scroll { 320ms ease-in-out }`. When Rust sets the new int
// index, `scroll` EASES to it and the fan repaints ONLY during the 320ms,
// then idles. NO `animation-tick` (that would force continuous fps = the
// CPU cost we are avoiding); NO Timer.
// 3. TRANSFORM-ONLY layout. Each cover i derives offset = i - scroll;
// x = center + offset*pitch; size = base * scale(|offset|); a per-depth
// black overlay dims by |offset| on an INNER Rectangle (never root
// opacity). Covers with |offset| > 3 are `visible:false` (~7 on screen).
// This is CSS `transform: translateX()+scale()` done with Slint geometry —
// FLAT scaled cards (NO rotateY/skew/perspective/reflection; Slint has no
// 3D and the owner accepted flat).
// 4. NAVIGATION. A side card at flat index i plays that queue position by
// mapping i -> the existing queue-wide play-history / play-coverflow-
// upcoming calls; the subsequent refresh moves `coverflow-index` and
// `scroll` animates to it. The center (offset ~0) is non-interactive.
//
// LAYOUT: 7 cards = 3 past (left, history) + center + 3 upcoming (right). The
// now-playing cover is ALWAYS centered and ALWAYS on top in Z (declared LAST =
// paints last). Cards may overlap toward the center (jukebox stack).
//
// PERF: the old version animated x / width / height over 500ms on every slot,
// re-laying-out clipped images each frame on every click. That is DROPPED — the
// cards snap to their new depth on a click (Option A). Combined with the Rust
// decoded-handle reuse (queue.rs) the covers no longer blink, so the snap is
// clean. A single 120ms opacity cross-fade on the INNER dim overlay (Option B)
// is the only motion — GPU-only, no relayout, no texture re-upload.
//
// SLINT GOTCHAS honored: `parent` is never read in any root binding (viewport
// dims passed as props; CoverSlot dims passed as props). Hand-placed fixed
// instances (no Repeater) and NO `changed x/y/width/height` watchers -> avoids
// the "Recursion detected" panic. `dim` is applied on an INNER Rectangle, never
// the slot root opacity (root opacity corrupts absolute positioning). The
// off-clamp uses Math.min (max-width is ignored on hand-positioned Rectangles).
//
// DATA MAPPING (unfiltered coverflow lists, correct regardless of sidebar
// page/search — populated in queue.rs refresh_async from state.upcoming[..3] /
// state.history[..3] with decoded-handle reuse):
// center (depth 0) <- NowPlayingState (unified source, also feeds the card)
// right-n (depth n) <- QueueState.coverflow-upcoming[n-1] (next tracks)
// left-n (depth n) <- QueueState.coverflow-history[n-1] (recent-first)
// Side covers navigate via QueueState.play-upcoming / play-history (index n-1);
// the center is non-interactive.
// SLINT GOTCHAS honored: `parent` is NEVER read in any root binding (viewport
// dims + the per-cover stage geometry are passed as props). Everything derives
// from the DATA value `i` and the `scroll` float — NO `changed x/y/width/height`
// watchers on rows (avoids the "Recursion detected" panic). `dim` is on an INNER
// Rectangle, never the slot root opacity. Math.min/max are 2-arg; clamp =
// Math.max(lo, Math.min(hi, x)). The center card is a SEPARATE top-most instance
// (Repeater can't reorder by data) so it paints over its neighbors.
import { QualityBadgeFull } from "../primitives/QualityBadgeFull.slint";
import { NowPlayingState, QueueState } from "../state.slint";
@@ -87,36 +86,47 @@ component EqualizerBars inherits Rectangle {
}
}
// One flat card in the pyramid. Dims passed as props (NEVER `parent` in the
// root binding). `dim` is the per-depth attenuation (0 center .. 0.55 outermost)
// applied on an INNER Rectangle, never the root opacity. `has-art` is true when
// the cover image is resolved; otherwise a neutral placeholder shows instead of
// a 0-size collapse. NO animated geometry — the card snaps to its depth on a
// click; only the dim overlay cross-fades (120ms, GPU-only).
component CoverSlot inherits Rectangle {
// One flat coverflow card. ALL geometry is derived from `offset` (= i - scroll)
// + the stage props passed in (NEVER `parent` in the root binding). The card
// position/size/dim are pure functions of `offset`, so when the parent's
// animated `scroll` changes, every card eases to its new transform with NO
// model change and NO source reassignment. `dim` is on an INNER Rectangle.
component CoverCard inherits Rectangle {
in property <image> art;
in property <length> slot-size;
in property <length> center-x; // window-x of the cover CENTER
in property <bool> has-art: false;
in property <float> offset; // signed distance from center (i - scroll)
in property <length> base-art; // depth-0 (center) edge length
in property <length> pitch; // x spacing between adjacent depths
in property <length> stage-cx; // window-x of the center
in property <length> stage-height;
in property <float> dim: 0.0; // 0..1 per-depth black-overlay opacity
in property <bool> has-art: false; // art image resolved (width > 0)
in property <bool> interactive: false;
callback navigate();
width: root.slot-size;
height: root.slot-size;
x: root.center-x - root.slot-size / 2;
// Shared center band; the larger center card naturally rises. Small upward
// bias to leave room for the song card below.
y: (root.stage-height - root.slot-size) / 2 - 12px;
property <float> ao: Math.abs(root.offset);
// Step-down scale: center 1.0 -> ~0.5 at |offset| >= ~2.8.
property <float> scale: Math.max(0.5, 1.0 - 0.18 * root.ao);
property <length> slot: root.base-art * root.scale;
// Per-depth black overlay: 0 at center, up to 0.55 outward.
property <float> dim: Math.min(0.55, root.ao * 0.18);
// Only ~7 cards near the center paint; the rest are dropped (no texture
// cost from off-screen rows — visible:false stops painting).
visible: root.ao <= 3.2;
width: root.slot;
height: root.slot;
// Center the card on (stage-cx + offset*pitch); small upward bias to leave
// room for the song card below.
x: root.stage-cx + root.offset * root.pitch - root.slot / 2;
y: (root.stage-height - root.slot) / 2 - 12px;
border-radius: 8px;
clip: true;
// Static drop-shadow on the center card only (never animated, never on the
// side cards — the attenuation carries their depth).
drop-shadow-blur: root.dim == 0.0 ? 28px : 0px;
// Static drop-shadow on (near-)center cards only — the attenuation carries
// the depth for the side cards. Never animated.
drop-shadow-blur: root.ao < 0.5 ? 28px : 0px;
drop-shadow-color: #00000066;
drop-shadow-offset-y: root.dim == 0.0 ? 8px : 0px;
drop-shadow-offset-y: root.ao < 0.5 ? 8px : 0px;
// Neutral placeholder when the item exists but its art is unresolved.
Rectangle {
@@ -135,21 +145,17 @@ component CoverSlot inherits Rectangle {
visible: root.has-art;
}
// Per-depth attenuation — a semi-transparent BLACK overlay on an INNER
// Rectangle (never the slot root opacity). The ONLY animation: a short
// opacity cross-fade so the attenuation eases as a card changes depth.
// GPU-only (no relayout, no clipped-image re-raster) -> no CPU spike.
// Per-depth attenuation on an INNER Rectangle (never the root opacity).
Rectangle {
width: parent.width;
height: parent.height;
border-radius: 8px;
background: #000000;
opacity: root.dim;
animate opacity { duration: 120ms; easing: ease-out; }
}
// Side cards navigate; the center is non-interactive.
if root.interactive: TouchArea {
if root.interactive && root.ao > 0.5: TouchArea {
mouse-cursor: pointer;
clicked => { root.navigate(); }
}
@@ -168,41 +174,25 @@ export component CoverflowPanel inherits Rectangle {
// clearance: reserve = pad-top(52) + info + clearance(132) = 364px.
property <length> base-art: Math.max(160px,
Math.min(Math.min(root.viewport-height - 364px, root.viewport-width * 0.42), 440px));
// X spacing between adjacent depths (overlapping inward).
property <length> pitch: root.base-art * 0.42;
// Step-down SCALE (center tallest): depth0 1.00, depth1 0.80, depth2 0.64,
// depth3 0.50.
property <length> size1: root.base-art * 0.80;
property <length> size2: root.base-art * 0.64;
property <length> size3: root.base-art * 0.50;
// --- Animated scroll (the ONLY motion) -------------------------------
// Bound to the int current-index; Rust moving the index eases `scroll` over
// 320ms (repaints only during the transition, then idles).
property <float> scroll: QueueState.coverflow-index;
animate scroll { duration: 320ms; easing: ease-in-out; }
// X offsets (center-anchored, overlapping inward). Spec ratios off1 0.42,
// off2 0.74, off3 1.02. Each clamped so the card stays inside the half-window
// with a 16px margin (Math.min — max-width is ignored on hand-positioned
// rects). Chain off1 < off2 < off3 so the order never crosses.
property <length> half-w: root.viewport-width / 2;
property <length> off3: Math.min(root.base-art * 1.02,
Math.max(0px, root.half-w - root.size3 / 2 - 16px));
property <length> off2: Math.min(root.base-art * 0.74,
Math.max(0px, root.off3 - root.size3 / 4));
property <length> off1: Math.min(root.base-art * 0.42,
Math.max(0px, root.off2 - root.size2 / 4));
// --- Center artwork source (unified NowPlayingState, like the siblings) --
// Center card art prefers the unified large now-playing cover (sharper),
// falling back to the model row's small cover while it resolves.
property <int> center-idx: QueueState.coverflow-index;
property <image> center-art: NowPlayingState.artwork-large.width > 0
? NowPlayingState.artwork-large
: NowPlayingState.artwork;
property <bool> center-has-art: root.center-art.width > 0;
// --- Side item presence (unfiltered coverflow lists) ----------------
property <bool> has-up1: QueueState.coverflow-upcoming.length > 0;
property <bool> has-up2: QueueState.coverflow-upcoming.length > 1;
property <bool> has-up3: QueueState.coverflow-upcoming.length > 2;
property <bool> has-hist1: QueueState.coverflow-history.length > 0;
property <bool> has-hist2: QueueState.coverflow-history.length > 1;
property <bool> has-hist3: QueueState.coverflow-history.length > 2;
// --- Pyramid stage ---------------------------------------------------
fan := Rectangle {
// --- Cover fan stage -------------------------------------------------
Rectangle {
x: 0px;
y: 52px; // pad-top, matches the siblings
width: root.viewport-width;
@@ -210,96 +200,62 @@ export component CoverflowPanel inherits Rectangle {
property <length> cx: root.viewport-width / 2;
// Declaration order = paint order: depth3 -> depth1 outward-to-inward,
// CENTER LAST (on top). Left/right of each depth interleaved.
// depth3 LEFT <- history[2]
CoverSlot {
slot-size: root.size3;
center-x: parent.cx - root.off3;
// All side + far covers from the stable flat model. The center is drawn
// separately (below) so it paints on top — a Repeater renders in data
// order and cannot reorder by |offset|.
for item[i] in QueueState.coverflow-tracks: CoverCard {
offset: i - root.scroll;
base-art: root.base-art;
pitch: root.pitch;
stage-cx: parent.cx;
stage-height: parent.height;
dim: 0.55;
art: root.has-hist3 ? QueueState.coverflow-history[2].artwork : root.center-art;
has-art: root.has-hist3 && QueueState.coverflow-history[2].artwork.width > 0;
interactive: root.has-hist3;
visible: root.has-hist3;
navigate => { QueueState.play-history(2); }
art: item.artwork;
has-art: item.artwork.width > 0;
// The center (i == current index) is drawn by the top instance; this
// Repeater copy stays non-interactive and hides exactly at center so
// there is no double-draw flicker through the 320ms ease.
interactive: i != root.center-idx;
navigate => {
// Flat index -> queue-wide play call. Flat order is
// [history.reversed (oldest-first) ++ NOW ++ upcoming], and
// center-idx = history.len():
// i < center-idx -> a history cover. flat history is
// oldest-first while QueueStateFull.history is most-recent-
// first, so hist_index = center-idx - 1 - i.
// i > center-idx -> an upcoming cover.
// up_index = i - center-idx - 1.
if (i < root.center-idx) {
QueueState.play-history(root.center-idx - 1 - i);
} else if (i > root.center-idx) {
QueueState.play-coverflow-upcoming(i - root.center-idx - 1);
}
// depth3 RIGHT <- upcoming[2]
CoverSlot {
slot-size: root.size3;
center-x: parent.cx + root.off3;
stage-height: parent.height;
dim: 0.55;
art: root.has-up3 ? QueueState.coverflow-upcoming[2].artwork : root.center-art;
has-art: root.has-up3 && QueueState.coverflow-upcoming[2].artwork.width > 0;
interactive: root.has-up3;
visible: root.has-up3;
navigate => { QueueState.play-coverflow-upcoming(2); }
}
// depth2 LEFT <- history[1]
CoverSlot {
slot-size: root.size2;
center-x: parent.cx - root.off2;
stage-height: parent.height;
dim: 0.40;
art: root.has-hist2 ? QueueState.coverflow-history[1].artwork : root.center-art;
has-art: root.has-hist2 && QueueState.coverflow-history[1].artwork.width > 0;
interactive: root.has-hist2;
visible: root.has-hist2;
navigate => { QueueState.play-history(1); }
}
// depth2 RIGHT <- upcoming[1]
CoverSlot {
slot-size: root.size2;
center-x: parent.cx + root.off2;
// CENTER card — drawn LAST so it paints over its neighbors. Bound to the
// current-index row's offset (eases to 0 with `scroll`). Uses the unified
// large cover for sharpness; non-interactive (matches the disabled Tauri
// center button).
CoverCard {
offset: root.center-idx - root.scroll;
base-art: root.base-art;
pitch: root.pitch;
stage-cx: parent.cx;
stage-height: parent.height;
dim: 0.40;
art: root.has-up2 ? QueueState.coverflow-upcoming[1].artwork : root.center-art;
has-art: root.has-up2 && QueueState.coverflow-upcoming[1].artwork.width > 0;
interactive: root.has-up2;
visible: root.has-up2;
navigate => { QueueState.play-coverflow-upcoming(1); }
}
// depth1 LEFT <- history[0]
CoverSlot {
slot-size: root.size1;
center-x: parent.cx - root.off1;
stage-height: parent.height;
dim: 0.22;
art: root.has-hist1 ? QueueState.coverflow-history[0].artwork : root.center-art;
has-art: root.has-hist1 && QueueState.coverflow-history[0].artwork.width > 0;
interactive: root.has-hist1;
visible: root.has-hist1;
navigate => { QueueState.play-history(0); }
}
// depth1 RIGHT <- upcoming[0]
CoverSlot {
slot-size: root.size1;
center-x: parent.cx + root.off1;
stage-height: parent.height;
dim: 0.22;
art: root.has-up1 ? QueueState.coverflow-upcoming[0].artwork : root.center-art;
has-art: root.has-up1 && QueueState.coverflow-upcoming[0].artwork.width > 0;
interactive: root.has-up1;
visible: root.has-up1;
navigate => { QueueState.play-coverflow-upcoming(0); }
}
// CENTER (depth 0) <- NowPlayingState. Declared LAST = paints on top.
// Non-interactive, like the disabled Tauri center button.
CoverSlot {
slot-size: root.base-art;
center-x: parent.cx;
stage-height: parent.height;
dim: 0.0;
art: root.center-art;
has-art: root.center-has-art;
art: root.center-has-art ? root.center-art
: (QueueState.coverflow-tracks.length > root.center-idx
? QueueState.coverflow-tracks[root.center-idx].artwork
: root.center-art);
has-art: root.center-has-art
|| (QueueState.coverflow-tracks.length > root.center-idx
&& QueueState.coverflow-tracks[root.center-idx].artwork.width > 0);
interactive: false;
}
}
// --- Song card below the pyramid ------------------------------------
// Reuses the StaticPanel pattern verbatim, fed by NowPlayingState. Pinned
// under the pyramid, respecting the 132px player clearance.
// under the fan, respecting the 132px player clearance.
VerticalLayout {
x: 0px;
y: 0px;
+22 -9
View File
@@ -3248,13 +3248,25 @@ export global QueueState {
in property <[QueueItem]> history: [];
// --- Immersive coverflow (mode 2) ------------------------------------
// The next 3 / previous 3 tracks, taken from the UNFILTERED queue so the
// coverflow pyramid is correct regardless of the sidebar's page or search
// filter. Index 0 = next / most-recent. Decoded artwork handles are reused
// across refreshes (id-diff) so a one-position shift never re-decodes the
// covers still on screen.
in property <[QueueItem]> coverflow-upcoming: [];
in property <[QueueItem]> coverflow-history: [];
// ONE STABLE flat ordered model of the whole queue, oldest-first:
// [history.reversed (oldest..newest), NOW-PLAYING, upcoming...]
// This list and its decoded cover handles do NOT change on a pure track
// advance/jump — only `coverflow-index` (the flat position of NOW) moves,
// and the .slint `scroll` float animates to it. The model is rebuilt by the
// Rust controller ONLY when the queue CONTENTS change (different id-sequence:
// new queue / shuffle / add / remove), gated by `coverflow-seq-hash`. On a
// pure advance the model setter is SKIPPED entirely (no Repeater rebuild, no
// Image churn), so visible covers never re-decode. Windowed (±4) lazy decode
// keeps at most one new cover decoding per advance.
in property <[QueueItem]> coverflow-tracks: [];
// Flat index of the NOW-PLAYING cover within `coverflow-tracks`
// (= history.len() when a current track exists, else 0). The .slint panel
// binds an animated `scroll` float to this int so a change eases the fan.
in property <int> coverflow-index: 0;
// Order-sensitive rolling fingerprint of the flat id-sequence. The Rust
// controller compares this to the value it last pushed; equal => pure
// advance => skip the model rebuild and only update `coverflow-index`.
in property <int> coverflow-seq-hash: 0;
// --- Shared ----------------------------------------------------------
// Active tab: 0 = Queue, 1 = History.
@@ -3266,8 +3278,9 @@ export global QueueState {
// Play the upcoming entry at `index` within the current page slice.
callback play-upcoming(int);
// Play an upcoming entry by its QUEUE-WIDE (unfiltered) index. Used by the
// immersive coverflow, whose cards index `coverflow-upcoming` (= the real
// next-3, page/search-independent) — NOT the paged play-upcoming.
// immersive coverflow: a side card at flat index `i > coverflow-index` maps
// to up_index = i - coverflow-index - 1 and dispatches here (page/search-
// independent) — NOT the paged play-upcoming.
callback play-coverflow-upcoming(int);
// Play a history entry by its `index` in the `history` list.
callback play-history(int);