From fb9b26a06cf72d8d9f61fb260d9db76937623713 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 08:35:02 +0100 Subject: [PATCH] Work out the creative grid's stacks once per tab or search, not every frame With the creative inventory open, every frame cloned all the tabs with their stacks (twice), and items() cloned the selected tab's stacks again on each of its three or four calls a frame; on the search tab each call ran the whole search again, building every stack's localised name. That took the frame rate from about 1,900 to 980 with the inventory open and 340 while searching (#1953). Vanilla fills ItemPickerMenu.items when the tab or the search changes (selectTab, refreshSearchResults): the grid's stacks are now kept until the tab, the search text or the language changes, and the screen draws the tabs without copying their stacks. --- crates/horizon-client/src/creative.rs | 75 +++++++++++++++++++++++---- crates/horizon-client/src/game.rs | 5 +- 2 files changed, 68 insertions(+), 12 deletions(-) diff --git a/crates/horizon-client/src/creative.rs b/crates/horizon-client/src/creative.rs index 249e40b11..95d32ac90 100644 --- a/crates/horizon-client/src/creative.rs +++ b/crates/horizon-client/src/creative.rs @@ -3,7 +3,12 @@ //! (`creative-inventory.json`), a 9x5 scrolling grid and the search tab. use crate::{Result, items::ItemStack}; use serde_json::Value; -use std::{collections::HashMap, fs, path::Path}; +use std::{ + collections::HashMap, + fs, + path::Path, + sync::{Arc, Mutex}, +}; #[derive(Clone, Debug)] pub struct Tab { @@ -42,6 +47,17 @@ pub struct Creative { /// The search tab's stacks, in its display order. search_items: Vec, search_index: Vec, + /// ItemPickerMenu.items: what the grid shows, filled when the tab or the + /// search changes (selectTab, refreshSearchResults), not on every frame. + shown: Mutex>, +} +/// The grid's stacks for one tab, search text and language. +struct Shown { + tab: usize, + search: String, + /// A display name, so a language change refills the search results. + language: String, + items: Arc<[ItemStack]>, } /// Display names from the pinned en_us language file. #[derive(Default)] @@ -288,6 +304,7 @@ impl Creative { search_focused: std::time::Instant::now(), search_items, search_index, + shown: Mutex::new(None), } } /// Where a stack comes in the creative tabs (the search tab lists them @@ -300,6 +317,22 @@ impl Creative { .position(|s| s.same_item_same_components(stack)) .or_else(|| items.iter().position(|s| s.item == stack.item)) } + /// The tabs without their stacks: what the screen draws of them each frame. + pub fn tab_headers(&self) -> Vec { + self.tabs + .iter() + .map(|t| Tab { + id: t.id.clone(), + title: t.title.clone(), + icon: t.icon.clone(), + items: Vec::new(), + top: t.top, + column: t.column, + search: t.search, + inventory: t.inventory, + }) + .collect() + } pub fn tab(&self) -> &Tab { &self.tabs[self.selected.min(self.tabs.len() - 1)] } @@ -380,17 +413,39 @@ impl Creative { }) .collect() } - /// Items shown by the selected tab (the search tab filters by `search`). - pub fn items(&self, names: &Names) -> Vec { - let tab = self.tab(); - if tab.search { - return self - .search_results(&self.search, names) + /// Items shown by the selected tab (the search tab filters by `search`), + /// worked out again only when the tab, the search or the language changed. + pub fn items(&self, names: &Names) -> Arc<[ItemStack]> { + let tab = self.selected.min(self.tabs.len() - 1); + let search = if self.tab().search { + self.search.as_str() + } else { + "" + }; + let language = names.display_get("itemGroup.search").unwrap_or_default(); + let mut shown = self.shown.lock().unwrap_or_else(|e| e.into_inner()); + if let Some(s) = shown.as_ref() + && s.tab == tab + && s.search == search + && s.language == language + { + return s.items.clone(); + } + let items: Arc<[ItemStack]> = if self.tab().search { + self.search_results(search, names) .into_iter() .map(|i| self.search_items[i].clone()) - .collect(); - } - tab.items.clone() + .collect() + } else { + self.tab().items.as_slice().into() + }; + *shown = Some(Shown { + tab, + search: search.to_owned(), + language, + items: items.clone(), + }); + items } pub fn rows(&self, names: &Names) -> usize { self.items(names).len().div_ceil(9) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 8591c721f..4defa03ef 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -9721,8 +9721,9 @@ impl Game<'_> { fn draw_creative(&mut self, batch: &mut HudBatch) { let (ox, oy) = Self::creative_origin(batch); let selected = self.creative_screen.selected; - let tabs = self.creative_screen.tabs.clone(); - let tab = self.creative_screen.tab().clone(); + // Only what is drawn of the tabs: their stacks stay where they are. + let tabs = self.creative_screen.tab_headers(); + let tab = tabs[selected.min(tabs.len() - 1)].clone(); let tab_sprite = |t: &horizon_client::creative::Tab, on: bool| { format!( "gui/sprites/container/creative_inventory/tab_{}_{}_{}",