From 9839d1d08f0f0c729c66a42bd0c0948d2075331c Mon Sep 17 00:00:00 2001 From: UltraProdigy <187078471+UltraProdigy@users.noreply.github.com> Date: Mon, 9 Nov 2026 01:11:38 -0500 Subject: [PATCH 1/5] ci: run build and test on release branches --- .github/workflows/build-and-test.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/build-and-test.yml b/.github/workflows/build-and-test.yml index 3ee2f686..796502d7 100644 --- a/.github/workflows/build-and-test.yml +++ b/.github/workflows/build-and-test.yml @@ -3,9 +3,9 @@ name: Build and test on: pull_request: - branches: [ master, main ] + branches: [ master, main, release/** ] push: - branches: [ master, main ] + branches: [ master, main, release/** ] jobs: build-and-test: From fbbeafcd794c22bd6cca5a3b4bf1361edd8d880c Mon Sep 17 00:00:00 2001 From: slprime <31038811+slprime@users.noreply.github.com> Date: Tue, 10 Nov 2026 19:22:17 +0200 Subject: [PATCH 2/5] Fix WorldClient leak after leaving the world (#1115) --- .../java/codechicken/nei/ClientHandler.java | 8 +++++ .../codechicken/nei/ItemCraftablesPanel.java | 11 ++++++- .../nei/recipe/RecipeItemInputHandler.java | 30 ++++++++++++------- .../nei/recipe/RecipeTooltipLineHandler.java | 1 - .../nei/recipe/debug/DebugHandlerWidget.java | 4 +++ 5 files changed, 42 insertions(+), 12 deletions(-) diff --git a/src/main/java/codechicken/nei/ClientHandler.java b/src/main/java/codechicken/nei/ClientHandler.java index f78cc1fa..c39e9348 100644 --- a/src/main/java/codechicken/nei/ClientHandler.java +++ b/src/main/java/codechicken/nei/ClientHandler.java @@ -54,7 +54,10 @@ import codechicken.nei.guihook.GuiContainerManager; import codechicken.nei.recipe.GuiCraftingRecipe; import codechicken.nei.recipe.GuiUsageRecipe; import codechicken.nei.recipe.IRecipeHandler; +import codechicken.nei.recipe.RecipeHandlerRef; +import codechicken.nei.recipe.RecipeItemInputHandler; import codechicken.nei.recipe.StackInfo; +import codechicken.nei.recipe.debug.DebugHandlerWidget; import cpw.mods.fml.client.CustomModLoadingErrorDisplayException; import cpw.mods.fml.common.FMLCommonHandler; import cpw.mods.fml.common.Loader; @@ -444,6 +447,11 @@ public class ClientHandler { if (event.world == mc.theWorld) { NEIClientConfig.unloadWorld(); ItemMobSpawner.clearEntityReferences(); + RecipeItemInputHandler.instance.clearTooltipCache(); + RecipeHandlerRef.clearCache(); + ItemPanels.itemPanel.craftablesPanel.clearGuiReferences(); + DebugHandlerWidget.instance.clearGuiReferences(); + NEIController.manager = null; } } diff --git a/src/main/java/codechicken/nei/ItemCraftablesPanel.java b/src/main/java/codechicken/nei/ItemCraftablesPanel.java index 35189e91..c4859ef8 100644 --- a/src/main/java/codechicken/nei/ItemCraftablesPanel.java +++ b/src/main/java/codechicken/nei/ItemCraftablesPanel.java @@ -137,7 +137,11 @@ public class ItemCraftablesPanel @Override public void execute() { - pendingResult.set(generateCraftables(ItemCraftablesPanel.this.pendingSnapshot)); + final CraftablesSnapshot snapshot = ItemCraftablesPanel.this.pendingSnapshot; + + if (snapshot != null) { + pendingResult.set(generateCraftables(snapshot)); + } } }; @@ -298,6 +302,11 @@ public class ItemCraftablesPanel } } + public void clearGuiReferences() { + this.lastGuiContainer = null; + this.pendingSnapshot = null; + } + private GuiContainer getGuiContainer() { final GuiContainer firstGui = NEIClientUtils.getGuiContainer(); return (firstGui instanceof GuiRecipegui) ? gui.firstGui : firstGui; diff --git a/src/main/java/codechicken/nei/recipe/RecipeItemInputHandler.java b/src/main/java/codechicken/nei/recipe/RecipeItemInputHandler.java index cb17f46a..ad950018 100644 --- a/src/main/java/codechicken/nei/recipe/RecipeItemInputHandler.java +++ b/src/main/java/codechicken/nei/recipe/RecipeItemInputHandler.java @@ -19,12 +19,21 @@ import codechicken.nei.recipe.Recipe.RecipeId; public class RecipeItemInputHandler implements IContainerInputHandler, IContainerTooltipHandler { + public static final RecipeItemInputHandler instance = new RecipeItemInputHandler(); + protected RecipeTooltipLineHandler recipeTooltipLineHandler = null; + protected RecipeItemInputHandler() { + + } + public static void load() { - RecipeItemInputHandler recipeHandler = new RecipeItemInputHandler(); - GuiContainerManager.addInputHandler(recipeHandler); - GuiContainerManager.addTooltipHandler(recipeHandler); + GuiContainerManager.addInputHandler(instance); + GuiContainerManager.addTooltipHandler(instance); + } + + public void clearTooltipCache() { + this.recipeTooltipLineHandler = null; } @Override @@ -64,16 +73,17 @@ public class RecipeItemInputHandler implements IContainerInputHandler, IContaine : null; if (recipeId == null) { - recipeTooltipLineHandler = null; - } else if (recipeTooltipLineHandler == null || !recipeTooltipLineHandler.getRecipeId().equals(recipeId)) { - recipeTooltipLineHandler = new RecipeTooltipLineHandler(recipeId); - } + clearTooltipCache(); + } else if (this.recipeTooltipLineHandler == null + || !this.recipeTooltipLineHandler.getRecipeId().equals(recipeId)) { + this.recipeTooltipLineHandler = new RecipeTooltipLineHandler(recipeId); + } - if (recipeTooltipLineHandler != null) { - currenttip.add(GuiDraw.TOOLTIP_HANDLER + GuiDraw.getTipLineId(recipeTooltipLineHandler)); + if (this.recipeTooltipLineHandler != null) { + currenttip.add(GuiDraw.TOOLTIP_HANDLER + GuiDraw.getTipLineId(this.recipeTooltipLineHandler)); } } else { - recipeTooltipLineHandler = null; + clearTooltipCache(); } return currenttip; diff --git a/src/main/java/codechicken/nei/recipe/RecipeTooltipLineHandler.java b/src/main/java/codechicken/nei/recipe/RecipeTooltipLineHandler.java index cdfd7ddb..78e21221 100644 --- a/src/main/java/codechicken/nei/recipe/RecipeTooltipLineHandler.java +++ b/src/main/java/codechicken/nei/recipe/RecipeTooltipLineHandler.java @@ -35,7 +35,6 @@ public class RecipeTooltipLineHandler implements ITooltipLineHandler { protected long lastUpdate = System.currentTimeMillis(); protected String recipeName = ""; - protected GuiRecipe gui = null; protected RecipeHandlerRef handlerRef = null; protected RecipeWidget widget = null; protected RecipeId recipeId = null; diff --git a/src/main/java/codechicken/nei/recipe/debug/DebugHandlerWidget.java b/src/main/java/codechicken/nei/recipe/debug/DebugHandlerWidget.java index 683c9029..14460ca8 100644 --- a/src/main/java/codechicken/nei/recipe/debug/DebugHandlerWidget.java +++ b/src/main/java/codechicken/nei/recipe/debug/DebugHandlerWidget.java @@ -733,6 +733,10 @@ public class DebugHandlerWidget extends Widget implements IContainerTooltipHandl }); } + public void clearGuiReferences() { + this.hoveredRecipe = null; + } + public void loadHandlerInfoPatch() { ClientHandler.loadSettingsFile("handlers.patch", lines -> { From 0185cd64b10ed30af47d09e17d5e6062b09226f5 Mon Sep 17 00:00:00 2001 From: slprime <31038811+slprime@users.noreply.github.com> Date: Thu, 12 Nov 2026 01:35:53 +0200 Subject: [PATCH 3/5] Optimize GUI overlap scan for item panels (#1118) --- .../codechicken/nei/AbstractSubpanel.java | 9 +- .../codechicken/nei/GridOverlapScanner.java | 188 ++++++++++++++++++ src/main/java/codechicken/nei/ItemsGrid.java | 62 +++--- .../java/codechicken/nei/LayoutManager.java | 3 + .../java/codechicken/nei/NEIClientConfig.java | 8 - .../java/codechicken/nei/PanelWidget.java | 51 +++-- src/main/resources/assets/nei/lang/en_US.lang | 3 - src/main/resources/assets/nei/lang/ru_RU.lang | 3 - src/main/resources/assets/nei/lang/uk_UA.lang | 3 - .../java/codechicken/nei/ItemsGridTest.java | 43 +++- 10 files changed, 288 insertions(+), 85 deletions(-) create mode 100644 src/main/java/codechicken/nei/GridOverlapScanner.java diff --git a/src/main/java/codechicken/nei/AbstractSubpanel.java b/src/main/java/codechicken/nei/AbstractSubpanel.java index abc90957..d51b3c4c 100644 --- a/src/main/java/codechicken/nei/AbstractSubpanel.java +++ b/src/main/java/codechicken/nei/AbstractSubpanel.java @@ -8,6 +8,7 @@ import org.lwjgl.opengl.GL11; import codechicken.lib.vec.Rectangle4i; import codechicken.nei.ItemsGrid.ItemsGridSlot; import codechicken.nei.api.GuiInfo; +import codechicken.nei.api.INEIGuiHandler; import codechicken.nei.api.ShortcutInputHandler; import codechicken.nei.drawable.DrawableBuilder; import codechicken.nei.drawable.DrawableResource; @@ -55,12 +56,14 @@ public abstract class AbstractSubpanel lastGui = new WeakReference<>(null); + + private boolean invalidated = true; + + private final Rectangle4i rect = new Rectangle4i(); + private boolean[] checked = new boolean[0]; + private int[] queue = new int[0]; + private int tail; + + private Predicate isHidden; + private boolean[] hidden; + private int hiddenCount; + private int left; + private int top; + private int slotSize; + private int columns; + + public static void requestScan() { + scanRequested = true; + } + + public static void beginFrame(GuiContainer gui, boolean shouldShowTooltip) { + + if (wasShowTooltip != shouldShowTooltip) { + scanRequested = true; + } + + wasShowTooltip = shouldShowTooltip; + + if (lastGui.get() != gui) { + lastGui = new WeakReference<>(gui); + scanRequested = true; + } + + scanFrame = scanRequested; + scanRequested = false; + } + + public static boolean isScanFrame() { + return scanFrame; + } + + public void invalidate() { + this.invalidated = true; + } + + public boolean shouldRefresh() { + final boolean refresh = this.invalidated || scanFrame; + this.invalidated = false; + return refresh; + } + + public int scan(Predicate isHidden, int left, int top, int slotSize, int rows, int columns, + boolean seedLeft, boolean seedRight, boolean[] hidden) { + final int size = rows * columns; + + if (this.checked.length < size) { + this.checked = new boolean[size]; + this.queue = new int[size]; + } else { + Arrays.fill(this.checked, 0, size, false); + } + + this.isHidden = isHidden; + this.hidden = hidden; + this.hiddenCount = 0; + this.tail = 0; + this.left = left; + this.top = top; + this.slotSize = slotSize; + this.columns = columns; + + for (int r = 0; r < rows; r++) { + if (seedLeft) { + probe(r, 0); + } + if (seedRight) { + probe(r, columns - 1); + } + } + + for (int head = 0; head < this.tail; head++) { + final int row = this.queue[head] / columns; + final int column = this.queue[head] % columns; + + for (int r = Math.max(0, row - 1); r <= Math.min(rows - 1, row + 1); r++) { + for (int c = Math.max(0, column - 1); c <= Math.min(columns - 1, column + 1); c++) { + probe(r, c); + } + } + } + + for (int r = 0; r < rows; r++) { + for (int c = 0; c < columns; c++) { + if (this.checked[r * columns + c]) { + continue; + } + + int c1 = c; + while (c1 + 1 < columns && !this.checked[r * columns + c1 + 1]) { + c1++; + } + + int r1 = r; + while (r1 + 1 < rows && isUnchecked(r1 + 1, c, c1)) { + r1++; + } + + scanArea(r, r1, c, c1); + c = c1; + } + } + + this.isHidden = null; + this.hidden = null; + + return this.hiddenCount; + } + + private void probe(int row, int column) { + final int idx = row * this.columns + column; + + if (!this.checked[idx]) { + this.checked[idx] = true; + + if (test(row, row, column, column)) { + this.hidden[idx] = true; + this.queue[this.tail++] = idx; + this.hiddenCount++; + } + } + } + + private void scanArea(int r0, int r1, int c0, int c1) { + + if (!test(r0, r1, c0, c1)) { + for (int r = r0; r <= r1; r++) { + Arrays.fill(this.checked, r * this.columns + c0, r * this.columns + c1 + 1, true); + } + } else if (r0 == r1 && c0 == c1) { + this.checked[r0 * this.columns + c0] = true; + this.hidden[r0 * this.columns + c0] = true; + this.hiddenCount++; + } else if (r1 - r0 >= c1 - c0) { + final int mid = (r0 + r1) / 2; + scanArea(r0, mid, c0, c1); + scanArea(mid + 1, r1, c0, c1); + } else { + final int mid = (c0 + c1) / 2; + scanArea(r0, r1, c0, mid); + scanArea(r0, r1, mid + 1, c1); + } + } + + private boolean isUnchecked(int row, int c0, int c1) { + for (int c = c0; c <= c1; c++) { + if (this.checked[row * this.columns + c]) { + return false; + } + } + return true; + } + + private boolean test(int r0, int r1, int c0, int c1) { + this.rect.set( + this.left + c0 * this.slotSize, + this.top + r0 * this.slotSize, + (c1 - c0 + 1) * this.slotSize, + (r1 - r0 + 1) * this.slotSize); + return this.isHidden.test(this.rect); + } + +} diff --git a/src/main/java/codechicken/nei/ItemsGrid.java b/src/main/java/codechicken/nei/ItemsGrid.java index e8595585..481b32e0 100644 --- a/src/main/java/codechicken/nei/ItemsGrid.java +++ b/src/main/java/codechicken/nei/ItemsGrid.java @@ -282,6 +282,8 @@ public abstract class ItemsGrid getItems() { @@ -359,12 +361,13 @@ public abstract class ItemsGrid 0) { final INEIGuiHandler[] handlers = GuiInfo.getGuiHandlersSnapshot(); - if (NEIClientConfig.optimizeGuiOverlapComputation()) { - checkGuiOverlap(gui, handlers, 0, columns - 2, 1); - checkGuiOverlap(gui, handlers, columns - 1, 1, -1); - } else { - checkGuiOverlap(gui, handlers, 0, columns, 1); - } + final Rectangle4i origin = getSlotRect(0, 0); + + this.perPage -= this.overlapScanner.scan( + rect -> GuiInfo.hideItemPanelSlot(gui, rect, handlers), + origin.x, + origin.y, + SLOT_SIZE, + this.rows, + this.columns, + origin.x + this.columns * SLOT_SIZE > gui.guiLeft, + origin.x < gui.guiLeft + gui.xSize, + slotMap); } - if (oldRows != rows || oldColumns != columns || !Arrays.equals(oldSlotMap, invalidSlotMap)) { + this.invalidSlotMap = slotMap; + + if (!Arrays.equals(oldSlotMap, slotMap)) { onGridChanged(); } } - private void checkGuiOverlap(GuiContainer gui, INEIGuiHandler[] handlers, int start, int end, int dir) { - boolean validColumn = false; - - for (int c = start; c != end && (!NEIClientConfig.optimizeGuiOverlapComputation() || !validColumn); c += dir) { - validColumn = true; - - for (int r = 0; r < rows; r++) { - final int idx = columns * r + c; - if (idx >= 0 && idx < invalidSlotMap.length - && !invalidSlotMap[idx] - && GuiInfo.hideItemPanelSlot(gui, getSlotRect(r, c), handlers)) { - invalidSlotMap[idx] = true; - validColumn = false; - perPage--; - } - } - } - } - public T getSlotMouseOver(int mousex, int mousey) { if (!contains(mousex, mousey)) { return null; diff --git a/src/main/java/codechicken/nei/LayoutManager.java b/src/main/java/codechicken/nei/LayoutManager.java index 0b5c0dea..7caabfa6 100644 --- a/src/main/java/codechicken/nei/LayoutManager.java +++ b/src/main/java/codechicken/nei/LayoutManager.java @@ -388,6 +388,8 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH } public static void layout(GuiContainer gui) { + GridOverlapScanner.beginFrame(gui, GuiContainerManager.shouldShowTooltip(gui)); + VisiblityData visiblity = new VisiblityData(); visiblity.showNEI = !isHidden(); visiblity.showBookmarkPanel = !isBookmarkPanelHidden(); @@ -821,6 +823,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH if (!isEnabled()) return; + GridOverlapScanner.requestScan(); AutoFocusWidget.instance.guiTick(); for (Widget widget : drawWidgets) widget.update(); diff --git a/src/main/java/codechicken/nei/NEIClientConfig.java b/src/main/java/codechicken/nei/NEIClientConfig.java index 1a532500..1af5bbc3 100644 --- a/src/main/java/codechicken/nei/NEIClientConfig.java +++ b/src/main/java/codechicken/nei/NEIClientConfig.java @@ -498,10 +498,6 @@ public class NEIClientConfig { tag.getTag("inventory.showItemQuantityWidget").setComment("Show Item Quantity Widget").getBooleanValue(true); API.addOption(new OptionToggleButton("inventory.showItemQuantityWidget", true)); - tag.getTag("inventory.optimize_gui_overlap_computation").setComment("Optimize computation for GUI overlap") - .getBooleanValue(false); - API.addOption(new OptionToggleButton("inventory.optimize_gui_overlap_computation", true)); - tag.getTag("inventory.autocrafting").setComment("Autocrafting").getBooleanValue(true); API.addOption(new OptionToggleButton("inventory.autocrafting", true)); @@ -1160,10 +1156,6 @@ public class NEIClientConfig { return getBooleanSetting("inventory.bookmarks.craftingTreeZoomWithoutModifier"); } - public static boolean optimizeGuiOverlapComputation() { - return getBooleanSetting("inventory.optimize_gui_overlap_computation"); - } - public static boolean showCycledIngredientsTooltip() { return getBooleanSetting("inventory.guirecipe.cycledIngredientsTooltip"); } diff --git a/src/main/java/codechicken/nei/PanelWidget.java b/src/main/java/codechicken/nei/PanelWidget.java index 11d5041f..8fca99bf 100644 --- a/src/main/java/codechicken/nei/PanelWidget.java +++ b/src/main/java/codechicken/nei/PanelWidget.java @@ -29,6 +29,9 @@ public abstract class PanelWidget getItems() { return this.grid.getItems(); } @@ -105,26 +108,15 @@ public abstract class PanelWidget= w) { + if (paddingLeft + paddingRight >= this.w) { return 0; } @@ -132,16 +124,35 @@ public abstract class PanelWidget { private int overlapRefreshes; - @Override - protected int getGridRenderingCacheMode() { - return 1; - } - @Override protected void updateGuiOverlapSlots(GuiContainer gui) { overlapRefreshes++; From 1a27b02412c6eb2950e03d62db36e80aa2cf7e81 Mon Sep 17 00:00:00 2001 From: DarkShadow44 Date: Fri, 13 Nov 2026 00:53:07 +0100 Subject: [PATCH 4/5] Don't copy stack unless it changed (#1116) Co-authored-by: slprime <31038811+slprime@users.noreply.github.com> --- src/main/java/codechicken/nei/ItemZoom.java | 7 ++++- .../codechicken/nei/util/FavoriteStorage.java | 27 ++++++++++++++++++- 2 files changed, 32 insertions(+), 2 deletions(-) diff --git a/src/main/java/codechicken/nei/ItemZoom.java b/src/main/java/codechicken/nei/ItemZoom.java index ac866dcb..d3786363 100644 --- a/src/main/java/codechicken/nei/ItemZoom.java +++ b/src/main/java/codechicken/nei/ItemZoom.java @@ -127,7 +127,12 @@ public class ItemZoom extends Widget implements IContainerInputHandler { this.displayName = "Unnamed"; } - this.stack = StackInfo.loadFromNBT(StackInfo.itemStackToNBT(stack), 0); + // Copying the stack copies its whole NBT, so it is only done when the hovered stack changes + final boolean sameStack = this.stack != null && this.stack.isItemEqual(stack) + && ItemStack.areItemStackTagsEqual(this.stack, stack); + if (!sameStack) { + this.stack = StackInfo.loadFromNBT(StackInfo.itemStackToNBT(stack), 0); + } } else { this.stack = null; this.displayName = ""; diff --git a/src/main/java/codechicken/nei/util/FavoriteStorage.java b/src/main/java/codechicken/nei/util/FavoriteStorage.java index 44454088..6ea7e4a6 100644 --- a/src/main/java/codechicken/nei/util/FavoriteStorage.java +++ b/src/main/java/codechicken/nei/util/FavoriteStorage.java @@ -26,6 +26,9 @@ public class FavoriteStorage { protected final Map recipeIdToItemHash = new HashMap<>(); protected final Map itemHashToItemStack = new HashMap<>(); + /** The key of the last looked up stack. Its NBT copies the whole stack, which is looked up every frame. */ + private static volatile LookupKey lastLookupKey = null; + public void clear() { this.itemStackToRecipeId.clear(); this.fluidToRecipeId.clear(); @@ -95,7 +98,7 @@ public class FavoriteStorage { RecipeId recipeId = this.itemHashToRecipeId.get(getItemKey(stack)); if (recipeId == null) { - recipeId = this.itemStackToRecipeId.get(StackInfo.itemStackToNBT(stack, false)); + recipeId = this.itemStackToRecipeId.get(getLookupKey(stack)); } if (recipeId == null) { @@ -105,6 +108,28 @@ public class FavoriteStorage { return recipeId; } + private static NBTTagCompound getLookupKey(ItemStack stack) { + LookupKey key = lastLookupKey; + + if (key == null || !key.stack.isItemEqual(stack) || !ItemStack.areItemStackTagsEqual(key.stack, stack)) { + key = new LookupKey(stack.copy(), StackInfo.itemStackToNBT(stack, false)); + lastLookupKey = key; + } + + return key.nbt; + } + + private static class LookupKey { + + private final ItemStack stack; + private final NBTTagCompound nbt; + + private LookupKey(ItemStack stack, NBTTagCompound nbt) { + this.stack = stack; + this.nbt = nbt; + } + } + public ItemStack getItemStack(RecipeId recipeId) { NBTTagCompound itemStackNBT = this.recipeIdToItemStack.get(recipeId); From 8e6b31de18957c532a87764f901043167e7332e3 Mon Sep 17 00:00:00 2001 From: slprime <31038811+slprime@users.noreply.github.com> Date: Fri, 13 Nov 2026 23:25:20 +0200 Subject: [PATCH 5/5] Speed up GUID cache and bookmark recipe lookups (#1119) --- src/main/java/codechicken/nei/ItemZoom.java | 2 +- .../nei/bookmark/BookmarkGridGenerator.java | 6 ++--- .../nei/bookmark/RecipeChainDetails.java | 6 +++++ .../nei/bookmark/SortableItem.java | 4 ++-- .../codechicken/nei/recipe/StackInfo.java | 24 ++++++++++--------- .../GTFluidStackStringifyHandler.java | 19 ++++++++++----- .../nei/util/ItemUntranslator.java | 12 +++++++--- 7 files changed, 46 insertions(+), 27 deletions(-) diff --git a/src/main/java/codechicken/nei/ItemZoom.java b/src/main/java/codechicken/nei/ItemZoom.java index d3786363..91b57c3b 100644 --- a/src/main/java/codechicken/nei/ItemZoom.java +++ b/src/main/java/codechicken/nei/ItemZoom.java @@ -131,7 +131,7 @@ public class ItemZoom extends Widget implements IContainerInputHandler { final boolean sameStack = this.stack != null && this.stack.isItemEqual(stack) && ItemStack.areItemStackTagsEqual(this.stack, stack); if (!sameStack) { - this.stack = StackInfo.loadFromNBT(StackInfo.itemStackToNBT(stack), 0); + this.stack = StackInfo.withAmount(stack, 0); } } else { this.stack = null; diff --git a/src/main/java/codechicken/nei/bookmark/BookmarkGridGenerator.java b/src/main/java/codechicken/nei/bookmark/BookmarkGridGenerator.java index c5a6aa55..20258fc8 100644 --- a/src/main/java/codechicken/nei/bookmark/BookmarkGridGenerator.java +++ b/src/main/java/codechicken/nei/bookmark/BookmarkGridGenerator.java @@ -7,7 +7,6 @@ import java.util.HashMap; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; -import java.util.stream.Collectors; import codechicken.nei.BookmarkPanel.BookmarkViewMode; import codechicken.nei.ItemSorter; @@ -132,7 +131,7 @@ public class BookmarkGridGenerator { itemIndex++; } - } else if (group.crafting != null && group.crafting.itemToRecipe.values().contains(bookmarkItem.recipeId)) { + } else if (group.crafting != null && group.crafting.recipeToItems.containsKey(bookmarkItem.recipeId)) { absoluteSlotIndex = generateCollapsedRecipe(prevBookmarkItem, itemIndex, absoluteSlotIndex, borderGrid); prevBookmarkItem = bookmarkItem; @@ -218,8 +217,7 @@ public class BookmarkGridGenerator { } private List getShadows(BookmarkGroup group, RecipeId recipeId) { - return group.crafting.itemToRecipe.entrySet().stream().filter(entry -> recipeId.equals(entry.getValue())) - .map(entry -> entry.getKey()).collect(Collectors.toList()); + return new ArrayList<>(group.crafting.recipeToItems.getOrDefault(recipeId, Collections.emptyList())); } private int nextSlotIndex(int index, BookmarkItem previousMeta, BookmarkItem meta, BookmarkViewMode viewMode) { diff --git a/src/main/java/codechicken/nei/bookmark/RecipeChainDetails.java b/src/main/java/codechicken/nei/bookmark/RecipeChainDetails.java index 9afc8eea..457e8b41 100644 --- a/src/main/java/codechicken/nei/bookmark/RecipeChainDetails.java +++ b/src/main/java/codechicken/nei/bookmark/RecipeChainDetails.java @@ -111,6 +111,7 @@ public class RecipeChainDetails { public final Map calculatedItems = new HashMap<>(); public final Map itemToRecipe = new HashMap<>(); + public final Map> recipeToItems = new HashMap<>(); public final Set outputRecipes = new HashSet<>(); public final Set recipeInMiddle = new HashSet<>(); @@ -124,6 +125,7 @@ public class RecipeChainDetails { } this.itemToRecipe.clear(); + this.recipeToItems.clear(); this.outputRecipes.clear(); this.recipeInMiddle.clear(); this.calculatedItems.clear(); @@ -180,6 +182,10 @@ public class RecipeChainDetails { } + for (Map.Entry entry : this.itemToRecipe.entrySet()) { + this.recipeToItems.computeIfAbsent(entry.getValue(), recipeId -> new ArrayList<>()).add(entry.getKey()); + } + for (Map.Entry entry : chainItems.entrySet()) { final int itemIndex = entry.getKey(); if (itemIndex >= 0 && this.calculatedItems.containsKey(itemIndex)) { diff --git a/src/main/java/codechicken/nei/bookmark/SortableItem.java b/src/main/java/codechicken/nei/bookmark/SortableItem.java index e39ccca0..d81c35f5 100644 --- a/src/main/java/codechicken/nei/bookmark/SortableItem.java +++ b/src/main/java/codechicken/nei/bookmark/SortableItem.java @@ -37,8 +37,8 @@ public class SortableItem { && (group.viewMode == BookmarkViewMode.TODO_LIST || group.crafting != null); this.crossGroup = !group.collapsed && group.viewMode == BookmarkViewMode.TODO_LIST && bookmarkItem.type != BookmarkItemType.INGREDIENT; - this.isCollapsedRecipe = group.crafting != null && group.crafting.itemToRecipe.values().stream() - .anyMatch(recipeId -> this.bookmarkItem.equalsRecipe(recipeId, this.bookmarkItem.groupId)); + this.isCollapsedRecipe = group.crafting != null && this.bookmarkItem.recipeId != null + && group.crafting.recipeToItems.containsKey(this.bookmarkItem.recipeId); this.update(); } diff --git a/src/main/java/codechicken/nei/recipe/StackInfo.java b/src/main/java/codechicken/nei/recipe/StackInfo.java index 1d54850d..0e889bb5 100644 --- a/src/main/java/codechicken/nei/recipe/StackInfo.java +++ b/src/main/java/codechicken/nei/recipe/StackInfo.java @@ -4,6 +4,7 @@ import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; import net.minecraft.item.Item; import net.minecraft.item.ItemStack; @@ -16,7 +17,7 @@ import net.minecraftforge.fluids.FluidStack; import net.minecraftforge.fluids.IFluidContainerItem; import codechicken.nei.ClientHandler; -import codechicken.nei.ItemStackMap; +import codechicken.nei.ItemStackMap.StackMetaKey; import codechicken.nei.LRUCache; import codechicken.nei.api.IStackStringifyHandler; import codechicken.nei.api.ItemInfo; @@ -31,7 +32,7 @@ public class StackInfo { private static final FluidStack NULL_FLUID = new FluidStack(FluidRegistry.WATER, 0); public static final List stackStringifyHandlers = new ArrayList<>(); private static final Map> guidfilters = new HashMap<>(); - private static final ItemStackMap guidcache = new ItemStackMap<>(); + private static final Map> guidcache = new ConcurrentHashMap<>(); private static final LRUCache fluidcache = new LRUCache<>(200); private static boolean isPausedItemDamageSound = false; @@ -182,7 +183,9 @@ public class StackInfo { } public static String getItemStackGUID(ItemStack stack) { - String guid = guidcache.get(stack); + final Item stackItem = stack.getItem(); + final Map itemGuids = stackItem != null ? guidcache.get(stackItem) : null; + String guid = itemGuids != null ? itemGuids.get(new StackMetaKey(stack)) : null; if (guid != null) { return guid; @@ -190,7 +193,7 @@ public class StackInfo { final NBTTagCompound nbTag = itemStackToNBT(stack, false); - if (nbTag == null) { + if (nbTag == null || stack.getItem() == null) { return "unknown"; } @@ -239,16 +242,15 @@ public class StackInfo { } }); - synchronized (guidcache) { - guidcache.put(stack, keys.toString()); - } + guid = keys.toString(); } else { - synchronized (guidcache) { - guidcache.put(stack, NBTHelper.toString(nbTag)); - } + guid = NBTHelper.toString(nbTag); } - return guidcache.get(stack); + guidcache.computeIfAbsent(stack.getItem(), item -> new ConcurrentHashMap<>()) + .put(new StackMetaKey(stack.copy()), guid); + + return guid; } public static void loadGuidFilters() { diff --git a/src/main/java/codechicken/nei/recipe/stackinfo/GTFluidStackStringifyHandler.java b/src/main/java/codechicken/nei/recipe/stackinfo/GTFluidStackStringifyHandler.java index ab0bf37a..4644104e 100644 --- a/src/main/java/codechicken/nei/recipe/stackinfo/GTFluidStackStringifyHandler.java +++ b/src/main/java/codechicken/nei/recipe/stackinfo/GTFluidStackStringifyHandler.java @@ -10,6 +10,9 @@ import net.minecraftforge.fluids.Fluid; import net.minecraftforge.fluids.FluidRegistry; import net.minecraftforge.fluids.FluidStack; +import com.google.common.base.Supplier; +import com.google.common.base.Suppliers; + import codechicken.nei.api.IStackStringifyHandler; import codechicken.nei.item.ItemFluidDisplay; import cpw.mods.fml.common.registry.GameRegistry; @@ -22,6 +25,11 @@ public class GTFluidStackStringifyHandler implements IStackStringifyHandler { protected static Class gtMetaGeneratedTool = null; protected static Field playSound = null; + private static final Supplier AE2FC_FLUID_PACKET = Suppliers + .memoize(() -> GameRegistry.findItem("ae2fc", "fluid_packet")); + private static final Supplier AE2FC_FLUID_DROP = Suppliers + .memoize(() -> GameRegistry.findItem("ae2fc", "fluid_drop")); + static { try { final ClassLoader loader = GTFluidStackStringifyHandler.class.getClassLoader(); @@ -94,11 +102,11 @@ public class GTFluidStackStringifyHandler implements IStackStringifyHandler { return new FluidStack(fluid, 0); } - } else if (item == GameRegistry.findItem("ae2fc", "fluid_packet")) { + } else if (item == AE2FC_FLUID_PACKET.get()) { NBTTagCompound nbtTag = stack.getTagCompound(); return FluidStack.loadFluidStackFromNBT((NBTTagCompound) nbtTag.getTag("FluidStack")); - } else if (item == GameRegistry.findItem("ae2fc", "fluid_drop")) { + } else if (item == AE2FC_FLUID_DROP.get()) { NBTTagCompound nbtTag = stack.getTagCompound(); Fluid fluid = FluidRegistry.getFluid(nbtTag.getString("Fluid").toLowerCase()); @@ -113,9 +121,9 @@ public class GTFluidStackStringifyHandler implements IStackStringifyHandler { @Override public ItemStack normalizeRecipeQueryStack(ItemStack stack) { + final Item item = stack.getItem(); - if (stack.getItem() == GameRegistry.findItem("ae2fc", "fluid_drop") - || stack.getItem() == GameRegistry.findItem("ae2fc", "fluid_packet")) { + if (item == AE2FC_FLUID_DROP.get() || item == AE2FC_FLUID_PACKET.get()) { final FluidStack fluidStack = getFluid(stack); if (fluidStack != null) { @@ -139,8 +147,7 @@ public class GTFluidStackStringifyHandler implements IStackStringifyHandler { @Override public boolean isFluidDisplayItem(ItemStack stack) { final Item item = stack.getItem(); - return (itemFluidDisplay != null && itemFluidDisplay.isInstance(item)) - || item == GameRegistry.findItem("ae2fc", "fluid_packet"); + return (itemFluidDisplay != null && itemFluidDisplay.isInstance(item)) || item == AE2FC_FLUID_PACKET.get(); } } diff --git a/src/main/java/codechicken/nei/util/ItemUntranslator.java b/src/main/java/codechicken/nei/util/ItemUntranslator.java index b4a48d23..be88ccd0 100644 --- a/src/main/java/codechicken/nei/util/ItemUntranslator.java +++ b/src/main/java/codechicken/nei/util/ItemUntranslator.java @@ -10,6 +10,7 @@ import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Properties; +import java.util.concurrent.ConcurrentHashMap; import java.util.stream.Stream; import net.minecraft.creativetab.CreativeTabs; @@ -128,8 +129,8 @@ public class ItemUntranslator { private static final String CONFIG_FILE = "untranslator.cfg"; private static final ItemUntranslator instance = new ItemUntranslator(); - private final Map secondNames = new HashMap<>(); - private final Map processedNames = new HashMap<>(); + private final Map secondNames = new ConcurrentHashMap<>(); + private final Map processedNames = new ConcurrentHashMap<>(); private ItemUntranslator() {} @@ -241,14 +242,19 @@ public class ItemUntranslator { return EnumChatFormatting.getTextWithoutFormattingCodes(name).trim(); } - public synchronized String getItemStackDisplayName(ItemStack stack) { + public String getItemStackDisplayName(ItemStack stack) { if (stack == null || this.secondNames.isEmpty()) { return ""; } final String guidKey = StackInfo.getItemStackGUID(stack); + final String displayName = this.processedNames.get(guidKey); + return displayName != null ? displayName : processDisplayName(stack, guidKey); + } + + private synchronized String processDisplayName(ItemStack stack, String guidKey) { return this.processedNames.computeIfAbsent(guidKey, stackKey -> { String displayName = this.secondNames.get(stackKey);