Added FocusedStackProvider api.

Optimised item rendering.

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

2 files changed, 96 insertions, 29 deletions

diff --git a/src/main/java/me/shedaniel/rei/impl/ItemEntryStack.java b/src/main/java/me/shedaniel/rei/impl/ItemEntryStack.java
index af2ac018d..fdd7155ec 100644
--- a/src/main/java/me/shedaniel/rei/impl/ItemEntryStack.java
+++ b/src/main/java/me/shedaniel/rei/impl/ItemEntryStack.java
@@ -25,6 +25,7 @@ package me.shedaniel.rei.impl;
 
 import com.google.common.collect.Lists;
 import com.mojang.blaze3d.platform.GlStateManager;
+import com.mojang.blaze3d.systems.RenderSystem;
 import me.shedaniel.math.Point;
 import me.shedaniel.math.Rectangle;
 import me.shedaniel.rei.api.*;
@@ -53,7 +54,6 @@ import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -293,22 +293,52 @@ public class ItemEntryStack extends AbstractEntryStack implements OptimalEntrySt
     @Override
     public void render(MatrixStack matrices, Rectangle bounds, int mouseX, int mouseY, float delta) {
         optimisedRenderStart(matrices, delta);
-        optimisedRenderBase(matrices, bounds, mouseX, mouseY, delta);
+        VertexConsumerProvider.Immediate immediate = MinecraftClient.getInstance().getBufferBuilders().getEntityVertexConsumers();
+        optimisedRenderBase(matrices, immediate, bounds, mouseX, mouseY, delta);
+        immediate.draw();
         optimisedRenderOverlay(matrices, bounds, mouseX, mouseY, delta);
         optimisedRenderEnd(matrices, delta);
     }
     
-    @SuppressWarnings("deprecation")
     @Override
     public void optimisedRenderStart(MatrixStack matrices, float delta) {
-        MinecraftClient.getInstance().getTextureManager().bindTexture(SpriteAtlasTexture.BLOCK_ATLAS_TEX);
-        GlStateManager.enableRescaleNormal();
+        optimisedRenderStart(matrices, delta, true);
     }
     
     @SuppressWarnings("deprecation")
+    public void optimisedRenderStart(MatrixStack matrices, float delta, boolean isOptimised) {
+        MinecraftClient.getInstance().getTextureManager().bindTexture(SpriteAtlasTexture.BLOCK_ATLAS_TEX);
+        MinecraftClient.getInstance().getTextureManager().getTexture(SpriteAtlasTexture.BLOCK_ATLAS_TEX).setFilter(false, false);
+        RenderSystem.pushMatrix();
+        RenderSystem.enableRescaleNormal();
+        RenderSystem.enableAlphaTest();
+        RenderSystem.defaultAlphaFunc();
+        RenderSystem.enableBlend();
+        RenderSystem.blendFunc(GlStateManager.SrcFactor.SRC_ALPHA, GlStateManager.DstFactor.ONE_MINUS_SRC_ALPHA);
+        RenderSystem.color4f(1.0F, 1.0F, 1.0F, 1.0F);
+        if (isOptimised) {
+            boolean sideLit = getModelFromStack(itemStack).isSideLit();
+            if (!sideLit)
+                DiffuseLighting.disableGuiDepthLighting();
+        }
+    }
+    
     @Override
     public void optimisedRenderEnd(MatrixStack matrices, float delta) {
-        GlStateManager.disableRescaleNormal();
+        optimisedRenderEnd(matrices, delta, true);
+    }
+    
+    @SuppressWarnings("deprecation")
+    public void optimisedRenderEnd(MatrixStack matrices, float delta, boolean isOptimised) {
+        RenderSystem.enableDepthTest();
+        RenderSystem.disableAlphaTest();
+        RenderSystem.disableRescaleNormal();
+        if (isOptimised) {
+            boolean sideLit = getModelFromStack(itemStack).isSideLit();
+            if (!sideLit)
+                DiffuseLighting.enableGuiDepthLighting();
+        }
+        RenderSystem.popMatrix();
     }
     
     private BakedModel getModelFromStack(ItemStack stack) {
@@ -316,22 +346,19 @@ public class ItemEntryStack extends AbstractEntryStack implements OptimalEntrySt
     }
     
     @Override
-    public void optimisedRenderBase(MatrixStack matrices, Rectangle bounds, int mouseX, int mouseY, float delta) {
+    public int groupingHash() {
+        return 1738923 + (getModelFromStack(itemStack).isSideLit() ? 1 : 0);
+    }
+    
+    @Override
+    public void optimisedRenderBase(MatrixStack matrices, VertexConsumerProvider.Immediate immediate, Rectangle bounds, int mouseX, int mouseY, float delta) {
         if (!isEmpty() && get(Settings.RENDER).get()) {
             ItemStack stack = getItemStack();
             ((ItemStackHook) (Object) stack).rei_setRenderEnchantmentGlint(get(Settings.Item.RENDER_ENCHANTMENT_GLINT).get());
             matrices.push();
             matrices.translate(bounds.getCenterX(), bounds.getCenterY(), 100.0F + getZ());
             matrices.scale(bounds.getWidth(), (bounds.getWidth() + bounds.getHeight()) / -2f, bounds.getHeight());
-            VertexConsumerProvider.Immediate immediate = MinecraftClient.getInstance().getBufferBuilders().getEntityVertexConsumers();
-            BakedModel model = getModelFromStack(stack);
-            boolean sideLit = !model.isSideLit();
-            if (sideLit)
-                DiffuseLighting.disableGuiDepthLighting();
-            MinecraftClient.getInstance().getItemRenderer().renderItem(stack, ModelTransformation.Mode.GUI, false, matrices, immediate, 15728880, OverlayTexture.DEFAULT_UV, model);
-            immediate.draw();
-            if (sideLit)
-                DiffuseLighting.enableGuiDepthLighting();
+            MinecraftClient.getInstance().getItemRenderer().renderItem(stack, ModelTransformation.Mode.GUI, false, matrices, immediate, 15728880, OverlayTexture.DEFAULT_UV, getModelFromStack(stack));
             matrices.pop();
             ((ItemStackHook) (Object) stack).rei_setRenderEnchantmentGlint(false);
         }
diff --git a/src/main/java/me/shedaniel/rei/impl/RecipeHelperImpl.java b/src/main/java/me/shedaniel/rei/impl/RecipeHelperImpl.java
index b9d23b679..66e9e33ef 100644
--- a/src/main/java/me/shedaniel/rei/impl/RecipeHelperImpl.java
+++ b/src/main/java/me/shedaniel/rei/impl/RecipeHelperImpl.java
@@ -36,13 +36,17 @@ import me.shedaniel.rei.impl.subsets.SubsetsRegistryImpl;
 import me.shedaniel.rei.utils.CollectionUtils;
 import net.fabricmc.api.EnvType;
 import net.fabricmc.api.Environment;
+import net.minecraft.client.gui.screen.Screen;
 import net.minecraft.client.gui.screen.ingame.ContainerScreen;
 import net.minecraft.recipe.Recipe;
 import net.minecraft.recipe.RecipeManager;
 import net.minecraft.util.ActionResult;
 import net.minecraft.util.Identifier;
+import net.minecraft.util.TypedActionResult;
 import net.minecraft.util.Util;
 import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.*;
 import java.util.function.Consumer;
@@ -54,26 +58,23 @@ import java.util.stream.Collectors;
 @Environment(EnvType.CLIENT)
 public class RecipeHelperImpl implements RecipeHelper {
     
-    private static final Comparator<DisplayVisibilityHandler> VISIBILITY_HANDLER_COMPARATOR;
+    private static final Comparator<FocusedStackProvider> FOCUSED_STACK_PROVIDER_COMPARATOR = Comparator.comparingDouble(FocusedStackProvider::getPriority).reversed();
+    private static final Comparator<DisplayVisibilityHandler> VISIBILITY_HANDLER_COMPARATOR = Comparator.comparingDouble(DisplayVisibilityHandler::getPriority).reversed();
     @SuppressWarnings("rawtypes")
     private static final Comparator<Recipe> RECIPE_COMPARATOR = Comparator.comparing((Recipe o) -> o.getId().getNamespace()).thenComparing(o -> o.getId().getPath());
     
-    static {
-        Comparator<DisplayVisibilityHandler> comparator = Comparator.comparingDouble(DisplayVisibilityHandler::getPriority);
-        VISIBILITY_HANDLER_COMPARATOR = comparator.reversed();
-    }
-    
-    private final List<AutoTransferHandler> autoTransferHandlers = Lists.newLinkedList();
-    private final List<RecipeFunction> recipeFunctions = Lists.newLinkedList();
-    private final List<ScreenClickArea> screenClickAreas = Lists.newLinkedList();
+    private final List<FocusedStackProvider> focusedStackProviders = Lists.newArrayList();
+    private final List<AutoTransferHandler> autoTransferHandlers = Lists.newArrayList();
+    private final List<RecipeFunction> recipeFunctions = Lists.newArrayList();
+    private final List<ScreenClickArea> screenClickAreas = Lists.newArrayList();
     private final int[] recipeCount = {0};
     private final Map<Identifier, List<RecipeDisplay>> recipeCategoryListMap = Maps.newLinkedHashMap();
     private final Map<RecipeCategory<?>, Identifier> categories = Maps.newLinkedHashMap();
     private final Map<Identifier, RecipeCategory<?>> reversedCategories = Maps.newHashMap();
-    private final Map<Identifier, ButtonAreaSupplier> autoCraftAreaSupplierMap = Maps.newLinkedHashMap();
-    private final Map<Identifier, List<List<EntryStack>>> categoryWorkingStations = Maps.newLinkedHashMap();
-    private final List<DisplayVisibilityHandler> displayVisibilityHandlers = Lists.newLinkedList();
-    private final List<LiveRecipeGenerator<RecipeDisplay>> liveRecipeGenerators = Lists.newLinkedList();
+    private final Map<Identifier, ButtonAreaSupplier> autoCraftAreaSupplierMap = Maps.newHashMap();
+    private final Map<Identifier, List<List<EntryStack>>> categoryWorkingStations = Maps.newHashMap();
+    private final List<DisplayVisibilityHandler> displayVisibilityHandlers = Lists.newArrayList();
+    private final List<LiveRecipeGenerator<RecipeDisplay>> liveRecipeGenerators = Lists.newArrayList();
     private RecipeManager recipeManager;
     private boolean arePluginsLoading = false;
     
@@ -362,6 +363,7 @@ public class RecipeHelperImpl implements RecipeHelper {
         this.displayVisibilityHandlers.clear();
         this.liveRecipeGenerators.clear();
         this.autoTransferHandlers.clear();
+        this.focusedStackProviders.clear();
         ((SubsetsRegistryImpl) SubsetsRegistry.INSTANCE).reset();
         ((FluidSupportProviderImpl) FluidSupportProvider.INSTANCE).reset();
         ((DisplayHelperImpl) DisplayHelper.getInstance()).resetData();
@@ -424,6 +426,23 @@ public class RecipeHelperImpl implements RecipeHelper {
                     return -1f;
                 }
             });
+        registerFocusedStackProvider(new FocusedStackProvider() {
+            @Override
+            @NotNull
+            public TypedActionResult<EntryStack> provide(Screen screen) {
+                if (screen instanceof ContainerScreen) {
+                    ContainerScreen<?> containerScreen = (ContainerScreen<?>) screen;
+                    if (containerScreen.focusedSlot != null && !containerScreen.focusedSlot.getStack().isEmpty())
+                        return TypedActionResult.success(EntryStack.create(containerScreen.focusedSlot.getStack()));
+                }
+                return TypedActionResult.pass(EntryStack.empty());
+            }
+            
+            @Override
+            public double getPriority() {
+                return -1.0;
+            }
+        });
         DisplayHelper.getInstance().registerHandler(new OverlayDecider() {
             @Override
             public boolean isHandingScreen(Class<?> screen) {
@@ -479,6 +498,27 @@ public class RecipeHelperImpl implements RecipeHelper {
     }
     
     @Override
+    public void registerFocusedStackProvider(FocusedStackProvider provider) {
+        focusedStackProviders.add(provider);
+        focusedStackProviders.sort(FOCUSED_STACK_PROVIDER_COMPARATOR);
+    }
+    
+    @Override
+    @Nullable
+    public EntryStack getScreenFocusedStack(Screen screen) {
+        for (FocusedStackProvider provider : focusedStackProviders) {
+            TypedActionResult<EntryStack> result = Objects.requireNonNull(provider.provide(screen));
+            if (result.getResult() == ActionResult.SUCCESS) {
+                if (!result.getValue().isEmpty())
+                    return result.getValue();
+                return null;
+            } else if (result.getResult() == ActionResult.FAIL)
+                return null;
+        }
+        return null;
+    }
+    
+    @Override
     public List<AutoTransferHandler> getSortedAutoCraftingHandler() {
         return autoTransferHandlers.stream().sorted(Comparator.comparingDouble(AutoTransferHandler::getPriority).reversed()).collect(Collectors.toList());
     }