1 files changed, 116 insertions, 0 deletions

diff --git a/src/main/java/lv/enes/mc/eris_alchemy/client/ErisAlchemyClientRegistry.java b/src/main/java/lv/enes/mc/eris_alchemy/client/ErisAlchemyClientRegistry.java
new file mode 100644
index 0000000..3680fd5
--- /dev/null
+++ b/src/main/java/lv/enes/mc/eris_alchemy/client/ErisAlchemyClientRegistry.java
@@ -0,0 +1,116 @@
+package lv.enes.mc.eris_alchemy.client;
+
+import lv.enes.mc.eris_alchemy.block.entity.AlchemicalChestBlockEntity;
+import net.fabricmc.fabric.api.client.rendering.v1.BuiltinItemRendererRegistry.DynamicItemRenderer;
+import net.minecraft.client.gui.screens.MenuScreens.ScreenConstructor;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.client.gui.screens.inventory.MenuAccess;
+import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider;
+import net.minecraft.client.renderer.blockentity.ChestRenderer;
+import net.minecraft.world.inventory.AbstractContainerMenu;
+import net.minecraft.world.inventory.MenuType;
+import net.minecraft.world.level.ItemLike;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.entity.BlockEntityType;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.function.BiConsumer;
+
+import static lv.enes.mc.eris_alchemy.ErisAlchemyRegistry.*;
+
+public final class ErisAlchemyClientRegistry {
+        private ErisAlchemyClientRegistry() {}
+
+        public static final class BlockEntityRenderers {
+                private BlockEntityRenderers() {}
+
+                @FunctionalInterface
+                public interface Consumer {
+                        <T extends BlockEntity> void consume(BlockEntityType<? extends T> type, BlockEntityRendererProvider<T> provider);
+                }
+
+                public static void consume(Consumer consumer) {
+                        data.values().forEach(pair -> pair.beConsumed(consumer));
+                }
+
+                private record Pair<T extends BlockEntity>(
+                                BlockEntityType<? extends T> type,
+                                BlockEntityRendererProvider<T> provider
+                ) {
+                        public void beConsumed(Consumer consumer) {
+                                consumer.consume(type, provider);
+                        }
+                }
+
+                private static final Map<BlockEntityType<?>, Pair<?>> data = new LinkedHashMap<>();
+
+                private static <T extends BlockEntity> void register(
+                                BlockEntityType<? extends T> type,
+                                BlockEntityRendererProvider<T> provider
+                ) {
+                        data.put(type, new Pair<>(type, provider));
+                }
+
+                static {
+                        register(BlockEntities.ALCHEMICAL_CHEST, ChestRenderer::new);
+                }
+        }
+
+        public static final class ItemRenderers {
+                private ItemRenderers() {}
+
+                public static void consume(BiConsumer<? super ItemLike, ? super DynamicItemRenderer> consumer) {
+                        data.forEach(consumer);
+                }
+
+                private static final Map<ItemLike, DynamicItemRenderer> data = new LinkedHashMap<>();
+
+                private static void register(ItemLike item, DynamicItemRenderer renderer) {
+                        data.put(item, renderer);
+                }
+
+                static {
+                        register(
+                                        Items.ALCHEMICAL_CHEST,
+                                        new ChestItemRenderer<>(Blocks.ALCHEMICAL_CHEST, AlchemicalChestBlockEntity::new)::renderByItem
+                        );
+                }
+        }
+
+        public static final class MenuScreens {
+                private MenuScreens() {}
+
+                @FunctionalInterface
+                public interface Consumer {
+                        <M extends AbstractContainerMenu, S extends Screen & MenuAccess<M>>
+                        void consume(MenuType<? extends M> menu, ScreenConstructor<M, S> constructor);
+                }
+
+                public static void consume(Consumer consumer) {
+                        data.values().forEach(pair -> pair.beConsumed(consumer));
+                }
+
+                private record Pair<M extends AbstractContainerMenu, S extends Screen & MenuAccess<M>>(
+                        MenuType<? extends M> menu,
+                        ScreenConstructor<M, S> constructor
+                ) {
+                        public void beConsumed(Consumer consumer) {
+                                consumer.consume(menu, constructor);
+                        }
+                }
+
+                private static final Map<MenuType<?>, Pair<?, ?>> data = new LinkedHashMap<>();
+
+                private static <M extends AbstractContainerMenu, S extends Screen & MenuAccess<M>> void register(
+                        MenuType<? extends M> menu,
+                        ScreenConstructor<M, S> constructor
+                ) {
+                        data.put(menu, new Pair<>(menu, constructor));
+                }
+
+                static {
+                        register(Menus.ALCHEMICAL_CHEST, AlchemicalChestScreen::new);
+                }
+        }
+}