diff options
23 files changed, 1813 insertions, 76 deletions
@@ -5,6 +5,8 @@ build/ out/ classes/ +private.gradle + # idea .idea/ @@ -20,6 +22,10 @@ bin/ .classpath .project +# naughty filesystems + +.directory + # fabric run/
\ No newline at end of file @@ -1,16 +1,6 @@ -# Fabric Example Mod +# LibGui -## Setup - -1. Edit build.gradle and mod.json to suit your needs. - * The "mixins" object can be removed from mod.json if you do not need to use mixins. - * Please replace all occurences of "modid" with your own mod ID - sometimes, a different string may also suffice. -2. Run the following command: - -``` -./gradlew idea -``` - -## License - -This template is available under the CC0 license. Feel free to learn from it and incorporate it in your own projects. +Minecraft GUIs without spending forever painstakingly aligning things to the background image. +Instead, LibGui takes a logical description of your GUI, and draws it on-the-fly like any modern +GUI system. Controls can be hung on an itemslot grid or offset from it. Panel styles, colors, +and opacity can be customized, and everything can be extended.
\ No newline at end of file diff --git a/build.gradle b/build.gradle index d2adc6d..b8342b2 100644 --- a/build.gradle +++ b/build.gradle @@ -6,6 +6,10 @@ plugins { sourceCompatibility = JavaVersion.VERSION_1_8 targetCompatibility = JavaVersion.VERSION_1_8 +if(rootProject.file('private.gradle').exists()) { //Publishing details + apply from: 'private.gradle' +} + archivesBaseName = project.archives_base_name version = project.mod_version group = project.maven_group @@ -22,6 +26,7 @@ dependencies { // Fabric API. This is technically optional, but you probably want it anyway. modCompile "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}" + compileOnly ("com.google.code.findbugs:jsr305:3.0.2") { transitive = false } // PSA: Some older mods, compiled on Loom 0.2.1, might have outdated Maven POMs. // You may need to force-disable transitiveness on them. } @@ -63,6 +68,10 @@ publishing { publications { mavenJava(MavenPublication) { // add all the jars that should be included when publishing to maven + artifact ("${project.buildDir.absolutePath}/libs/${archivesBaseName}-${project.version}.jar") { //release jar - file location not provided anywhere in loom + classifier null + builtBy remapJar + } artifact(jar) { builtBy remapJar } diff --git a/gradle.properties b/gradle.properties index 8820f34..4eb4fac 100644 --- a/gradle.properties +++ b/gradle.properties @@ -9,8 +9,8 @@ org.gradle.jvmargs=-Xmx1G # Mod Properties mod_version = 1.0.0 - maven_group = net.fabricmc - archives_base_name = fabric-example-mod + maven_group = io.github.cottonmc + archives_base_name = LibGUI # Dependencies # currently not on the main fabric site, check on the maven: https://maven.fabricmc.net/net/fabricmc/fabric diff --git a/src/main/java/io/github/cottonmc/cotton/gui/CottonScreenController.java b/src/main/java/io/github/cottonmc/cotton/gui/CottonScreenController.java new file mode 100644 index 0000000..47b56f6 --- /dev/null +++ b/src/main/java/io/github/cottonmc/cotton/gui/CottonScreenController.java @@ -0,0 +1,397 @@ +package io.github.cottonmc.cotton.gui; + +import java.util.ArrayList; + +import javax.annotation.Nullable; + +import io.github.cottonmc.cotton.gui.client.BackgroundPainter; +import io.github.cottonmc.cotton.gui.widget.WGridPanel; +import io.github.cottonmc.cotton.gui.widget.WItemSlot; +import io.github.cottonmc.cotton.gui.widget.WPanel; +import io.github.cottonmc.cotton.gui.widget.WPlainPanel; +import io.github.cottonmc.cotton.gui.widget.WWidget; +import net.fabricmc.api.EnvType; +import net.fabricmc.api.Environment; +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.block.InventoryProvider; +import net.minecraft.block.entity.BlockEntity; +import net.minecraft.container.ArrayPropertyDelegate; +import net.minecraft.container.BlockContext; +import net.minecraft.container.CraftingContainer; +import net.minecraft.container.PropertyDelegate; +import net.minecraft.container.Slot; +import net.minecraft.container.SlotActionType; +import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.entity.player.PlayerInventory; +import net.minecraft.inventory.Inventory; +import net.minecraft.item.ItemStack; +import net.minecraft.recipe.Recipe; +import net.minecraft.recipe.RecipeFinder; +import net.minecraft.recipe.RecipeInputProvider; +import net.minecraft.recipe.RecipeType; +import net.minecraft.world.World; + +public abstract class CottonScreenController extends CraftingContainer<Inventory> { + + protected Inventory blockInventory; + protected PlayerInventory playerInventory; + protected RecipeType<?> recipeType; + protected World world; + protected PropertyDelegate propertyDelegate; + + protected WPanel rootPanel = new WGridPanel(); + protected int titleColor = 0xFF404040; + + public CottonScreenController(RecipeType<?> recipeType, int syncId, PlayerInventory playerInventory) { + super(null, syncId); + this.blockInventory = null; + this.playerInventory = playerInventory; + this.recipeType = recipeType; + this.world = playerInventory.player.world; + this.propertyDelegate = null;//new ArrayPropertyDelegate(1); + } + + public CottonScreenController(RecipeType<?> recipeType, int syncId, PlayerInventory playerInventory, Inventory blockInventory, PropertyDelegate propertyDelegate) { + super(null, syncId); + this.blockInventory = blockInventory; + this.playerInventory = playerInventory; + this.recipeType = recipeType; + this.world = playerInventory.player.world; + this.propertyDelegate = propertyDelegate; + if (propertyDelegate!=null && propertyDelegate.size()>0) this.addProperties(propertyDelegate); + } + + public WPanel getRootPanel() { + return rootPanel; + } + + public int getTitleColor() { + return titleColor; + } + + public CottonScreenController setRootPanel(WPanel panel) { + this.rootPanel = panel; + return this; + } + + public CottonScreenController setTitleColor(int color) { + this.titleColor = color; + return this; + } + + @Environment(EnvType.CLIENT) + public void addPainters() { + if (this.rootPanel!=null) { + this.rootPanel.setBackgroundPainter(BackgroundPainter.VANILLA); + } + } + + public void addSlotPeer(ValidatedSlot slot) { + this.addSlot(slot); + } + + @Override + public ItemStack onSlotClick(int slotNumber, int button, SlotActionType action, PlayerEntity player) { + if (action==SlotActionType.QUICK_MOVE) { + + if (slotNumber < 0) { + return ItemStack.EMPTY; + } + + if (slotNumber>=this.slotList.size()) return ItemStack.EMPTY; + Slot slot = this.slotList.get(slotNumber); + if (slot == null || !slot.canTakeItems(player)) { + return ItemStack.EMPTY; + } + + ItemStack remaining = ItemStack.EMPTY; + if (slot != null && slot.hasStack()) { + ItemStack toTransfer = slot.getStack(); + remaining = toTransfer.copy(); + //if (slot.inventory==blockInventory) { + if (blockInventory!=null) { + if (slot.inventory==blockInventory) { + //Try to transfer the item from the block into the player's inventory + if (!this.insertItem(toTransfer, this.playerInventory, true)) { + return ItemStack.EMPTY; + } + } else if (!this.insertItem(toTransfer, this.blockInventory, false)) { //Try to transfer the item from the player to the block + return ItemStack.EMPTY; + } + } else { + //There's no block, just swap between the player's storage and their hotbar + if (!swapHotbar(toTransfer, slotNumber, this.playerInventory)) { + return ItemStack.EMPTY; + } + } + + if (toTransfer.isEmpty()) { + slot.setStack(ItemStack.EMPTY); + } else { + slot.markDirty(); + } + } + + return remaining; + } else { + return super.onSlotClick(slotNumber, button, action, player); + } + } + + /** WILL MODIFY toInsert! Returns true if anything was inserted. */ + private boolean insertIntoExisting(ItemStack toInsert, Slot slot) { + ItemStack curSlotStack = slot.getStack(); + if (!curSlotStack.isEmpty() && canStacksCombine(toInsert, curSlotStack)) { + int combinedAmount = curSlotStack.getCount() + toInsert.getCount(); + if (combinedAmount <= toInsert.getMaxCount()) { + toInsert.setCount(0); + curSlotStack.setCount(combinedAmount); + slot.markDirty(); + return true; + } else if (curSlotStack.getCount() < toInsert.getMaxCount()) { + toInsert.decrement(toInsert.getMaxCount() - curSlotStack.getCount()); + curSlotStack.setCount(toInsert.getMaxCount()); + slot.markDirty(); + return true; + } + } + return false; + } + + /** WILL MODIFY toInsert! Returns true if anything was inserted. */ + private boolean insertIntoEmpty(ItemStack toInsert, Slot slot) { + ItemStack curSlotStack = slot.getStack(); + if (curSlotStack.isEmpty() && slot.canInsert(toInsert)) { + if (toInsert.getCount() > slot.getMaxStackAmount()) { + slot.setStack(toInsert.split(slot.getMaxStackAmount())); + } else { + slot.setStack(toInsert.split(toInsert.getCount())); + } + + slot.markDirty(); + return true; + } + + return false; + } + + private boolean insertItem(ItemStack toInsert, Inventory inventory, boolean walkBackwards) { + //Make a unified list of slots *only from this inventory* + ArrayList<Slot> inventorySlots = new ArrayList<>(); + for(Slot slot : slotList) { + if (slot.inventory==inventory) inventorySlots.add(slot); + } + if (inventorySlots.isEmpty()) return false; + + //Try to insert it on top of existing stacks + boolean inserted = false; + if (walkBackwards) { + for(int i=inventorySlots.size()-1; i>=0; i--) { + Slot curSlot = inventorySlots.get(i); + if (insertIntoExisting(toInsert, curSlot)) inserted = true; + if (toInsert.isEmpty()) break; + } + } else { + for(int i=0; i<inventorySlots.size(); i++) { + Slot curSlot = inventorySlots.get(i); + if (insertIntoExisting(toInsert, curSlot)) inserted = true; + if (toInsert.isEmpty()) break; + } + + } + + //If we still have any, shove them into empty slots + if (!toInsert.isEmpty()) { + if (walkBackwards) { + for(int i=inventorySlots.size()-1; i>=0; i--) { + Slot curSlot = inventorySlots.get(i); + if (insertIntoEmpty(toInsert, curSlot)) inserted = true; + if (toInsert.isEmpty()) break; + } + } else { + for(int i=0; i<inventorySlots.size(); i++) { + Slot curSlot = inventorySlots.get(i); + if (insertIntoEmpty(toInsert, curSlot)) inserted = true; + if (toInsert.isEmpty()) break; + } + + } + } + + return inserted; + } + + private boolean swapHotbar(ItemStack toInsert, int slotNumber, Inventory inventory) { + //Feel out the slots to see what's storage versus hotbar + ArrayList<Slot> storageSlots = new ArrayList<>(); + ArrayList<Slot> hotbarSlots = new ArrayList<>(); + boolean swapToStorage = true; + boolean inserted = false; + + for(Slot slot : slotList) { + if (slot.inventory==inventory && slot instanceof ValidatedSlot) { + int index = ((ValidatedSlot)slot).getInventoryIndex(); + if (PlayerInventory.isValidHotbarIndex(index)) { + hotbarSlots.add(slot); + } else { + storageSlots.add(slot); + if (index==slotNumber) swapToStorage = false; + } + } + } + if (storageSlots.isEmpty() || hotbarSlots.isEmpty()) return false; + + if (swapToStorage) { + //swap from hotbar to storage + for(int i=0; i<storageSlots.size(); i++) { + Slot curSlot = storageSlots.get(i); + if (insertIntoExisting(toInsert, curSlot)) inserted = true; + if (toInsert.isEmpty()) break; + } + if (!toInsert.isEmpty()) { + for(int i=0; i<storageSlots.size(); i++) { + Slot curSlot = storageSlots.get(i); + if (insertIntoEmpty(toInsert, curSlot)) inserted = true; + if (toInsert.isEmpty()) break; + } + } + } else { + //swap from storage to hotbar + for(int i=0; i<hotbarSlots.size(); i++) { + Slot curSlot = hotbarSlots.get(i); + if (insertIntoExisting(toInsert, curSlot)) inserted = true; + if (toInsert.isEmpty()) break; + } + if (!toInsert.isEmpty()) { + for(int i=0; i<hotbarSlots.size(); i++) { + Slot curSlot = hotbarSlots.get(i); + if (insertIntoEmpty(toInsert, curSlot)) inserted = true; + if (toInsert.isEmpty()) break; + } + } + } + + return inserted; + } + + @Nullable + public WWidget doMouseUp(int x, int y, int state) { + if (rootPanel!=null) return rootPanel.onMouseUp(x, y, state); + return null; + } + + @Nullable + public WWidget doMouseDown(int x, int y, int button) { + if (rootPanel!=null) return rootPanel.onMouseDown(x, y, button); + return null; + } + + public void doMouseDrag(int x, int y, int button) { + if (rootPanel!=null) rootPanel.onMouseDrag(x, y, button); + } + + public void doClick(int x, int y, int button) { + if (rootPanel!=null) rootPanel.onClick(x, y, button); + } + + /** + * Gets the PropertyDelegate associated with this Controller. + */ + @Nullable + public PropertyDelegate getPropertyDelegate() { + // TODO Auto-generated method stub + return propertyDelegate; + } + + public WPanel createPlayerInventoryPanel() { + WPlainPanel inv = new WPlainPanel(); + inv.add(WItemSlot.ofPlayerStorage(playerInventory), 0, 0); + inv.add(WItemSlot.of(playerInventory, 0, 9, 1), 0, 16*4 - 6); + return inv; + } + + public static Inventory getBlockInventory(BlockContext ctx) { + return ctx.run((world, pos) -> { + BlockState state = world.getBlockState(pos); + Block b = state.getBlock(); + + if (b instanceof InventoryProvider) { + return ((InventoryProvider)b).getInventory(state, world, pos); + } + + BlockEntity be = world.getBlockEntity(pos); + if (be!=null) { + if (be instanceof InventoryProvider) { + return ((InventoryProvider)be).getInventory(state, world, pos); + } else if (be instanceof Inventory) { + return (Inventory)be; + } + } + + return EmptyInventory.INSTANCE; + }).orElse(EmptyInventory.INSTANCE); + } + + public static PropertyDelegate getBlockPropertyDelegate(BlockContext ctx) { + return ctx.run((world, pos) -> { + BlockState state = world.getBlockState(pos); + Block block = state.getBlock(); + if (block instanceof PropertyDelegateHolder) { + return ((PropertyDelegateHolder)block).getPropertyDelegate(); + } + BlockEntity be = world.getBlockEntity(pos); + if (be!=null && be instanceof PropertyDelegateHolder) { + return ((PropertyDelegateHolder)be).getPropertyDelegate(); + } + + return new ArrayPropertyDelegate(0); + }).orElse(new ArrayPropertyDelegate(0)); + } + + //extends CraftingContainer<Inventory> { + @Override + public void populateRecipeFinder(RecipeFinder recipeFinder) { + if (this.blockInventory instanceof RecipeInputProvider) { + ((RecipeInputProvider)this.blockInventory).provideRecipeInputs(recipeFinder); + } + } + + @Override + public void clearCraftingSlots() { + if (this.blockInventory!=null) this.blockInventory.clear(); + } + + @Override + public boolean matches(Recipe<? super Inventory> recipe) { + if (blockInventory==null || world==null) return false; + return false; //TODO recipe support + } + + @Override + public abstract int getCraftingResultSlotIndex(); + + @Override + public int getCraftingWidth() { + return 1; + } + + @Override + public int getCraftingHeight() { + return 1; + } + + @Override + @Environment(EnvType.CLIENT) + public int getCraftingSlotCount() { + return 1; + } + + //(implied) extends Container { + @Override + public boolean canUse(PlayerEntity entity) { + return (blockInventory!=null) ? blockInventory.canPlayerUseInv(entity) : true; + } + //} + //} +} diff --git a/src/main/java/io/github/cottonmc/cotton/gui/EmptyInventory.java b/src/main/java/io/github/cottonmc/cotton/gui/EmptyInventory.java new file mode 100644 index 0000000..a80b5da --- /dev/null +++ b/src/main/java/io/github/cottonmc/cotton/gui/EmptyInventory.java @@ -0,0 +1,53 @@ +package io.github.cottonmc.cotton.gui; + +import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.inventory.Inventory; +import net.minecraft.item.ItemStack; + +public class EmptyInventory implements Inventory { + public static final EmptyInventory INSTANCE = new EmptyInventory(); + + private EmptyInventory() {} + + @Override + public void clear() {} + + @Override + public int getInvSize() { + return 0; + } + + @Override + public boolean isInvEmpty() { + return true; + } + + @Override + public ItemStack getInvStack(int var1) { + return ItemStack.EMPTY; + } + + @Override + public ItemStack takeInvStack(int var1, int var2) { + return ItemStack.EMPTY; + } + + @Override + public ItemStack removeInvStack(int var1) { + return ItemStack.EMPTY; + } + + @Override + public void setInvStack(int var1, ItemStack var2) { + } + + @Override + public void markDirty() { + } + + @Override + public boolean canPlayerUseInv(PlayerEntity var1) { + return false; + } + +} diff --git a/src/main/java/io/github/cottonmc/cotton/gui/PropertyDelegateHolder.java b/src/main/java/io/github/cottonmc/cotton/gui/PropertyDelegateHolder.java new file mode 100644 index 0000000..6ec1476 --- /dev/null +++ b/src/main/java/io/github/cottonmc/cotton/gui/PropertyDelegateHolder.java @@ -0,0 +1,7 @@ +package io.github.cottonmc.cotton.gui; + +import net.minecraft.container.PropertyDelegate; + +public interface PropertyDelegateHolder { + public PropertyDelegate getPropertyDelegate(); +} diff --git a/src/main/java/io/github/cottonmc/cotton/gui/ValidatedSlot.java b/src/main/java/io/github/cottonmc/cotton/gui/ValidatedSlot.java new file mode 100644 index 0000000..9301761 --- /dev/null +++ b/src/main/java/io/github/cottonmc/cotton/gui/ValidatedSlot.java @@ -0,0 +1,46 @@ +package io.github.cottonmc.cotton.gui; + +import net.minecraft.container.Slot; +import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.inventory.Inventory; +import net.minecraft.item.ItemStack; + +public class ValidatedSlot extends Slot { + private final int slotNumber; + + public ValidatedSlot(Inventory inventoryIn, int index, int xPosition, int yPosition) { + super(inventoryIn, index, xPosition, yPosition); + if (inventoryIn==null) throw new IllegalArgumentException("Can't make an itemslot from a null inventory!"); + this.slotNumber = index; + } + + @Override + public boolean canInsert(ItemStack stack) { + return inventory.isValidInvStack(slotNumber, stack); + } + + @Override + public boolean canTakeItems(PlayerEntity player) { + return inventory.canPlayerUseInv(player); + } + + @Override + public ItemStack getStack() { + if (inventory==null) { + System.out.println("Prevented null-inventory from WItemSlot with slot #: "+slotNumber); + return ItemStack.EMPTY; + } + + ItemStack result = super.getStack(); + if (result==null) { + System.out.println("Prevented null-itemstack crash from: "+inventory.getClass().getCanonicalName()); + return ItemStack.EMPTY; + } + + return result; + } + + public int getInventoryIndex() { + return slotNumber; + } +}
\ No newline at end of file diff --git a/src/main/java/io/github/cottonmc/cotton/gui/client/BackgroundPainter.java b/src/main/java/io/github/cottonmc/cotton/gui/client/BackgroundPainter.java new file mode 100644 index 0000000..38f9130 --- /dev/null +++ b/src/main/java/io/github/cottonmc/cotton/gui/client/BackgroundPainter.java @@ -0,0 +1,37 @@ +package io.github.cottonmc.cotton.gui.client; + +import io.github.cottonmc.cotton.gui.widget.WWidget; + +public interface BackgroundPainter { + /** + * Paint the specified panel to the screen. + * @param left The absolute position of the left of the panel, in gui-screen coordinates + * @param top The absolute position of the top of the panel, in gui-screen coordinates + * @param panel The panel being painted + */ + public void paintBackground(int left, int top, WWidget panel); + + + + public static BackgroundPainter VANILLA = (left, top, panel) -> { + ScreenDrawing.drawGuiPanel(left-8, top-8, panel.getWidth()+16, panel.getHeight()+16); + + }; + + + + public static BackgroundPainter createColorful(int panelColor) { + return (left, top, panel) -> { + ScreenDrawing.drawGuiPanel(left-8, top-8, panel.getWidth()+16, panel.getHeight()+16, panelColor); + }; + } + + public static BackgroundPainter createColorful(int panelColor, float contrast) { + return (left, top, panel) -> { + int shadowColor = ScreenDrawing.multiplyColor(panelColor, 1.0f - contrast); + int hilightColor = ScreenDrawing.multiplyColor(panelColor, 1.0f + contrast); + + ScreenDrawing.drawGuiPanel(left-8, top-8, panel.getWidth()+16, panel.getHeight()+16, shadowColor, panelColor, hilightColor, 0xFF000000); + }; + } +} diff --git a/src/main/java/io/github/cottonmc/cotton/gui/client/CottonScreen.java b/src/main/java/io/github/cottonmc/cotton/gui/client/CottonScreen.java new file mode 100644 index 0000000..dc78a25 --- /dev/null +++ b/src/main/java/io/github/cottonmc/cotton/gui/client/CottonScreen.java @@ -0,0 +1,237 @@ +package io.github.cottonmc.cotton.gui.client; + +import io.github.cottonmc.cotton.gui.CottonScreenController; +import io.github.cottonmc.cotton.gui.widget.WPanel; +import io.github.cottonmc.cotton.gui.widget.WWidget; +import net.minecraft.client.MinecraftClient; +import net.minecraft.client.gui.screen.ingame.AbstractContainerScreen; +import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.text.LiteralText; +import net.minecraft.text.Text; +import net.minecraft.util.Nameable; + +public class CottonScreen<T extends CottonScreenController> extends AbstractContainerScreen<T> { + protected CottonScreenController container; + public static final int PADDING = 8; + protected WWidget lastResponder = null; + + public CottonScreen(T container, PlayerEntity player) { + super(container, player.inventory, new LiteralText("")); + this.container = container; + width = 18*9; + height = 18*9; + this.containerWidth = 18*9; + this.containerHeight = 18*9; + } + + /* + * RENDERING NOTES: + * + * * "width" and "height" are the width and height of the overall screen + * * "containerWidth" and "containerHeight" are the width and height of the panel to render + * * "left" and "top" are *actually* self-explanatory + * * coordinates start at 0,0 at the topleft of the screen. + */ + + + /* + * These methods are called frequently and empty, meaning they're probably *meant* for subclasses to override to + * provide core GUI functionality. + */ + + @Override + public void init(MinecraftClient minecraftClient_1, int screenWidth, int screenHeight) { + super.init(minecraftClient_1, screenWidth, screenHeight); + + container.addPainters(); + + reposition(); + } + + public void reposition() { + WPanel basePanel = container.getRootPanel(); + if (basePanel!=null) { + basePanel.validate(container); + + containerWidth = basePanel.getWidth(); + containerHeight = basePanel.getHeight(); + + //DEBUG + if (containerWidth<16) containerWidth=300; + if (containerHeight<16) containerHeight=300; + //if (left<0 || left>300) left = 10; + //if (top<0 || top>300) top = 10; + } + left = (width / 2) - (containerWidth / 2); + top = (height / 2) - (containerHeight / 2); + } + + //Will probably re-activate for animation! + //@Override + //public void updateScreen() { + // System.out.println("updateScreen"); + //} + + @Override + public void onClose() { + super.onClose(); + } + + @Override + public boolean isPauseScreen() { + //...yeah, we're going to go ahead and override that. + return false; + } + + /* + * While these methods are implemented in GuiScreen, chances are we'll be shadowing a lot of the GuiScreen methods + * in order to implement our own button protocol and more advanced features. + */ + + + @Override + public boolean charTyped(char typedChar, int keyCode) { + if (MinecraftClient.getInstance().options.keyInventory.matchesKey(keyCode, keyCode)); + + return super.charTyped(typedChar, keyCode); + } + + @Override + public boolean mouseClicked(double mouseX, double mouseY, int mouseButton) { + boolean result = super.mouseClicked(mouseX, mouseY, mouseButton); + int containerX = (int)mouseX-left; + int containerY = (int)mouseY-top; + if (containerX<0 || containerY<0 || containerX>=width || containerY>=height) return result; + lastResponder = container.doMouseDown(containerX, containerY, mouseButton); + return result; + } + + @Override + public boolean mouseReleased(double mouseX, double mouseY, int mouseButton) { //Testing shows that STATE IS ACTUALLY BUTTON + boolean result = super.mouseReleased(mouseX, mouseY, mouseButton); + int containerX = (int)mouseX-left; + int containerY = (int)mouseY-top; + if (containerX<0 || containerY<0 || containerX>=width || containerY>=height) return result; + + WWidget responder = container.doMouseUp(containerX, containerY, mouseButton); + if (responder!=null && responder==lastResponder) container.doClick(containerX, containerY, mouseButton); + lastResponder = null; + return result; + } + + @Override + public boolean mouseDragged(double mouseX, double mouseY, int mouseButton, double unknown_1, double unknown_2) { + boolean result = super.mouseDragged(mouseX, mouseY, mouseButton, unknown_1, unknown_2); + + int containerX = (int)mouseX-left; + int containerY = (int)mouseY-top; + if (containerX<0 || containerY<0 || containerX>=width || containerY>=height) return result; + container.doMouseDrag(containerX, containerY, mouseButton); + return result; + } + + /* + @Override + protected void actionPerformed(GuiButton button) throws IOException { + super.actionPerformed(button); + }*/ + + /* + * We'll probably wind up calling some of this manually, but they do useful things for us so we may leave + * them unharmed. + */ + /* + @Override + public void setWorldAndResolution(Minecraft mc, int width, int height) { + super.setWorldAndResolution(mc, width, height); + + WPanel basePanel = container.getRootPanel(); + if (basePanel!=null) { + xSize = basePanel.getWidth(); + ySize = basePanel.getHeight(); + } + left = (width / 2) - (xSize / 2); + top = (height / 2) - (ySize / 2); + + } + */ + + @Override + public void resize(MinecraftClient minecraftClient_1, int int_1, int int_2) { + //super.onScaleChanged(minecraftClient_1, int_1, int_2); + this.width = int_1; + this.height = int_2; + reposition(); + } + + /* + * SPECIAL FUNCTIONS: Where possible, we want to draw everything based on *actual GUI state and composition* rather + * than relying on pre-baked textures that the programmer then needs to carefully match up their GUI to. + */ + + private int multiplyColor(int color, float amount) { + int a = color & 0xFF000000; + float r = (color >> 16 & 255) / 255.0F; + float g = (color >> 8 & 255) / 255.0F; + float b = (color & 255) / 255.0F; + + r = Math.min(r*amount, 1.0f); + g = Math.min(g*amount, 1.0f); + b = Math.min(b*amount, 1.0f); + + int ir = (int)(r*255); + int ig = (int)(g*255); + int ib = (int)(b*255); + + return a | + (ir << 16) | + (ig << 8) | + ib; + } + + @Override + protected void drawBackground(float partialTicks, int mouseX, int mouseY) { + if (this.container==null) { + System.out.println("CONTAINER IS NULL."); + return; + } + WPanel root = this.container.getRootPanel(); + if (root==null) return; + + root.paintBackground(left, top); + + //TODO: Change this to a label that lives in the rootPanel instead? + if (container instanceof Nameable) { + Text name = ((Nameable)container).getDisplayName(); + font.draw(name.asFormattedString(), left, top, container.getTitleColor()); + } else if (getTitle() != null) { + font.draw(getTitle().asFormattedString(), left, top, container.getTitleColor()); + } + } + + @Override + protected void drawForeground(int mouseX, int mouseY) { + //if (cursorDragSlots != null && this.container.getRootPanel() != null) { + if (this.container==null) { + System.out.println("CONTAINER IS NULL."); + return; + } + + if (this.container.getRootPanel()!=null) { + this.container.getRootPanel().paintForeground(left, top, mouseX, mouseY); + } + //} + } + + @Override + public void render(int mouseX, int mouseY, float partialTicks) { + // Render the background shadow + this.renderBackground(); + + this.drawBackground(partialTicks, mouseX, mouseY); + + super.render(mouseX, mouseY, partialTicks); + drawMouseoverTooltip(mouseX, mouseY); + } + +} diff --git a/src/main/java/io/github/cottonmc/cotton/gui/client/ScreenDrawing.java b/src/main/java/io/github/cottonmc/cotton/gui/client/ScreenDrawing.java new file mode 100644 index 0000000..5592e5d --- /dev/null +++ b/src/main/java/io/github/cottonmc/cotton/gui/client/ScreenDrawing.java @@ -0,0 +1,235 @@ +package io.github.cottonmc.cotton.gui.client; + +import org.lwjgl.opengl.GL11; + +import com.mojang.blaze3d.platform.GlStateManager; + +import net.minecraft.client.MinecraftClient; +import net.minecraft.client.render.BufferBuilder; +import net.minecraft.client.render.Tessellator; +import net.minecraft.client.render.VertexFormats; +import net.minecraft.util.Identifier; + +public class ScreenDrawing { + private ScreenDrawing() {} + + public static void rect(Identifier texture, int left, int top, int width, int height, int color) { + rect(texture, left, top, width, height, 0, 0, 1, 1, color, 0); + } + + public static void rect(Identifier texture, int left, int top, int width, int height, float u1, float v1, float u2, float v2, int color) { + rect(texture, left, top, width, height, u1, v1, u2, v2, 0xFFFFFFFF, 0); + } + + public static void rect(Identifier texture, int left, int top, int width, int height, float u1, float v1, float u2, float v2, int color, int z) { + MinecraftClient.getInstance().getTextureManager().bindTexture(texture); + + //float scale = 0.00390625F; + + if (width <= 0) width = 1; + if (height <= 0) height = 1; + + float r = (color >> 16 & 255) / 255.0F; + float g = (color >> 8 & 255) / 255.0F; + float b = (color & 255) / 255.0F; + Tessellator tessellator = Tessellator.getInstance(); + BufferBuilder buffer = tessellator.getBufferBuilder(); + GlStateManager.enableBlend(); + //GlStateManager.disableTexture2D(); + GlStateManager.blendFuncSeparate(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA, GlStateManager.SourceFactor.ONE, GlStateManager.DestFactor.ZERO); + GlStateManager.color4f(r, g, b, 1.0f); + buffer.begin(GL11.GL_QUADS, VertexFormats.POSITION_UV); //I thought GL_QUADS was deprecated but okay, sure. + buffer.vertex(left, top + height, z).texture(u1, v2).next(); + buffer.vertex(left + width, top + height, z).texture(u2, v2).next(); + buffer.vertex(left + width, top, z).texture(u2, v1).next(); + buffer.vertex(left, top, z).texture(u1, v1).next(); + tessellator.draw(); + //GlStateManager.enableTexture2D(); + GlStateManager.disableBlend(); + } + + /** + * Draws an untextured rectangle of the specified RGB color. + */ + public static void rect(int left, int top, int width, int height, int color) { + if (width <= 0) width = 1; + if (height <= 0) height = 1; + + float a = (color >> 24 & 255) / 255.0F; + float r = (color >> 16 & 255) / 255.0F; + float g = (color >> 8 & 255) / 255.0F; + float b = (color & 255) / 255.0F; + Tessellator tessellator = Tessellator.getInstance(); + BufferBuilder buffer = tessellator.getBufferBuilder(); + GlStateManager.enableBlend(); + GlStateManager.disableTexture(); + GlStateManager.blendFuncSeparate(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA, GlStateManager.SourceFactor.ONE, GlStateManager.DestFactor.ZERO); + GlStateManager.color4f(r, g, b, a); + buffer.begin(GL11.GL_QUADS, VertexFormats.POSITION); //I thought GL_QUADS was deprecated but okay, sure. + buffer.vertex(left, top + height, 0.0D).next(); + buffer.vertex(left + width, top + height, 0.0D).next(); + buffer.vertex(left + width, top, 0.0D).next(); + buffer.vertex(left, top, 0.0D).next(); + tessellator.draw(); + GlStateManager.enableTexture(); + GlStateManager.disableBlend(); + } + + public static void maskedRect(Identifier mask, Identifier texture, int left, int top, int width, int height) { + + + rect(mask, left, top, width, height, 0, 0, 1, 1, 0xFFFFFFFF, 7); + + GlStateManager.enableDepthTest(); + GlStateManager.depthFunc(GL11.GL_EQUAL); + + rect(texture, left, top, width, height, 0, 0, 1, 1, 0xFFFFFFFF, 7); + + GlStateManager.depthFunc(GL11.GL_LESS); + GlStateManager.disableDepthTest(); + } + + /** + * Draws a rectangle for a Fluid, because fluids are tough. + */ + /* + public static void rect(Fluid fluid, int left, int top, int width, int height, float u1, float v1, float u2, float v2, int color) { + Identifier fluidTexture = fluid.getStill(); + + TextureAtlasSprite tas = Minecraft.getMinecraft().getTextureMapBlocks().getAtlasSprite(fluidTexture.toString()); + Minecraft.getMinecraft().getTextureManager().bindTexture(TextureMap.LOCATION_BLOCKS_TEXTURE); + + if (width <= 0) width = 1; + if (height <= 0) height = 1; + + float a = (color >> 24 & 255) / 255.0F; + float r = (color >> 16 & 255) / 255.0F; + float g = (color >> 8 & 255) / 255.0F; + float b = (color & 255) / 255.0F; + Tessellator tessellator = Tessellator.getInstance(); + BufferBuilder buffer = tessellator.getBufferBuilder(); + GlStateManager.enableBlend(); + //GlStateManager.disableTexture2D(); + GlStateManager.blendFuncSeparate(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA, GlStateManager.SourceFactor.ONE, GlStateManager.DestFactor.ZERO); + GlStateManager.color4f(r, g, b, a); + buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX); //I thought GL_QUADS was deprecated but okay, sure. + buffer.pos(left, top + height, 0.0D).tex(tas.getInterpolatedU(u1), tas.getInterpolatedV(v2)).endVertex(); + buffer.pos(left + width, top + height, 0.0D).tex(tas.getInterpolatedU(u2), tas.getInterpolatedV(v2)).endVertex(); + buffer.pos(left + width, top, 0.0D).tex(tas.getInterpolatedU(u2), tas.getInterpolatedV(v1)).endVertex(); + buffer.pos(left, top, 0.0D).tex(tas.getInterpolatedU(u1), tas.getInterpolatedV(v1)).endVertex(); + tessellator.draw(); + //GlStateManager.enableTexture2D(); + GlStateManager.disableBlend(); + }*/ + + /* + public static void rect(Fluid fluid, int left, int top, int width, int height, int color) { + rect(fluid, left, top, width, height, 0, 0, 16, 16, color); + }*/ + + /** + * Draws a beveled, round rectangle that is substantially similar to default Minecraft UI panels. + */ + public static void drawGuiPanel(int x, int y, int width, int height) { + drawGuiPanel(x, y, width, height, 0xFF555555, 0xFFC6C6C6, 0xFFFFFFFF, 0xFF000000); + } + + public static void drawGuiPanel(int x, int y, int width, int height, int panelColor) { + int shadowColor = multiplyColor(panelColor, 0.50f); + int hilightColor = multiplyColor(panelColor, 1.25f); + + drawGuiPanel(x, y, width, height, shadowColor, panelColor, hilightColor, 0xFF000000); + } + + public static void drawGuiPanel(int x, int y, int width, int height, int shadow, int panel, int hilight, int outline) { + rect(x + 3, y + 3, width - 6, height - 6, panel); //Main panel area + + rect(x + 2, y + 1, width - 4, 2, hilight); //Top hilight + rect(x + 2, y + height - 3, width - 4, 2, shadow); //Bottom shadow + rect(x + 1, y + 2, 2, height - 4, hilight); //Left hilight + rect(x + width - 3, y + 2, 2, height - 4, shadow); //Right shadow + rect(x + width - 3, y + 2, 1, 1, panel); //Topright non-hilight/non-shadow transition pixel + rect(x + 2, y + height - 3, 1, 1, panel); //Bottomleft non-hilight/non-shadow transition pixel + rect(x + 3, y + 3, 1, 1, hilight); //Topleft round hilight pixel + rect(x + width - 4, y + height - 4, 1, 1, shadow); //Bottomright round shadow pixel + + rect(x + 2, y, width - 4, 1, outline); //Top outline + rect(x, y + 2, 1, height - 4, outline); //Left outline + rect(x + width - 1, y + 2, 1, height - 4, outline); //Right outline + rect(x + 2, y + height - 1, width - 4, 1, outline); //Bottom outline + rect(x + 1, y + 1, 1, 1, outline); //Topleft round pixel + rect(x + 1, y + height - 2, 1, 1, outline); //Bottomleft round pixel + rect(x + width - 2, y + 1, 1, 1, outline); //Topright round pixel + rect(x + width - 2, y + height - 2, 1, 1, outline); //Bottomright round pixel + } + + /** + * Draws a default-sized recessed itemslot panel + */ + public static void drawBeveledPanel(int x, int y) { + drawBeveledPanel(x, y, 18, 18, 0xFF373737, 0xFF8b8b8b, 0xFFFFFFFF); + } + + /** + * Draws a default-color recessed itemslot panel of variable size + */ + public static void drawBeveledPanel(int x, int y, int width, int height) { + drawBeveledPanel(x, y, width, height, 0xFF373737, 0xFF8b8b8b, 0xFFFFFFFF); + } + + /** + * Draws a generalized-case beveled panel. Can be inset or outset depending on arguments. + * @param x x coordinate of the topleft corner + * @param y y coordinate of the topleft corner + * @param width width of the panel + * @param height height of the panel + * @param topleft color of the top/left bevel + * @param panel color of the panel area + * @param bottomright color of the bottom/right bevel + */ + public static void drawBeveledPanel(int x, int y, int width, int height, int topleft, int panel, int bottomright) { + rect(x, y, width, height, panel); //Center panel + rect(x, y, width - 1, 1, topleft); //Top shadow + rect(x, y + 1, 1, height - 2, topleft); //Left shadow + rect(x + width - 1, y + 1, 1, height - 1, bottomright); //Right hilight + rect(x + 1, y + height - 1, width - 1, 1, bottomright); //Bottom hilight + } + + public static void drawString(String s, int x, int y, int color) { + MinecraftClient.getInstance().getFontManager().getTextRenderer(MinecraftClient.DEFAULT_TEXT_RENDERER_ID).draw(s, x, y, color); + } + + public static void drawTooltip(String s, int x, int y) { + + } + + public static int colorAtOpacity(int opaque, float opacity) { + if (opacity<0.0f) opacity=0.0f; + if (opacity>1.0f) opacity=1.0f; + + int a = (int)(opacity * 255.0f); + + return (opaque & 0xFFFFFF) | (a << 24); + } + + public static int multiplyColor(int color, float amount) { + int a = color & 0xFF000000; + float r = (color >> 16 & 255) / 255.0F; + float g = (color >> 8 & 255) / 255.0F; + float b = (color & 255) / 255.0F; + + r = Math.min(r*amount, 1.0f); + g = Math.min(g*amount, 1.0f); + b = Math.min(b*amount, 1.0f); + + int ir = (int)(r*255); + int ig = (int)(g*255); + int ib = (int)(b*255); + + return + a | + (ir << 16) | + (ig << 8) | + ib; + } +} diff --git a/src/main/java/io/github/cottonmc/cotton/gui/widget/WBar.java b/src/main/java/io/github/cottonmc/cotton/gui/widget/WBar.java new file mode 100644 index 0000000..e180276 --- /dev/null +++ b/src/main/java/io/github/cottonmc/cotton/gui/widget/WBar.java @@ -0,0 +1,175 @@ +package io.github.cottonmc.cotton.gui.widget; + +import java.util.List; + +import io.github.cottonmc.cotton.gui.CottonScreenController; +import io.github.cottonmc.cotton.gui.client.ScreenDrawing; +import net.fabricmc.api.EnvType; +import net.fabricmc.api.Environment; +import net.minecraft.container.PropertyDelegate; +import net.minecraft.text.Text; +import net.minecraft.text.TranslatableText; +import net.minecraft.util.Identifier; + +public class WBar extends WWidget { + protected final Identifier bg; + protected final Identifier bar; + protected final int field; + protected final int max; + protected int maxValue; + protected PropertyDelegate properties; + protected final Direction direction; + protected String tooltipLabel; + protected Text tooltipTextComponent; + + public WBar(Identifier bg, Identifier bar, int field, int maxfield) { + this(bg, bar, field, maxfield, Direction.UP); + } + + public WBar(Identifier bg, Identifier bar, int field, int maxfield, Direction dir) { + this.bg = bg; + this.bar = bar; + this.field = field; + this.max = maxfield; + this.maxValue = 0; + this.direction = dir; + } + + /** + * Adds a tooltip to the WBar. + * + * Formatting Guide: The tooltip label is passed into String.Format and can recieve two integers + * (%d) - the first is the current value of the bar's focused field, and the second is the + * bar's focused maximum. + * @param label String to render on the tooltip. + * @return WBar with tooltip enabled and set. + */ + public WBar withTooltip(String label) { + this.tooltipLabel = label; + return this; + } + + + + public WBar withTooltip(Text label) { + this.tooltipTextComponent = label; + return this; + } + + @Override + public boolean canResize() { + return true; + } + + @Environment(EnvType.CLIENT) + @Override + public void paintBackground(int x, int y) { + if (bg!=null) { + ScreenDrawing.rect(bg, x, y, getWidth(), getHeight(), 0xFFFFFFFF); + } else { + ScreenDrawing.rect(x, y, getWidth(), getHeight(), ScreenDrawing.colorAtOpacity(0x000000, 0.25f)); + } + + float percent = properties.get(field) / (float) properties.get(max); + if (percent < 0) percent = 0f; + if (percent > 1) percent = 1f; + + int barMax = getWidth(); + if (direction == Direction.DOWN || direction == Direction.UP) barMax = getHeight(); + percent = ((int) (percent * barMax)) / (float) barMax; //Quantize to bar size + + int barSize = (int) (barMax * percent); + if (barSize <= 0) return; + + switch(direction) { //anonymous blocks in this switch statement are to sandbox variables + case UP: { + int left = x; + int top = y + getHeight(); + top -= barSize; + if (bar!=null) { + ScreenDrawing.rect(bar, left, top, getWidth(), barSize, 0, 1 - percent, 1, 1, 0xFFFFFFFF); + } else { + ScreenDrawing.rect(left, top, getWidth(), barSize, ScreenDrawing.colorAtOpacity(0xFFFFFF, 0.5f)); + } + break; + } + case RIGHT: { + if (bar!=null) { + ScreenDrawing.rect(bar, x, y, barSize, getHeight(), 0, 0, percent, 1, 0xFFFFFFFF); + } else { + ScreenDrawing.rect(x, y, barSize, getHeight(), ScreenDrawing.colorAtOpacity(0xFFFFFF, 0.5f)); + } + break; + } + case DOWN: { + if (bar!=null) { + ScreenDrawing.rect(bar, x, y, getWidth(), barSize, 0, 0, 1, percent, 0xFFFFFFFF); + } else { + ScreenDrawing.rect(x, y, getWidth(), barSize, ScreenDrawing.colorAtOpacity(0xFFFFFF, 0.5f)); + } + break; + } + case LEFT: { + int left = x + getWidth(); + int top = y; + left -= barSize; + if (bar!=null) { + ScreenDrawing.rect(bar, left, top, barSize, getHeight(), 1 - percent, 0, 1, 1, 0xFFFFFFFF); + } else { + ScreenDrawing.rect(left, top, barSize, getHeight(), ScreenDrawing.colorAtOpacity(0xFFFFFF, 0.5f)); + } + break; + } + } + } + + @Override + public void addInformation(List<String> information) { + if (tooltipLabel!=null) { + int value = (field>=0) ? properties.get(field) : 0; + int valMax = (max>=0) ? properties.get(max) : maxValue; + String formatted = tooltipLabel; + try { + formatted = new TranslatableText(tooltipLabel, Integer.valueOf(value), Integer.valueOf(valMax)).asFormattedString(); + } catch (Throwable t) { + formatted = t.getLocalizedMessage(); + } //Fallback to raw tooltipLabel + information.add(formatted); + } + if (tooltipTextComponent!=null) { + try { + information.add(tooltipTextComponent.asFormattedString()); + } catch (Throwable t) { + information.add(t.getLocalizedMessage()); + } + } + } + + @Override + public void createPeers(CottonScreenController c) { + if (properties==null) properties = c.getPropertyDelegate(); + } + + /** + * Creates a WBar that has a constant maximum-value instead of getting the maximum from a field. + * @param bg the background image to use for the bar + * @param bar the foreground image that represents the filled bar + * @param properties the PropertyDelegate to pull bar values from + * @param field the field index for bar values + * @param maxValue the constant maximum value for the bar + * @param dir the direction the bar should grow towards + * @return a new WBar with a constant maximum value. + */ + public static WBar withConstantMaximum(Identifier bg, Identifier bar, int field, int maxValue, Direction dir) { + WBar result = new WBar(bg, bar, field, -1, dir); + result.maxValue = maxValue; + return result; + } + + public static enum Direction { + UP, + RIGHT, + DOWN, + LEFT; + } +}
\ No newline at end of file diff --git a/src/main/java/io/github/cottonmc/cotton/gui/widget/WGridPanel.java b/src/main/java/io/github/cottonmc/cotton/gui/widget/WGridPanel.java new file mode 100644 index 0000000..a3fcf94 --- /dev/null +++ b/src/main/java/io/github/cottonmc/cotton/gui/widget/WGridPanel.java @@ -0,0 +1,27 @@ +package io.github.cottonmc.cotton.gui.widget; + +public class WGridPanel extends WPanel { + public void add(WWidget w, int x, int y) { + children.add(w); + w.parent = this; + w.setLocation(x * 18, y * 18); + if (w.canResize()) { + w.setSize(18, 18); + } + + expandToFit(w); + //valid = false; + } + + public void add(WWidget w, int x, int y, int width, int height) { + children.add(w); + w.parent = this; + w.setLocation(x * 18, y * 18); + if (w.canResize()) { + w.setSize(width * 18, height * 18); + } + + expandToFit(w); + //valid = false; + } +}
\ No newline at end of file diff --git a/src/main/java/io/github/cottonmc/cotton/gui/widget/WItemSlot.java b/src/main/java/io/github/cottonmc/cotton/gui/widget/WItemSlot.java new file mode 100644 index 0000000..0e6b981 --- /dev/null +++ b/src/main/java/io/github/cottonmc/cotton/gui/widget/WItemSlot.java @@ -0,0 +1,147 @@ +package io.github.cottonmc.cotton.gui.widget; + +import java.util.List; + +import com.google.common.collect.Lists; + +import io.github.cottonmc.cotton.gui.CottonScreenController; +import io.github.cottonmc.cotton.gui.ValidatedSlot; +import io.github.cottonmc.cotton.gui.client.BackgroundPainter; +import io.github.cottonmc.cotton.gui.client.ScreenDrawing; +import net.fabricmc.api.EnvType; +import net.fabricmc.api.Environment; +import net.minecraft.container.Slot; +import net.minecraft.inventory.Inventory; + +public class WItemSlot extends WWidget { + private final List<Slot> peers = Lists.newArrayList(); + private BackgroundPainter backgroundPainter; + private Inventory inventory; + //private CottonScreenController container; + private int startIndex = 0; + private int slotsWide = 1; + private int slotsHigh = 1; + private boolean big = false; + //private boolean ltr = true; + private float opacity = 0.2f; + + public WItemSlot(Inventory inventory, int startIndex, int slotsWide, int slotsHigh, boolean big, boolean ltr) { + this.inventory = inventory; + this.startIndex = startIndex; + this.slotsWide = slotsWide; + this.slotsHigh = slotsHigh; + this.big = big; + //this.ltr = ltr; + } + + private WItemSlot() {} + + public static WItemSlot of(Inventory inventory, int index) { + WItemSlot w = new WItemSlot(); + w.inventory = inventory; + w.startIndex = index; + + return w; + } + + public static WItemSlot of(Inventory inventory, int startIndex, int slotsWide, int slotsHigh) { + WItemSlot w = new WItemSlot(); + w.inventory = inventory; + w.startIndex = startIndex; + w.slotsWide = slotsWide; + w.slotsHigh = slotsHigh; + + return w; + } + + public static WItemSlot outputOf(Inventory inventory, int index) { + WItemSlot w = new WItemSlot(); + w.inventory = inventory; + w.startIndex = index; + w.big = true; + + return w; + } + + public static WItemSlot ofPlayerStorage(Inventory inventory) { + WItemSlot w = new WItemSlot(); + w.inventory = inventory; + w.startIndex = 9; + w.slotsWide = 9; + w.slotsHigh = 3; + //w.ltr = false; + + return w; + } + + @Override + public int getWidth() { + return slotsWide * 18; + } + + @Override + public int getHeight() { + return slotsHigh * 18; + } + + @Override + public void createPeers(CottonScreenController c) { + //this.container = c; + peers.clear(); + int index = startIndex; + + /*if (ltr) { + for (int x = 0; x < slotsWide; x++) { + for (int y = 0; y < slotsHigh; y++) { + ValidatedSlot slot = new ValidatedSlot(inventory, index, this.getAbsoluteX() + (x * 18), this.getAbsoluteY() + (y * 18)); + peers.add(slot); + c.addSlotPeer(slot); + index++; + } + } + } else {*/ + for (int y = 0; y < slotsHigh; y++) { + for (int x = 0; x < slotsWide; x++) { + ValidatedSlot slot = new ValidatedSlot(inventory, index, this.getAbsoluteX() + (x * 18), this.getAbsoluteY() + (y * 18)); + peers.add(slot); + c.addSlotPeer(slot); + index++; + } + } + //} + } + + @Environment(EnvType.CLIENT) + public void setBackgroundPainter(BackgroundPainter painter) { + this.backgroundPainter = painter; + } + + @Environment(EnvType.CLIENT) + @Override + public void paintBackground(int x, int y) { + if (backgroundPainter!=null) { + backgroundPainter.paintBackground(x, y, this); + } else { + for (int xi = 0; xi < slotsWide; xi++) { + for (int yi = 0; yi < slotsHigh; yi++) { + //int lo = ScreenDrawing.colorAtOpacity(0x000000, 0.72f); + //int bg = ScreenDrawing.colorAtOpacity(0x000000, 0.29f); + //int hi = ScreenDrawing.colorAtOpacity(0xFFFFFF, 1.0f); + //if (container!=null) { + int lo = ScreenDrawing.colorAtOpacity(0x000000, opacity); + int bg = ScreenDrawing.colorAtOpacity(0x000000, opacity/2.4f); + int hi = ScreenDrawing.colorAtOpacity(0xFFFFFF, opacity); + //} + + if (big) { + ScreenDrawing.drawBeveledPanel((xi * 18) + x - 4, (yi * 18) + y - 4, 24, 24, + lo, bg, hi); + } else { + ScreenDrawing.drawBeveledPanel((xi * 18) + x - 1, (yi * 18) + y - 1, 18, 18, + lo, bg, hi); + } + } + } + } + } +}
\ No newline at end of file diff --git a/src/main/java/io/github/cottonmc/cotton/gui/widget/WLabel.java b/src/main/java/io/github/cottonmc/cotton/gui/widget/WLabel.java new file mode 100644 index 0000000..fb034b8 --- /dev/null +++ b/src/main/java/io/github/cottonmc/cotton/gui/widget/WLabel.java @@ -0,0 +1,45 @@ +package io.github.cottonmc.cotton.gui.widget; + +import io.github.cottonmc.cotton.gui.client.ScreenDrawing; +import net.minecraft.text.LiteralText; +import net.minecraft.text.Text; +public class WLabel extends WWidget { + protected final Text text; + protected final int color; + + public static final int DEFAULT_TEXT_COLOR = 0x404040; + + public WLabel(String text, int color) { + this(new LiteralText(text), color); + } + + public WLabel(Text text, int color) { + this.text = text; + this.color = color; + } + + public WLabel(String text) { + this(text, DEFAULT_TEXT_COLOR); + } + + @Override + public void paintBackground(int x, int y) { + String translated = text.asFormattedString(); + ScreenDrawing.drawString(translated, x, y, color); + } + + @Override + public boolean canResize() { + return false; + } + + @Override + public int getWidth() { + return 8; //We don't actually clip to our boundaries so return a dummy value. + } + + @Override + public int getHeight() { + return 8; + } +}
\ No newline at end of file diff --git a/src/main/java/io/github/cottonmc/cotton/gui/widget/WPanel.java b/src/main/java/io/github/cottonmc/cotton/gui/widget/WPanel.java new file mode 100644 index 0000000..1fa0510 --- /dev/null +++ b/src/main/java/io/github/cottonmc/cotton/gui/widget/WPanel.java @@ -0,0 +1,141 @@ +package io.github.cottonmc.cotton.gui.widget; + +import java.util.List; + +import com.google.common.collect.Lists; + +import io.github.cottonmc.cotton.gui.CottonScreenController; +import io.github.cottonmc.cotton.gui.client.BackgroundPainter; +import net.fabricmc.api.EnvType; +import net.fabricmc.api.Environment; + +public class WPanel extends WWidget { + protected final List<WWidget> children = Lists.newArrayList(); + @Environment(EnvType.CLIENT) + private BackgroundPainter backgroundPainter = null; + + @Override + public void createPeers(CottonScreenController c) { + //System.out.println("Creating peers - before: "+c.slotList.size()); + for(WWidget child : children) { + child.createPeers(c); + } + //System.out.println("Peers created - after: "+c.slotList.size()); + } + + public void remove(WWidget w) { + children.remove(w); + } + + @Override + public boolean canResize() { + return true; + } + + @Environment(EnvType.CLIENT) + public WPanel setBackgroundPainter(BackgroundPainter painter) { + this.backgroundPainter = painter; + return this; + } + + /** + * Uses this Panel's layout rules to reposition and resize components to fit nicely in the panel. + */ + public void layout() { + for(WWidget child : children) { + if (child instanceof WPanel) ((WPanel) child).layout(); + expandToFit(child); + } + } + + protected void expandToFit(WWidget w) { + int pushRight = w.getX()+w.getWidth(); + int pushDown = w.getY()+w.getHeight(); + this.setSize(Math.max(this.getWidth(), pushRight), Math.max(this.getHeight(), pushDown)); + } + + @Override + public WWidget onMouseUp(int x, int y, int button) { + if (children.isEmpty()) return super.onMouseUp(x, y, button); + for(int i=children.size()-1; i>=0; i--) { //Backwards so topmost widgets get priority + WWidget child = children.get(i); + if ( x>=child.getX() && + y>=child.getY() && + x<child.getX()+child.getWidth() && + y<child.getY()+child.getHeight()) { + return child.onMouseUp(x-child.getX(), y-child.getY(), button); + } + } + return super.onMouseUp(x, y, button); + } + + @Override + public WWidget onMouseDown(int x, int y, int button) { + if (children.isEmpty()) return super.onMouseDown(x, y, button); + for(int i=children.size()-1; i>=0; i--) { //Backwards so topmost widgets get priority + WWidget child = children.get(i); + if ( x>=child.getX() && + y>=child.getY() && + x<child.getX()+child.getWidth() && + y<child.getY()+child.getHeight()) { + return child.onMouseDown(x-child.getX(), y-child.getY(), button); + } + } + return super.onMouseDown(x, y, button); + } + + @Override + public void onMouseDrag(int x, int y, int button) { + if (children.isEmpty()) return; + for(int i=children.size()-1; i>=0; i--) { //Backwards so topmost widgets get priority + WWidget child = children.get(i); + if ( x>=child.getX() && + y>=child.getY() && + x<child.getX()+child.getWidth() && + y<child.getY()+child.getHeight()) { + child.onMouseDrag(x-child.getX(), y-child.getY(), button); + return; //Only send the message to the first valid recipient + } + } + super.onMouseDrag(x, y, button); + } + + @Override + public void onClick(int x, int y, int button) { + if (children.isEmpty()) return; + for(int i=children.size()-1; i>=0; i--) { //Backwards so topmost widgets get priority + WWidget child = children.get(i); + if ( x>=child.getX() && + y>=child.getY() && + x<child.getX()+child.getWidth() && + y<child.getY()+child.getHeight()) { + child.onClick(x-child.getX(), y-child.getY(), button); + return; //Only send the message to the first valid recipient + } + } + } + + @Override + public void validate(CottonScreenController c) { + layout(); + createPeers(c); + } + + @Environment(EnvType.CLIENT) + @Override + public void paintBackground(int x, int y) { + if (backgroundPainter!=null) backgroundPainter.paintBackground(x, y, this); + + for(WWidget child : children) { + child.paintBackground(x + child.getX(), y + child.getY()); + } + } + + @Environment(EnvType.CLIENT) + @Override + public void paintForeground(int x, int y, int mouseX, int mouseY) { + for(WWidget child : children) { + child.paintForeground(x + child.getX(), y + child.getY(), mouseX, mouseY); + } + } +} diff --git a/src/main/java/io/github/cottonmc/cotton/gui/widget/WPlainPanel.java b/src/main/java/io/github/cottonmc/cotton/gui/widget/WPlainPanel.java new file mode 100644 index 0000000..310ae69 --- /dev/null +++ b/src/main/java/io/github/cottonmc/cotton/gui/widget/WPlainPanel.java @@ -0,0 +1,27 @@ +package io.github.cottonmc.cotton.gui.widget; + +public class WPlainPanel extends WPanel { + public void add(WWidget w, int x, int y) { + children.add(w); + w.parent = this; + w.setLocation(x, y); + if (w.canResize()) { + w.setSize(18, 18); + } + + expandToFit(w); + //valid = false; + } + + public void add(WWidget w, int x, int y, int width, int height) { + children.add(w); + w.parent = this; + w.setLocation(x, y); + if (w.canResize()) { + w.setSize(width, height); + } + + expandToFit(w); + //valid = false; + } +}
\ No newline at end of file diff --git a/src/main/java/io/github/cottonmc/cotton/gui/widget/WWidget.java b/src/main/java/io/github/cottonmc/cotton/gui/widget/WWidget.java new file mode 100644 index 0000000..f1eb1d6 --- /dev/null +++ b/src/main/java/io/github/cottonmc/cotton/gui/widget/WWidget.java @@ -0,0 +1,210 @@ +package io.github.cottonmc.cotton.gui.widget; + +import java.util.ArrayList; +import java.util.List; + +import io.github.cottonmc.cotton.gui.CottonScreenController; +import net.fabricmc.api.EnvType; +import net.fabricmc.api.Environment; +import net.minecraft.client.MinecraftClient; +import net.minecraft.client.gui.screen.Screen; + +public class WWidget { + protected WPanel parent; + private int x = 0; + private int y = 0; + private int width = 18; + private int height = 18; + //private boolean renderTooltip; + + public void setLocation(int x, int y) { + this.x = x; + this.y = y; + } + + public void setSize(int x, int y) { + this.width = x; + this.height = y; + } + + public int getX() { + return x; + } + + public int getY() { + return y; + } + + public int getAbsoluteX() { + if (parent==null) { + return getX(); + } else { + return getX() + parent.getAbsoluteX(); + } + } + + public int getAbsoluteY() { + if (parent==null) { + return getY(); + } else { + return getY() + parent.getAbsoluteY(); + } + } + + public int getWidth() { + return width; + } + + public int getHeight() { + return height; + } + + public boolean canResize() { + return false; + } + + //public void setParent(WPanel parent) { + // this.parent = parent; + //} + + //public boolean getRenderTooltip() { + // return renderTooltip; + //} + + //public void setRenderTooltip(boolean renderTooltip) { + // this.renderTooltip = renderTooltip; + //} + + /** + * Draw this Widget at the specified coordinates. The coordinates provided are the top-level device coordinates of + * this widget's topleft corner, so don't translate by the widget X/Y! That's already been done. Your "valid" + * drawing space is from (x, y) to (x + width - 1, y + height - 1) inclusive. However, no scissor or depth masking + * is done, so please take care to respect your boundaries. + * @param x The X coordinate of the leftmost pixels of this widget in device (opengl) coordinates + * @param y The Y coordinate of the topmost pixels of this widget in device (opengl) coordinates + */ + public void paint(int x, int y) { + + } + + /** + * Notifies this widget that the mouse has been pressed while inside its bounds + * @param x The X coordinate of the event, in widget-space (0 is the left edge of this widget) + * @param y The Y coordinate of the event, in widget-space (0 is the top edge of this widget) + * @param button The mouse button that was used. Button numbering is consistent with LWJGL Mouse (0=left, 1=right, 2=mousewheel click) + */ + public WWidget onMouseDown(int x, int y, int button) { + return this; + } + + /** + * Notifies this widget that the mouse has been moved while pressed and inside its bounds + * @param x The X coordinate of the event, in widget-space (0 is the left edge of this widget) + * @param y The Y coordinate of the event, in widget-space (0 is the top edge of this widget) + * @param button The mouse button that was used. Button numbering is consistent with LWJGL Mouse (0=left, 1=right, 2=mousewheel click) + */ + public void onMouseDrag(int x, int y, int button) { + } + + /** + * Notifies this widget that the mouse has been released while inside its bounds + * @param x The X coordinate of the event, in widget-space (0 is the left edge of this widget) + * @param y The Y coordinate of the event, in widget-space (0 is the top edge of this widget) + * @param button The mouse button that was used. Button numbering is consistent with LWJGL Mouse (0=left, 1=right, 2=mousewheel click) + */ + public WWidget onMouseUp(int x, int y, int button) { + return this; + } + + /** + * Notifies this widget that the mouse has been pressed and released, both while inside its bounds. + * @param x The X coordinate of the event, in widget-space (0 is the left edge of this widget) + * @param y The Y coordinate of the event, in widget-space (0 is the top edge of this widget) + * @param button The mouse button that was used. Button numbering is consistent with LWJGL Mouse (0=left, 1=right, 2=mousewheel click) + */ + public void onClick(int x, int y, int button) { + } + + /** + * Creates "heavyweight" component peers + * @param c the top-level Container that will hold the peers + */ + public void createPeers(CottonScreenController c) { + } + + @Environment(EnvType.CLIENT) + public void paintBackground(int x, int y) { + } + + @Environment(EnvType.CLIENT) + public void paintForeground(int x, int y, int mouseX, int mouseY) { + if (mouseX >= x && mouseX < x+getWidth() && mouseY >= y && mouseY < y+getHeight()) { + renderTooltip(mouseX-x+getX(),mouseY-y+getY() ); + } + } + + /** + * Internal method to conditionally render tooltip data. This requires an overriden {@link #addInformation(List) + * addInformation} method to insert data into the tooltip - without this, the method returns early, because no work + * is needing to be done on an empty list. + * @param tX The adjusted X coordinate at which to render the tooltip. + * @param tY The adjusted X coordinate at which to render the tooltip. + */ + @Environment(EnvType.CLIENT) + protected void renderTooltip(int tX, int tY) { + List<String> info = new ArrayList<>(); + addInformation(info); + + if (info.size() == 0) + return; + + Screen screen = MinecraftClient.getInstance().currentScreen; + screen.renderTooltip(info, tX, tY); + /* + MinecraftClient mc = MinecraftClient.getInstance(); + int width = mc.window.getScaledWidth(); + int height = mc.window.getScaledHeight(); + //TODO: Hook into or copy Screen::drawStackTooltip or Screen::drawTooltip + TextRenderer renderer = mc.getFontManager().getTextRenderer(MinecraftClient.DEFAULT_TEXT_RENDERER_ID); + //Get width of the panel + int maxWidth = 0; + for(String s : info) { + maxWidth = Math.max(maxWidth, renderer.getStringWidth(s)); + } + //TODO: Draw background panel + + //Draw strings + for(int i=0; i<info.size(); i++) { + //renderer.draw(info, tX, tY, renderer.getStringWidth(str)) + //GuiUtils.drawHoveringText(info, tX, tY, width, height, -1, mc.fontRenderer); + }*/ + } + + //public boolean isValid() { + // return valid; + //} + + /** + * Creates component peers, lays out children, and initializes animation data for this Widget and all its children. + * The host container must clear any heavyweight peers from its records before this method is called. + */ + public void validate(CottonScreenController host) { + //valid = true; + } + + /** + * Marks this Widget as having dirty state; component peers may need to be recreated, children adapted to a new size, + * and animation data reset. + */ + //public void invalidate() { + // valid = false; + //} + + /** + * Adds information to this widget's tooltip. This requires a call to {@link #setRenderTooltip(boolean) + * setRenderTooltip} (obviously passing in {@code true}), in order to enable the rendering of your tooltip. + * @param information List containing all previous tooltip data. + */ + public void addInformation(List<String> information) { +} +} diff --git a/src/main/java/net/fabricmc/example/ExampleMod.java b/src/main/java/net/fabricmc/example/ExampleMod.java deleted file mode 100644 index e5ed082..0000000 --- a/src/main/java/net/fabricmc/example/ExampleMod.java +++ /dev/null @@ -1,14 +0,0 @@ -package net.fabricmc.example; - -import net.fabricmc.api.ModInitializer; - -public class ExampleMod implements ModInitializer { - @Override - public void onInitialize() { - // This code runs as soon as Minecraft is in a mod-load-ready state. - // However, some things (like resources) may still be uninitialized. - // Proceed with mild caution. - - System.out.println("Hello Fabric world!"); - } -} diff --git a/src/main/java/net/fabricmc/example/mixin/ExampleMixin.java b/src/main/java/net/fabricmc/example/mixin/ExampleMixin.java deleted file mode 100644 index 0fc8f68..0000000 --- a/src/main/java/net/fabricmc/example/mixin/ExampleMixin.java +++ /dev/null @@ -1,15 +0,0 @@ -package net.fabricmc.example.mixin; - -import net.minecraft.client.MinecraftClient; -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(MinecraftClient.class) -public class ExampleMixin { - @Inject(at = @At("HEAD"), method = "init()V") - private void init(CallbackInfo info) { - System.out.println("This line is printed by an example mod mixin!"); - } -} diff --git a/src/main/resources/assets/modid/icon.png b/src/main/resources/assets/libgui/icon.png Binary files differindex 047b91f..047b91f 100644 --- a/src/main/resources/assets/modid/icon.png +++ b/src/main/resources/assets/libgui/icon.png diff --git a/src/main/resources/fabric.mod.json b/src/main/resources/fabric.mod.json index f37c644..d803a84 100644 --- a/src/main/resources/fabric.mod.json +++ b/src/main/resources/fabric.mod.json @@ -1,31 +1,21 @@ { "schemaVersion": 1, - "id": "modid", + "id": "libgui", "version": "${version}", - "name": "Example Mod", - "description": "This is an example description! Tell everyone what your mod is about!", + "name": "LibGui", + "description": "Easy grid-based GUIs for Fabric", "authors": [ - "Me!" + "Falkreon" ], "contact": { - "homepage": "https://fabricmc.net/", - "sources": "https://github.com/FabricMC/fabric-example-mod" + "sources": "https://github.com/CottonMC/LibGUI" }, - "license": "CC0-1.0", - "icon": "assets/modid/icon.png", + "license": "MIT", + "icon": "assets/libgui/icon.png", "environment": "*", - "entrypoints": { - "main": [ - "net.fabricmc.example.ExampleMod" - ] - }, - "mixins": [ - "modid.mixins.json" - ], - "depends": { "fabricloader": ">=0.4.0", "fabric": "*" diff --git a/src/main/resources/modid.mixins.json b/src/main/resources/modid.mixins.json deleted file mode 100644 index e243f0a..0000000 --- a/src/main/resources/modid.mixins.json +++ /dev/null @@ -1,13 +0,0 @@ -{ - "required": true, - "package": "net.fabricmc.example.mixin", - "compatibilityLevel": "JAVA_8", - "mixins": [ - ], - "client": [ - "ExampleMixin" - ], - "injectors": { - "defaultRequire": 1 - } -} |
