Improved recipe viewer slots and general compat

src/main/java/brachy/modularui/api/widget/IGuiAction.java

@@ -49,4 +49,28 @@ interface MouseDrag extends IGuiAction {
 
         boolean drag(GuiContext context, int button, double dragX, double dragY);
     }
+
+    @FunctionalInterface
+    interface MouseEnterArea extends IGuiAction {
+
+        void enter(GuiContext context);
+    }
+
+    @FunctionalInterface
+    interface MouseLeaveArea extends IGuiAction {
+
+        void leave(GuiContext context, int timeBelowMouse);
+    }
+
+    @FunctionalInterface
+    interface MouseStartHover extends IGuiAction {
+
+        void startHover(GuiContext context);
+    }
+
+    @FunctionalInterface
+    interface MouseEndHover extends IGuiAction {
+
+        void endHover(GuiContext context, int timeHovered);
+    }
 }

src/main/java/brachy/modularui/core/ModularUIMixinPlugin.java

@@ -0,0 +1,78 @@
+package brachy.modularui.core;
+
+import net.minecraftforge.fml.ModLoader;
+import net.minecraftforge.fml.loading.FMLLoader;
+
+import org.objectweb.asm.tree.ClassNode;
+import org.spongepowered.asm.mixin.extensibility.IMixinConfigPlugin;
+import org.spongepowered.asm.mixin.extensibility.IMixinInfo;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class ModularUIMixinPlugin implements IMixinConfigPlugin {
+
+    private static final String MIXIN_PACKAGE = "brachy.modularui.core.mixins.";
+    private static final Map<String, String> MOD_COMPAT_MIXINS = new HashMap<>();
+
+    private static final String DEV_PACKAGE = "dev.";
+
+    static {
+        MOD_COMPAT_MIXINS.put("roughlyenoughitems", "rei.");
+        MOD_COMPAT_MIXINS.put("emi", "emi.");
+        MOD_COMPAT_MIXINS.put("jei", "jei.");
+    }
+
+    @Override
+    public boolean shouldApplyMixin(String targetClassName, String mixinClassName) {
+        if (!mixinClassName.startsWith(MIXIN_PACKAGE)) {
+            // skip checking mixins that aren't in our package
+            // this should never happen, but better safe than sorry
+            return true;
+        }
+        if (!FMLLoader.getLoadingModList().getErrors().isEmpty()) {
+            // stop processing mixins if we have load errors to avoid getting bad crash reports in our issues
+            return false;
+        }
+        mixinClassName = mixinClassName.substring(MIXIN_PACKAGE.length());
+
+        if (mixinClassName.startsWith(DEV_PACKAGE)) {
+            // don't load dev-only mixins in prod
+            return !FMLLoader.isProduction();
+        }
+        for (var compatMod : MOD_COMPAT_MIXINS.entrySet()) {
+            if (mixinClassName.startsWith(compatMod.getValue())) {
+                return isModLoaded(compatMod.getKey());
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public void onLoad(String mixinPackage) {}
+
+    @Override
+    public String getRefMapperConfig() {
+        return null;
+    }
+
+    @Override
+    public void acceptTargets(Set<String> myTargets, Set<String> otherTargets) {}
+
+    @Override
+    public List<String> getMixins() {
+        return null;
+    }
+
+    @Override
+    public void preApply(String targetClassName, ClassNode targetClass, String mixinClassName, IMixinInfo mixinInfo) {}
+
+    @Override
+    public void postApply(String targetClassName, ClassNode targetClass, String mixinClassName, IMixinInfo mixinInfo) {}
+
+    private static boolean isModLoaded(String modId) {
+        return FMLLoader.getLoadingModList().getModFileById(modId) != null;
+    }
+}

src/main/java/brachy/modularui/core/mixins/emi/EmiRenderHelperMixin.java

@@ -0,0 +1,25 @@
+package brachy.modularui.core.mixins.emi;
+
+import brachy.modularui.integration.emi.recipe.ModularUIEmiRecipe;
+
+import dev.emi.emi.EmiRenderHelper;
+import dev.emi.emi.api.recipe.EmiRecipe;
+import dev.emi.emi.runtime.EmiDrawContext;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(value = EmiRenderHelper.class, remap = false)
+public class EmiRenderHelperMixin {
+
+    @Inject(method = "renderRecipe",
+            at = @At(value = "INVOKE", target = "Ldev/emi/emi/api/recipe/EmiRecipe;addWidgets(Ldev/emi/emi/api/widget/WidgetHolder;)V"))
+    private static void modularui$tellTheRecipeItsInATooltip(EmiRecipe recipe, EmiDrawContext context, int x, int y,
+                                                             boolean showMissing, int overlayColor,
+                                                             CallbackInfo ci) {
+        if (recipe instanceof ModularUIEmiRecipe muiRecipe) {
+            muiRecipe.useScreenCacheForNextWidgetQuery();
+        }
+    }
+}

src/main/java/brachy/modularui/core/mixins/jei/RecipeGuiLogicMixin.java

@@ -0,0 +1,25 @@
+package brachy.modularui.core.mixins.jei;
+
+import brachy.modularui.integration.jei.recipe.ModularUIJeiCategory;
+
+import com.llamalad7.mixinextras.sugar.Local;
+import mezz.jei.api.recipe.category.IRecipeCategory;
+import mezz.jei.gui.recipes.RecipeGuiLogic;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.ModifyVariable;
+
+@Mixin(value = RecipeGuiLogic.class, remap = false)
+public class RecipeGuiLogicMixin {
+
+    @ModifyVariable(method = "getVisibleRecipeLayoutsWithButtons", at = @At(value = "STORE"), name = "recipeHeight")
+    private int modularui$useCategoryMaxHeightForLayout(int recipeHeight,
+                                                        @Local(name = "recipeCategory") IRecipeCategory<?> recipeCategory) {
+        // if this is a MUI category, force the gui to use the category's max height as the recipe height
+        //  (instead of the height of the first recipe it finds, which may be shorter than others)
+        if (recipeCategory instanceof ModularUIJeiCategory<?> muiCategory) {
+            return muiCategory.getMaxHeight();
+        }
+        return recipeHeight;
+    }
+}

src/main/java/brachy/modularui/core/mixins/jei/RecipeLayoutAccessor.java

@@ -0,0 +1,14 @@
+package brachy.modularui.core.mixins.jei;
+
+import mezz.jei.library.gui.ingredients.CycleTicker;
+import mezz.jei.library.gui.recipes.RecipeLayout;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(value = RecipeLayout.class, remap = false)
+public interface RecipeLayoutAccessor {
+
+    @Accessor("cycleTicker")
+    CycleTicker modularui$getCycleTicker();
+
+}

src/main/java/brachy/modularui/core/mixins/jei/RecipeLayoutBuilderAccessor.java

@@ -0,0 +1,13 @@
+package brachy.modularui.core.mixins.jei;
+
+import mezz.jei.api.runtime.IIngredientManager;
+import mezz.jei.library.gui.recipes.layout.builder.RecipeLayoutBuilder;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(value = RecipeLayoutBuilder.class, remap = false)
+public interface RecipeLayoutBuilderAccessor {
+
+    @Accessor("ingredientManager")
+    IIngredientManager modularui$getIngredientManager();
+}

src/main/java/brachy/modularui/core/mixins/jei/RecipeLayoutBuilderMixin.java

@@ -0,0 +1,40 @@
+package brachy.modularui.core.mixins.jei;
+
+import brachy.modularui.integration.jei.recipe.ModularUIJeiCategory;
+
+import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
+import mezz.jei.api.gui.builder.IRecipeLayoutBuilder;
+import mezz.jei.api.recipe.category.IRecipeCategory;
+import mezz.jei.library.gui.recipes.layout.builder.RecipeLayoutBuilder;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+
+@Mixin(value = RecipeLayoutBuilder.class, remap = false)
+public abstract class RecipeLayoutBuilderMixin<T> implements IRecipeLayoutBuilder {
+
+    @Shadow
+    private @Final T recipe;
+
+    @Shadow
+    private @Final IRecipeCategory<T> recipeCategory;
+
+    @ModifyExpressionValue(method = { "createShapelessIcon", "getRecipeTransferButtonPosition" },
+            at = @At(value = "INVOKE", target = "Lmezz/jei/api/recipe/category/IRecipeCategory;getWidth()I"), require = 0)
+    private int modularui$makeWidthRecipeDependent(int original) {
+        if (recipeCategory instanceof ModularUIJeiCategory<T> muiCategory) {
+            return muiCategory.getWidth(this.recipe);
+        }
+        return original;
+    }
+
+    @ModifyExpressionValue(method = { "createShapelessIcon", "getRecipeTransferButtonPosition" },
+            at = @At(value = "INVOKE", target = "Lmezz/jei/api/recipe/category/IRecipeCategory;getHeight()I"), require = 0)
+    private int modularui$makeHeightRecipeDependent(int original) {
+        if (recipeCategory instanceof ModularUIJeiCategory<T> muiCategory) {
+            return muiCategory.getHeight(recipe);
+        }
+        return original;
+    }
+}

src/main/java/brachy/modularui/core/mixins/jei/RecipeLayoutMixin.java

@@ -0,0 +1,55 @@
+package brachy.modularui.core.mixins.jei;
+
+import brachy.modularui.integration.jei.recipe.ModularUIJeiCategory;
+
+import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import com.llamalad7.mixinextras.sugar.Local;
+import mezz.jei.api.gui.IRecipeLayoutDrawable;
+import mezz.jei.api.gui.inputs.RecipeSlotUnderMouse;
+import mezz.jei.api.recipe.category.IRecipeCategory;
+import mezz.jei.library.gui.recipes.RecipeLayout;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+
+import java.util.Optional;
+
+@Mixin(value = RecipeLayout.class, remap = false)
+public abstract class RecipeLayoutMixin<R> implements IRecipeLayoutDrawable<R> {
+
+    @WrapOperation(method = "drawOverlays",
+                   at = @At(value = "INVOKE", target = "Lmezz/jei/library/gui/recipes/RecipeLayout;getSlotUnderMouse(DD)Ljava/util/Optional;"))
+    private Optional<RecipeSlotUnderMouse> modularui$disableIngredientTooltipRender(RecipeLayout<R> self, double mouseX, double mouseY,
+                                                                                    Operation<Optional<RecipeSlotUnderMouse>> original) {
+        if (self.getRecipeCategory() instanceof ModularUIJeiCategory<R>){
+            return Optional.empty();
+        }
+        return original.call(self, mouseX, mouseY);
+    }
+
+    @ModifyExpressionValue(method = "<init>",
+                           at = @At(value = "INVOKE", target = "Lmezz/jei/api/recipe/category/IRecipeCategory;getWidth()I"),
+                           require = 0)
+    private int modularui$makeWidthRecipeDependent(int original,
+                                                   @Local(argsOnly = true) IRecipeCategory<R> recipeCategory,
+                                                   @Local(argsOnly = true) R recipe) {
+        if (recipeCategory instanceof ModularUIJeiCategory<R> muiCategory) {
+            return muiCategory.getWidth(recipe);
+        }
+        return original;
+    }
+
+    @ModifyExpressionValue(method = "<init>",
+                           at = @At(value = "INVOKE", target = "Lmezz/jei/api/recipe/category/IRecipeCategory;getHeight()I"),
+                           require = 0)
+    private int modularui$makeHeightRecipeDependent(int original,
+                                                    @Local(argsOnly = true) IRecipeCategory<R> recipeCategory,
+                                                    @Local(argsOnly = true) R recipe) {
+        if (recipeCategory instanceof ModularUIJeiCategory<R> muiCategory) {
+            return muiCategory.getHeight(recipe);
+        }
+        return original;
+    }
+}

src/main/java/brachy/modularui/core/mixins/jei/RecipeSlotAccessor.java

@@ -0,0 +1,36 @@
+package brachy.modularui.core.mixins.jei;
+
+import mezz.jei.api.gui.ingredient.IRecipeSlotRichTooltipCallback;
+import mezz.jei.api.ingredients.ITypedIngredient;
+import mezz.jei.api.recipe.RecipeIngredientRole;
+import mezz.jei.library.gui.ingredients.ICycler;
+import mezz.jei.library.gui.ingredients.RecipeSlot;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Mutable;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+import java.util.List;
+import java.util.Optional;
+
+@Mixin(value = RecipeSlot.class, remap = false)
+public interface RecipeSlotAccessor {
+
+    @Accessor("role")
+    @Mutable
+    void modularui$setRole(RecipeIngredientRole role);
+
+    @Accessor("cycler")
+    @Mutable
+    void modularui$setCycler(ICycler cycler);
+
+    @Accessor("tooltipCallbacks")
+    List<IRecipeSlotRichTooltipCallback> modularui$getTooltipCallbacks();
+
+    @Accessor("allIngredients")
+    @Mutable
+    void modularui$setAllIngredients(List<Optional<ITypedIngredient<?>>> allIngredients);
+
+    @Accessor("displayIngredients")
+    @Mutable
+    void modularui$setDisplayIngredients(List<Optional<ITypedIngredient<?>>> displayIngredients);
+}

src/main/java/brachy/modularui/core/mixins/rei/DefaultDisplayViewingScreenMixin.java

@@ -0,0 +1,69 @@
+package brachy.modularui.core.mixins.rei;
+
+import brachy.modularui.integration.rei.recipe.ModularUIReiDisplay;
+import brachy.modularui.integration.rei.recipe.ModularUIReiCategory;
+
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import com.llamalad7.mixinextras.sugar.Local;
+import com.llamalad7.mixinextras.sugar.ref.LocalIntRef;
+import me.shedaniel.rei.api.client.registry.display.DisplayCategory;
+import me.shedaniel.rei.api.common.category.CategoryIdentifier;
+import me.shedaniel.rei.api.common.display.Display;
+import me.shedaniel.rei.impl.client.gui.screen.AbstractDisplayViewingScreen;
+import me.shedaniel.rei.impl.client.gui.screen.DefaultDisplayViewingScreen;
+import me.shedaniel.rei.impl.display.DisplaySpec;
+import org.jetbrains.annotations.Nullable;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import java.util.List;
+import java.util.Map;
+import java.util.function.Supplier;
+import java.util.function.ToIntFunction;
+
+@SuppressWarnings("UnstableApiUsage")
+@Mixin(value = DefaultDisplayViewingScreen.class, remap = false)
+public abstract class DefaultDisplayViewingScreenMixin extends AbstractDisplayViewingScreen {
+
+    protected DefaultDisplayViewingScreenMixin(Map<DisplayCategory<?>, List<DisplaySpec>> categoryMap,
+                                               @Nullable CategoryIdentifier<?> category) {
+        super(categoryMap, category);
+    }
+
+    @WrapOperation(method = "lambda$checkExportDisplays$18", at = @At(value = "INVOKE", target = "Lme/shedaniel/rei/api/client/registry/display/DisplayCategory;getDisplayHeight()I"))
+    private int modularui$forcePerDisplayHeightInExport(DisplayCategory<?> category,
+                                                        Operation<Integer> original,
+                                                        @Local(name = "display") Display display) {
+        return modularui$calculateCustomDisplayHeight(getCurrentCategory(), display, original::call);
+    }
+
+    @Inject(method = "initDisplays",
+            at = @At(value = "INVOKE_ASSIGN", target = "Lme/shedaniel/rei/api/client/registry/display/DisplayCategory;getDisplayWidth(Lme/shedaniel/rei/api/common/display/Display;)I"))
+    private void modularui$perDisplayHeight(CallbackInfo ci,
+                                            @Local(name = "displayHeight") LocalIntRef displayHeight,
+                                            @Local(name = "displaySupplier") Supplier<Display> displaySupplier) {
+        displayHeight.set(modularui$calculateCustomDisplayHeight(getCurrentCategory(), displaySupplier.get(), null));
+    }
+
+    @SuppressWarnings("unchecked")
+    @Unique
+    private static int modularui$calculateCustomDisplayHeight(DisplayCategory<?> category, Display display,
+                                                              @Nullable ToIntFunction<DisplayCategory<?>> originalValue) {
+        if (category instanceof ModularUIReiCategory<?> muiCategory && display instanceof ModularUIReiDisplay muiDisplay) {
+            return ((ModularUIReiCategory<ModularUIReiDisplay>) muiCategory).getDisplayHeight(muiDisplay);
+        } else {
+            // if this isn't a MUI display, set it back to the original value
+            // (I think it's possible that an MUI category has a non-MUI display in it? not sure tho.)
+            if (originalValue == null) {
+                // originalValue == null means we can't trust it and should get the actual original value
+                return category.getDisplayHeight();
+            } else {
+                return originalValue.applyAsInt(category);
+            }
+        }
+    }
+}