Implement IIngredientFilter, IRecipeManagerPlugin and IGuiIngredientGroup#set, fix IDrawableBuilder with padding

Signed-off-by: shedaniel <daniel@shedaniel.me>

2 files changed, 89 insertions, 46 deletions

diff --git a/runtime/src/main/java/me/shedaniel/rei/impl/registry/DisplayRegistryImpl.java b/runtime/src/main/java/me/shedaniel/rei/impl/registry/DisplayRegistryImpl.java
index 421eeb527..5246d38f2 100644
--- a/runtime/src/main/java/me/shedaniel/rei/impl/registry/DisplayRegistryImpl.java
+++ b/runtime/src/main/java/me/shedaniel/rei/impl/registry/DisplayRegistryImpl.java
@@ -32,10 +32,10 @@ import me.shedaniel.rei.api.registry.display.Display;
 import me.shedaniel.rei.api.registry.display.DisplayCategory;
 import me.shedaniel.rei.api.registry.display.DisplayRegistry;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.Container;
 import net.minecraft.world.InteractionResult;
 import net.minecraft.world.item.crafting.Recipe;
 import org.apache.commons.lang3.mutable.MutableInt;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
@@ -45,8 +45,9 @@ import java.util.function.Predicate;
 public class DisplayRegistryImpl extends RecipeManagerContextImpl implements DisplayRegistry {
     private final Map<ResourceLocation, List<Display>> displays = new ConcurrentHashMap<>();
     private final Map<ResourceLocation, List<LiveDisplayGenerator<?>>> displayGenerators = new ConcurrentHashMap<>();
+    private final List<LiveDisplayGenerator<?>> globalDisplayGenerators = new ArrayList<>();
     private final List<DisplayVisibilityPredicate> visibilityPredicates = new ArrayList<>();
-    private final List<RecipeFiller<?, ?, ?>> fillers = new ArrayList<>();
+    private final List<DisplayFiller<?, ?>> fillers = new ArrayList<>();
     private final MutableInt displayCount = new MutableInt(0);
     
     @Override
@@ -78,17 +79,27 @@ public class DisplayRegistryImpl extends RecipeManagerContextImpl implements Dis
     }
     
     @Override
+    public <A extends Display> void registerGlobalDisplayGenerator(LiveDisplayGenerator<A> generator) {
+        globalDisplayGenerators.add(generator);
+    }
+    
+    @Override
     public <A extends Display> void registerDisplayGenerator(ResourceLocation categoryId, LiveDisplayGenerator<A> generator) {
         displayGenerators.computeIfAbsent(categoryId, location -> new ArrayList<>())
                 .add(generator);
     }
     
     @Override
-    public Map<ResourceLocation, List<LiveDisplayGenerator<?>>> getAllDisplayGenerators() {
+    public Map<ResourceLocation, List<LiveDisplayGenerator<?>>> getCategoryDisplayGenerators() {
         return Collections.unmodifiableMap(displayGenerators);
     }
     
     @Override
+    public List<LiveDisplayGenerator<?>> getGlobalDisplayGenerators() {
+        return Collections.unmodifiableList(globalDisplayGenerators);
+    }
+    
+    @Override
     public void registerVisibilityPredicate(DisplayVisibilityPredicate predicate) {
         visibilityPredicates.add(predicate);
         visibilityPredicates.sort(Comparator.reverseOrder());
@@ -117,8 +128,8 @@ public class DisplayRegistryImpl extends RecipeManagerContextImpl implements Dis
     }
     
     @Override
-    public <A extends Container, T extends Recipe<A>, D extends Display> void registerRecipes(Predicate<? extends T> recipeFilter, Function<T, D> mappingFunction) {
-        fillers.add(new RecipeFiller<>((Predicate<T>) recipeFilter, mappingFunction));
+    public <T, D extends Display> void registerFiller(Class<T> typeClass, Predicate<? extends T> predicate, Function<T, D> mappingFunction) {
+        fillers.add(new DisplayFiller<>(typeClass, (Predicate<T>) predicate, mappingFunction));
     }
     
     @Override
@@ -137,33 +148,47 @@ public class DisplayRegistryImpl extends RecipeManagerContextImpl implements Dis
             List<Recipe<?>> allSortedRecipes = getAllSortedRecipes();
             for (int i = allSortedRecipes.size() - 1; i >= 0; i--) {
                 Recipe<?> recipe = allSortedRecipes.get(i);
-                for (RecipeFiller<?, ?, ?> filler : fillers) {
-                    try {
-                        handleRecipe(filler, recipe);
-                    } catch (Throwable e) {
-                        RoughlyEnoughItemsCore.LOGGER.error("Failed to fill recipes!", e);
-                    }
+                Display display = tryFillDisplay(recipe);
+                if (display != null) {
+                    registerDisplay(0, display);
                 }
             }
         }
-        this.fillers.clear();
     }
     
-    private <A extends Container, T extends Recipe<A>, D extends Display> void handleRecipe(RecipeFiller<A, T, D> filler, Recipe<?> recipe) {
-        if (filler.recipeFilter.test((T) recipe)) {
-            registerDisplay(0, filler.mappingFunction.apply((T) recipe));
+    @Override
+    @Nullable
+    public <T> Display tryFillDisplay(T value) {
+        if (value instanceof Display) return (Display) value;
+        for (DisplayFiller<?, ?> filler : fillers) {
+            Display display = tryFillDisplayGenerics(filler, value);
+            if (display != null) return display;
         }
+        return null;
     }
     
-    private static class RecipeFiller<A extends Container, T extends Recipe<A>, D extends Display> {
-        private final Predicate<T> recipeFilter;
+    private <T, D extends Display> D tryFillDisplayGenerics(DisplayFiller<T, D> filler, Object value) {
+        try {
+            if (filler.typeClass.isInstance(value) && filler.predicate.test((T) value)) {
+                return filler.mappingFunction.apply((T) value);
+            }
+        } catch (Throwable e) {
+            RoughlyEnoughItemsCore.LOGGER.error("Failed to fill displays!", e);
+        }
+        
+        return null;
+    }
+    
+    private static class DisplayFiller<T, D extends Display> {
+        private final Class<T> typeClass;
+        private final Predicate<T> predicate;
         
         private final Function<T, D> mappingFunction;
         
-        public RecipeFiller(Predicate<T> recipeFilter, Function<T, D> mappingFunction) {
-            this.recipeFilter = recipeFilter;
+        public DisplayFiller(Class<T> typeClass, Predicate<T> predicate, Function<T, D> mappingFunction) {
+            this.typeClass = typeClass;
+            this.predicate = predicate;
             this.mappingFunction = mappingFunction;
         }
-        
     }
 }
diff --git a/runtime/src/main/java/me/shedaniel/rei/impl/view/ViewsImpl.java b/runtime/src/main/java/me/shedaniel/rei/impl/view/ViewsImpl.java
index ad573abb9..55319da56 100644
--- a/runtime/src/main/java/me/shedaniel/rei/impl/view/ViewsImpl.java
+++ b/runtime/src/main/java/me/shedaniel/rei/impl/view/ViewsImpl.java
@@ -44,6 +44,7 @@ import net.minecraft.resources.ResourceLocation;
 import org.jetbrains.annotations.ApiStatus;
 
 import java.util.*;
+import java.util.function.Consumer;
 import java.util.stream.Collectors;
 
 @ApiStatus.Internal
@@ -115,37 +116,13 @@ public class ViewsImpl implements Views {
         
         int generatorsCount = 0;
         
-        for (Map.Entry<ResourceLocation, List<LiveDisplayGenerator<?>>> entry : DisplayRegistry.getInstance().getAllDisplayGenerators().entrySet()) {
+        for (Map.Entry<ResourceLocation, List<LiveDisplayGenerator<?>>> entry : DisplayRegistry.getInstance().getCategoryDisplayGenerators().entrySet()) {
             ResourceLocation categoryId = entry.getKey();
             Set<Display> set = new LinkedHashSet<>();
             generatorsCount += entry.getValue().size();
             
             for (LiveDisplayGenerator<Display> generator : (List<LiveDisplayGenerator<Display>>) (List) entry.getValue()) {
-                for (EntryStack<?> stack : recipesFor) {
-                    Optional<List<Display>> recipeForDisplays = generator.getRecipeFor(stack);
-                    if (recipeForDisplays.isPresent()) {
-                        for (Display display : recipeForDisplays.get()) {
-                            if (isDisplayVisible(display))
-                                set.add(display);
-                        }
-                    }
-                }
-                for (EntryStack<?> stack : usagesFor) {
-                    Optional<List<Display>> usageForDisplays = generator.getUsageFor(stack);
-                    if (usageForDisplays.isPresent()) {
-                        for (Display display : usageForDisplays.get()) {
-                            if (isDisplayVisible(display))
-                                set.add(display);
-                        }
-                    }
-                }
-                Optional<List<Display>> displaysGenerated = generator.generate(builder);
-                if (displaysGenerated.isPresent()) {
-                    for (Display display : displaysGenerated.get()) {
-                        if (isDisplayVisible(display))
-                            set.add(display);
-                    }
-                }
+                generateLiveDisplays(generator, builder, set::add);
             }
             
             if (!set.isEmpty()) {
@@ -153,6 +130,14 @@ public class ViewsImpl implements Views {
             }
         }
         
+        Consumer<Display> displayConsumer = display -> {
+            CollectionUtils.getOrPutEmptyList(result, CategoryRegistry.getInstance().get(display.getCategoryIdentifier()).getCategory()).add(display);
+        };
+        for (LiveDisplayGenerator<Display> generator : (List<LiveDisplayGenerator<Display>>) (List) DisplayRegistry.getInstance().getGlobalDisplayGenerators()) {
+            generatorsCount++;
+            generateLiveDisplays(generator, builder, displayConsumer);
+        }
+        
         String message = String.format("Built Recipe View in %s for %d categories, %d recipes for, %d usages for and %d live recipe generators.",
                 stopwatch.stop().toString(), categories.size(), recipesFor.size(), usagesFor.size(), generatorsCount);
         if (ConfigObject.getInstance().doDebugSearchTimeRequired()) {
@@ -163,6 +148,39 @@ public class ViewsImpl implements Views {
         return result;
     }
     
+    private <T extends Display> void generateLiveDisplays(LiveDisplayGenerator<T> generator, ViewSearchBuilder builder, Consumer<T> displayConsumer) {
+        for (EntryStack<?> stack : builder.getRecipesFor()) {
+            Optional<List<T>> recipeForDisplays = generator.getRecipeFor(stack);
+            if (recipeForDisplays.isPresent()) {
+                for (T display : recipeForDisplays.get()) {
+                    if (isDisplayVisible(display)) {
+                        displayConsumer.accept(display);
+                    }
+                }
+            }
+        }
+        
+        for (EntryStack<?> stack : builder.getUsagesFor()) {
+            Optional<List<T>> usageForDisplays = generator.getUsageFor(stack);
+            if (usageForDisplays.isPresent()) {
+                for (T display : usageForDisplays.get()) {
+                    if (isDisplayVisible(display)) {
+                        displayConsumer.accept(display);
+                    }
+                }
+            }
+        }
+        
+        Optional<List<T>> displaysGenerated = generator.generate(builder);
+        if (displaysGenerated.isPresent()) {
+            for (T display : displaysGenerated.get()) {
+                if (isDisplayVisible(display)) {
+                    displayConsumer.accept(display);
+                }
+            }
+        }
+    }
+    
     @Override
     public Collection<EntryStack<?>> findCraftableEntriesByItems(Iterable<? extends EntryStack<?>> inventoryItems) {
         Set<EntryStack<?>> craftables = new HashSet<>();