Add in most EIO lib code, still some work to be done with widgets

This commit is contained in:
tterrag1098 committed 2015-04-29 21:46:25 -04:00
1 parent 1805db39ad
commit d2746001ce
79 files changed
+10632 -69

No files matched your search

+11
View File
@@ -0,0 +1,11 @@
package cofh.api;
public class CoFHAPIProps {
private CoFHAPIProps() {
}
public static final String VERSION = "1.7.10R1.0.3";
}
+9
View File
@@ -0,0 +1,9 @@
/**
* (C) 2014 Team CoFH / CoFH / Cult of the Full Hub
* http://www.teamcofh.com
*/
@API(apiVersion = CoFHAPIProps.VERSION, owner = "CoFHLib", provides = "CoFHAPI")
package cofh.api;
import cpw.mods.fml.common.API;
@@ -0,0 +1,13 @@
package cofh.api.transport;
interface IEnderAttuned {
public String getChannelString();
public int getFrequency();
public boolean setFrequency(int frequency);
public boolean clearFrequency();
}
@@ -0,0 +1,35 @@
package cofh.api.transport;
/**
* This interface is implemented on Ender Attuned objects which can receive Energy (Redstone Flux).
*
* @author King Lemming
*
*/
public interface IEnderEnergyHandler extends IEnderAttuned {
/**
* Return whether or not the Ender Attuned object can currently send energy (Redstone Flux).
*/
boolean canSendEnergy();
/**
* This should be checked to see if the Ender Attuned object can currently receive energy (Redstone Flux).
*
* Note: In practice, this can (and should) be used to ensure that something does not send to itself.
*/
boolean canReceiveEnergy();
/**
* This tells the Ender Attuned object to receive energy. This returns the amount remaining, *not* the amount received - a return of 0 means that all energy
* was received!
*
* @param energy
* Amount of energy to be received.
* @param simulate
* If TRUE, the result will only be simulated.
* @return Amount of energy that is remaining (or would be remaining, if simulated).
*/
int receiveEnergy(int energy, boolean simulate);
}
@@ -0,0 +1,37 @@
package cofh.api.transport;
import net.minecraftforge.fluids.FluidStack;
/**
* This interface is implemented on Ender Attuned objects which can receive Fluid.
*
* @author King Lemming
*
*/
public interface IEnderFluidHandler extends IEnderAttuned {
/**
* Return whether or not the Ender Attuned object can currently send FluidStacks.
*/
boolean canSendFluid();
/**
* This should be checked to see if the Ender Attuned object can currently receive a FluidStack.
*
* Note: In practice, this can (and should) be used to ensure that something does not send to itself.
*/
boolean canReceiveFluid();
/**
* This tells the Ender Attuned object to receive a FluidStack. This returns what remains of the original stack, *not* the amount received - a null return
* means that the entire stack was received!
*
* @param fluid
* FluidStack to be received.
* @param simulate
* If TRUE, the result will only be simulated.
* @return FluidStack representing how much fluid is remaining (or would be remaining, if simulated).
*/
FluidStack receiveFluid(FluidStack fluid, boolean simulate);
}
@@ -0,0 +1,38 @@
package cofh.api.transport;
import net.minecraft.item.ItemStack;
/**
* This interface is implemented on Ender Attuned objects which can receive Items.
*
* @author King Lemming
*
*/
public interface IEnderItemHandler extends IEnderAttuned {
/**
* Return whether or not the Ender Attuned object can currently send ItemStacks.
*/
boolean canSendItems();
/**
* This should be checked to see if the Ender Attuned object can currently receive an ItemStack.
*
* Note: In practice, this can (and should) be used to ensure that something does not send to itself.
*/
boolean canReceiveItems();
/**
* This tells the Ender Attuned object to receive an ItemStack. This returns what remains of the original stack, *not* the amount received - a null return
* means that the entire stack was received!
*
* This function does not support simulation because Inventory manipulation in Minecraft is an absolute mess and it would be a computational liability to do
* so.
*
* @param item
* ItemStack to be received.
* @return An ItemStack representing how much is remaining.
*/
ItemStack receiveItem(ItemStack item);
}
@@ -0,0 +1,26 @@
package cofh.api.transport;
import net.minecraft.item.ItemStack;
import net.minecraftforge.common.util.ForgeDirection;
/**
* This interface is implemented on ItemDucts. Use it to attempt to eject items into an entry point.
*
* @author Zeldo Kavira, King Lemming
*
*/
public interface IItemDuct {
/**
* Insert an ItemStack into the IItemDuct. Will only accept items if there is a valid destination. This returns what is remaining of the original stack - a
* null return means that the entire stack was accepted/routed!
*
* @param from
* Orientation the item is inserted from.
* @param item
* ItemStack to be inserted. The size of this stack corresponds to the maximum amount to insert.
* @return An ItemStack representing how much is remaining after the item was inserted into the Duct.
*/
public ItemStack insertItem(ForgeDirection from, ItemStack item);
}
@@ -0,0 +1,287 @@
package cofh.api.transport;
import gnu.trove.map.hash.THashMap;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import net.minecraftforge.common.config.Configuration;
public final class RegistryEnderAttuned {
public static Map<String, Map<Integer, List<IEnderItemHandler>>> inputItem = new THashMap<String, Map<Integer, List<IEnderItemHandler>>>();
public static Map<String, Map<Integer, List<IEnderFluidHandler>>> inputFluid = new THashMap<String, Map<Integer, List<IEnderFluidHandler>>>();
public static Map<String, Map<Integer, List<IEnderEnergyHandler>>> inputEnergy = new THashMap<String, Map<Integer, List<IEnderEnergyHandler>>>();
public static Map<String, Map<Integer, List<IEnderItemHandler>>> outputItem = new THashMap<String, Map<Integer, List<IEnderItemHandler>>>();
public static Map<String, Map<Integer, List<IEnderFluidHandler>>> outputFluid = new THashMap<String, Map<Integer, List<IEnderFluidHandler>>>();
public static Map<String, Map<Integer, List<IEnderEnergyHandler>>> outputEnergy = new THashMap<String, Map<Integer, List<IEnderEnergyHandler>>>();
public static Configuration linkConf;
public static Map<String, String> clientFrequencyNames = new LinkedHashMap<String, String>();
public static Map<String, String> clientFrequencyNamesReversed = new LinkedHashMap<String, String>();
public static void clear() {
inputItem.clear();
inputFluid.clear();
inputEnergy.clear();
outputItem.clear();
outputFluid.clear();
outputEnergy.clear();
}
public static List<IEnderItemHandler> getLinkedItemInputs(IEnderItemHandler theAttuned) {
if (inputItem.get(theAttuned.getChannelString()) == null) {
return null;
}
return inputItem.get(theAttuned.getChannelString()).get(theAttuned.getFrequency());
}
public static List<IEnderItemHandler> getLinkedItemOutputs(IEnderItemHandler theAttuned) {
if (outputItem.get(theAttuned.getChannelString()) == null) {
return null;
}
return outputItem.get(theAttuned.getChannelString()).get(theAttuned.getFrequency());
}
public static List<IEnderFluidHandler> getLinkedFluidInputs(IEnderFluidHandler theAttuned) {
if (inputFluid.get(theAttuned.getChannelString()) == null) {
return null;
}
return inputFluid.get(theAttuned.getChannelString()).get(theAttuned.getFrequency());
}
public static List<IEnderFluidHandler> getLinkedFluidOutputs(IEnderFluidHandler theAttuned) {
if (outputFluid.get(theAttuned.getChannelString()) == null) {
return null;
}
return outputFluid.get(theAttuned.getChannelString()).get(theAttuned.getFrequency());
}
public static List<IEnderEnergyHandler> getLinkedEnergyInputs(IEnderEnergyHandler theAttuned) {
if (inputEnergy.get(theAttuned.getChannelString()) == null) {
return null;
}
return inputEnergy.get(theAttuned.getChannelString()).get(theAttuned.getFrequency());
}
public static List<IEnderEnergyHandler> getLinkedEnergyOutputs(IEnderEnergyHandler theAttuned) {
if (outputEnergy.get(theAttuned.getChannelString()) == null) {
return null;
}
return outputEnergy.get(theAttuned.getChannelString()).get(theAttuned.getFrequency());
}
/* HELPER FUNCTIONS */
public static void addItemHandler(IEnderItemHandler theAttuned) {
if (theAttuned.canSendItems()) {
if (inputItem.get(theAttuned.getChannelString()) == null) {
inputItem.put(theAttuned.getChannelString(), new HashMap<Integer, List<IEnderItemHandler>>());
}
if (inputItem.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()) == null) {
inputItem.get(theAttuned.getChannelString()).put(theAttuned.getFrequency(), new ArrayList<IEnderItemHandler>());
}
if (!inputItem.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()).contains(theAttuned)) {
inputItem.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()).add(theAttuned);
}
}
if (theAttuned.canReceiveItems()) {
if (outputItem.get(theAttuned.getChannelString()) == null) {
outputItem.put(theAttuned.getChannelString(), new HashMap<Integer, List<IEnderItemHandler>>());
}
if (outputItem.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()) == null) {
outputItem.get(theAttuned.getChannelString()).put(theAttuned.getFrequency(), new ArrayList<IEnderItemHandler>());
}
if (!outputItem.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()).contains(theAttuned)) {
outputItem.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()).add(theAttuned);
}
}
}
public static void addFluidHandler(IEnderFluidHandler theAttuned) {
if (theAttuned.canSendFluid()) {
if (inputFluid.get(theAttuned.getChannelString()) == null) {
inputFluid.put(theAttuned.getChannelString(), new HashMap<Integer, List<IEnderFluidHandler>>());
}
if (inputFluid.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()) == null) {
inputFluid.get(theAttuned.getChannelString()).put(theAttuned.getFrequency(), new ArrayList<IEnderFluidHandler>());
}
if (!inputFluid.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()).contains(theAttuned)) {
inputFluid.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()).add(theAttuned);
}
}
if (theAttuned.canReceiveFluid()) {
if (outputFluid.get(theAttuned.getChannelString()) == null) {
outputFluid.put(theAttuned.getChannelString(), new HashMap<Integer, List<IEnderFluidHandler>>());
}
if (outputFluid.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()) == null) {
outputFluid.get(theAttuned.getChannelString()).put(theAttuned.getFrequency(), new ArrayList<IEnderFluidHandler>());
}
if (!outputFluid.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()).contains(theAttuned)) {
outputFluid.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()).add(theAttuned);
}
}
}
public static void addEnergyHandler(IEnderEnergyHandler theAttuned) {
if (theAttuned.canSendEnergy()) {
if (inputEnergy.get(theAttuned.getChannelString()) == null) {
inputEnergy.put(theAttuned.getChannelString(), new HashMap<Integer, List<IEnderEnergyHandler>>());
}
if (inputEnergy.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()) == null) {
inputEnergy.get(theAttuned.getChannelString()).put(theAttuned.getFrequency(), new ArrayList<IEnderEnergyHandler>());
}
if (!inputEnergy.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()).contains(theAttuned)) {
inputEnergy.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()).add(theAttuned);
}
}
if (theAttuned.canReceiveEnergy()) {
if (outputEnergy.get(theAttuned.getChannelString()) == null) {
outputEnergy.put(theAttuned.getChannelString(), new HashMap<Integer, List<IEnderEnergyHandler>>());
}
if (outputEnergy.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()) == null) {
outputEnergy.get(theAttuned.getChannelString()).put(theAttuned.getFrequency(), new ArrayList<IEnderEnergyHandler>());
}
if (!outputEnergy.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()).contains(theAttuned)) {
outputEnergy.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()).add(theAttuned);
}
}
}
public static void removeItemHandler(IEnderItemHandler theAttuned) {
if (inputItem.get(theAttuned.getChannelString()) != null) {
if (inputItem.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()) != null) {
inputItem.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()).remove(theAttuned);
if (inputItem.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()).size() == 0) {
inputItem.get(theAttuned.getChannelString()).remove(theAttuned.getFrequency());
}
}
}
if (outputItem.get(theAttuned.getChannelString()) != null) {
if (outputItem.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()) != null) {
outputItem.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()).remove(theAttuned);
if (outputItem.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()).size() == 0) {
outputItem.get(theAttuned.getChannelString()).remove(theAttuned.getFrequency());
}
}
}
}
public static void removeFluidHandler(IEnderFluidHandler theAttuned) {
if (inputFluid.get(theAttuned.getChannelString()) != null) {
if (inputFluid.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()) != null) {
inputFluid.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()).remove(theAttuned);
if (inputFluid.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()).size() == 0) {
inputFluid.get(theAttuned.getChannelString()).remove(theAttuned.getFrequency());
}
}
}
if (outputFluid.get(theAttuned.getChannelString()) != null) {
if (outputFluid.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()) != null) {
outputFluid.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()).remove(theAttuned);
if (outputFluid.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()).size() == 0) {
outputFluid.get(theAttuned.getChannelString()).remove(theAttuned.getFrequency());
}
}
}
}
public static void removeEnergyHandler(IEnderEnergyHandler theAttuned) {
if (inputEnergy.get(theAttuned.getChannelString()) != null) {
if (inputEnergy.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()) != null) {
inputEnergy.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()).remove(theAttuned);
if (inputEnergy.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()).size() == 0) {
inputEnergy.get(theAttuned.getChannelString()).remove(theAttuned.getFrequency());
}
}
}
if (outputEnergy.get(theAttuned.getChannelString()) != null) {
if (outputEnergy.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()) != null) {
outputEnergy.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()).remove(theAttuned);
if (outputEnergy.get(theAttuned.getChannelString()).get(theAttuned.getFrequency()).size() == 0) {
outputEnergy.get(theAttuned.getChannelString()).remove(theAttuned.getFrequency());
}
}
}
}
public static void add(IEnderAttuned theAttuned) {
if (theAttuned instanceof IEnderItemHandler) {
addItemHandler((IEnderItemHandler) theAttuned);
}
if (theAttuned instanceof IEnderFluidHandler) {
addFluidHandler((IEnderFluidHandler) theAttuned);
}
if (theAttuned instanceof IEnderEnergyHandler) {
addEnergyHandler((IEnderEnergyHandler) theAttuned);
}
}
public static void remove(IEnderAttuned theAttuned) {
if (theAttuned instanceof IEnderItemHandler) {
removeItemHandler((IEnderItemHandler) theAttuned);
}
if (theAttuned instanceof IEnderFluidHandler) {
removeFluidHandler((IEnderFluidHandler) theAttuned);
}
if (theAttuned instanceof IEnderEnergyHandler) {
removeEnergyHandler((IEnderEnergyHandler) theAttuned);
}
}
public static void sortClientNames() {
List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>(clientFrequencyNames.entrySet());
Collections.sort(list, new Comparator<Map.Entry<String, String>>() {
@Override
public int compare(Map.Entry<String, String> o1, Map.Entry<String, String> o2) {
int int1 = Integer.valueOf(clientFrequencyNamesReversed.get(o1.getValue()));
int int2 = Integer.valueOf(clientFrequencyNamesReversed.get(o2.getValue()));
return int1 > int2 ? 1 : int1 == int2 ? 0 : -1;
}
});
Map<String, String> result = new LinkedHashMap<String, String>();
for (Map.Entry<String, String> entry : list) {
result.put(entry.getKey(), entry.getValue());
}
clientFrequencyNames = result;
}
public static void clearClientNames() {
clientFrequencyNames.clear();
clientFrequencyNamesReversed.clear();
}
public static void addClientNames(String owner, String name) {
if (!owner.isEmpty()) {
clientFrequencyNames.put(owner, name);
clientFrequencyNamesReversed.put(name, owner);
}
}
}
@@ -0,0 +1,10 @@
/**
* (C) 2014 Team CoFH / CoFH / Cult of the Full Hub
* http://www.teamcofh.com
*/
@API(apiVersion = CoFHAPIProps.VERSION, owner = "CoFHAPI", provides = "CoFHAPI|transport")
package cofh.api.transport;
import cofh.api.CoFHAPIProps;
import cpw.mods.fml.common.API;
@@ -0,0 +1,42 @@
package com.enderio.core.client.gui;
import net.minecraft.client.gui.GuiScreen;
import org.lwjgl.opengl.GL11;
import com.enderio.core.client.render.RenderUtil;
class FakeEmptySlot {
private static final int WIDTH = ItemButton.DEFAULT_WIDTH;
private static final int HWIDTH = ItemButton.HWIDTH;
private static final int HEIGHT = ItemButton.DEFAULT_HEIGHT;
private static final int HHEIGHT = ItemButton.HHEIGHT;
private int xPosition;
private int yPosition;
private GuiScreen g;
public FakeEmptySlot(GuiScreen g, int x, int y) {
xPosition = x;
yPosition = y;
this.g = g;
}
@SuppressWarnings("synthetic-access")
public void drawSlot() {
RenderUtil.bindItemTexture();
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
int hoverState = 0;
// top half
g.drawTexturedModalRect(xPosition, yPosition, 0, 46 + hoverState * 20, HWIDTH, HHEIGHT);
g.drawTexturedModalRect(xPosition + HWIDTH, yPosition, 200 - HWIDTH, 46 + hoverState * 20, HWIDTH, HHEIGHT);
// bottom half
g.drawTexturedModalRect(xPosition, yPosition + HHEIGHT, 0, 64 - HHEIGHT + (hoverState * 20), HWIDTH, HHEIGHT);
g.drawTexturedModalRect(xPosition + HWIDTH, yPosition + HHEIGHT, 200 - HWIDTH, 64 - HHEIGHT + (hoverState * 20), HWIDTH, HHEIGHT);
}
}
@@ -0,0 +1,26 @@
package com.enderio.core.client.gui;
import net.minecraft.item.ItemStack;
public class GhostSlot {
public int x;
public int y;
public boolean visible = true;
public ItemStack stack;
public boolean isMouseOver(int mx, int my) {
return mx >= x && mx < (x+16) && my >= y && my < (y+16);
}
public boolean isVisible() {
return visible;
}
public ItemStack getStack() {
return stack;
}
public void putStack(ItemStack stack) {
}
}
@@ -0,0 +1,636 @@
package com.enderio.core.client.gui;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.GuiTextField;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.client.renderer.RenderHelper;
import net.minecraft.inventory.Container;
import net.minecraft.item.ItemStack;
import net.minecraft.util.Timer;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL12;
import codechicken.nei.VisiblityData;
import codechicken.nei.api.INEIGuiHandler;
import codechicken.nei.api.TaggedInventoryArea;
import com.enderio.core.client.gui.ToolTipManager.ToolTipRenderer;
import com.enderio.core.client.render.RenderUtil;
import com.google.common.collect.Lists;
import cpw.mods.fml.common.Optional;
import crazypants.enderio.gui.IGuiOverlay;
import crazypants.enderio.gui.IconButtonEIO;
import crazypants.enderio.gui.TextFieldEIO;
import crazypants.enderio.gui.VScrollbarEIO;
@Optional.InterfaceList({
@Optional.Interface(iface = "codechicken.nei.api.INEIGuiHandler", modid = "NotEnoughItems")
})
public abstract class GuiContainerBase extends GuiContainer implements ToolTipRenderer, IGuiScreen, INEIGuiHandler {
protected ToolTipManager ttMan = new ToolTipManager();
protected List<IGuiOverlay> overlays = new ArrayList<IGuiOverlay>();
protected List<TextFieldEIO> textFields = Lists.newArrayList();
protected List<VScrollbarEIO> scrollbars = new ArrayList<VScrollbarEIO>();
protected List<GhostSlot> ghostSlots = new ArrayList<GhostSlot>();
protected GhostSlot hoverGhostSlot;
protected VScrollbarEIO draggingScrollbar;
protected GuiContainerBase(Container par1Container) {
super(par1Container);
}
@Override
public void initGui() {
super.initGui();
fixupGuiPosition();
for (IGuiOverlay overlay : overlays) {
overlay.init(this);
}
for (TextFieldEIO f : textFields) {
f.init(this);
}
}
protected void fixupGuiPosition() {
}
@Override
protected void keyTyped(char c, int key) {
GuiTextField focused = null;
for (GuiTextField f : textFields) {
if (f.isFocused()) {
focused = f;
}
}
// If esc is pressed
if(key == 1) {
// If there is a focused text field unfocus it
if(focused != null && key == 1) {
focused.setFocused(false);
focused = null;
return;
} else if(!hideOverlays()) { // Otherwise close overlays/GUI
this.mc.thePlayer.closeScreen();
return;
}
}
// If the user pressed tab, switch to the next text field, or unfocus if there are none
if(c == '\t') {
for (int i = 0; i < textFields.size(); i++) {
TextFieldEIO f = textFields.get(i);
if (f.isFocused()) {
textFields.get((i + 1) % textFields.size()).setFocused(true);
f.setFocused(false);
return;
}
}
}
// If there is a focused text field, attempt to type into it
if(focused != null) {
if(focused.textboxKeyTyped(c, key)) {
return;
}
}
// More NEI behavior, f key focuses first text field
if(c == 'f' && focused == null && !textFields.isEmpty()) {
focused = textFields.get(0);
focused.setFocused(true);
}
// Finally if 'e' was pressed but not captured by a text field, close the overlays/GUI
if(key == this.mc.gameSettings.keyBindInventory.getKeyCode()) {
if(!hideOverlays()) {
this.mc.thePlayer.closeScreen();
}
return;
}
// If the key was not captured, let NEI do its thing
super.keyTyped(c, key);
}
public boolean hideOverlays() {
for (IGuiOverlay overlay : overlays) {
if(overlay.isVisible()) {
overlay.setVisible(false);
return true;
}
}
return false;
}
@Override
public void addToolTip(GuiToolTip toolTip) {
ttMan.addToolTip(toolTip);
}
@Override
public void updateScreen() {
super.updateScreen();
for (GuiTextField f : textFields) {
f.updateCursorCounter();
}
}
@Override
public void handleMouseInput() {
int x = Mouse.getEventX() * this.width / this.mc.displayWidth;
int y = this.height - Mouse.getEventY() * this.height / this.mc.displayHeight - 1;
int b = Mouse.getEventButton();
for (IGuiOverlay overlay : overlays) {
if(overlay != null && overlay.isVisible() && overlay.handleMouseInput(x, y, b)) {
return;
}
}
int delta = Mouse.getEventDWheel();
if(delta != 0) {
mouseWheel(x, y, delta);
}
super.handleMouseInput();
}
@Override
protected boolean func_146978_c(int p_146978_1_, int p_146978_2_, int p_146978_3_, int p_146978_4_, int p_146978_5_, int p_146978_6_) {
int x = Mouse.getEventX() * this.width / this.mc.displayWidth;
int y = this.height - Mouse.getEventY() * this.height / this.mc.displayHeight - 1;
for (IGuiOverlay overlay : overlays) {
if(overlay != null && overlay.isVisible() && overlay.isMouseInBounds(x, y)) {
return false;
}
}
return super.func_146978_c(p_146978_1_, p_146978_2_, p_146978_3_, p_146978_4_, p_146978_5_, p_146978_6_);
}
@Override
public List<GhostSlot> getGhostSlots() {
return ghostSlots;
}
protected void ghostSlotClicked(GhostSlot slot, int x, int y, int button) {
ItemStack st = Minecraft.getMinecraft().thePlayer.inventory.getItemStack();
slot.putStack(st);
}
@Override
protected void mouseClicked(int x, int y, int button) {
for (GuiTextField f : textFields) {
f.mouseClicked(x, y, button);
}
if(!scrollbars.isEmpty()) {
if(draggingScrollbar != null) {
draggingScrollbar.mouseClicked(x, y, button);
return;
}
for(VScrollbarEIO vs : scrollbars) {
if(vs.mouseClicked(x, y, button)) {
draggingScrollbar = vs;
return;
}
}
}
if(!ghostSlots.isEmpty()) {
GhostSlot slot = getGhostSlot(x, y);
if(slot != null) {
ghostSlotClicked(slot, x, y, button);
return;
}
}
// Right click field clearing
if(button == 1) {
for (TextFieldEIO tf : textFields) {
if(tf.contains(x, y)) {
tf.setText("");
}
}
}
// Button events for non-left-clicks
if(button >= 1) {
for(Object obj : buttonList) {
if(obj instanceof IconButtonEIO) {
IconButtonEIO btn = (IconButtonEIO) obj;
if(btn.mousePressedButton(mc, x, y, button)) {
btn.func_146113_a(this.mc.getSoundHandler());
actionPerformedButton(btn, button);
}
}
}
}
super.mouseClicked(x, y, button);
}
@Override
protected void mouseMovedOrUp(int x, int y, int button) {
if(draggingScrollbar != null) {
draggingScrollbar.mouseMovedOrUp(x, y, button);
draggingScrollbar = null;
}
super.mouseMovedOrUp(x, y, button);
}
@Override
protected void mouseClickMove(int x, int y, int button, long time) {
if(draggingScrollbar != null) {
draggingScrollbar.mouseClickMove(x, y, button, time);
return;
}
super.mouseClickMove(x, y, button, time);
}
protected void mouseWheel(int x, int y, int delta) {
if(!scrollbars.isEmpty()) {
for(VScrollbarEIO vs : scrollbars) {
vs.mouseWheel(x, y, delta);
}
}
}
protected void actionPerformedButton(IconButtonEIO btn, int mouseButton) {
actionPerformed(btn);
}
public void addOverlay(IGuiOverlay overlay) {
overlays.add(overlay);
}
public void removeOverlay(IGuiOverlay overlay) {
overlays.remove(overlay);
}
public void addScrollbar(VScrollbarEIO vs) {
scrollbars.add(vs);
vs.adjustPosition();
}
public void removeScrollbar(VScrollbarEIO vs) {
scrollbars.remove(vs);
if(draggingScrollbar == vs) {
draggingScrollbar = null;
}
}
private int realMx, realMy;
@Override
protected final void drawGuiContainerForegroundLayer(int mouseX, int mouseY) {
drawForegroundImpl(mouseX, mouseY);
Timer t = RenderUtil.getTimer();
if(t != null) {
GL11.glPushMatrix();
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
GL11.glDisable(GL11.GL_DEPTH_TEST);
for (IGuiOverlay overlay : overlays) {
if(overlay != null && overlay.isVisible()) {
overlay.draw(realMx, realMy, t.renderPartialTicks);
}
}
GL11.glEnable(GL11.GL_DEPTH_TEST);
GL11.glPopMatrix();
}
}
@Override
protected void drawGuiContainerBackgroundLayer(float par1, int mouseX, int mouseY) {
for (GuiTextField f : textFields) {
f.drawTextBox();
}
if(!scrollbars.isEmpty()) {
for(VScrollbarEIO vs : scrollbars) {
vs.drawScrollbar(mouseX, mouseY);
}
}
drawGhostSlots(mouseX, mouseY);
}
@Override
public void drawScreen(int par1, int par2, float par3) {
hoverGhostSlot = null;
int mx = realMx = par1;
int my = realMy = par2;
for (IGuiOverlay overlay : overlays) {
if(overlay != null && overlay.isVisible() && isMouseInOverlay(par1, par2, overlay)) {
mx = -5000;
my = -5000;
this.drawItemStack(this.mc.thePlayer.inventory.getItemStack(), par1 - this.guiLeft - 8, par2 - this.guiTop - 8, null);
}
}
super.drawScreen(mx, my, par3);
if(draggingScrollbar == null) {
if(hoverGhostSlot != null && mc.thePlayer.inventory.getItemStack() == null) {
ItemStack stack = hoverGhostSlot.getStack();
if(stack != null) {
renderToolTip(stack, par1, par2);
}
}
ttMan.drawTooltips(this, par1, par2);
}
}
// copied from super with hate
protected void drawItemStack(ItemStack stack, int mouseX, int mouseY, String str)
{
GL11.glTranslatef(0.0F, 0.0F, 32.0F);
this.zLevel = 200.0F;
itemRender.zLevel = 200.0F;
FontRenderer font = null;
if(stack != null) {
font = stack.getItem().getFontRenderer(stack);
}
if(font == null) {
font = fontRendererObj;
}
itemRender.renderItemAndEffectIntoGUI(font, this.mc.getTextureManager(), stack, mouseX, mouseY);
itemRender.renderItemOverlayIntoGUI(font, this.mc.getTextureManager(), stack, mouseX, mouseY, str);
this.zLevel = 0.0F;
itemRender.zLevel = 0.0F;
}
protected void drawFakeItemsStart() {
zLevel = 100.0F;
itemRender.zLevel = 100.0F;
GL11.glPushAttrib(GL11.GL_ALL_ATTRIB_BITS);
GL11.glEnable(GL11.GL_LIGHTING);
GL11.glEnable(GL12.GL_RESCALE_NORMAL);
GL11.glEnable(GL11.GL_DEPTH_TEST);
RenderHelper.enableGUIStandardItemLighting();
}
protected void drawFakeItemStack(int x, int y, ItemStack stack) {
itemRender.renderItemAndEffectIntoGUI(fontRendererObj, mc.renderEngine, stack, x, y);
}
protected void drawFakeItemHover(int x, int y) {
GL11.glDisable(GL11.GL_LIGHTING);
GL11.glDisable(GL11.GL_DEPTH_TEST);
GL11.glColorMask(true, true, true, false);
drawGradientRect(x, y, x + 16, y + 16, 0x80FFFFFF, 0x80FFFFFF);
GL11.glColorMask(true, true, true, true);
GL11.glEnable(GL11.GL_DEPTH_TEST);
GL11.glEnable(GL11.GL_LIGHTING);
}
protected void drawFakeItemsEnd() {
GL11.glPopAttrib();
itemRender.zLevel = 0.0F;
zLevel = 0.0F;
}
protected void drawGhostSlots(int mouseX, int mouseY) {
if(ghostSlots.isEmpty()) {
return;
}
int sx = getGuiLeft();
int sy = getGuiTop();
drawFakeItemsStart();
try {
hoverGhostSlot = null;
for(GhostSlot slot : ghostSlots) {
ItemStack stack = slot.getStack();
if(slot.isVisible()) {
if(stack != null) {
drawFakeItemStack(slot.x + sx, slot.y + sy, stack);
}
if(slot.isMouseOver(mouseX - sx, mouseY - sy)) {
hoverGhostSlot = slot;
}
}
}
if(hoverGhostSlot != null) {
// draw hover last to prevent it from affecting rendering of other slots ...
drawFakeItemHover(hoverGhostSlot.x + sx, hoverGhostSlot.y + sy);
}
} finally {
drawFakeItemsEnd();
}
}
protected GhostSlot getGhostSlot(int mouseX, int mouseY) {
mouseX -= getGuiLeft();
mouseY -= getGuiTop();
for(GhostSlot slot : ghostSlots) {
if(slot.isVisible() && slot.isMouseOver(mouseX, mouseY)) {
return slot;
}
}
return null;
}
private boolean isMouseInOverlay(int mouseX, int mouseY, IGuiOverlay overlay) {
int x = mouseX - getGuiLeft();
int y = mouseY - getGuiTop();
return overlay.getBounds().contains(x, y);
}
@Override
public void removeToolTip(GuiToolTip toolTip) {
ttMan.removeToolTip(toolTip);
}
protected void drawForegroundImpl(int mouseX, int mouseY) {
super.drawGuiContainerForegroundLayer(mouseX, mouseY);
}
@SuppressWarnings({ "rawtypes", "unchecked" })
@Override
public void drawHoveringText(List par1List, int par2, int par3, FontRenderer font) {
GL11.glPushAttrib(GL11.GL_ENABLE_BIT);
GL11.glPushAttrib(GL11.GL_LIGHTING_BIT);
copyOfdrawHoveringText(par1List, par2, par3, font);
GL11.glPopAttrib();
GL11.glPopAttrib();
}
//This is a copy of the super class method due to 'Method not found' errors
// reported with some mods installed.
protected void copyOfdrawHoveringText(List<String> par1List, int par2, int par3, FontRenderer font) {
if(!par1List.isEmpty())
{
GL11.glDisable(GL12.GL_RESCALE_NORMAL);
RenderHelper.disableStandardItemLighting();
GL11.glDisable(GL11.GL_LIGHTING);
GL11.glDisable(GL11.GL_DEPTH_TEST);
int k = 0;
Iterator<String> iterator = par1List.iterator();
while (iterator.hasNext())
{
String s = (String) iterator.next();
int l = font.getStringWidth(s);
if(l > k)
{
k = l;
}
}
int i1 = par2 + 12;
int j1 = par3 - 12;
int k1 = 8;
if(par1List.size() > 1)
{
k1 += 2 + (par1List.size() - 1) * 10;
}
if(i1 + k > this.width)
{
i1 -= 28 + k;
}
if(j1 + k1 + 6 > this.height)
{
j1 = this.height - k1 - 6;
}
this.zLevel = 300.0F;
//itemRenderer.zLevel = 300.0F;
int l1 = -267386864;
this.drawGradientRect(i1 - 3, j1 - 4, i1 + k + 3, j1 - 3, l1, l1);
this.drawGradientRect(i1 - 3, j1 + k1 + 3, i1 + k + 3, j1 + k1 + 4, l1, l1);
this.drawGradientRect(i1 - 3, j1 - 3, i1 + k + 3, j1 + k1 + 3, l1, l1);
this.drawGradientRect(i1 - 4, j1 - 3, i1 - 3, j1 + k1 + 3, l1, l1);
this.drawGradientRect(i1 + k + 3, j1 - 3, i1 + k + 4, j1 + k1 + 3, l1, l1);
int i2 = 1347420415;
int j2 = (i2 & 16711422) >> 1 | i2 & -16777216;
this.drawGradientRect(i1 - 3, j1 - 3 + 1, i1 - 3 + 1, j1 + k1 + 3 - 1, i2, j2);
this.drawGradientRect(i1 + k + 2, j1 - 3 + 1, i1 + k + 3, j1 + k1 + 3 - 1, i2, j2);
this.drawGradientRect(i1 - 3, j1 - 3, i1 + k + 3, j1 - 3 + 1, i2, i2);
this.drawGradientRect(i1 - 3, j1 + k1 + 2, i1 + k + 3, j1 + k1 + 3, j2, j2);
for (int k2 = 0; k2 < par1List.size(); ++k2)
{
String s1 = (String) par1List.get(k2);
font.drawStringWithShadow(s1, i1, j1, -1);
if(k2 == 0)
{
j1 += 2;
}
j1 += 10;
}
this.zLevel = 0.0F;
//itemRenderer.zLevel = 0.0F;
GL11.glEnable(GL11.GL_LIGHTING);
GL11.glEnable(GL11.GL_DEPTH_TEST);
RenderHelper.enableStandardItemLighting();
GL11.glEnable(GL12.GL_RESCALE_NORMAL);
}
}
@Override
public int getGuiLeft() {
return guiLeft;
}
@Override
public int getGuiTop() {
return guiTop;
}
@Override
public int getXSize() {
return xSize;
}
@Override
public int getYSize() {
return ySize;
}
public void setGuiLeft(int i) {
guiLeft = i;
}
public void setGuiTop(int i) {
guiTop = i;
}
public void setXSize(int i) {
xSize = i;
}
public void setYSize(int i) {
ySize = i;
}
@Override
public FontRenderer getFontRenderer() {
return Minecraft.getMinecraft().fontRenderer;
}
@SuppressWarnings("unchecked")
@Override
public void addButton(GuiButton button) {
if(!buttonList.contains(button)) {
buttonList.add(button);
}
}
@Override
public void removeButton(GuiButton button) {
buttonList.remove(button);
}
@Override
public int getOverlayOffsetX() {
return 0;
}
@Override
public void doActionPerformed(GuiButton guiButton) {
actionPerformed(guiButton);
}
@Override
@Optional.Method(modid = "NotEnoughItems")
public VisiblityData modifyVisiblity(GuiContainer gc, VisiblityData vd) {
return vd;
}
@Override
@Optional.Method(modid = "NotEnoughItems")
public Iterable<Integer> getItemSpawnSlots(GuiContainer gc, ItemStack is) {
return null;
}
@Override
@Optional.Method(modid = "NotEnoughItems")
public List<TaggedInventoryArea> getInventoryAreas(GuiContainer gc) {
return Collections.<TaggedInventoryArea>emptyList();
}
@Override
@Optional.Method(modid = "NotEnoughItems")
public boolean handleDragNDrop(GuiContainer gc, int i, int i1, ItemStack is, int i2) {
return false;
}
@Override
@Optional.Method(modid = "NotEnoughItems")
public boolean hideItemPanelSlot(GuiContainer gc, int x, int y, int w, int h) {
return false;
}
}
@@ -0,0 +1,101 @@
package com.enderio.core.client.gui;
import net.minecraft.client.gui.Gui;
import net.minecraft.util.IIcon;
import net.minecraft.util.ResourceLocation;
import org.lwjgl.opengl.GL11;
import com.enderio.core.client.render.IconUtil;
import com.enderio.core.client.render.RenderUtil;
public class GuiIconRenderer extends Gui {
public static final int DEFAULT_WIDTH = 24;
public static final int HWIDTH = DEFAULT_WIDTH / 2;
public static final int DEFAULT_HEIGHT = 24;
public static final int HHEIGHT = DEFAULT_HEIGHT / 2;
protected int hwidth = HWIDTH;
protected int hheight = HHEIGHT;
protected int width = DEFAULT_WIDTH;
protected int height = DEFAULT_HEIGHT;
protected IIcon icon;
protected ResourceLocation texture;
private int yPosition;
private int xPosition;
private float alpha = 1.0f;
public GuiIconRenderer(int x, int y, int itemId, int itemMeta) {
xPosition = x;
yPosition = y;
icon = IconUtil.getIconForItem(itemId, itemMeta);
texture = RenderUtil.ITEM_TEX;
}
public GuiIconRenderer(int x, int y, IIcon icon, ResourceLocation texture) {
xPosition = x;
yPosition = y;
this.icon = icon;
this.texture = texture;
}
public void setSize(int width, int height) {
this.width = width;
this.height = height;
hwidth = width / 2;
hheight = height / 2;
}
public int getWidth() {
return width;
}
public int getHeight() {
return height;
}
public IIcon getIcon() {
return icon;
}
public float getAlpha() {
return alpha;
}
public void setAlpha(float alpha) {
this.alpha = alpha;
}
public void setIcon(IIcon icon) {
this.icon = icon;
}
public ResourceLocation getTexture() {
return texture;
}
public void setTexture(ResourceLocation textureName) {
this.texture = textureName;
}
public void draw() {
GL11.glColor4f(1.0F, 1.0F, 1.0F, alpha);
GL11.glPushAttrib(GL11.GL_ENABLE_BIT);
GL11.glEnable(GL11.GL_BLEND);
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
RenderUtil.bindTexture(texture);
drawTexturedModelRectFromIcon(xPosition, yPosition, icon, width, height);
GL11.glPopAttrib();
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
}
}
@@ -0,0 +1,230 @@
package com.enderio.core.client.gui;
import java.util.Iterator;
import java.util.List;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.renderer.RenderHelper;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL12;
import com.enderio.core.client.gui.ToolTipManager.ToolTipRenderer;
public abstract class GuiScreenBase extends GuiScreen implements ToolTipRenderer, IGuiScreen {
protected ToolTipManager ttMan = new ToolTipManager();
/** The X size of the inventory window in pixels. */
protected int xSize = 176;
/** The Y size of the inventory window in pixels. */
protected int ySize = 166;
/**
* Starting X position for the Gui. Inconsistent use for Gui backgrounds.
*/
protected int guiLeft;
/**
* Starting Y position for the Gui. Inconsistent use for Gui backgrounds.
*/
protected int guiTop;
protected boolean drawButtons = true;
protected GuiScreenBase(int xSize, int ySize) {
this.xSize = xSize;
this.ySize = ySize;
}
@Override
public void addToolTip(GuiToolTip toolTip) {
ttMan.addToolTip(toolTip);
}
@Override
public void removeToolTip(GuiToolTip toolTip) {
ttMan.removeToolTip(toolTip);
}
@Override
public void initGui() {
super.initGui();
guiLeft = (this.width - this.xSize) / 2;
guiTop = (this.height - this.ySize) / 2;
}
@Override
public void drawScreen(int par1, int par2, float par3) {
drawDefaultBackground();
drawBackgroundLayer(par3, par1, par2);
RenderHelper.disableStandardItemLighting();
GL11.glDisable(GL11.GL_LIGHTING);
GL11.glDisable(GL11.GL_DEPTH_TEST);
GL11.glDisable(GL12.GL_RESCALE_NORMAL);
if(drawButtons) {
RenderHelper.enableGUIStandardItemLighting();
super.drawScreen(par1, par2, par3);
}
GL11.glEnable(GL12.GL_RESCALE_NORMAL);
GL11.glPushMatrix();
GL11.glTranslatef(guiLeft, guiTop, 0.0F);
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
GL11.glDisable(GL11.GL_LIGHTING);
drawForegroundLayer(par1, par2);
GL11.glEnable(GL11.GL_LIGHTING);
GL11.glPopMatrix();
GL11.glEnable(GL11.GL_LIGHTING);
GL11.glEnable(GL11.GL_DEPTH_TEST);
RenderHelper.enableStandardItemLighting();
}
protected abstract void drawBackgroundLayer(float par3, int par1, int par2);
protected final void drawForegroundLayer(int mouseX, int mouseY) {
drawForegroundImpl(mouseX, mouseY);
ttMan.drawTooltips(this, mouseX, mouseY);
}
protected void drawForegroundImpl(int mouseX, int mouseY) {
}
@Override
public void drawHoveringText(List par1List, int par2, int par3, FontRenderer font) {
if(!par1List.isEmpty()) {
GL11.glPushAttrib(GL11.GL_ENABLE_BIT);
GL11.glPushAttrib(GL11.GL_LIGHTING_BIT);
GL11.glDisable(GL12.GL_RESCALE_NORMAL);
RenderHelper.disableStandardItemLighting();
GL11.glDisable(GL11.GL_LIGHTING);
GL11.glDisable(GL11.GL_DEPTH_TEST);
int k = 0;
Iterator iterator = par1List.iterator();
while (iterator.hasNext())
{
String s = (String) iterator.next();
int l = font.getStringWidth(s);
if(l > k)
{
k = l;
}
}
int i1 = par2 + 12;
int j1 = par3 - 12;
int k1 = 8;
if(par1List.size() > 1)
{
k1 += 2 + (par1List.size() - 1) * 10;
}
if(i1 + k > this.width)
{
i1 -= 28 + k;
}
if(j1 + k1 + 6 > this.height)
{
j1 = this.height - k1 - 6;
}
this.zLevel = 300.0F;
int l1 = -267386864;
this.drawGradientRect(i1 - 3, j1 - 4, i1 + k + 3, j1 - 3, l1, l1);
this.drawGradientRect(i1 - 3, j1 + k1 + 3, i1 + k + 3, j1 + k1 + 4, l1, l1);
this.drawGradientRect(i1 - 3, j1 - 3, i1 + k + 3, j1 + k1 + 3, l1, l1);
this.drawGradientRect(i1 - 4, j1 - 3, i1 - 3, j1 + k1 + 3, l1, l1);
this.drawGradientRect(i1 + k + 3, j1 - 3, i1 + k + 4, j1 + k1 + 3, l1, l1);
int i2 = 1347420415;
int j2 = (i2 & 16711422) >> 1 | i2 & -16777216;
this.drawGradientRect(i1 - 3, j1 - 3 + 1, i1 - 3 + 1, j1 + k1 + 3 - 1, i2, j2);
this.drawGradientRect(i1 + k + 2, j1 - 3 + 1, i1 + k + 3, j1 + k1 + 3 - 1, i2, j2);
this.drawGradientRect(i1 - 3, j1 - 3, i1 + k + 3, j1 - 3 + 1, i2, i2);
this.drawGradientRect(i1 - 3, j1 + k1 + 2, i1 + k + 3, j1 + k1 + 3, j2, j2);
for (int k2 = 0; k2 < par1List.size(); ++k2)
{
String s1 = (String) par1List.get(k2);
font.drawStringWithShadow(s1, i1, j1, -1);
if(k2 == 0)
{
j1 += 2;
}
j1 += 10;
}
this.zLevel = 0.0F;
GL11.glEnable(GL11.GL_LIGHTING);
GL11.glEnable(GL11.GL_DEPTH_TEST);
RenderHelper.enableStandardItemLighting();
GL11.glEnable(GL12.GL_RESCALE_NORMAL);
GL11.glPopAttrib();
GL11.glPopAttrib();
}
}
@Override
public int getGuiLeft() {
return guiLeft;
}
@Override
public int getGuiTop() {
return guiTop;
}
@Override
public int getXSize() {
return xSize;
}
@Override
public int getYSize() {
return xSize;
}
@Override
public FontRenderer getFontRenderer() {
return Minecraft.getMinecraft().fontRenderer;
}
@Override
public void addButton(GuiButton button) {
if(!buttonList.contains(button)) {
buttonList.add(button);
}
}
@Override
public void removeButton(GuiButton button) {
buttonList.remove(button);
}
@Override
public void doActionPerformed(GuiButton guiButton) {
actionPerformed(guiButton);
}
}
@@ -0,0 +1,407 @@
package com.enderio.core.client.gui;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.ScaledResolution;
import net.minecraft.client.renderer.Tessellator;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.GL11;
public abstract class GuiScrollableList<T> {
private final Minecraft mc = Minecraft.getMinecraft();
protected int originX;
protected int originY;
protected int width;
protected int height;
protected int minY;
protected int maxY;
protected int minX;
protected int maxX;
protected final int slotHeight;
private int scrollUpButtonID;
private int scrollDownButtonID;
protected int mouseX;
protected int mouseY;
private float initialClickY = -2.0F;
private float scrollMultiplier;
private float amountScrolled;
protected int selectedIndex = -1;
private long lastClickedTime;
private boolean showSelectionBox = true;
protected int margin = 4;
protected List<ListSelectionListener<T>> listeners = new CopyOnWriteArrayList<ListSelectionListener<T>>();
public GuiScrollableList(int width, int height, int originX, int originY, int slotHeight) {
this.width = width;
this.height = height;
this.originX = originX;
this.originY = originY;
this.slotHeight = slotHeight;
minY = originY;
maxY = minY + height;
minX = originX;
maxX = minX + width;
}
public void onGuiInit(IGuiScreen gui) {
minY = originY + gui.getGuiTop();
maxY = minY + height;
minX = originX + gui.getGuiLeft();
maxX = minX + width;
}
public void addSelectionListener(ListSelectionListener<T> listener) {
listeners.add(listener);
}
public void removeSelectionListener(ListSelectionListener<T> listener) {
listeners.remove(listener);
}
public T getSelectedElement() {
return getElementAt(selectedIndex);
}
public void setSelection(T selection) {
setSelection(getIndexOf(selection));
}
public void setSelection(int index) {
if(index == selectedIndex) {
return;
}
selectedIndex = index;
for (ListSelectionListener<T> listener : listeners) {
listener.selectionChanged(this, selectedIndex);
}
}
public int getIndexOf(T element) {
if(element == null) {
return -1;
}
for (int i = 0; i < getNumElements(); i++) {
if(element.equals(getElementAt(i))) {
return i;
}
}
return -1;
}
public abstract T getElementAt(int index);
public abstract int getNumElements();
protected abstract void drawElement(int elementIndex, int x, int y, int height, Tessellator tessellator);
protected boolean elementClicked(int elementIndex, boolean doubleClick) {
return true;
}
public void setShowSelectionBox(boolean val) {
showSelectionBox = val;
}
protected int getContentHeight() {
return getNumElements() * slotHeight;
}
public void setScrollButtonIds(int scrollUpButtonID, int scrollDownButtonID) {
this.scrollUpButtonID = scrollUpButtonID;
this.scrollDownButtonID = scrollDownButtonID;
}
private void clampScrollToBounds() {
int i = getContentOverhang();
if(i < 0) {
i *= -1;
}
if(amountScrolled < 0.0F) {
amountScrolled = 0.0F;
}
if(amountScrolled > i) {
amountScrolled = i;
}
}
public int getContentOverhang() {
return getContentHeight() - (height - margin);
}
public void actionPerformed(GuiButton b) {
if(b.enabled) {
if(b.id == scrollUpButtonID) {
amountScrolled -= slotHeight * 2 / 3;
initialClickY = -2.0F;
clampScrollToBounds();
} else if(b.id == scrollDownButtonID) {
amountScrolled += slotHeight * 2 / 3;
initialClickY = -2.0F;
clampScrollToBounds();
}
}
}
/**
* draws the slot to the screen, pass in mouse's current x and y and partial
* ticks
*/
public void drawScreen(int mX, int mY, float partialTick) {
this.mouseX = mX;
this.mouseY = mY;
processMouseEvents();
clampScrollToBounds();
GL11.glDisable(GL11.GL_LIGHTING);
GL11.glDisable(GL11.GL_FOG);
ScaledResolution sr = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight);
int sx = minX * sr.getScaleFactor();
int sw = width * sr.getScaleFactor();
int sy = mc.displayHeight - (maxY * sr.getScaleFactor());
int sh = height * sr.getScaleFactor();
GL11.glEnable(GL11.GL_SCISSOR_TEST);
GL11.glScissor(sx, sy, sw, sh);
Tessellator tessellator = Tessellator.instance;
drawContainerBackground(tessellator);
int contentYOffset = this.minY + margin - (int) this.amountScrolled;
for (int i = 0; i < getNumElements(); ++i) {
int elementY = contentYOffset + i * this.slotHeight;
int slotHeight = this.slotHeight - margin;
if(elementY <= maxY && elementY + slotHeight >= minY) {
if(showSelectionBox && i == selectedIndex) {
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
GL11.glDisable(GL11.GL_TEXTURE_2D);
tessellator.startDrawingQuads();
tessellator.setColorOpaque_I(8421504);
tessellator.addVertexWithUV(minX, elementY + slotHeight + 2, 0.0D, 0.0D, 1.0D);
tessellator.addVertexWithUV(maxX, elementY + slotHeight + 2, 0.0D, 1.0D, 1.0D);
tessellator.addVertexWithUV(maxX, elementY - 2, 0.0D, 1.0D, 0.0D);
tessellator.addVertexWithUV(minX, elementY - 2, 0.0D, 0.0D, 0.0D);
tessellator.setColorOpaque_I(0);
tessellator.addVertexWithUV(minX + 1, elementY + slotHeight + 1, 0.0D, 0.0D, 1.0D);
tessellator.addVertexWithUV(maxX - 1, elementY + slotHeight + 1, 0.0D, 1.0D, 1.0D);
tessellator.addVertexWithUV(maxX - 1, elementY - 1, 0.0D, 1.0D, 0.0D);
tessellator.addVertexWithUV(minX + 1, elementY - 1, 0.0D, 0.0D, 0.0D);
tessellator.draw();
GL11.glEnable(GL11.GL_TEXTURE_2D);
}
drawElement(i, minX, elementY, slotHeight, tessellator);
}
}
GL11.glDisable(GL11.GL_SCISSOR_TEST);
GL11.glDisable(GL11.GL_DEPTH_TEST);
GL11.glEnable(GL11.GL_BLEND);
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
GL11.glDisable(GL11.GL_ALPHA_TEST);
GL11.glShadeModel(GL11.GL_SMOOTH);
GL11.glDisable(GL11.GL_TEXTURE_2D);
tessellator.startDrawingQuads();
tessellator.setColorRGBA_I(0, 0);
tessellator.addVertexWithUV(this.minX, this.minY + margin, 0.0D, 0.0D, 1.0D);
tessellator.addVertexWithUV(this.maxX, this.minY + margin, 0.0D, 1.0D, 1.0D);
tessellator.setColorRGBA_I(0, 255);
tessellator.addVertexWithUV(this.maxX, this.minY, 0.0D, 1.0D, 0.0D);
tessellator.addVertexWithUV(this.minX, this.minY, 0.0D, 0.0D, 0.0D);
tessellator.draw();
tessellator.startDrawingQuads();
tessellator.setColorRGBA_I(0, 255);
tessellator.addVertexWithUV(this.minX, this.maxY, 0.0D, 0.0D, 1.0D);
tessellator.addVertexWithUV(this.maxX, this.maxY, 0.0D, 1.0D, 1.0D);
tessellator.setColorRGBA_I(0, 0);
tessellator.addVertexWithUV(this.maxX, this.maxY - margin, 0.0D, 1.0D, 0.0D);
tessellator.addVertexWithUV(this.minX, this.maxY - margin, 0.0D, 0.0D, 0.0D);
tessellator.draw();
renderScrollBar(tessellator);
GL11.glEnable(GL11.GL_TEXTURE_2D);
GL11.glShadeModel(GL11.GL_FLAT);
GL11.glEnable(GL11.GL_ALPHA_TEST);
GL11.glDisable(GL11.GL_BLEND);
}
protected void renderScrollBar(Tessellator tessellator) {
int contentHeightOverBounds = getContentOverhang();
if(contentHeightOverBounds > 0) {
int clear = (maxY - minY) * (maxY - minY) / getContentHeight();
if(clear < 32) {
clear = 32;
}
if(clear > maxY - minY - 8) {
clear = maxY - minY - 8;
}
int y = (int) this.amountScrolled * (maxY - minY - clear) / contentHeightOverBounds + minY;
if(y < minY) {
y = minY;
}
GL11.glDisable(GL11.GL_TEXTURE_2D);
int scrollBarMinX = getScrollBarX();
int scrollBarMaxX = scrollBarMinX + 6;
tessellator.startDrawingQuads();
tessellator.setColorRGBA_I(0, 255);
tessellator.addVertexWithUV(scrollBarMinX, maxY, 0.0D, 0.0D, 1.0D);
tessellator.addVertexWithUV(scrollBarMaxX, maxY, 0.0D, 1.0D, 1.0D);
tessellator.addVertexWithUV(scrollBarMaxX, minY, 0.0D, 1.0D, 0.0D);
tessellator.addVertexWithUV(scrollBarMinX, minY, 0.0D, 0.0D, 0.0D);
tessellator.setColorRGBA_F(0.3f, 0.3f, 0.3f, 1);
tessellator.addVertexWithUV(scrollBarMinX, (y + clear), 0.0D, 0.0D, 1.0D);
tessellator.addVertexWithUV(scrollBarMaxX, (y + clear), 0.0D, 1.0D, 1.0D);
tessellator.addVertexWithUV(scrollBarMaxX, y, 0.0D, 1.0D, 0.0D);
tessellator.addVertexWithUV(scrollBarMinX, y, 0.0D, 0.0D, 0.0D);
tessellator.setColorRGBA_F(0.7f, 0.7f, 0.7f, 1);
tessellator.addVertexWithUV(scrollBarMinX, (y + clear - 1), 0.0D, 0.0D, 1.0D);
tessellator.addVertexWithUV((scrollBarMaxX - 1), (y + clear - 1), 0.0D, 1.0D, 1.0D);
tessellator.addVertexWithUV((scrollBarMaxX - 1), y, 0.0D, 1.0D, 0.0D);
tessellator.addVertexWithUV(scrollBarMinX, y, 0.0D, 0.0D, 0.0D);
tessellator.draw();
GL11.glEnable(GL11.GL_TEXTURE_2D);
}
}
private void processMouseEvents() {
if(Mouse.isButtonDown(0)) {
processMouseBown();
} else {
while (!mc.gameSettings.touchscreen && Mouse.next()) {
int mouseWheelDelta = Mouse.getEventDWheel();
if(mouseWheelDelta != 0) {
if(mouseWheelDelta > 0) {
mouseWheelDelta = -1;
} else if(mouseWheelDelta < 0) {
mouseWheelDelta = 1;
}
amountScrolled += mouseWheelDelta * slotHeight / 2;
}
}
initialClickY = -1.0F;
}
}
private void processMouseBown() {
int contentHeightOverBounds;
if(initialClickY == -1.0F) {
if(mouseY >= minY && mouseY <= maxY && mouseX >= minX && mouseX <= maxX + 6) {
boolean clickInBounds = true;
int y = mouseY - minY + (int) amountScrolled - margin;
int mouseOverElement = y / slotHeight;
if(mouseX >= minX && mouseX <= maxX && mouseOverElement >= 0 && y >= 0 && mouseOverElement < getNumElements()) {
boolean doubleClick = mouseOverElement == selectedIndex && Minecraft.getSystemTime() - lastClickedTime < 250L;
if(elementClicked(mouseOverElement, doubleClick)) {
setSelection(mouseOverElement);
}
lastClickedTime = Minecraft.getSystemTime();
} else if(mouseX >= minX && mouseX <= maxX && y < 0) {
clickInBounds = false;
}
int scrollBarMinX = getScrollBarX();
int scrollBarMaxX = scrollBarMinX + 6;
if(mouseX >= scrollBarMinX && mouseX <= scrollBarMaxX) {
scrollMultiplier = -1.0F;
contentHeightOverBounds = getContentOverhang();
if(contentHeightOverBounds < 1) {
contentHeightOverBounds = 1;
}
int empty = (int) ((float) ((maxY - minY) * (maxY - minY)) / (float) getContentHeight());
if(empty < 32) {
empty = 32;
}
if(empty > maxY - minY - 8) {
empty = maxY - minY - 8;
}
scrollMultiplier /= (float) (maxY - minY - empty) / (float) contentHeightOverBounds;
} else {
scrollMultiplier = 1.0F;
}
if(clickInBounds) {
initialClickY = mouseY;
} else {
initialClickY = -2.0F;
}
} else {
initialClickY = -2.0F;
}
} else if(initialClickY >= 0.0F) {
// Scrolling
amountScrolled -= (mouseY - initialClickY) * scrollMultiplier;
initialClickY = mouseY;
}
}
protected int getScrollBarX() {
return minX + width;
}
protected void drawContainerBackground(Tessellator tess) {
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
GL11.glDisable(GL11.GL_TEXTURE_2D);
tess.startDrawingQuads();
tess.setColorOpaque_I(2105376);
tess.addVertex(minX, maxY, 0.0D);
tess.addVertex(maxX, maxY, 0.0D);
tess.addVertex(maxX, minY, 0.0D);
tess.addVertex(minX, minY, 0.0D);
tess.draw();
GL11.glEnable(GL11.GL_TEXTURE_2D);
}
}
@@ -0,0 +1,105 @@
package com.enderio.core.client.gui;
import java.awt.Rectangle;
import java.util.ArrayList;
import java.util.List;
public class GuiToolTip {
private static final long DELAY = 0;
protected Rectangle bounds;
private long mouseOverStart;
protected final List<String> text;
private int lastMouseX = -1;
private int lastMouseY = -1;
private boolean visible = true;
public GuiToolTip(Rectangle bounds, String... lines) {
this.bounds = bounds;
if(lines != null) {
text = new ArrayList<String>(lines.length);
for (String line : lines) {
text.add(line);
}
} else {
text = new ArrayList<String>();
}
}
public GuiToolTip(Rectangle bounds, List<String> lines) {
this.bounds = bounds;
if(lines == null) {
text = new ArrayList<String>();
} else {
text = new ArrayList<String>(lines);
}
}
public boolean isVisible() {
return visible;
}
public void setVisible(boolean visible) {
this.visible = visible;
}
public Rectangle getBounds() {
return bounds;
}
public void setBounds(Rectangle bounds) {
this.bounds = bounds;
}
public void onTick(int mouseX, int mouseY) {
if(lastMouseX != mouseX || lastMouseY != mouseY) {
mouseOverStart = 0;
}
if(bounds.contains(mouseX, mouseY)) {
if(mouseOverStart == 0) {
mouseOverStart = System.currentTimeMillis();
}
} else {
mouseOverStart = 0;
}
lastMouseX = mouseX;
lastMouseY = mouseY;
}
public boolean shouldDraw() {
if(!visible) {
return false;
}
updateText();
if(mouseOverStart == 0) {
return false;
}
return System.currentTimeMillis() - mouseOverStart >= DELAY;
}
protected void updateText() {
}
public void setToolTipText(String... txt) {
text.clear();
if(txt != null) {
for (String line : txt) {
text.add(line);
}
}
}
public List<String> getToolTipText() {
return text;
}
}
@@ -0,0 +1,29 @@
package com.enderio.core.client.gui;
import java.awt.Rectangle;
public interface IGuiOverlay {
void init(IGuiScreen screen);
Rectangle getBounds();
void draw(int mouseX, int mouseY, float partialTick);
// //consume event?
// boolean mouseClicked(int par1, int par2, int par3);
//
// boolean mouseClickMove(int par1, int par2, int par3, long p_146273_4_);
//
// boolean mouseMovedOrUp(int par1, int par2, int par3);
void setVisible(boolean visible);
boolean isVisible();
boolean handleMouseInput(int x, int y, int b);
boolean isMouseInBounds(int mouseX, int mouseY);
}
@@ -0,0 +1,30 @@
package com.enderio.core.client.gui;
import java.util.List;
import net.minecraft.client.gui.GuiButton;
public interface IGuiScreen {
void addToolTip(GuiToolTip toolTip);
void removeToolTip(GuiToolTip toolTip);
int getGuiLeft();
int getGuiTop();
int getXSize();
int getYSize();
void addButton(GuiButton button);
void removeButton(GuiButton button);
int getOverlayOffsetX();
void doActionPerformed(GuiButton but);
List<GhostSlot> getGhostSlots();
}
@@ -0,0 +1,98 @@
package com.enderio.core.client.gui;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.util.IIcon;
import net.minecraft.util.ResourceLocation;
import org.lwjgl.opengl.GL11;
import com.enderio.core.client.render.RenderUtil;
public class IconButton extends GuiButton {
public static final int DEFAULT_WIDTH = 24;
public static final int HWIDTH = DEFAULT_WIDTH / 2;
public static final int DEFAULT_HEIGHT = 24;
public static final int HHEIGHT = DEFAULT_HEIGHT / 2;
protected int hwidth;
protected int hheight;
protected IIcon icon;
protected ResourceLocation texture;
public IconButton(FontRenderer fr, int id, int x, int y, IIcon icon, ResourceLocation texture) {
super(id, x, y, DEFAULT_WIDTH, DEFAULT_HEIGHT, "");
hwidth = HWIDTH;
hheight = HHEIGHT;
this.icon = icon;
this.texture = texture;
}
public void setSize(int width, int height) {
this.width = width;
this.height = height;
hwidth = width / 2;
hheight = height / 2;
}
public IIcon getIcon() {
return icon;
}
public void setIcon(IIcon icon) {
this.icon = icon;
}
public ResourceLocation getTexture() {
return texture;
}
public void setTexture(ResourceLocation textureName) {
this.texture = textureName;
}
/**
* Draws this button to the screen.
*/
@SuppressWarnings("synthetic-access")
@Override
public void drawButton(Minecraft par1Minecraft, int par2, int par3) {
if(visible) {
RenderUtil.bindTexture("textures/gui/widgets.png");
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
this.field_146123_n = par2 >= this.xPosition && par3 >= this.yPosition && par2 < this.xPosition + width
&& par3 < this.yPosition + height;
int hoverState = getHoverState(this.field_146123_n);
// x, y, u, v, width, height
// top half
drawTexturedModalRect(xPosition, yPosition, 0, 46 + hoverState * 20, hwidth, hheight);
drawTexturedModalRect(xPosition + hwidth, yPosition, 200 - hwidth, 46 + hoverState * 20, hwidth, hheight);
// bottom half
drawTexturedModalRect(xPosition, yPosition + hheight, 0, 66 - hheight + (hoverState * 20), hwidth, hheight);
drawTexturedModalRect(xPosition + hwidth, yPosition + hheight, 200 - hwidth, 66 - hheight + (hoverState * 20), hwidth, hheight);
mouseDragged(par1Minecraft, par2, par3);
if(icon != null && texture != null) {
GL11.glPushAttrib(GL11.GL_ENABLE_BIT);
GL11.glEnable(GL11.GL_BLEND);
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
RenderUtil.bindTexture(texture);
int xLoc = xPosition + 2;
int yLoc = yPosition + 2;
drawTexturedModelRectFromIcon(xLoc, yLoc, icon, width - 4, height - 4);
GL11.glPopAttrib();
}
}
}
}
@@ -0,0 +1,33 @@
package com.enderio.core.client.gui;
import net.minecraft.client.gui.FontRenderer;
import net.minecraft.util.IIcon;
import net.minecraft.util.ResourceLocation;
public class IconToggleButton extends IconButton {
private boolean selected = false;
public IconToggleButton(FontRenderer fr, int id, int x, int y, IIcon icon, ResourceLocation texture) {
super(fr, id, x, y, icon, texture);
}
public boolean isSelected() {
return selected;
}
public void setSelected(boolean selected) {
this.selected = selected;
}
@Override
public int getHoverState(boolean par1) {
int result = 1;
if(!enabled || selected) {
result = 0;
} else if(par1) {
result = 2;
}
return result;
}
}
@@ -0,0 +1,85 @@
package com.enderio.core.client.gui;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.renderer.entity.RenderItem;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import org.lwjgl.opengl.GL11;
import com.enderio.core.client.render.RenderUtil;
public class ItemButton extends GuiButton {
public static final RenderItem ITEM_RENDERER = new RenderItem();
public static final int DEFAULT_WIDTH = 24;
public static final int HWIDTH = DEFAULT_WIDTH / 2;
public static final int DEFAULT_HEIGHT = 24;
public static final int HHEIGHT = DEFAULT_HEIGHT / 2;
private ItemStack item;
private FontRenderer fr;
protected int hwidth;
protected int hheight;
public ItemButton(FontRenderer fr, int id, int x, int y, Item item) {
super(id, x, y, DEFAULT_WIDTH, DEFAULT_HEIGHT, "");
this.fr = fr;
this.item = new ItemStack(item, 1, 0);
hwidth = HWIDTH;
hheight = HHEIGHT;
}
public void setSize(int width, int height) {
this.width = width;
this.height = height;
hwidth = width / 2;
hheight = height / 2;
}
/**
* Draws this button to the screen.
*/
@SuppressWarnings("synthetic-access")
@Override
public void drawButton(Minecraft par1Minecraft, int par2, int par3) {
if(visible) {
RenderUtil.bindTexture("textures/gui/widgets.png");
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
this.field_146123_n = par2 >= this.xPosition && par3 >= this.yPosition && par2 < this.xPosition + width
&& par3 < this.yPosition + height;
int hoverState = this.getHoverState(this.field_146123_n);
// x, y, u, v, width, height
// top half
drawTexturedModalRect(xPosition, yPosition, 0, 46 + hoverState * 20, hwidth, hheight);
drawTexturedModalRect(xPosition + hwidth, yPosition, 200 - hwidth, 46 + hoverState * 20, hwidth, hheight);
// bottom half
drawTexturedModalRect(xPosition, yPosition + hheight, 0, 66 - hheight + (hoverState * 20), hwidth, hheight);
drawTexturedModalRect(xPosition + hwidth, yPosition + hheight, 200 - hwidth, 66 - hheight + (hoverState * 20), hwidth, hheight);
mouseDragged(par1Minecraft, par2, par3);
int l = 14737632;
if(!this.enabled) {
l = -6250336;
} else if(this.field_146123_n) {
l = 16777120;
}
int xLoc = xPosition + hwidth - 8;
int yLoc = yPosition + hheight - 10;
ITEM_RENDERER.renderItemIntoGUI(fr, par1Minecraft.renderEngine, item, xLoc, yLoc);
}
}
}
@@ -0,0 +1,7 @@
package com.enderio.core.client.gui;
public interface ListSelectionListener<T> {
void selectionChanged(GuiScrollableList<T> list, int selectedIndex);
}
@@ -0,0 +1,41 @@
package com.enderio.core.client.gui;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
public class TemplateSlot extends Slot {
protected int slotIndex;
public TemplateSlot(IInventory inventory, int slotIndex, int x, int y) {
super(inventory, slotIndex, x, y);
this.slotIndex = slotIndex;
}
@Override
public boolean canTakeStack(EntityPlayer player) {
return true;
}
@Override
public ItemStack decrStackSize(int par1) {
return null;
}
@Override
public boolean isItemValid(ItemStack stack) {
return true;
}
@Override
public void putStack(ItemStack par1ItemStack) {
if(par1ItemStack != null) {
par1ItemStack.stackSize = 0;
}
inventory.setInventorySlotContents(slotIndex, par1ItemStack);
onSlotChanged();
}
}
@@ -0,0 +1,100 @@
package com.enderio.core.client.gui;
import java.lang.reflect.Field;
import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.gui.GuiTextField;
import com.google.common.base.Strings;
import cpw.mods.fml.relauncher.ReflectionHelper;
public class TextFieldEIO extends GuiTextField {
public interface ICharFilter {
boolean passesFilter(TextFieldEIO tf, char c);
}
public static final ICharFilter FILTER_NUMERIC = new ICharFilter() {
@Override
public boolean passesFilter(TextFieldEIO tf, char c) {
return Character.isDigit(c) || (c == '-' && Strings.isNullOrEmpty(tf.getText()));
}
};
public static ICharFilter FILTER_ALPHABETICAL = new ICharFilter() {
@Override
public boolean passesFilter(TextFieldEIO tf, char c) {
return Character.isLetter(c);
}
};
public static ICharFilter FILTER_ALPHANUMERIC = new ICharFilter() {
@Override
public boolean passesFilter(TextFieldEIO tf, char c) {
return FILTER_NUMERIC.passesFilter(tf, c) || FILTER_ALPHABETICAL.passesFilter(tf, c);
}
};
private final int xOrigin;
private final int yOrigin;
private ICharFilter filter;
private static Field canLoseFocus;
static {
try {
canLoseFocus = ReflectionHelper.findField(GuiTextField.class, "canLoseFocus", "field_146212_n", "n");
canLoseFocus.setAccessible(true);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public TextFieldEIO(FontRenderer fnt, int x, int y, int width, int height) {
this(fnt, x, y, width, height, null);
}
public TextFieldEIO(FontRenderer fnt, int x, int y, int width, int height, ICharFilter charFilter) {
super(fnt, x, y, width, height);
this.xOrigin = x;
this.yOrigin = y;
this.filter = charFilter;
}
public void init(IGuiScreen gui) {
this.xPosition = xOrigin + gui.getGuiLeft();
this.yPosition = yOrigin + gui.getGuiTop();
}
public TextFieldEIO setCharFilter(ICharFilter filter) {
this.filter = filter;
return this;
}
@Override
public boolean textboxKeyTyped(char c, int key) {
if(filter == null || filter.passesFilter(this, c) || isSpecialChar(c, key)) {
return super.textboxKeyTyped(c, key);
}
return false;
}
public static boolean isSpecialChar(char c, int key) {
// taken from the giant switch statement in GuiTextField
return c == 1 || c == 3 || c == 22 || c == 24 || key == 14 || key == 199 || key == 203 || key == 205 || key == 207 || key == 211;
}
public boolean getCanLoseFocus() {
try {
return canLoseFocus.getBoolean(this);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public boolean contains(int x, int y) {
return x >= this.xPosition && x < this.xPosition + this.width && y >= this.yPosition && y < this.yPosition + this.height;
}
}
@@ -0,0 +1,74 @@
package com.enderio.core.client.gui;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import net.minecraft.client.gui.FontRenderer;
public class ToolTipManager {
public static interface ToolTipRenderer {
int getGuiLeft();
int getGuiTop();
int getXSize();
FontRenderer getFontRenderer();
void drawHoveringText(List par1List, int par2, int par3, FontRenderer font);
}
private List<GuiToolTip> toolTips = new ArrayList<GuiToolTip>();
public void addToolTip(GuiToolTip toolTip) {
if(!toolTips.contains(toolTip)) {
toolTips.add(toolTip);
}
}
public void removeToolTip(GuiToolTip toolTip) {
toolTips.remove(toolTip);
}
protected final void drawTooltips(ToolTipRenderer renderer, int mouseX, int mouseY) {
for (GuiToolTip toolTip : toolTips) {
toolTip.onTick(mouseX - renderer.getGuiLeft(), mouseY - renderer.getGuiTop());
if(toolTip.shouldDraw()) {
drawTooltip(toolTip, mouseX, mouseY, renderer);
}
}
}
protected void drawTooltip(GuiToolTip toolTip, int mouseX, int mouseY, ToolTipRenderer renderer) {
List<String> list = toolTip.getToolTipText();
if(list == null) {
return;
}
List<String> formatted = new ArrayList<String>(list.size());
for (int i = 0; i < list.size(); i++) {
if(i == 0) {
formatted.add("\u00a7f" + list.get(i));
} else {
formatted.add("\u00a77" + list.get(i));
}
}
if(mouseX > renderer.getGuiLeft() + renderer.getXSize() / 2) {
int maxWidth = 0;
Iterator iterator = formatted.iterator();
while (iterator.hasNext()) {
String s = (String) iterator.next();
int w = renderer.getFontRenderer().getStringWidth(s);
if(w > maxWidth) {
maxWidth = w;
}
}
mouseX -= (maxWidth + 18);
}
renderer.drawHoveringText(formatted, mouseX, mouseY, renderer.getFontRenderer());
}
}
@@ -0,0 +1,190 @@
package com.enderio.core.client.gui;
import java.awt.Rectangle;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.Tessellator;
import org.lwjgl.opengl.GL11;
import com.enderio.core.client.render.RenderUtil;
public class VScrollbarEIO {
protected final IGuiScreen gui;
protected int xOrigin;
protected int yOrigin;
protected int height;
protected int xPosition;
protected int yPosition;
protected Rectangle wholeArea;
protected Rectangle btnUp;
protected Rectangle btnDown;
protected Rectangle thumbArea;
protected int scrollPos;
protected int scrollMax;
protected boolean pressedUp;
protected boolean pressedDown;
protected boolean pressedThumb;
protected int scrollDir;
protected long timeNextScroll;
public VScrollbarEIO(IGuiScreen gui, int xOrigin, int yOrigin, int height) {
this.gui = gui;
this.xOrigin = xOrigin;
this.yOrigin = yOrigin;
this.height = height;
}
public void adjustPosition() {
xPosition = xOrigin + gui.getGuiLeft();
yPosition = yOrigin + gui.getGuiTop();
wholeArea = new Rectangle(xPosition, yPosition,
(int)IconEIO.VSCROLL_THUMB_OFF.width, height);
btnUp = new Rectangle(xPosition, yPosition,
(int)IconEIO.UP_ARROW_OFF.width, (int)IconEIO.UP_ARROW_OFF.height);
btnDown = new Rectangle(xPosition, yPosition + Math.max(0, height - (int)IconEIO.DOWN_ARROW_OFF.height),
(int)IconEIO.DOWN_ARROW_OFF.width, (int)IconEIO.DOWN_ARROW_OFF.height);
thumbArea = new Rectangle(xPosition, yPosition + btnUp.height,
(int)IconEIO.VSCROLL_THUMB_OFF.width, Math.max(0, height - (btnUp.height + btnDown.height)));
}
public int getScrollPos() {
return scrollPos;
}
public void setScrollPos(int scrollPos) {
this.scrollPos = limitPos(scrollPos);
}
public void scrollBy(int amount) {
setScrollPos(scrollPos + amount);
}
public int getScrollMax() {
return scrollMax;
}
public void setScrollMax(int scrollMax) {
this.scrollMax = scrollMax;
setScrollPos(scrollPos);
}
public void drawScrollbar(int mouseX, int mouseY) {
boolean hoverUp = btnUp.contains(mouseX, mouseY);
boolean hoverDown = btnDown.contains(mouseX, mouseY);
IconEIO iconUp;
if(pressedUp) {
iconUp = hoverUp ? IconEIO.UP_ARROW_HOVER_ON : IconEIO.UP_ARROW_ON;
} else {
iconUp = hoverUp ? IconEIO.UP_ARROW_HOVER_OFF : IconEIO.UP_ARROW_OFF;
}
IconEIO iconDown;
if(pressedDown) {
iconDown = hoverDown ? IconEIO.DOWN_ARROW_HOVER_ON : IconEIO.DOWN_ARROW_ON;
} else {
iconDown = hoverDown ? IconEIO.DOWN_ARROW_HOVER_OFF : IconEIO.DOWN_ARROW_OFF;
}
if(scrollDir != 0) {
long time = Minecraft.getSystemTime();
if((timeNextScroll - time) <= 0) {
timeNextScroll = time + 100;
scrollBy(scrollDir);
}
}
RenderUtil.bindTexture(IconEIO.TEXTURE);
GL11.glPushAttrib(GL11.GL_ENABLE_BIT);
GL11.glEnable(GL11.GL_BLEND);
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
GL11.glColor3f(1, 1, 1);
Tessellator tes = Tessellator.instance;
tes.startDrawingQuads();
iconUp.renderIcon(btnUp.x, btnUp.y, false);
iconDown.renderIcon(btnDown.x, btnDown.y, false);
if(scrollMax > 0) {
int thumbPos = getThumbPosition();
boolean hoverThumb = thumbArea.contains(mouseX, mouseY) && mouseY >= thumbPos && mouseY < thumbPos + (int) IconEIO.VSCROLL_THUMB_OFF.height;
IconEIO iconThumb;
if(pressedThumb) {
iconThumb = IconEIO.VSCROLL_THUMB_HOVER_ON;
} else {
iconThumb = hoverThumb ? IconEIO.VSCROLL_THUMB_HOVER_OFF : IconEIO.VSCROLL_THUMB_OFF;
}
iconThumb.renderIcon(thumbArea.x, thumbPos, false);
}
tes.draw();
GL11.glPopAttrib();
}
public boolean mouseClicked(int x, int y, int button) {
if(button == 0) {
if(scrollMax > 0 && thumbArea.contains(x, y)) {
int thumbPos = getThumbPosition();
pressedUp = y < thumbPos;
pressedDown = y >= thumbPos + (int)IconEIO.VSCROLL_THUMB_OFF.height;
pressedThumb = !pressedUp && !pressedDown;
} else {
pressedUp = btnUp.contains(x, y);
pressedDown = btnDown.contains(x, y);
pressedThumb = false;
}
scrollDir = (pressedDown ? 1 : 0) - (pressedUp ? 1 : 0);
if(scrollDir != 0) {
timeNextScroll = Minecraft.getSystemTime() + 200;
scrollBy(scrollDir);
}
}
return isDragActive();
}
public boolean mouseClickMove(int x, int y, int button, long time) {
if(pressedThumb) {
int pos = y - (thumbArea.y + (int)IconEIO.VSCROLL_THUMB_OFF.height/2);
int len = thumbArea.height - (int)IconEIO.VSCROLL_THUMB_OFF.height;
if(len > 0) {
setScrollPos(Math.round(pos * (float)scrollMax / (float)len));
}
return true;
}
return false;
}
public void mouseMovedOrUp(int x, int y, int button) {
pressedUp = false;
pressedDown = false;
pressedThumb = false;
scrollDir = 0;
}
public void mouseWheel(int x, int y, int delta) {
if(!isDragActive() && wholeArea.contains(x, y)) {
scrollBy(-Integer.signum(delta));
}
}
public boolean isDragActive() {
return pressedUp || pressedDown || pressedThumb;
}
protected int getThumbPosition() {
return thumbArea.y + (thumbArea.height - (int)IconEIO.VSCROLL_THUMB_OFF.height) * scrollPos / scrollMax;
}
protected int limitPos(int pos) {
return Math.max(0, Math.min(pos, scrollMax));
}
}
@@ -0,0 +1,385 @@
package com.enderio.core.client.render;
import java.util.ArrayList;
import java.util.List;
import com.enderio.core.common.util.BlockCoord;
import com.enderio.core.common.vecmath.Vector2f;
import com.enderio.core.common.vecmath.Vector3d;
import com.enderio.core.common.vecmath.Vector3f;
import com.enderio.core.common.vecmath.Vertex;
import net.minecraft.block.Block;
import net.minecraft.util.AxisAlignedBB;
import net.minecraftforge.common.util.ForgeDirection;
public final class BoundingBox {
public static final BoundingBox UNIT_CUBE = new BoundingBox(0, 0, 0, 1, 1, 1);
public final float minX;
public final float minY;
public final float minZ;
public final float maxX;
public final float maxY;
public final float maxZ;
public BoundingBox(AxisAlignedBB bb) {
this(bb.minX, bb.minY, bb.minZ, bb.maxX, bb.maxY, bb.maxZ);
}
public BoundingBox(float minX, float minY, float minZ, float maxX, float maxY, float maxZ) {
this.minX = minX;
this.minY = minY;
this.minZ = minZ;
this.maxX = maxX;
this.maxY = maxY;
this.maxZ = maxZ;
}
public BoundingBox(double minX, double minY, double minZ, double maxX, double maxY, double maxZ) {
this.minX = (float) minX;
this.minY = (float) minY;
this.minZ = (float) minZ;
this.maxX = (float) maxX;
this.maxY = (float) maxY;
this.maxZ = (float) maxZ;
}
public BoundingBox(Vector3d min, Vector3d max) {
this(min.x, min.y, min.z, max.x, max.y, max.z);
}
public BoundingBox(BoundingBox copy) {
this(copy.minX, copy.minY, copy.minZ, copy.maxX, copy.maxY, copy.maxZ);
}
public BoundingBox(BlockCoord bc) {
this(bc.x, bc.y, bc.z, bc.x + 1, bc.y + 1, bc.z + 1);
}
public BoundingBox(Block block) {
this(block.getBlockBoundsMinX(), block.getBlockBoundsMinY(), block.getBlockBoundsMinZ(), block.getBlockBoundsMaxX(), block.getBlockBoundsMaxY(), block.getBlockBoundsMaxZ());
}
public BoundingBox expandBy(BoundingBox other) {
return new BoundingBox(
Math.min(minX, other.minX), Math.min(minY, other.minY), Math.min(minZ, other.minZ),
Math.max(maxX, other.maxX), Math.max(maxY, other.maxY), Math.max(maxZ, other.maxZ));
}
public boolean contains(BoundingBox other) {
return minX >= other.minX && minY <= other.minY && minZ <= other.minZ && maxX >= other.maxX && maxY <= other.maxY && maxZ <= other.maxZ;
}
public boolean intersects(BoundingBox other) {
return other.maxX > this.minX && other.minX < this.maxX ? (other.maxY > this.minY && other.minY < this.maxY ? other.maxZ > this.minZ
&& other.minZ < this.maxZ : false) : false;
}
public boolean isValid() {
return minX < maxX && minY < maxY && minZ < maxZ;
}
public BoundingBox scale(double x, double y, double z) {
return scale((float) x, (float) y, (float) z);
}
public BoundingBox scale(float x, float y, float z) {
x = 1 - x;
y = 1 - y;
z = 1 - z;
float w = ((maxX - minX) * x) / 2;
float h = ((maxY - minY) * y) / 2;
float d = ((maxZ - minZ) * z) / 2;
return new BoundingBox(minX + w, minY + h, minZ + d, maxX - w, maxY - h, maxZ - d);
}
public BoundingBox translate(float x, float y, float z) {
return new BoundingBox(minX + x, minY + y, minZ + z, maxX + x, maxY + y, maxZ + z);
}
public BoundingBox translate(Vector3d translation) {
return translate((float) translation.x, (float) translation.y, (float) translation.z);
}
public BoundingBox translate(Vector3f vec) {
return translate(vec.x, vec.y, vec.z);
}
public BoundingBox transform(VertexTransform iTransformation) {
Vector3d min = new Vector3d(minX, minY, minZ);
Vector3d max = new Vector3d(maxX, maxY, maxZ);
iTransformation.apply(min);
iTransformation.apply(max);
return new BoundingBox(
Math.min(min.x, max.x), Math.min(min.y, max.y), Math.min(min.z, max.z),
Math.max(min.x, max.x), Math.max(min.y, max.y), Math.max(min.z, max.z));
}
/**
* Returns the vertices of the corners for the specified face in counter
* clockwise order.
*
* @param face
* @return
*/
public List<Vertex> getCornersWithUvForFace(ForgeDirection face) {
return getCornersWithUvForFace(face, 0, 1, 0, 1);
}
public List<Vertex> getCornersWithUvForFace(ForgeDirection face, float minU, float maxU, float minV, float maxV) {
List<Vertex> result = new ArrayList<Vertex>(4);
switch (face) {
case NORTH:
result.add(new Vertex(new Vector3d(maxX, minY, minZ), new Vector3f(0, 0, -1), new Vector2f(minU, minV)));
result.add(new Vertex(new Vector3d(minX, minY, minZ), new Vector3f(0, 0, -1), new Vector2f(maxU, minV)));
result.add(new Vertex(new Vector3d(minX, maxY, minZ), new Vector3f(0, 0, -1), new Vector2f(maxU, maxV)));
result.add(new Vertex(new Vector3d(maxX, maxY, minZ), new Vector3f(0, 0, -1), new Vector2f(minU, maxV)));
break;
case SOUTH:
result.add(new Vertex(new Vector3d(minX, minY, maxZ), new Vector3f(0, 0, 1), new Vector2f(maxU, minV)));
result.add(new Vertex(new Vector3d(maxX, minY, maxZ), new Vector3f(0, 0, 1), new Vector2f(minU, minV)));
result.add(new Vertex(new Vector3d(maxX, maxY, maxZ), new Vector3f(0, 0, 1), new Vector2f(minU, maxV)));
result.add(new Vertex(new Vector3d(minX, maxY, maxZ), new Vector3f(0, 0, 1), new Vector2f(maxU, maxV)));
break;
case EAST:
result.add(new Vertex(new Vector3d(maxX, maxY, minZ), new Vector3f(1, 0, 0), new Vector2f(maxU, maxV)));
result.add(new Vertex(new Vector3d(maxX, maxY, maxZ), new Vector3f(1, 0, 0), new Vector2f(minU, maxV)));
result.add(new Vertex(new Vector3d(maxX, minY, maxZ), new Vector3f(1, 0, 0), new Vector2f(minU, minV)));
result.add(new Vertex(new Vector3d(maxX, minY, minZ), new Vector3f(1, 0, 0), new Vector2f(maxU, minV)));
break;
case WEST:
result.add(new Vertex(new Vector3d(minX, minY, minZ), new Vector3f(-1, 0, 0), new Vector2f(maxU, minV)));
result.add(new Vertex(new Vector3d(minX, minY, maxZ), new Vector3f(-1, 0, 0), new Vector2f(minU, minV)));
result.add(new Vertex(new Vector3d(minX, maxY, maxZ), new Vector3f(-1, 0, 0), new Vector2f(minU, maxV)));
result.add(new Vertex(new Vector3d(minX, maxY, minZ), new Vector3f(-1, 0, 0), new Vector2f(maxU, maxV)));
break;
case UP:
result.add(new Vertex(new Vector3d(maxX, maxY, maxZ), new Vector3f(0, 1, 0), new Vector2f(minU, minV)));
result.add(new Vertex(new Vector3d(maxX, maxY, minZ), new Vector3f(0, 1, 0), new Vector2f(minU, maxV)));
result.add(new Vertex(new Vector3d(minX, maxY, minZ), new Vector3f(0, 1, 0), new Vector2f(maxU, maxV)));
result.add(new Vertex(new Vector3d(minX, maxY, maxZ), new Vector3f(0, 1, 0), new Vector2f(maxU, minV)));
break;
case DOWN: //
case UNKNOWN:
default:
result.add(new Vertex(new Vector3d(minX, minY, minZ), new Vector3f(0, -1, 0), new Vector2f(maxU, maxV)));
result.add(new Vertex(new Vector3d(maxX, minY, minZ), new Vector3f(0, -1, 0), new Vector2f(minU, maxV)));
result.add(new Vertex(new Vector3d(maxX, minY, maxZ), new Vector3f(0, -1, 0), new Vector2f(minU, minV)));
result.add(new Vertex(new Vector3d(minX, minY, maxZ), new Vector3f(0, -1, 0), new Vector2f(maxU, minV)));
break;
}
return result;
}
/**
* Returns the vertices of the corners for the specified face in counter
* clockwise order, starting with the top left.
*
* @param face
* @return
*/
public List<Vector3f> getCornersForFace(ForgeDirection face) {
List<Vector3f> result = new ArrayList<Vector3f>(4);
switch (face) {
case NORTH:
result.add(new Vector3f(minX, maxY, minZ));
result.add(new Vector3f(maxX, maxY, minZ));
result.add(new Vector3f(maxX, minY, minZ));
result.add(new Vector3f(minX, minY, minZ));
break;
case SOUTH:
result.add(new Vector3f(minX, maxY, maxZ));
result.add(new Vector3f(minX, minY, maxZ));
result.add(new Vector3f(maxX, minY, maxZ));
result.add(new Vector3f(maxX, maxY, maxZ));
break;
case EAST:
result.add(new Vector3f(maxX, minY, maxZ));
result.add(new Vector3f(maxX, minY, minZ));
result.add(new Vector3f(maxX, maxY, minZ));
result.add(new Vector3f(maxX, maxY, maxZ));
break;
case WEST:
result.add(new Vector3f(minX, maxY, maxZ));
result.add(new Vector3f(minX, maxY, minZ));
result.add(new Vector3f(minX, minY, minZ));
result.add(new Vector3f(minX, minY, maxZ));
break;
case UP:
result.add(new Vector3f(maxX, maxY, maxZ));
result.add(new Vector3f(maxX, maxY, minZ));
result.add(new Vector3f(minX, maxY, minZ));
result.add(new Vector3f(minX, maxY, maxZ));
break;
case DOWN:
case UNKNOWN:
default:
result.add(new Vector3f(minX, minY, maxZ));
result.add(new Vector3f(minX, minY, minZ));
result.add(new Vector3f(maxX, minY, minZ));
result.add(new Vector3f(maxX, minY, maxZ));
break;
}
return result;
}
/**
* Returns the vertices of the corners for the specified face in counter
* clockwise order, starting with the top left.
*
* @param face
* @return
*/
public List<Vector3d> getCornersForFaceD(ForgeDirection face) {
List<Vector3d> result = new ArrayList<Vector3d>(4);
switch (face) {
case NORTH:
result.add(new Vector3d(minX, maxY, minZ));
result.add(new Vector3d(maxX, maxY, minZ));
result.add(new Vector3d(maxX, minY, minZ));
result.add(new Vector3d(minX, minY, minZ));
break;
case SOUTH:
result.add(new Vector3d(minX, maxY, maxZ));
result.add(new Vector3d(minX, minY, maxZ));
result.add(new Vector3d(maxX, minY, maxZ));
result.add(new Vector3d(maxX, maxY, maxZ));
break;
case EAST:
result.add(new Vector3d(maxX, minY, maxZ));
result.add(new Vector3d(maxX, minY, minZ));
result.add(new Vector3d(maxX, maxY, minZ));
result.add(new Vector3d(maxX, maxY, maxZ));
break;
case WEST:
result.add(new Vector3d(minX, maxY, maxZ));
result.add(new Vector3d(minX, maxY, minZ));
result.add(new Vector3d(minX, minY, minZ));
result.add(new Vector3d(minX, minY, maxZ));
break;
case UP:
result.add(new Vector3d(maxX, maxY, maxZ));
result.add(new Vector3d(maxX, maxY, minZ));
result.add(new Vector3d(minX, maxY, minZ));
result.add(new Vector3d(minX, maxY, maxZ));
break;
case DOWN:
case UNKNOWN:
default:
result.add(new Vector3d(minX, minY, maxZ));
result.add(new Vector3d(minX, minY, minZ));
result.add(new Vector3d(maxX, minY, minZ));
result.add(new Vector3d(maxX, minY, maxZ));
break;
}
return result;
}
public Vector3d getCenter() {
return new Vector3d(minX + (maxX - minX) / 2, minY + (maxY - minY) / 2, minZ + (maxZ - minZ) / 2);
}
public float sizeX() {
return Math.abs(maxX - minX);
}
public float sizeY() {
return Math.abs(maxY - minY);
}
public float sizeZ() {
return Math.abs(maxZ - minZ);
}
public Vector3d getMin() {
return new Vector3d(minX, minY, minZ);
}
public Vector3d getMax() {
return new Vector3d(maxX, maxY, maxZ);
}
public float getArea() {
return sizeX() * sizeY() * sizeZ();
}
@Override
public String toString() {
return "BoundingBox [minX=" + minX + ", minY=" + minY + ", minZ=" + minZ + ", maxX=" + maxX + ", maxY=" + maxY + ", maxZ=" + maxZ + "]";
}
public BoundingBox fixMinMax() {
float mnX = minX;
float mnY = minY;
float mnZ = minZ;
float mxX = maxX;
float mxY = maxY;
float mxZ = maxZ;
boolean mod = false;
if(minX > maxX) {
mnX = maxX;
mxX = minX;
mod = true;
}
if(minY > maxY) {
mnY = maxY;
mxY = minY;
mod = true;
}
if(minZ > maxZ) {
mnZ = maxZ;
mxZ = minZ;
mod = true;
}
if(!mod) {
return this;
}
return new BoundingBox(mnX, mnY, mnZ, mxX, mxY, mxZ);
}
public AxisAlignedBB getAxisAlignedBB() {
return AxisAlignedBB.getBoundingBox(minX, minY, minZ, maxX, maxY, maxZ);
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + Float.floatToIntBits(maxX);
result = prime * result + Float.floatToIntBits(maxY);
result = prime * result + Float.floatToIntBits(maxZ);
result = prime * result + Float.floatToIntBits(minX);
result = prime * result + Float.floatToIntBits(minY);
result = prime * result + Float.floatToIntBits(minZ);
return result;
}
@Override
public boolean equals(Object obj) {
if(this == obj)
return true;
if(obj == null)
return false;
if(getClass() != obj.getClass())
return false;
BoundingBox other = (BoundingBox) obj;
if(Float.floatToIntBits(maxX) != Float.floatToIntBits(other.maxX))
return false;
if(Float.floatToIntBits(maxY) != Float.floatToIntBits(other.maxY))
return false;
if(Float.floatToIntBits(maxZ) != Float.floatToIntBits(other.maxZ))
return false;
if(Float.floatToIntBits(minX) != Float.floatToIntBits(other.minX))
return false;
if(Float.floatToIntBits(minY) != Float.floatToIntBits(other.minY))
return false;
if(Float.floatToIntBits(minZ) != Float.floatToIntBits(other.minZ))
return false;
return true;
}
}
@@ -0,0 +1,69 @@
package com.enderio.core.client.render;
import java.awt.Color;
import com.enderio.core.common.vecmath.Vector3f;
import com.enderio.core.common.vecmath.Vector4f;
public final class ColorUtil {
public static Vector4f toFloat(Color color) {
float[] rgba = color.getComponents(null);
return new Vector4f(rgba[0], rgba[1], rgba[2], rgba[3]);
}
public static Vector3f toFloat(int rgb) {
int r = rgb >> 16 & 255;
int g = rgb >> 8 & 255;
int b = rgb & 255;
return new Vector3f(r / 255F, g / 255F, b / 255F);
}
public static int getRGB(Color color) {
return getRGB(color.getRed(), color.getGreen(), color.getBlue());
}
public static int getRGBA(Color color) {
return getRGBA(color.getRed(), color.getGreen(), color.getBlue(), color.getAlpha());
}
public static int getARGB(Color color) {
return getRGBA(color.getAlpha(), color.getRed(), color.getGreen(), color.getBlue());
}
public static int getRGB(Vector3f rgb) {
return getRGB(rgb.x, rgb.y, rgb.z);
}
public static int getRGB(float r, float g, float b) {
return getRGB((int) (r * 255), (int) (g * 255), (int) (b * 255));
}
public static int getRGBA(Vector4f col) {
return getRGBA(col.x, col.y,col.z,col.w);
}
public static int getRGBA(float r, float g, float b, float a) {
return getRGBA((int) (r * 255), (int) (g * 255), (int) (b * 255), (int) (a * 255));
}
public static int getARGB(float r, float g, float b, float a) {
return getARGB((int) (a * 255), (int) (r * 255), (int) (g * 255), (int) (b * 255));
}
public static int getRGB(int r, int g, int b) {
return (r & 0xFF) << 16 | (g & 0xFF) << 8 | (b & 0xFF);
}
public static int getARGB(int r, int g, int b, int a) {
return (a & 0xFF) << 24 | (r & 0xFF) << 16 | (g & 0xFF) << 8 | (b & 0xFF);
}
public static int getRGBA(int r, int g, int b, int a) {
return (r & 0xFF) << 24 | (g & 0xFF) << 16 | (b & 0xFF) << 8 | (a & 0xFF);
}
private ColorUtil() {
}
}
@@ -0,0 +1,337 @@
package com.enderio.core.client.render;
import java.util.ArrayList;
import java.util.EnumSet;
import java.util.List;
import com.enderio.core.common.util.BlockCoord;
import com.enderio.core.common.util.ForgeDirectionOffsets;
import com.enderio.core.common.vecmath.Vector2f;
import com.enderio.core.common.vecmath.Vector3d;
import com.enderio.core.common.vecmath.Vector4f;
import com.enderio.core.common.vecmath.Vertex;
import net.minecraft.block.Block;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
public class ConnectedTextureRenderer implements IRenderFace, IConnectedTextureRenderer {
public static interface TextureCallback {
public IIcon getTextureForFace(ForgeDirection dir);
}
public static class DefaultTextureCallback implements TextureCallback {
private final IIcon tex;
private final Block block;
private final int meta;
public DefaultTextureCallback(IIcon borderTex) {
this.tex = borderTex;
block = null;
meta = 0;
}
public DefaultTextureCallback(Block block, int meta) {
tex = null;
this.block = block;
this.meta = meta;
}
@Override
public IIcon getTextureForFace(ForgeDirection dir) {
if(tex != null) {
return tex;
}
if(block != null) {
return block.getIcon(dir.ordinal(), meta);
}
return null;
}
}
private boolean forceAllEdges = false;
private TextureCallback edgeTexureCallback;
private boolean matchMetaData;
private EnumSet<ForgeDirection> sidesToRender = EnumSet.allOf(ForgeDirection.class);
public boolean isForceAllEdges() {
return forceAllEdges;
}
public void setForceAllEdges(boolean forceAllEdges) {
this.forceAllEdges = forceAllEdges;
}
public TextureCallback getEdgeTexureCallback() {
return edgeTexureCallback;
}
public void setEdgeTexureCallback(TextureCallback edgeTexureCallback) {
this.edgeTexureCallback = edgeTexureCallback;
}
public void setEdgeTexture(IIcon texture) {
if(texture == null) {
edgeTexureCallback = null;
return;
}
edgeTexureCallback = new DefaultTextureCallback(texture);
}
public void setMatchMeta(boolean matchMetaData) {
this.matchMetaData = matchMetaData;
}
public void setSidesToRender(EnumSet<ForgeDirection> sides) {
sidesToRender = sides.clone();
}
@Override
public boolean matchesMetadata(int meta1, int meta2) {
return !this.matchMetaData || meta1 == meta2;
}
@Override
public void renderFace(CustomRenderBlocks rb, ForgeDirection face, Block par1Block, double x, double y, double z, IIcon texture, List<Vertex> refVertices,
boolean translateToXYZ) {
if (!sidesToRender.contains(face)) {
return;
}
List<Vertex> finalVerts = new ArrayList<Vertex>();
finalVerts.addAll(refVertices);
IIcon borderTex = edgeTexureCallback == null ? null : edgeTexureCallback.getTextureForFace(face);
if(borderTex != null) {
texture = borderTex;
List<ForgeDirection> edges;
if(forceAllEdges) {
edges = RenderUtil.getEdgesForFace(face);
} else {
edges = RenderUtil.getNonConectedEdgesForFace(rb.blockAccess, (int) x, (int) y, (int) z, face, this);
}
List<ForgeDirection> allEdges = RenderUtil.getEdgesForFace(face);
float scaleFactor = 15f / 16f;
Vector2f uv = new Vector2f();
//for each that needs a border, add a geom for the border and move in the 'centre' of the face
//so there is no overlap
for (ForgeDirection edge : edges) {
//We need to move the 'centre' of the face so it doesn't overlap with the border
moveCorners(refVertices, edge, 1 - scaleFactor);
//Now create the geometry for this edge of the border
float xLen = 1 - Math.abs(edge.offsetX) * scaleFactor;
float yLen = 1 - Math.abs(edge.offsetY) * scaleFactor;
float zLen = 1 - Math.abs(edge.offsetZ) * scaleFactor;
xLen -= 2* (1 - par1Block.getBlockBoundsMaxX()) - par1Block.getBlockBoundsMinX();
yLen -= 2* (1 - par1Block.getBlockBoundsMaxY()) - par1Block.getBlockBoundsMinY();
zLen -= 2* (1 - par1Block.getBlockBoundsMaxZ()) - par1Block.getBlockBoundsMinZ();
BoundingBox bb = BoundingBox.UNIT_CUBE.scale(xLen, yLen, zLen);
List<Vector3d> corners = bb.getCornersForFaceD(face);
for (Vector3d corner : corners) {
if(translateToXYZ) {
corner.x += x;
corner.y += y;
corner.z += z;
}
corner.x += (float) (edge.offsetX * 0.5) - Math.signum(edge.offsetX) * xLen / 2f;
corner.y += (float) (edge.offsetY * 0.5) - Math.signum(edge.offsetY) * yLen / 2f;
corner.z += (float) (edge.offsetZ * 0.5) - Math.signum(edge.offsetZ) * zLen / 2f;
}
int[] indices = new int[] { 0, 1, 2, 3 };
for (int index : indices) {
Vector3d corner = corners.get(index);
if(translateToXYZ) {
RenderUtil.getUvForCorner(uv, corner, (int) x, (int) y, (int) z, face, texture);
} else {
RenderUtil.getUvForCorner(uv, corner, 0, 0, 0, face, texture);
}
Vertex vertex = new Vertex();
vertex.xyz.set(corner);
//vertex.xyz.add(ForgeDirectionOffsets.offsetScaled(face, 0.00005));
vertex.uv = new Vector2f(uv);
applyLighting(vertex, corner, refVertices);
finalVerts.add(vertex);
}
}
for (int i = 0; i < allEdges.size(); i++) {
ForgeDirection dir = allEdges.get(i);
ForgeDirection dir2 = i + 1 < allEdges.size() ? allEdges.get(i + 1) : allEdges.get(0);
if(needsCorner(dir, dir2, edges, face, par1Block, x, y, z, rb.blockAccess)) {
Vertex v = new Vertex();
v.uv = new Vector2f();
v.xyz.set(ForgeDirectionOffsets.forDir(dir));
v.xyz.add(ForgeDirectionOffsets.forDir(dir2));
//TODO: dodgy hack to just move the corner forward a bit
v.xyz.add(ForgeDirectionOffsets.offsetScaled(face, 0.001f));
v.xyz.x = Math.max(-0.001, v.xyz.x);
v.xyz.y = Math.max(-0.001, v.xyz.y);
v.xyz.z = Math.max(-0.001, v.xyz.z);
v.xyz.x -= (1 - par1Block.getBlockBoundsMaxX()) - par1Block.getBlockBoundsMinX();
v.xyz.y -= (1 - par1Block.getBlockBoundsMaxY()) - par1Block.getBlockBoundsMinY();
v.xyz.z -= (1 - par1Block.getBlockBoundsMaxZ()) - par1Block.getBlockBoundsMinZ();
if(ForgeDirectionOffsets.isPositiveOffset(face)) {
v.xyz.add(ForgeDirectionOffsets.forDir(face));
}
if(translateToXYZ) {
v.xyz.x += x;
v.xyz.y += y;
v.xyz.z += z;
RenderUtil.getUvForCorner(v.uv, v.xyz, (int) x, (int) y, (int) z, face, texture);
} else {
RenderUtil.getUvForCorner(v.uv, v.xyz, 0, 0, 0, face, texture);
}
applyLighting(v, v.xyz, refVertices);
finalVerts.add(v);
Vector3d corner = new Vector3d(v.xyz);
if(ForgeDirectionOffsets.isPositiveOffset(face)) {
addVertexForCorner(face, x, y, z, texture, translateToXYZ, finalVerts, dir2, null, corner);
addVertexForCorner(face, x, y, z, texture, translateToXYZ, finalVerts, dir, dir2, corner);
addVertexForCorner(face, x, y, z, texture, translateToXYZ, finalVerts, dir, null, corner);
} else {
addVertexForCorner(face, x, y, z, texture, translateToXYZ, finalVerts, dir, null, corner);
addVertexForCorner(face, x, y, z, texture, translateToXYZ, finalVerts, dir, dir2, corner);
addVertexForCorner(face, x, y, z, texture, translateToXYZ, finalVerts, dir2, null, corner);
}
}
}
}
RenderUtil.addVerticesToTessellator(finalVerts, Tessellator.instance);
}
private Vertex getClosestVertex(List<Vertex> vertices, Vector3d corner) {
Vertex result = null;
double d2 = Double.MAX_VALUE;
for (Vertex v : vertices) {
double tmp = corner.distanceSquared(v.xyz);
if(tmp <= d2) {
result = v;
d2 = tmp;
}
}
return result;
}
private void addVertexForCorner(ForgeDirection face, double x, double y, double z, IIcon texture, boolean translateToXYZ, List<Vertex> vertices,
ForgeDirection dir, ForgeDirection dir2, Vector3d corner) {
float scale = 1 / 16f;
Vertex vert = new Vertex();
vert.uv = new Vector2f();
vert.xyz.set(corner);
vert.xyz.sub(ForgeDirectionOffsets.offsetScaled(dir, scale));
if(dir2 != null) {
vert.xyz.sub(ForgeDirectionOffsets.offsetScaled(dir2, scale));
}
if(translateToXYZ) {
RenderUtil.getUvForCorner(vert.uv, vert.xyz, (int) x, (int) y, (int) z, face, texture);
} else {
RenderUtil.getUvForCorner(vert.uv, vert.xyz, 0, 0, 0, face, texture);
}
applyLighting(vert, corner, vertices);
vertices.add(vert);
}
private void applyLighting(Vertex vert, Vector3d samplePoint, List<Vertex> litVertices) {
Vertex closest = getClosestVertex(litVertices, samplePoint);
if(closest == null) {
return;
}
vert.setBrightness(closest.brightness);
Vector4f col = closest.getColor();
if(col != null) {
vert.setColor(col);
}
}
private boolean needsCorner(ForgeDirection dir, ForgeDirection dir2, List<ForgeDirection> edges, ForgeDirection face,
Block par1Block, double x, double y,
double z, IBlockAccess blockAccess) {
if(edges.contains(dir) || edges.contains(dir2)) {
return false;
}
BlockCoord bc = new BlockCoord((int) x, (int) y, (int) z);
BlockCoord testLoc = bc.getLocation(dir);
if(RenderUtil.getNonConectedEdgesForFace(blockAccess, testLoc.x, testLoc.y, testLoc.z, face, this).contains(dir2)) {
return true;
}
testLoc = bc.getLocation(dir2);
if(RenderUtil.getNonConectedEdgesForFace(blockAccess, testLoc.x, testLoc.y, testLoc.z, face, this).contains(dir)) {
return true;
}
return false;
}
private void moveCorners(List<Vertex> vertices, ForgeDirection edge, float scaleFactor) {
int[] indices = getClosest(edge, vertices);
if(indices[0] < 0) {
return;
}
vertices.get(indices[0]).xyz.x -= scaleFactor * edge.offsetX;
vertices.get(indices[1]).xyz.x -= scaleFactor * edge.offsetX;
vertices.get(indices[0]).xyz.y -= scaleFactor * edge.offsetY;
vertices.get(indices[1]).xyz.y -= scaleFactor * edge.offsetY;
vertices.get(indices[0]).xyz.z -= scaleFactor * edge.offsetZ;
vertices.get(indices[1]).xyz.z -= scaleFactor * edge.offsetZ;
}
private int[] getClosest(ForgeDirection edge, List<Vertex> vertices) {
int[] res = new int[] { -1, -1 };
boolean highest = edge.offsetX > 0 || edge.offsetY > 0 || edge.offsetZ > 0;
double minMax = highest ? -Double.MAX_VALUE : Double.MAX_VALUE;
int index = 0;
for (Vertex v : vertices) {
double val = get(v.xyz, edge);
if(highest ? val >= minMax : val <= minMax) {
if(val != minMax) {
res[0] = index;
} else {
res[1] = index;
}
minMax = val;
}
index++;
}
return res;
}
private double get(Vector3d xyz, ForgeDirection edge) {
if(edge == ForgeDirection.EAST || edge == ForgeDirection.WEST) {
return xyz.x;
}
if(edge == ForgeDirection.UP || edge == ForgeDirection.DOWN) {
return xyz.y;
}
return xyz.z;
}
}
@@ -0,0 +1,340 @@
package com.enderio.core.client.render;
import com.enderio.core.common.vecmath.Vector3d;
import net.minecraft.block.Block;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.util.IIcon;
import net.minecraftforge.common.util.ForgeDirection;
public final class CubeRenderer {
public static final Vector3d[] verts = new Vector3d[8];
static {
for (int i = 0; i < verts.length; i++) {
verts[i] = new Vector3d();
}
}
public static void render(Block block, int meta) {
render(block, meta, null);
}
public static void render(Block block, int meta, VertexTransform xForm) {
IIcon[] icons = new IIcon[6];
for(ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) {
icons[dir.ordinal()] = block.getIcon(dir.ordinal(), meta);
}
render(BoundingBox.UNIT_CUBE.translate(0, -0.1f, 0), icons, xForm, true);
}
public static void render(BoundingBox bb, IIcon tex) {
render(bb, tex, null, false);
}
public static void render(BoundingBox bb, IIcon tex, boolean tintSides) {
render(bb, tex, null, tintSides);
}
public static void render(BoundingBox bb, IIcon tex, VertexTransform xForm) {
render(bb, tex.getMinU(), tex.getMaxU(), tex.getMinV(), tex.getMaxV(), xForm, false);
}
public static void render(BoundingBox bb, IIcon tex, VertexTransform xForm, float[] brightnessPerSide, boolean tintSides) {
float minU = 0;
float minV = 0;
float maxU = 1;
float maxV = 1;
if(tex != null) {
minU = tex.getMinU();
minV = tex.getMinV();
maxU = tex.getMaxU();
maxV = tex.getMaxV();
}
render(bb, minU, maxU, minV, maxV, xForm, brightnessPerSide, tintSides);
}
public static void render(BoundingBox bb, IIcon tex, VertexTransform xForm, boolean tintSides) {
float minU = 0;
float minV = 0;
float maxU = 1;
float maxV = 1;
if(tex != null) {
minU = tex.getMinU();
minV = tex.getMinV();
maxU = tex.getMaxU();
maxV = tex.getMaxV();
}
render(bb, minU, maxU, minV, maxV, xForm, tintSides);
}
public static void render(BoundingBox bb, float minU, float maxU, float minV, float maxV, boolean tintSides) {
render(bb, minU, maxU, minV, maxV, null, tintSides);
}
public static void render(BoundingBox bb, float minU, float maxU, float minV, float maxV) {
render(bb, minU, maxU, minV, maxV, null, false);
}
public static void render(BoundingBox bb, float minU, float maxU, float minV, float maxV, VertexTransform xForm) {
render(bb, minU, maxU, minV, maxV, xForm, false);
}
public static void render(BoundingBox bb, float minU, float maxU, float minV, float maxV, VertexTransform xForm, boolean tintSides) {
float[] brightnessPerSide = null;
if(tintSides) {
brightnessPerSide = new float[6];
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) {
brightnessPerSide[dir.ordinal()] = RenderUtil.getColorMultiplierForFace(dir);
}
}
render(bb, minU, maxU, minV, maxV, xForm, brightnessPerSide);
}
public static void render(BoundingBox bb, float minU, float maxU, float minV, float maxV, VertexTransform xForm, float[] brightnessPerSide, boolean tintSides) {
if(tintSides) {
if(brightnessPerSide == null || brightnessPerSide.length != 6) {
brightnessPerSide = new float[] { 1, 1, 1, 1, 1, 1 };
}
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) {
brightnessPerSide[dir.ordinal()] = brightnessPerSide[dir.ordinal()] * RenderUtil.getColorMultiplierForFace(dir);
}
}
render(bb, minU, maxU, minV, maxV, xForm, brightnessPerSide);
}
public static void render(BoundingBox bb, float minU, float maxU, float minV, float maxV, VertexTransform xForm, float[] brightnessPerSide) {
if(brightnessPerSide != null && brightnessPerSide.length != 6) {
brightnessPerSide = null;
}
setupVertices(bb, xForm);
float tmp = minV;
minV = maxV;
maxV = tmp;
Tessellator tessellator = Tessellator.instance;
tessellator.setNormal(0, 0, -1);
if(brightnessPerSide != null) {
float cm = brightnessPerSide[ForgeDirection.NORTH.ordinal()];
tessellator.setColorOpaque_F(cm, cm, cm);
}
addVecWithUV(verts[1], minU, minV);
addVecWithUV(verts[0], maxU, minV);
addVecWithUV(verts[3], maxU, maxV);
addVecWithUV(verts[2], minU, maxV);
tessellator.setNormal(0, 0, 1);
if(brightnessPerSide != null) {
float cm = brightnessPerSide[ForgeDirection.SOUTH.ordinal()];
tessellator.setColorOpaque_F(cm, cm, cm);
}
addVecWithUV(verts[4], minU, minV);
addVecWithUV(verts[5], maxU, minV);
addVecWithUV(verts[6], maxU, maxV);
addVecWithUV(verts[7], minU, maxV);
tessellator.setNormal(0, 1, 0);
if(brightnessPerSide != null) {
float cm = brightnessPerSide[ForgeDirection.UP.ordinal()];
tessellator.setColorOpaque_F(cm, cm, cm);
}
addVecWithUV(verts[6], minU, minV);
addVecWithUV(verts[2], minU, maxV);
addVecWithUV(verts[3], maxU, maxV);
addVecWithUV(verts[7], maxU, minV);
tessellator.setNormal(0, -1, 0);
if(brightnessPerSide != null) {
float cm = brightnessPerSide[ForgeDirection.DOWN.ordinal()];
tessellator.setColorOpaque_F(cm, cm, cm);
}
addVecWithUV(verts[0], maxU, maxV);
addVecWithUV(verts[1], minU, maxV);
addVecWithUV(verts[5], minU, minV);
addVecWithUV(verts[4], maxU, minV);
tessellator.setNormal(1, 0, 0);
if(brightnessPerSide != null) {
float cm = brightnessPerSide[ForgeDirection.EAST.ordinal()];
tessellator.setColorOpaque_F(cm, cm, cm);
}
addVecWithUV(verts[2], minU, maxV);
addVecWithUV(verts[6], maxU, maxV);
addVecWithUV(verts[5], maxU, minV);
addVecWithUV(verts[1], minU, minV);
tessellator.setNormal(-1, 0, 0);
if(brightnessPerSide != null) {
float cm = brightnessPerSide[ForgeDirection.WEST.ordinal()];
tessellator.setColorOpaque_F(cm, cm, cm);
}
addVecWithUV(verts[0], minU, minV);
addVecWithUV(verts[4], maxU, minV);
addVecWithUV(verts[7], maxU, maxV);
addVecWithUV(verts[3], minU, maxV);
}
public static void render(BoundingBox bb, IIcon[] icons, boolean tintSides) {
float[] brightnessPerSide = null;
if(tintSides) {
brightnessPerSide = new float[6];
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) {
brightnessPerSide[dir.ordinal()] = RenderUtil.getColorMultiplierForFace(dir);
}
}
render(bb, icons, null, brightnessPerSide);
}
public static void render(BoundingBox bb, IIcon[] icons, VertexTransform xForm, boolean tintSides) {
float[] brightnessPerSide = null;
if(tintSides) {
brightnessPerSide = new float[6];
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) {
brightnessPerSide[dir.ordinal()] = RenderUtil.getColorMultiplierForFace(dir);
}
}
render(bb, icons, xForm, brightnessPerSide);
}
public static void render(BoundingBox bb, IIcon[] faceTextures, VertexTransform xForm, float[] brightnessPerSide) {
setupVertices(bb, xForm);
float minU;
float maxU;
float minV;
float maxV;
IIcon tex;
Tessellator tessellator = Tessellator.instance;
tessellator.setNormal(0, 0, -1);
if(brightnessPerSide != null) {
float cm = brightnessPerSide[ForgeDirection.NORTH.ordinal()];
tessellator.setColorOpaque_F(cm, cm, cm);
}
tex = faceTextures[ForgeDirection.NORTH.ordinal()];
minU = tex.getMinU();
maxU = tex.getMaxU();
minV = tex.getMinV();
maxV = tex.getMaxV();
addVecWithUV(verts[1], minU, maxV);
addVecWithUV(verts[0], maxU, maxV);
addVecWithUV(verts[3], maxU, minV);
addVecWithUV(verts[2], minU, minV);
tessellator.setNormal(0, 0, 1);
if(brightnessPerSide != null) {
float cm = brightnessPerSide[ForgeDirection.SOUTH.ordinal()];
tessellator.setColorOpaque_F(cm, cm, cm);
}
tex = faceTextures[ForgeDirection.SOUTH.ordinal()];
minU = tex.getMinU();
maxU = tex.getMaxU();
minV = tex.getMinV();
maxV = tex.getMaxV();
addVecWithUV(verts[4], minU, maxV);
addVecWithUV(verts[5], maxU, maxV);
addVecWithUV(verts[6], maxU, minV);
addVecWithUV(verts[7], minU, minV);
tessellator.setNormal(0, 1, 0);
if(brightnessPerSide != null) {
float cm = brightnessPerSide[ForgeDirection.UP.ordinal()];
tessellator.setColorOpaque_F(cm, cm, cm);
}
tex = faceTextures[ForgeDirection.UP.ordinal()];
minU = tex.getMinU();
maxU = tex.getMaxU();
minV = tex.getMinV();
maxV = tex.getMaxV();
addVecWithUV(verts[6], minU, minV);
addVecWithUV(verts[2], minU, maxV);
addVecWithUV(verts[3], maxU, maxV);
addVecWithUV(verts[7], maxU, minV);
tessellator.setNormal(0, -1, 0);
if(brightnessPerSide != null) {
float cm = brightnessPerSide[ForgeDirection.DOWN.ordinal()];
tessellator.setColorOpaque_F(cm, cm, cm);
}
tex = faceTextures[ForgeDirection.DOWN.ordinal()];
minU = tex.getMinU();
maxU = tex.getMaxU();
minV = tex.getMinV();
maxV = tex.getMaxV();
addVecWithUV(verts[0], maxU, maxV);
addVecWithUV(verts[1], minU, maxV);
addVecWithUV(verts[5], minU, minV);
addVecWithUV(verts[4], maxU, minV);
tessellator.setNormal(1, 0, 0);
if(brightnessPerSide != null) {
float cm = brightnessPerSide[ForgeDirection.EAST.ordinal()];
tessellator.setColorOpaque_F(cm, cm, cm);
}
tex = faceTextures[ForgeDirection.EAST.ordinal()];
minU = tex.getMinU();
maxU = tex.getMaxU();
minV = tex.getMinV();
maxV = tex.getMaxV();
addVecWithUV(verts[2], minU, minV);
addVecWithUV(verts[6], maxU, minV);
addVecWithUV(verts[5], maxU, maxV);
addVecWithUV(verts[1], minU, maxV);
tessellator.setNormal(-1, 0, 0);
if(brightnessPerSide != null) {
float cm = brightnessPerSide[ForgeDirection.WEST.ordinal()];
tessellator.setColorOpaque_F(cm, cm, cm);
}
tex = faceTextures[ForgeDirection.WEST.ordinal()];
minU = tex.getMinU();
maxU = tex.getMaxU();
minV = tex.getMinV();
maxV = tex.getMaxV();
addVecWithUV(verts[0], minU, maxV);
addVecWithUV(verts[4], maxU, maxV);
addVecWithUV(verts[7], maxU, minV);
addVecWithUV(verts[3], minU, minV);
}
public static void setupVertices(BoundingBox bound) {
setupVertices(bound, null);
}
public static void setupVertices(BoundingBox bound, VertexTransform xForm) {
verts[0].set(bound.minX, bound.minY, bound.minZ);
verts[1].set(bound.maxX, bound.minY, bound.minZ);
verts[2].set(bound.maxX, bound.maxY, bound.minZ);
verts[3].set(bound.minX, bound.maxY, bound.minZ);
verts[4].set(bound.minX, bound.minY, bound.maxZ);
verts[5].set(bound.maxX, bound.minY, bound.maxZ);
verts[6].set(bound.maxX, bound.maxY, bound.maxZ);
verts[7].set(bound.minX, bound.maxY, bound.maxZ);
if(xForm != null) {
for (Vector3d vec : verts) {
xForm.apply(vec);
}
}
}
public static void addVecWithUV(Vector3d vec, double u, double v) {
Tessellator.instance.addVertexWithUV(vec.x, vec.y, vec.z, u, v);
}
private CubeRenderer() {
}
}
@@ -0,0 +1,58 @@
package com.enderio.core.client.render;
import java.util.Collection;
import net.minecraft.block.Block;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
public class CustomCubeRenderer {
public static final CustomCubeRenderer instance = new CustomCubeRenderer();
private CustomRenderBlocks rb = null;
private IIcon overrideTexture;
public void renderBlock(IBlockAccess ba, Block par1Block, int par2, int par3, int par4) {
renderBlock(ba, par1Block, par2, par3, par4, (IRenderFace) null);
}
public void renderBlock(IBlockAccess ba, Block par1Block, int par2, int par3, int par4, IRenderFace renderer) {
if(rb == null) {
rb = new CustomRenderBlocks(ba);
}
rb.blockAccess = ba;
rb.setOverrideTexture(getOverrideTexture());
rb.setFaceRenderers(null);
if(renderer != null) {
rb.addFaceRenderer(renderer);
}
rb.setRenderBoundsFromBlock(par1Block);
rb.renderStandardBlock(par1Block, par2, par3, par4);
}
public void renderBlock(IBlockAccess ba, Block par1Block, int par2, int par3, int par4, Collection<IRenderFace> renderers) {
rb.blockAccess = ba;
rb.setOverrideTexture(getOverrideTexture());
rb.setFaceRenderers(renderers);
rb.setRenderBoundsFromBlock(par1Block);
rb.renderStandardBlock(par1Block, par2, par3, par4);
}
public IIcon getOverrideTexture() {
return overrideTexture;
}
public void setOverrideTexture(IIcon overrideTexture) {
this.overrideTexture = overrideTexture;
}
public CustomRenderBlocks getCustomRenderBlocks() {
if (rb == null) {
rb = new CustomRenderBlocks();
}
return rb;
}
}
@@ -0,0 +1,710 @@
package com.enderio.core.client.render;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import com.enderio.core.common.vecmath.Vertex;
import net.minecraft.block.Block;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
public class CustomRenderBlocks extends RenderBlocks {
boolean translateToXYZ = true;
boolean shouldRenderBaseTexture = true;
private final List<IRenderFace> renderFaceCallbacks = new ArrayList<IRenderFace>();
private IIcon overrideTexture;
public CustomRenderBlocks() {
super();
}
public CustomRenderBlocks(IBlockAccess par1iBlockAccess) {
super(par1iBlockAccess);
}
public void addFaceRenderer(IRenderFace renderer) {
renderFaceCallbacks.add(renderer);
}
public void setFaceRenderers(Collection<IRenderFace> renderers) {
renderFaceCallbacks.clear();
if(renderers != null) {
renderFaceCallbacks.addAll(renderers);
}
}
public void removeFaceRenderer(IRenderFace renderer) {
renderFaceCallbacks.remove(renderer);
}
public boolean isTranslateToXYZ() {
return translateToXYZ;
}
public void setTranslateToXYZ(boolean translateToXYZ) {
this.translateToXYZ = translateToXYZ;
}
public IIcon getOverrideTexture() {
return overrideTexture;
}
public void setOverrideTexture(IIcon overrideTexture) {
this.overrideTexture = overrideTexture;
}
public void setShouldRenderBaseTexture(boolean val) {
shouldRenderBaseTexture = val;
}
private void renderFace(ForgeDirection face, Block par1Block, double x, double y, double z, IIcon texture) {
if(renderFaceCallbacks.isEmpty()) {
doDefaultRenderFace(face, par1Block, x, y, z, overrideTexture == null ? texture : overrideTexture);
} else {
List<Vertex> faceVertices = createVerticesForFace(face, par1Block, x, y, z, overrideTexture == null ? texture : overrideTexture);
for (IRenderFace rf : renderFaceCallbacks) {
rf.renderFace(this, face, par1Block, x, y, z, overrideTexture == null ? texture : overrideTexture, faceVertices, translateToXYZ);
}
}
}
public List<Vertex> createVerticesForFace(ForgeDirection face, Block par1Block, double x, double y, double z, IIcon icon) {
switch (face) {
case DOWN:
return calcFaceYNeg(par1Block, x, y, z, icon);
case EAST:
return calcFaceXPos(par1Block, x, y, z, icon);
case NORTH:
return calcFaceZNeg(par1Block, x, y, z, icon);
case SOUTH:
return calcFaceZPos(par1Block, x, y, z, icon);
case UP:
return calcFaceYPos(par1Block, x, y, z, icon);
case WEST:
return calcFaceXNeg(par1Block, x, y, z, icon);
case UNKNOWN:
default:
break;
}
return Collections.emptyList();
}
public void doDefaultRenderFace(ForgeDirection face, Block par1Block, double par2, double par4, double par6, IIcon par8Icon) {
switch (face) {
case DOWN:
super.renderFaceYNeg(par1Block, par2, par4, par6, par8Icon);
break;
case EAST:
super.renderFaceXPos(par1Block, par2, par4, par6, par8Icon);
break;
case NORTH:
super.renderFaceZNeg(par1Block, par2, par4, par6, par8Icon);
break;
case SOUTH:
super.renderFaceZPos(par1Block, par2, par4, par6, par8Icon);
break;
case UP:
super.renderFaceYPos(par1Block, par2, par4, par6, par8Icon);
break;
case WEST:
super.renderFaceXNeg(par1Block, par2, par4, par6, par8Icon);
break;
case UNKNOWN:
default:
break;
}
}
@Override
public void renderFaceYNeg(Block par1Block, double par2, double par4, double par6, IIcon par8Icon) {
renderFace(ForgeDirection.DOWN, par1Block, par2, par4, par6, par8Icon);
}
@Override
public void renderFaceYPos(Block par1Block, double par2, double par4, double par6, IIcon par8Icon) {
renderFace(ForgeDirection.UP, par1Block, par2, par4, par6, par8Icon);
}
@Override
public void renderFaceZNeg(Block par1Block, double par2, double par4, double par6, IIcon par8Icon) {
renderFace(ForgeDirection.NORTH, par1Block, par2, par4, par6, par8Icon);
}
@Override
public void renderFaceZPos(Block par1Block, double par2, double par4, double par6, IIcon par8Icon) {
renderFace(ForgeDirection.SOUTH, par1Block, par2, par4, par6, par8Icon);
}
@Override
public void renderFaceXNeg(Block par1Block, double par2, double par4, double par6, IIcon par8Icon) {
renderFace(ForgeDirection.WEST, par1Block, par2, par4, par6, par8Icon);
}
@Override
public void renderFaceXPos(Block par1Block, double par2, double par4, double par6, IIcon par8Icon) {
renderFace(ForgeDirection.EAST, par1Block, par2, par4, par6, par8Icon);
}
private List<Vertex> calcFaceXNeg(Block par1Block, double par2, double par4, double par6, IIcon par8Icon) {
if(hasOverrideBlockTexture()) {
par8Icon = this.overrideBlockTexture;
}
double d3 = par8Icon.getInterpolatedU(this.renderMinZ * 16.0D);
double d4 = par8Icon.getInterpolatedU(this.renderMaxZ * 16.0D);
double d5 = par8Icon.getInterpolatedV(16.0D - this.renderMaxY * 16.0D);
double d6 = par8Icon.getInterpolatedV(16.0D - this.renderMinY * 16.0D);
double d7;
if(this.flipTexture) {
d7 = d3;
d3 = d4;
d4 = d7;
}
if(this.renderMinZ < 0.0D || this.renderMaxZ > 1.0D) {
d3 = par8Icon.getMinU();
d4 = par8Icon.getMaxU();
}
if(this.renderMinY < 0.0D || this.renderMaxY > 1.0D) {
d5 = par8Icon.getMinV();
d6 = par8Icon.getMaxV();
}
d7 = d4;
double d8 = d3;
double d9 = d5;
double d10 = d6;
if(this.uvRotateNorth == 1) {
d3 = par8Icon.getInterpolatedU(this.renderMinY * 16.0D);
d5 = par8Icon.getInterpolatedV(16.0D - this.renderMaxZ * 16.0D);
d4 = par8Icon.getInterpolatedU(this.renderMaxY * 16.0D);
d6 = par8Icon.getInterpolatedV(16.0D - this.renderMinZ * 16.0D);
d9 = d5;
d10 = d6;
d7 = d3;
d8 = d4;
d5 = d6;
d6 = d9;
} else if(this.uvRotateNorth == 2) {
d3 = par8Icon.getInterpolatedU(16.0D - this.renderMaxY * 16.0D);
d5 = par8Icon.getInterpolatedV(this.renderMinZ * 16.0D);
d4 = par8Icon.getInterpolatedU(16.0D - this.renderMinY * 16.0D);
d6 = par8Icon.getInterpolatedV(this.renderMaxZ * 16.0D);
d7 = d4;
d8 = d3;
d3 = d4;
d4 = d8;
d9 = d6;
d10 = d5;
} else if(this.uvRotateNorth == 3) {
d3 = par8Icon.getInterpolatedU(16.0D - this.renderMinZ * 16.0D);
d4 = par8Icon.getInterpolatedU(16.0D - this.renderMaxZ * 16.0D);
d5 = par8Icon.getInterpolatedV(this.renderMaxY * 16.0D);
d6 = par8Icon.getInterpolatedV(this.renderMinY * 16.0D);
d7 = d4;
d8 = d3;
d9 = d5;
d10 = d6;
}
double d11 = par2 + this.renderMinX;
double d12 = par4 + this.renderMinY;
double d13 = par4 + this.renderMaxY;
double d14 = par6 + this.renderMinZ;
double d15 = par6 + this.renderMaxZ;
List<Vertex> result = new ArrayList<Vertex>(4);
Vertex v;
if(enableAO) {
result.add(new Vertex(d11, d13, d15, d7, d9, brightnessTopLeft, colorRedTopLeft, this.colorGreenTopLeft, this.colorBlueTopLeft, 1));
result.add(new Vertex(d11, d13, d14, d3, d5, brightnessBottomLeft, colorRedBottomLeft, this.colorGreenBottomLeft, this.colorBlueBottomLeft, 1));
result.add(new Vertex(d11, d12, d14, d8, d10, brightnessBottomRight, colorRedBottomRight, this.colorGreenBottomRight, this.colorBlueBottomRight, 1));
result.add(new Vertex(d11, d12, d15, d4, d6, brightnessTopRight, colorRedTopRight, this.colorGreenTopRight, this.colorBlueTopRight, 1));
} else {
result.add(new Vertex(d11, d13, d15, d7, d9));
result.add(new Vertex(d11, d13, d14, d3, d5));
result.add(new Vertex(d11, d12, d14, d8, d10));
result.add(new Vertex(d11, d12, d15, d4, d6));
}
return result;
}
private List<Vertex> calcFaceYPos(Block par1Block, double par2, double par4, double par6, IIcon par8Icon) {
if(this.hasOverrideBlockTexture()) {
par8Icon = this.overrideBlockTexture;
}
double d3 = par8Icon.getInterpolatedU(this.renderMinX * 16.0D);
double d4 = par8Icon.getInterpolatedU(this.renderMaxX * 16.0D);
double d5 = par8Icon.getInterpolatedV(this.renderMinZ * 16.0D);
double d6 = par8Icon.getInterpolatedV(this.renderMaxZ * 16.0D);
if(this.renderMinX < 0.0D || this.renderMaxX > 1.0D) {
d3 = par8Icon.getMinU();
d4 = par8Icon.getMaxU();
}
if(this.renderMinZ < 0.0D || this.renderMaxZ > 1.0D) {
d5 = par8Icon.getMinV();
d6 = par8Icon.getMaxV();
}
double d7 = d4;
double d8 = d3;
double d9 = d5;
double d10 = d6;
if(this.uvRotateTop == 1) {
d3 = par8Icon.getInterpolatedU(this.renderMinZ * 16.0D);
d5 = par8Icon.getInterpolatedV(16.0D - this.renderMaxX * 16.0D);
d4 = par8Icon.getInterpolatedU(this.renderMaxZ * 16.0D);
d6 = par8Icon.getInterpolatedV(16.0D - this.renderMinX * 16.0D);
d9 = d5;
d10 = d6;
d7 = d3;
d8 = d4;
d5 = d6;
d6 = d9;
} else if(this.uvRotateTop == 2) {
d3 = par8Icon.getInterpolatedU(16.0D - this.renderMaxZ * 16.0D);
d5 = par8Icon.getInterpolatedV(this.renderMinX * 16.0D);
d4 = par8Icon.getInterpolatedU(16.0D - this.renderMinZ * 16.0D);
d6 = par8Icon.getInterpolatedV(this.renderMaxX * 16.0D);
d7 = d4;
d8 = d3;
d3 = d4;
d4 = d8;
d9 = d6;
d10 = d5;
} else if(this.uvRotateTop == 3) {
d3 = par8Icon.getInterpolatedU(16.0D - this.renderMinX * 16.0D);
d4 = par8Icon.getInterpolatedU(16.0D - this.renderMaxX * 16.0D);
d5 = par8Icon.getInterpolatedV(16.0D - this.renderMinZ * 16.0D);
d6 = par8Icon.getInterpolatedV(16.0D - this.renderMaxZ * 16.0D);
d7 = d4;
d8 = d3;
d9 = d5;
d10 = d6;
}
double d11 = par2 + this.renderMinX;
double d12 = par2 + this.renderMaxX;
double d13 = par4 + this.renderMaxY;
double d14 = par6 + this.renderMinZ;
double d15 = par6 + this.renderMaxZ;
List<Vertex> result = new ArrayList<Vertex>(4);
Vertex v;
if(enableAO) {
v = new Vertex(d12, d13, d15, d4, d6, brightnessTopLeft, colorRedTopLeft, this.colorGreenTopLeft, this.colorBlueTopLeft, 1);
result.add(v);
v = new Vertex(d12, d13, d14, d7, d9, brightnessBottomLeft, colorRedBottomLeft, this.colorGreenBottomLeft, this.colorBlueBottomLeft, 1);
result.add(v);
v = new Vertex(d11, d13, d14, d3, d5, brightnessBottomRight, colorRedBottomRight, this.colorGreenBottomRight, this.colorBlueBottomRight, 1);
result.add(v);
v = new Vertex(d11, d13, d15, d8, d10, brightnessTopRight, colorRedTopRight, this.colorGreenTopRight, this.colorBlueTopRight, 1);
result.add(v);
} else {
v = new Vertex(d12, d13, d15, d4, d6);
result.add(v);
v = new Vertex(d12, d13, d14, d7, d9);
result.add(v);
v = new Vertex(d11, d13, d14, d3, d5);
result.add(v);
v = new Vertex(d11, d13, d15, d8, d10);
result.add(v);
}
return result;
}
private List<Vertex> calcFaceZPos(Block par1Block, double par2, double par4, double par6, IIcon par8Icon)
{
Tessellator tessellator = Tessellator.instance;
if(this.hasOverrideBlockTexture())
{
par8Icon = this.overrideBlockTexture;
}
double d3 = par8Icon.getInterpolatedU(this.renderMinX * 16.0D);
double d4 = par8Icon.getInterpolatedU(this.renderMaxX * 16.0D);
double d5 = par8Icon.getInterpolatedV(16.0D - this.renderMaxY * 16.0D);
double d6 = par8Icon.getInterpolatedV(16.0D - this.renderMinY * 16.0D);
double d7;
if(this.flipTexture)
{
d7 = d3;
d3 = d4;
d4 = d7;
}
if(this.renderMinX < 0.0D || this.renderMaxX > 1.0D)
{
d3 = par8Icon.getMinU();
d4 = par8Icon.getMaxU();
}
if(this.renderMinY < 0.0D || this.renderMaxY > 1.0D)
{
d5 = par8Icon.getMinV();
d6 = par8Icon.getMaxV();
}
d7 = d4;
double d8 = d3;
double d9 = d5;
double d10 = d6;
if(this.uvRotateWest == 1)
{
d3 = par8Icon.getInterpolatedU(this.renderMinY * 16.0D);
d6 = par8Icon.getInterpolatedV(16.0D - this.renderMinX * 16.0D);
d4 = par8Icon.getInterpolatedU(this.renderMaxY * 16.0D);
d5 = par8Icon.getInterpolatedV(16.0D - this.renderMaxX * 16.0D);
d9 = d5;
d10 = d6;
d7 = d3;
d8 = d4;
d5 = d6;
d6 = d9;
}
else if(this.uvRotateWest == 2)
{
d3 = par8Icon.getInterpolatedU(16.0D - this.renderMaxY * 16.0D);
d5 = par8Icon.getInterpolatedV(this.renderMinX * 16.0D);
d4 = par8Icon.getInterpolatedU(16.0D - this.renderMinY * 16.0D);
d6 = par8Icon.getInterpolatedV(this.renderMaxX * 16.0D);
d7 = d4;
d8 = d3;
d3 = d4;
d4 = d8;
d9 = d6;
d10 = d5;
}
else if(this.uvRotateWest == 3)
{
d3 = par8Icon.getInterpolatedU(16.0D - this.renderMinX * 16.0D);
d4 = par8Icon.getInterpolatedU(16.0D - this.renderMaxX * 16.0D);
d5 = par8Icon.getInterpolatedV(this.renderMaxY * 16.0D);
d6 = par8Icon.getInterpolatedV(this.renderMinY * 16.0D);
d7 = d4;
d8 = d3;
d9 = d5;
d10 = d6;
}
double d11 = par2 + this.renderMinX;
double d12 = par2 + this.renderMaxX;
double d13 = par4 + this.renderMinY;
double d14 = par4 + this.renderMaxY;
double d15 = par6 + this.renderMaxZ;
List<Vertex> result = new ArrayList<Vertex>();
Vertex v;
if(enableAO) {
result.add(new Vertex(d11, d14, d15, d3, d5, brightnessTopLeft, colorRedTopLeft, this.colorGreenTopLeft, this.colorBlueTopLeft, 1));
result.add(new Vertex(d11, d13, d15, d8, d10, brightnessBottomLeft, this.colorRedBottomLeft, this.colorGreenBottomLeft, this.colorBlueBottomLeft, 1));
result.add(new Vertex(d12, d13, d15, d4, d6, brightnessBottomRight, colorRedBottomRight, this.colorGreenBottomRight, this.colorBlueBottomRight, 1));
result.add(new Vertex(d12, d14, d15, d7, d9, brightnessTopRight, colorRedTopRight, this.colorGreenTopRight, this.colorBlueTopRight, 1));
} else {
result.add(new Vertex(d11, d14, d15, d3, d5));
result.add(new Vertex(d11, d13, d15, d8, d10));
result.add(new Vertex(d12, d13, d15, d4, d6));
result.add(new Vertex(d12, d14, d15, d7, d9));
}
return result;
}
private List<Vertex> calcFaceZNeg(Block par1Block, double par2, double par4, double par6, IIcon par8Icon) {
if(this.hasOverrideBlockTexture())
{
par8Icon = this.overrideBlockTexture;
}
double d3 = par8Icon.getInterpolatedU(this.renderMinX * 16.0D);
double d4 = par8Icon.getInterpolatedU(this.renderMaxX * 16.0D);
double d5 = par8Icon.getInterpolatedV(16.0D - this.renderMaxY * 16.0D);
double d6 = par8Icon.getInterpolatedV(16.0D - this.renderMinY * 16.0D);
double d7;
if(this.flipTexture) {
d7 = d3;
d3 = d4;
d4 = d7;
}
if(this.renderMinX < 0.0D || this.renderMaxX > 1.0D) {
d3 = par8Icon.getMinU();
d4 = par8Icon.getMaxU();
}
if(this.renderMinY < 0.0D || this.renderMaxY > 1.0D) {
d5 = par8Icon.getMinV();
d6 = par8Icon.getMaxV();
}
d7 = d4;
double d8 = d3;
double d9 = d5;
double d10 = d6;
if(this.uvRotateEast == 2) {
d3 = par8Icon.getInterpolatedU(this.renderMinY * 16.0D);
d5 = par8Icon.getInterpolatedV(16.0D - this.renderMinX * 16.0D);
d4 = par8Icon.getInterpolatedU(this.renderMaxY * 16.0D);
d6 = par8Icon.getInterpolatedV(16.0D - this.renderMaxX * 16.0D);
d9 = d5;
d10 = d6;
d7 = d3;
d8 = d4;
d5 = d6;
d6 = d9;
} else if(this.uvRotateEast == 1) {
d3 = par8Icon.getInterpolatedU(16.0D - this.renderMaxY * 16.0D);
d5 = par8Icon.getInterpolatedV(this.renderMaxX * 16.0D);
d4 = par8Icon.getInterpolatedU(16.0D - this.renderMinY * 16.0D);
d6 = par8Icon.getInterpolatedV(this.renderMinX * 16.0D);
d7 = d4;
d8 = d3;
d3 = d4;
d4 = d8;
d9 = d6;
d10 = d5;
} else if(this.uvRotateEast == 3) {
d3 = par8Icon.getInterpolatedU(16.0D - this.renderMinX * 16.0D);
d4 = par8Icon.getInterpolatedU(16.0D - this.renderMaxX * 16.0D);
d5 = par8Icon.getInterpolatedV(this.renderMaxY * 16.0D);
d6 = par8Icon.getInterpolatedV(this.renderMinY * 16.0D);
d7 = d4;
d8 = d3;
d9 = d5;
d10 = d6;
}
double d11 = par2 + this.renderMinX;
double d12 = par2 + this.renderMaxX;
double d13 = par4 + this.renderMinY;
double d14 = par4 + this.renderMaxY;
double d15 = par6 + this.renderMinZ;
List<Vertex> result = new ArrayList<Vertex>();
Vertex v;
if(enableAO) {
result.add(new Vertex(d11, d14, d15, d7, d9, brightnessTopLeft, colorRedTopLeft, this.colorGreenTopLeft, this.colorBlueTopLeft, 1));
result.add(new Vertex(d12, d14, d15, d3, d5, brightnessBottomLeft, colorRedBottomLeft, this.colorGreenBottomLeft, this.colorBlueBottomLeft, 1));
result.add(new Vertex(d12, d13, d15, d8, d10, brightnessBottomRight, colorRedBottomRight, this.colorGreenBottomRight, this.colorBlueBottomRight, 1));
result.add(new Vertex(d11, d13, d15, d4, d6, brightnessTopRight, colorRedTopRight, this.colorGreenTopRight, this.colorBlueTopRight, 1));
} else {
result.add(new Vertex(d11, d14, d15, d7, d9));
result.add(new Vertex(d12, d14, d15, d3, d5));
result.add(new Vertex(d12, d13, d15, d8, d10));
result.add(new Vertex(d11, d13, d15, d4, d6));
}
return result;
}
private List<Vertex> calcFaceXPos(Block par1Block, double par2, double par4, double par6, IIcon par8Icon)
{
Tessellator tessellator = Tessellator.instance;
if(this.hasOverrideBlockTexture())
{
par8Icon = this.overrideBlockTexture;
}
double d3 = par8Icon.getInterpolatedU(this.renderMinZ * 16.0D);
double d4 = par8Icon.getInterpolatedU(this.renderMaxZ * 16.0D);
double d5 = par8Icon.getInterpolatedV(16.0D - this.renderMaxY * 16.0D);
double d6 = par8Icon.getInterpolatedV(16.0D - this.renderMinY * 16.0D);
double d7;
if(this.flipTexture)
{
d7 = d3;
d3 = d4;
d4 = d7;
}
if(this.renderMinZ < 0.0D || this.renderMaxZ > 1.0D)
{
d3 = par8Icon.getMinU();
d4 = par8Icon.getMaxU();
}
if(this.renderMinY < 0.0D || this.renderMaxY > 1.0D)
{
d5 = par8Icon.getMinV();
d6 = par8Icon.getMaxV();
}
d7 = d4;
double d8 = d3;
double d9 = d5;
double d10 = d6;
if(this.uvRotateSouth == 2)
{
d3 = par8Icon.getInterpolatedU(this.renderMinY * 16.0D);
d5 = par8Icon.getInterpolatedV(16.0D - this.renderMinZ * 16.0D);
d4 = par8Icon.getInterpolatedU(this.renderMaxY * 16.0D);
d6 = par8Icon.getInterpolatedV(16.0D - this.renderMaxZ * 16.0D);
d9 = d5;
d10 = d6;
d7 = d3;
d8 = d4;
d5 = d6;
d6 = d9;
}
else if(this.uvRotateSouth == 1)
{
d3 = par8Icon.getInterpolatedU(16.0D - this.renderMaxY * 16.0D);
d5 = par8Icon.getInterpolatedV(this.renderMaxZ * 16.0D);
d4 = par8Icon.getInterpolatedU(16.0D - this.renderMinY * 16.0D);
d6 = par8Icon.getInterpolatedV(this.renderMinZ * 16.0D);
d7 = d4;
d8 = d3;
d3 = d4;
d4 = d8;
d9 = d6;
d10 = d5;
}
else if(this.uvRotateSouth == 3)
{
d3 = par8Icon.getInterpolatedU(16.0D - this.renderMinZ * 16.0D);
d4 = par8Icon.getInterpolatedU(16.0D - this.renderMaxZ * 16.0D);
d5 = par8Icon.getInterpolatedV(this.renderMaxY * 16.0D);
d6 = par8Icon.getInterpolatedV(this.renderMinY * 16.0D);
d7 = d4;
d8 = d3;
d9 = d5;
d10 = d6;
}
double d11 = par2 + this.renderMaxX;
double d12 = par4 + this.renderMinY;
double d13 = par4 + this.renderMaxY;
double d14 = par6 + this.renderMinZ;
double d15 = par6 + this.renderMaxZ;
List<Vertex> result = new ArrayList<Vertex>(4);
Vertex v;
if(enableAO) {
result.add(new Vertex(d11, d12, d15, d8, d10, brightnessTopLeft, colorRedTopLeft, this.colorGreenTopLeft, this.colorBlueTopLeft, 1));
result.add(new Vertex(d11, d12, d14, d4, d6, brightnessBottomLeft, colorRedBottomLeft, this.colorGreenBottomLeft, this.colorBlueBottomLeft, 1));
result.add(new Vertex(d11, d13, d14, d7, d9, brightnessBottomRight, colorRedBottomRight, this.colorGreenBottomRight, this.colorBlueBottomRight, 1));
result.add(new Vertex(d11, d13, d15, d3, d5, brightnessTopRight, colorRedTopRight, this.colorGreenTopRight, this.colorBlueTopRight, 1));
} else {
result.add(new Vertex(d11, d12, d15, d8, d10));
result.add(new Vertex(d11, d12, d14, d4, d6));
result.add(new Vertex(d11, d13, d14, d7, d9));
result.add(new Vertex(d11, d13, d15, d3, d5));
}
return result;
}
private List<Vertex> calcFaceYNeg(Block par1Block, double x, double y, double z, IIcon icon) {
if(hasOverrideBlockTexture()) {
icon = this.overrideBlockTexture;
}
double minU = icon.getInterpolatedU(this.renderMinX * 16.0D);
double maxU = icon.getInterpolatedU(this.renderMaxX * 16.0D);
double minV = icon.getInterpolatedV(this.renderMinZ * 16.0D);
double maxV = icon.getInterpolatedV(this.renderMaxZ * 16.0D);
if(renderMinX < 0.0D || renderMaxX > 1.0D) {
minU = icon.getMinU();
maxU = icon.getMaxU();
}
if(this.renderMinZ < 0.0D || this.renderMaxZ > 1.0D) {
minV = icon.getMinV();
maxV = icon.getMaxV();
}
double d7 = maxU;
double d8 = minU;
double d9 = minV;
double d10 = maxV;
if(uvRotateBottom == 2) {
minU = icon.getInterpolatedU(this.renderMinZ * 16.0D);
minV = icon.getInterpolatedV(16.0D - this.renderMaxX * 16.0D);
maxU = icon.getInterpolatedU(this.renderMaxZ * 16.0D);
maxV = icon.getInterpolatedV(16.0D - this.renderMinX * 16.0D);
d9 = minV;
d10 = maxV;
d7 = minU;
d8 = maxU;
minV = maxV;
maxV = d9;
} else if(uvRotateBottom == 1) {
minU = icon.getInterpolatedU(16.0D - this.renderMaxZ * 16.0D);
minV = icon.getInterpolatedV(this.renderMinX * 16.0D);
maxU = icon.getInterpolatedU(16.0D - this.renderMinZ * 16.0D);
maxV = icon.getInterpolatedV(this.renderMaxX * 16.0D);
d7 = maxU;
d8 = minU;
minU = maxU;
maxU = d8;
d9 = maxV;
d10 = minV;
} else if(uvRotateBottom == 3) {
minU = icon.getInterpolatedU(16.0D - this.renderMinX * 16.0D);
maxU = icon.getInterpolatedU(16.0D - this.renderMaxX * 16.0D);
minV = icon.getInterpolatedV(16.0D - this.renderMinZ * 16.0D);
maxV = icon.getInterpolatedV(16.0D - this.renderMaxZ * 16.0D);
d7 = maxU;
d8 = minU;
d9 = minV;
d10 = maxV;
}
double minX = x + this.renderMinX;
double maxX = x + this.renderMaxX;
double minY = y + this.renderMinY;
double minZ = z + this.renderMinZ;
double maxZ = z + this.renderMaxZ;
List<Vertex> result = new ArrayList<Vertex>(4);
Vertex v;
if(this.enableAO) {
v = new Vertex(minX, minY, maxZ, d8, d10, brightnessTopLeft, colorRedTopLeft, colorGreenTopLeft, colorBlueTopLeft, 1f);
result.add(v);
v = new Vertex(minX, minY, minZ, minU, minV, brightnessBottomLeft, colorRedBottomLeft, colorGreenBottomLeft, colorBlueBottomLeft, 1f);
result.add(v);
v = new Vertex(maxX, minY, minZ, d7, d9, brightnessBottomRight, colorRedBottomRight, colorGreenBottomRight, colorBlueBottomRight, 1f);
result.add(v);
v = new Vertex(maxX, minY, maxZ, maxU, maxV, brightnessTopRight, colorRedTopRight, colorGreenTopRight, colorBlueTopRight, 1f);
result.add(v);
} else {
v = new Vertex(minX, minY, maxZ, d8, d10);
result.add(v);
v = new Vertex(minX, minY, minZ, minU, minV);
result.add(v);
v = new Vertex(maxX, minY, minZ, d7, d9);
result.add(v);
v = new Vertex(maxX, minY, maxZ, maxU, maxV);
result.add(v);
}
return result;
}
}
@@ -0,0 +1,7 @@
package com.enderio.core.client.render;
public interface IConnectedTextureRenderer {
boolean matchesMetadata(int meta1, int meta2);
}
@@ -0,0 +1,16 @@
package com.enderio.core.client.render;
import java.util.List;
import com.enderio.core.common.vecmath.Vertex;
import net.minecraft.block.Block;
import net.minecraft.util.IIcon;
import net.minecraftforge.common.util.ForgeDirection;
public interface IRenderFace {
void renderFace(CustomRenderBlocks rb, ForgeDirection face, Block par1Block, double x, double y, double z, IIcon texture, List<Vertex> refVertices,
boolean translateToXyz);
}
@@ -0,0 +1,69 @@
package com.enderio.core.client.render;
import java.util.ArrayList;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.item.Item;
import net.minecraft.util.IIcon;
import net.minecraftforge.client.event.TextureStitchEvent;
import net.minecraftforge.common.MinecraftForge;
import cpw.mods.fml.common.Mod;
import cpw.mods.fml.common.eventhandler.SubscribeEvent;
public class IconUtil {
public static interface IIconProvider {
public void registerIcons(IIconRegister register);
/** 0 = terrain.png, 1 = items.png */
public int getTextureType();
}
private static ArrayList<IIconProvider> iconProviders = new ArrayList<IIconProvider>();
public static IIcon whiteTexture;
public static IIcon blankTexture;
public static IIcon errorTexture;
static {
MinecraftForge.EVENT_BUS.register(new IconUtil());
addIconProvider(new IIconProvider() {
@Override
public void registerIcons(IIconRegister register) {
whiteTexture = register.registerIcon("enderio:white");
errorTexture = register.registerIcon("enderio:error");
blankTexture = register.registerIcon("enderio:blank");
}
@Override
public int getTextureType() {
return 0;
}
});
}
public static void addIconProvider(IIconProvider registrar) {
iconProviders.add(registrar);
}
@Mod.EventHandler
@SubscribeEvent
public void onIconLoad(TextureStitchEvent.Pre event) {
for (IIconProvider reg : iconProviders) {
if(reg.getTextureType() == event.map.getTextureType()) {
reg.registerIcons(event.map);
}
}
}
public static IIcon getIconForItem(int itemId, int meta) {
Item item = Item.getItemById(itemId);
if(item == null) {
return null;
}
return item.getIconFromDamage(meta);
}
}
@@ -0,0 +1,681 @@
package com.enderio.core.client.render;
import java.lang.reflect.Field;
import java.nio.FloatBuffer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javax.annotation.Nullable;
import net.minecraft.block.Block;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.renderer.GLAllocation;
import net.minecraft.client.renderer.OpenGlHelper;
import net.minecraft.client.renderer.RenderHelper;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.entity.RenderManager;
import net.minecraft.client.renderer.texture.TextureManager;
import net.minecraft.client.renderer.texture.TextureMap;
import net.minecraft.client.resources.IReloadableResourceManager;
import net.minecraft.client.resources.IResourceManagerReloadListener;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.IIcon;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.Timer;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.FluidTank;
import org.lwjgl.opengl.GL11;
import com.enderio.core.common.util.BlockCoord;
import com.enderio.core.common.util.Log;
import com.enderio.core.common.vecmath.Matrix4d;
import com.enderio.core.common.vecmath.VecmathUtil;
import com.enderio.core.common.vecmath.Vector2f;
import com.enderio.core.common.vecmath.Vector3d;
import com.enderio.core.common.vecmath.Vector3f;
import com.enderio.core.common.vecmath.Vector4d;
import com.enderio.core.common.vecmath.Vector4f;
import com.enderio.core.common.vecmath.Vertex;
import cpw.mods.fml.relauncher.ReflectionHelper;
import static net.minecraftforge.common.util.ForgeDirection.*;
import static org.lwjgl.opengl.GL11.*;
public class RenderUtil {
public static final Vector4f DEFAULT_TEXT_SHADOW_COL = new Vector4f(0.33f, 0.33f, 0.33f, 0.33f);
public static final Vector4f DEFAULT_TXT_COL = new Vector4f(1, 1, 1, 1);
public static final Vector4f DEFAULT_TEXT_BG_COL = new Vector4f(0.275f, 0.08f, 0.4f, 0.75f);
public static final Vector3d UP_V = new Vector3d(0, 1, 0);
public static final Vector3d ZERO_V = new Vector3d(0, 0, 0);
private static final FloatBuffer MATRIX_BUFFER = GLAllocation.createDirectFloatBuffer(16);
public static final ResourceLocation BLOCK_TEX = TextureMap.locationBlocksTexture;
public static final ResourceLocation ITEM_TEX = TextureMap.locationItemsTexture;
public static final ResourceLocation GLINT_TEX = new ResourceLocation("textures/misc/enchanted_item_glint.png");
public static int BRIGHTNESS_MAX = 15 << 20 | 15 << 4;
public static void loadMatrix(Matrix4d mat) {
MATRIX_BUFFER.rewind();
MATRIX_BUFFER.put((float) mat.m00);
MATRIX_BUFFER.put((float) mat.m01);
MATRIX_BUFFER.put((float) mat.m02);
MATRIX_BUFFER.put((float) mat.m03);
MATRIX_BUFFER.put((float) mat.m10);
MATRIX_BUFFER.put((float) mat.m11);
MATRIX_BUFFER.put((float) mat.m12);
MATRIX_BUFFER.put((float) mat.m13);
MATRIX_BUFFER.put((float) mat.m20);
MATRIX_BUFFER.put((float) mat.m21);
MATRIX_BUFFER.put((float) mat.m22);
MATRIX_BUFFER.put((float) mat.m23);
MATRIX_BUFFER.put((float) mat.m30);
MATRIX_BUFFER.put((float) mat.m31);
MATRIX_BUFFER.put((float) mat.m32);
MATRIX_BUFFER.put((float) mat.m33);
MATRIX_BUFFER.rewind();
GL11.glLoadMatrix(MATRIX_BUFFER);
}
private static Field timerField = initTimer();
/**
* Non-thread-safe holder for the current render pass. You must update this in
* your block's canRenderInPass method for it to work properly!
*/
public static volatile int theRenderPass = 0;
private static Field initTimer() {
Field f = null;
try {
f = ReflectionHelper.findField(Minecraft.class, "field_71428_T", "timer", "Q");
f.setAccessible(true);
} catch (Exception e) {
Log.error("Failed to initialize timer reflection for IO config.");
e.printStackTrace();
}
return f;
}
@Nullable
public static Timer getTimer() {
if(timerField == null) {
return null;
}
try {
return (Timer) timerField.get(Minecraft.getMinecraft());
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
public static TextureManager engine() {
return Minecraft.getMinecraft().renderEngine;
}
public static void bindItemTexture(ItemStack stack) {
engine().bindTexture(stack.getItemSpriteNumber() == 0 ? BLOCK_TEX : ITEM_TEX);
}
public static void bindItemTexture() {
engine().bindTexture(ITEM_TEX);
}
public static void bindBlockTexture() {
engine().bindTexture(BLOCK_TEX);
}
public static void bindGlintTexture() {
engine().bindTexture(BLOCK_TEX);
}
public static void bindTexture(String string) {
engine().bindTexture(new ResourceLocation(string));
}
public static void bindTexture(ResourceLocation tex) {
engine().bindTexture(tex);
}
public static FontRenderer fontRenderer() {
return Minecraft.getMinecraft().fontRenderer;
}
public static float[] getDefaultPerSideBrightness() {
float[] brightnessPerSide = new float[6];
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) {
brightnessPerSide[dir.ordinal()] = RenderUtil.getColorMultiplierForFace(dir);
}
return brightnessPerSide;
}
public static IIcon[] getBlockTextures(Block block, int meta) {
IIcon[] icons = new IIcon[6];
int i = 0;
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) {
icons[i] = block.getIcon(dir.ordinal(), meta);
i++;
}
return icons;
}
public static IIcon[] getBlockTextures(IBlockAccess world, int x, int y, int z) {
Block block = world.getBlock(x, y, z);
IIcon[] icons = new IIcon[6];
int i = 0;
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) {
icons[i] = block.getIcon(world, x, y, z, dir.ordinal());
i++;
}
return icons;
}
public static float claculateTotalBrightnessForLocation(World worldObj, int xCoord, int yCoord, int zCoord) {
int i = worldObj.getLightBrightnessForSkyBlocks(xCoord, yCoord, zCoord, 0);
int j = i % 65536;
int k = i / 65536;
float minLight = 0;
//0.2 - 1
float sunBrightness = worldObj.getSunBrightness(1);
float percentRecievedFromSun = k / 255f;
//Highest value recieved from a light
float fromLights = j / 255f;
// 0 - 1 for sun only, 0 - 0.6 for light only
float recievedPercent = worldObj.getLightBrightness(xCoord, yCoord, zCoord);
float highestValue = Math.max(fromLights, percentRecievedFromSun * sunBrightness);
return Math.max(0.2f, highestValue);
}
public static float getColorMultiplierForFace(ForgeDirection face) {
if(face == ForgeDirection.UP) {
return 1;
}
if(face == ForgeDirection.DOWN) {
return 0.5f;
}
if(face.offsetX != 0) {
return 0.6f;
}
return 0.8f; // z
}
public static int setTesselatorBrightness(IBlockAccess world, int x, int y, int z) {
Block block = world.getBlock(x, y, z);
int res = block == null ? world.getLightBrightnessForSkyBlocks(x, y, z, 0) : block.getMixedBrightnessForBlock(world, x, y, z);
Tessellator.instance.setBrightness(res);
Tessellator.instance.setColorRGBA_F(1, 1, 1, 1);
return res;
}
public static void renderQuad2D(double x, double y, double z, double width, double height, int colorRGB) {
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
GL11.glDisable(GL11.GL_TEXTURE_2D);
Tessellator tessellator = Tessellator.instance;
tessellator.startDrawingQuads();
tessellator.setColorOpaque_I(colorRGB);
tessellator.addVertex(x, y + height, z);
tessellator.addVertex(x + width, y + height, z);
tessellator.addVertex(x + width, y, z);
tessellator.addVertex(x, y, z);
tessellator.draw();
GL11.glEnable(GL11.GL_TEXTURE_2D);
}
public static void renderQuad2D(double x, double y, double z, double width, double height, Vector4f colorRGBA) {
GL11.glColor4f(colorRGBA.x, colorRGBA.y, colorRGBA.z, colorRGBA.w);
GL11.glDisable(GL11.GL_TEXTURE_2D);
Tessellator tessellator = Tessellator.instance;
tessellator.startDrawingQuads();
tessellator.addVertex(x, y + height, z);
tessellator.addVertex(x + width, y + height, z);
tessellator.addVertex(x + width, y, z);
tessellator.addVertex(x, y, z);
tessellator.draw();
GL11.glEnable(GL11.GL_TEXTURE_2D);
}
public static Matrix4d createBillboardMatrix(TileEntity te, EntityLivingBase entityPlayer) {
return createBillboardMatrix(new Vector3d(te.xCoord + 0.5, te.yCoord + 0.5, te.zCoord + 0.5), entityPlayer);
}
public static Matrix4d createBillboardMatrix(Vector3d lookAt, EntityLivingBase entityPlayer) {
Vector3d playerEye = new Vector3d(entityPlayer.posX, entityPlayer.posY + 1.62 - entityPlayer.yOffset, entityPlayer.posZ);
Vector3d blockOrigin = new Vector3d(lookAt.x, lookAt.y, lookAt.z);
Matrix4d lookMat = VecmathUtil.createMatrixAsLookAt(blockOrigin, playerEye, RenderUtil.UP_V);
lookMat.setTranslation(new Vector3d());
lookMat.invert();
return lookMat;
}
public static void renderBillboard(Matrix4d lookMat, float minU, float maxU, float minV, float maxV, double size, int brightness) {
Tessellator tes = Tessellator.instance;
tes.startDrawingQuads();
tes.setBrightness(brightness);
double s = size / 2;
Vector3d v = new Vector3d();
v.set(-s, s, 0);
lookMat.transform(v);
tes.addVertexWithUV(v.x, v.y, v.z, minU, maxV);
v.set(s, s, 0);
lookMat.transform(v);
tes.addVertexWithUV(v.x, v.y, v.z, maxU, maxV);
v.set(s, -s, 0);
lookMat.transform(v);
tes.addVertexWithUV(v.x, v.y, v.z, maxU, minV);
v.set(-s, -s, 0);
lookMat.transform(v);
tes.addVertexWithUV(v.x, v.y, v.z, minU, minV);
tes.draw();
}
/**
* left, bottom, right, top
*
* @param face
* @return
*/
public static List<ForgeDirection> getEdgesForFace(ForgeDirection face) {
List<ForgeDirection> result = new ArrayList<ForgeDirection>(4);
if(face.offsetY != 0) {
result.add(NORTH);
result.add(EAST);
result.add(SOUTH);
result.add(WEST);
} else if(face.offsetX != 0) {
result.add(DOWN);
result.add(SOUTH);
result.add(UP);
result.add(NORTH);
} else {
result.add(DOWN);
result.add(WEST);
result.add(UP);
result.add(EAST);
}
return result;
}
public static void addVerticesToTesselator(List<Vertex> vertices) {
addVerticesToTessellator(vertices, Tessellator.instance);
}
public static void addVerticesToTessellator(List<Vertex> vertices, Tessellator tes) {
for (Vertex v : vertices) {
if(v.brightness != -1) {
tes.setBrightness(v.brightness);
}
if(v.color != null) {
tes.setColorRGBA_F(v.r(), v.g(), v.b(), v.a());
}
if(v.uv != null) {
tes.setTextureUV(v.u(), v.v());
}
if(v.normal != null) {
tes.setNormal(v.nx(), v.ny(), v.nz());
}
tes.addVertex(v.x(), v.y(), v.z());
}
}
public static void renderConnectedTextureFace(IBlockAccess blockAccess, Block block, int x, int y, int z, ForgeDirection face, IIcon texture,
boolean forceAllEdges) {
renderConnectedTextureFace(blockAccess, block, x, y, z, face, texture, forceAllEdges, true, true);
}
public static void renderConnectedTextureFace(IBlockAccess blockAccess, Block block, int x, int y, int z, ForgeDirection face, IIcon texture,
boolean forceAllEdges, boolean translateToXYZ, boolean applyFaceShading) {
if((blockAccess == null && !forceAllEdges) || face == null || texture == null) {
return;
}
if(!forceAllEdges) {
Block check = blockAccess.getBlock(x, y, z);
if(check == null) {
return;
}
if(!check.shouldSideBeRendered(blockAccess, x + face.offsetX, y + face.offsetY, z + face.offsetZ, face.ordinal())) {
return;
}
}
BlockCoord bc = new BlockCoord(x, y, z);
List<ForgeDirection> edges;
if(forceAllEdges) {
edges = RenderUtil.getEdgesForFace(face);
} else {
edges = RenderUtil.getNonConectedEdgesForFace(blockAccess, x, y, z, face);
}
Tessellator tes = Tessellator.instance;
tes.setNormal(face.offsetX, face.offsetY, face.offsetZ);
if(applyFaceShading) {
float cm = RenderUtil.getColorMultiplierForFace(face);
tes.setColorOpaque_F(cm, cm, cm);
}
float scaleFactor = 15f / 16f;
Vector2f uv = new Vector2f();
for (ForgeDirection edge : edges) {
float xLen = 1 - Math.abs(edge.offsetX) * scaleFactor;
float yLen = 1 - Math.abs(edge.offsetY) * scaleFactor;
float zLen = 1 - Math.abs(edge.offsetZ) * scaleFactor;
xLen -= 2 * (1 - block.getBlockBoundsMaxX()) - block.getBlockBoundsMinX();
yLen -= 2 * (1 - block.getBlockBoundsMaxY()) - block.getBlockBoundsMinY();
zLen -= 2 * (1 - block.getBlockBoundsMaxZ()) - block.getBlockBoundsMinZ();
BoundingBox bb = BoundingBox.UNIT_CUBE.scale(xLen, yLen, zLen);
List<Vector3f> corners = bb.getCornersForFace(face);
for (Vector3f unitCorn : corners) {
Vector3d corner = new Vector3d(unitCorn);
if(translateToXYZ) {
corner.x += x;
corner.y += y;
corner.z += z;
}
corner.x += (float) (edge.offsetX * 0.5) - Math.signum(edge.offsetX) * xLen / 2f;
corner.y += (float) (edge.offsetY * 0.5) - Math.signum(edge.offsetY) * yLen / 2f;
corner.z += (float) (edge.offsetZ * 0.5) - Math.signum(edge.offsetZ) * zLen / 2f;
if(translateToXYZ) {
RenderUtil.getUvForCorner(uv, corner, x, y, z, face, texture);
} else {
RenderUtil.getUvForCorner(uv, corner, 0, 0, 0, face, texture);
}
tes.addVertexWithUV(corner.x, corner.y, corner.z, uv.x, uv.y);
}
}
}
public static List<ForgeDirection> getNonConectedEdgesForFace(IBlockAccess blockAccess, int x, int y, int z, ForgeDirection face) {
return getNonConectedEdgesForFace(blockAccess, x, y, z, face, null);
}
public static List<ForgeDirection> getNonConectedEdgesForFace(IBlockAccess blockAccess, int x, int y, int z, ForgeDirection face,
IConnectedTextureRenderer render) {
Block block = blockAccess.getBlock(x, y, z);
if(block == null) {
return Collections.emptyList();
}
if(!block.shouldSideBeRendered(blockAccess, x + face.offsetX, y + face.offsetY, z + face.offsetZ, face.ordinal())) {
return Collections.emptyList();
}
BlockCoord bc = new BlockCoord(x, y, z);
List<EdgeNeighbour> edges = new ArrayList<EdgeNeighbour>(4);
for (ForgeDirection dir : getEdgesForFace(face)) {
edges.add(new EdgeNeighbour(bc, dir));
}
List<ForgeDirection> result = new ArrayList<ForgeDirection>(4);
for (EdgeNeighbour edge : edges) {
boolean matchingNeighbour = blockAccess.getBlock(edge.bc.x, edge.bc.y, edge.bc.z) == block;
if(matchingNeighbour && render != null) {
matchingNeighbour = render.matchesMetadata(blockAccess.getBlockMetadata(x, y, z), blockAccess.getBlockMetadata(edge.bc.x, edge.bc.y, edge.bc.z));
}
if(!matchingNeighbour) {
result.add(edge.dir);
}
}
return result;
}
public static void getUvForCorner(Vector2f uv, Vector3d corner, int x, int y, int z, ForgeDirection face, IIcon icon) {
if(icon == null) {
return;
}
Vector3d p = new Vector3d(corner);
p.x -= x;
p.y -= y;
p.z -= z;
float uWidth = 1;
float vWidth = 1;
if(icon != null) {
uWidth = icon.getMaxU() - icon.getMinU();
vWidth = icon.getMaxV() - icon.getMinV();
}
uv.x = (float) VecmathUtil.distanceFromPointToPlane(getUPlaneForFace(face), p);
uv.y = (float) VecmathUtil.distanceFromPointToPlane(getVPlaneForFace(face), p);
if(icon != null) {
uv.x = icon.getMinU() + (uv.x * uWidth);
uv.y = icon.getMinV() + (uv.y * vWidth);
}
}
public static Vector4d getVPlaneForFace(ForgeDirection face) {
switch (face) {
case DOWN:
case UP:
return new Vector4d(0, 0, 1, 0);
case EAST:
case WEST:
case NORTH:
case SOUTH:
return new Vector4d(0, -1, 0, 1);
case UNKNOWN:
default:
break;
}
return null;
}
public static Vector4d getUPlaneForFace(ForgeDirection face) {
switch (face) {
case DOWN:
case UP:
return new Vector4d(1, 0, 0, 0);
case EAST:
return new Vector4d(0, 0, -1, 1);
case WEST:
return new Vector4d(0, 0, 1, 0);
case NORTH:
return new Vector4d(-1, 0, 0, 1);
case SOUTH:
return new Vector4d(1, 0, 0, 0);
case UNKNOWN:
default:
break;
}
return null;
}
public static ForgeDirection getVDirForFace(ForgeDirection face) {
switch (face) {
case DOWN:
case UP:
return SOUTH;
case EAST:
case WEST:
case NORTH:
case SOUTH:
return ForgeDirection.UP;
case UNKNOWN:
default:
break;
}
return null;
}
public static ForgeDirection getUDirForFace(ForgeDirection face) {
switch (face) {
case DOWN:
case UP:
return ForgeDirection.EAST;
case EAST:
return NORTH;
case WEST:
return SOUTH;
case NORTH:
return WEST;
case SOUTH:
return ForgeDirection.EAST;
case UNKNOWN:
default:
break;
}
return null;
}
public static void renderGuiTank(FluidTank tank, double x, double y, double zLevel, double width, double height) {
renderGuiTank(tank.getFluid(), tank.getCapacity(), tank.getFluidAmount(), x, y, zLevel, width, height);
}
public static void renderGuiTank(FluidStack fluid, int capacity, int amount, double x, double y, double zLevel, double width, double height) {
if(fluid == null || fluid.getFluid() == null || fluid.amount <= 0) {
return;
}
IIcon icon = fluid.getFluid().getStillIcon();
if(icon == null) {
icon = fluid.getFluid().getIcon();
if(icon == null) {
return;
}
}
int renderAmount = (int) Math.max(Math.min(height, amount * height / capacity), 1);
int posY = (int) (y + height - renderAmount);
RenderUtil.bindBlockTexture();
int color = fluid.getFluid().getColor(fluid);
GL11.glColor3ub((byte) (color >> 16 & 0xFF), (byte) (color >> 8 & 0xFF), (byte) (color & 0xFF));
GL11.glEnable(GL11.GL_BLEND);
for (int i = 0; i < width; i += 16) {
for (int j = 0; j < renderAmount; j += 16) {
int drawWidth = (int) Math.min(width - i, 16);
int drawHeight = Math.min(renderAmount - j, 16);
int drawX = (int) (x + i);
int drawY = posY + j;
double minU = icon.getMinU();
double maxU = icon.getMaxU();
double minV = icon.getMinV();
double maxV = icon.getMaxV();
Tessellator tessellator = Tessellator.instance;
tessellator.startDrawingQuads();
tessellator.addVertexWithUV(drawX, drawY + drawHeight, 0, minU, minV + (maxV - minV) * drawHeight / 16F);
tessellator.addVertexWithUV(drawX + drawWidth, drawY + drawHeight, 0, minU + (maxU - minU) * drawWidth / 16F, minV + (maxV - minV) * drawHeight / 16F);
tessellator.addVertexWithUV(drawX + drawWidth, drawY, 0, minU + (maxU - minU) * drawWidth / 16F, minV);
tessellator.addVertexWithUV(drawX, drawY, 0, minU, minV);
tessellator.draw();
}
}
GL11.glDisable(GL11.GL_BLEND);
}
public static void drawBillboardedText(Vector3f pos, String text, float size) {
drawBillboardedText(pos, text, size, DEFAULT_TXT_COL, true, DEFAULT_TEXT_SHADOW_COL, true, DEFAULT_TEXT_BG_COL);
}
public static void drawBillboardedText(Vector3f pos, String text, float size, Vector4f bgCol) {
drawBillboardedText(pos, text, size, DEFAULT_TXT_COL, true, DEFAULT_TEXT_SHADOW_COL, true, bgCol);
}
public static void drawBillboardedText(Vector3f pos, String text, float size, Vector4f txtCol, boolean drawShadow, Vector4f shadowCol,
boolean drawBackground, Vector4f bgCol) {
GL11.glPushMatrix();
GL11.glTranslatef(pos.x, pos.y, pos.z);
glRotatef(180, 1, 0, 0);
FontRenderer fnt = Minecraft.getMinecraft().fontRenderer;
float scale = size / fnt.FONT_HEIGHT;
GL11.glScalef(scale, scale, scale);
glRotatef(RenderManager.instance.playerViewY + 180, 0.0F, 1.0F, 0.0F);
glRotatef(-RenderManager.instance.playerViewX, 1.0F, 0.0F, 0.0F);
glTranslatef(-fnt.getStringWidth(text) / 2, 0, 0);
if(drawBackground) {
renderBackground(fnt, text, bgCol);
}
fnt.drawString(text, 0, 0, ColorUtil.getRGBA(txtCol));
if(drawShadow) {
glTranslatef(0.5f, 0.5f, 0.1f);
fnt.drawString(text, 0, 0, ColorUtil.getRGBA(shadowCol));
}
GL11.glPopMatrix();
RenderUtil.bindBlockTexture();
}
public static void renderBackground(FontRenderer fnt, String toRender, Vector4f color) {
glPushAttrib(GL_ALL_ATTRIB_BITS);
glDisable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glShadeModel(GL_SMOOTH);
glDisable(GL_ALPHA_TEST);
glDisable(GL_CULL_FACE);
glDepthMask(false);
RenderHelper.disableStandardItemLighting();
OpenGlHelper.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO); // stop random disappearing
float width = fnt.getStringWidth(toRender);
float height = fnt.FONT_HEIGHT;
float padding = 2f;
Tessellator tessellator = Tessellator.instance;
tessellator.startDrawingQuads();
tessellator.setColorRGBA_F(color.x, color.y, color.z, color.w);
tessellator.addVertex(-padding, -padding, 0);
tessellator.addVertex(-padding, height + padding, 0);
tessellator.addVertex(width + padding, height + padding, 0);
tessellator.addVertex(width + padding, -padding, 0);
tessellator.draw();
glPopAttrib();
}
private static class EdgeNeighbour {
final ForgeDirection dir;
final BlockCoord bc;
public EdgeNeighbour(BlockCoord bc, ForgeDirection dir) {
this.dir = dir;
this.bc = bc.getLocation(dir);
}
}
public static void registerReloadListener(IResourceManagerReloadListener obj) {
((IReloadableResourceManager) Minecraft.getMinecraft().getResourceManager()).registerReloadListener(obj);
}
}
@@ -0,0 +1,57 @@
package com.enderio.core.client.render;
import java.util.Collection;
import net.minecraft.block.Block;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.client.model.obj.GroupObject;
import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
public class TechneModelRenderer implements ISimpleBlockRenderingHandler {
private Collection<GroupObject> model;
private int renderId;
protected VertexTransform vt;
public TechneModelRenderer(String modid, String modelPath, int renderId) {
this(modid, modelPath, renderId, null);
}
public TechneModelRenderer(String modid, String modelPath, int renderId, VertexTransform vt) {
this(TechneUtil.getModelAll(modid, modelPath), renderId, vt);
}
public TechneModelRenderer(Collection<GroupObject> model, int renderId) {
this(model, renderId, null);
}
public TechneModelRenderer(Collection<GroupObject> model, int renderId, VertexTransform vt) {
this.model = model;
this.renderId = renderId;
this.vt = vt;
}
@Override
public void renderInventoryBlock(Block block, int metadata, int modelId, RenderBlocks renderer) {
TechneUtil.vt = this.vt;
TechneUtil.renderInventoryBlock(model, block, metadata, renderer);
}
@Override
public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) {
TechneUtil.vt = this.vt;
return TechneUtil.renderWorldBlock(model, world, x, y, z, block, renderer);
}
@Override
public boolean shouldRender3DInInventory(int modelId) {
return true;
}
@Override
public int getRenderId() {
return renderId;
}
}
@@ -0,0 +1,367 @@
/*
Copyright © 2014 RainWarrior
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
4. This notice may not be removed or altered from any source
distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.enderio.core.client.render;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import net.minecraft.block.Block;
import net.minecraft.client.model.ModelBox;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.client.model.PositionTextureVertex;
import net.minecraft.client.model.TexturedQuad;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.util.IIcon;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.client.model.obj.Face;
import net.minecraftforge.client.model.obj.GroupObject;
import net.minecraftforge.client.model.obj.TextureCoordinate;
import net.minecraftforge.client.model.obj.Vertex;
import net.minecraftforge.client.model.techne.TechneModel;
import net.minecraftforge.client.model.techne.TechneModelLoader;
import net.minecraftforge.common.util.ForgeDirection;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.vector.Matrix4f;
import org.lwjgl.util.vector.Vector3f;
import org.lwjgl.util.vector.Vector4f;
import com.enderio.core.common.vecmath.Vector3d;
import com.google.common.collect.Maps;
import cpw.mods.fml.common.ObfuscationReflectionHelper;
/**
* Slightly modified to fit the EnderIO source.
*
* @author Based on RainWarrior's code <a
* href=https://gist.github.com/RainWarrior
* /39794c3548de9dcc7303>here.</a>
*/
public class TechneUtil {
public static VertexTransform vt = null;
private static final TechneModelLoader modelLoader = new TechneModelLoader();
private static final Tessellator tes = Tessellator.instance;
public static List<GroupObject> bakeModel(ModelRenderer model) {
return bakeModel(model, 1);
}
public static List<GroupObject> bakeModel(ModelRenderer model, float scale) {
return bakeModel(model, scale, new Matrix4f());
}
public static List<GroupObject> bakeModel(ModelRenderer model, float scale, Matrix4f matrix) {
return bakeModel(model, scale, matrix, false);
}
/**
* Convert ModelRenderer to a list of GroupObjects, for ease of use in ISBRH
* and other static contexts.
*
* @param scale
* the scale factor, usually last argument to rendering methods
* @param matrix
* initial transformation matrix (replaces calling
* glTranslate/glRotate/e.t.c. before rendering)
* @param rotateYFirst
* true, of the order of rotations be like in
* ModelRenderer.renderWithRotation, false if like in
* ModelRenderer.render
*/
@SuppressWarnings("unchecked")
public static List<GroupObject> bakeModel(ModelRenderer model, float scale, Matrix4f matrix, boolean rotateYFirst) {
Matrix4f m = new Matrix4f(matrix);
m.translate(new Vector3f(model.offsetX + model.rotationPointX * scale, model.offsetY + model.rotationPointY * scale, model.offsetZ + model.rotationPointZ
* scale));
if(!rotateYFirst) {
m.rotate(model.rotateAngleZ, new Vector3f(0, 0, 1));
}
m.rotate(model.rotateAngleY, new Vector3f(0, 1, 0));
m.rotate(model.rotateAngleX, new Vector3f(1, 0, 0));
if(rotateYFirst) {
m.rotate(model.rotateAngleZ, new Vector3f(0, 0, 1));
}
Vector4f vec = new Vector4f();
List<GroupObject> res = new ArrayList<GroupObject>();
for (ModelBox box : (List<ModelBox>) model.cubeList) {
GroupObject obj = new GroupObject("", GL11.GL_QUADS);
TexturedQuad[] quads = (TexturedQuad[]) ObfuscationReflectionHelper.getPrivateValue(ModelBox.class, box, "quadList", "field_78254_i");
for (int i = 0; i < quads.length; i++) {
Face face = new Face();
face.vertices = new Vertex[4];
face.textureCoordinates = new TextureCoordinate[4];
for (int j = 0; j < 4; j++) {
PositionTextureVertex pv = quads[i].vertexPositions[j];
vec.x = (float) pv.vector3D.xCoord * scale;
vec.y = (float) pv.vector3D.yCoord * scale;
vec.z = (float) pv.vector3D.zCoord * scale;
vec.w = 1;
Matrix4f.transform(m, vec, vec);
face.vertices[j] = new Vertex(vec.x / vec.w, vec.y / vec.w, vec.z / vec.w);
// Increase the interpolation scale by multiples of 2
while (pv.texturePositionX > uMult) {
uMult *= 2;
}
while (pv.texturePositionY > vMult) {
vMult *= 2;
}
face.textureCoordinates[j] = new TextureCoordinate(pv.texturePositionX, pv.texturePositionY);
}
face.faceNormal = face.calculateFaceNormal();
obj.faces.add(face);
}
res.add(obj);
}
return res;
}
public static Map<String, GroupObject> bakeModel(TechneModel model) {
return bakeModel(model, 1);
}
public static Map<String, GroupObject> bakeModel(TechneModel model, float scale) {
return bakeModel(model, scale, new Matrix4f());
}
public static Map<String, GroupObject> bakeModel(TechneModel model, float scale, Matrix4f m) {
return bakeModel(model, scale, m, false);
}
// Used in the second pass of baking to adjust UVs to the proper interpolation
private static int uMult = 1, vMult = 1;
/**
* Use this to convert TechneModel to it's static representation
*/
@SuppressWarnings("unchecked")
public static Map<String, GroupObject> bakeModel(TechneModel model, float scale, Matrix4f m, boolean rotateYFirst) {
Map<String, ModelRenderer> parts = (Map<String, ModelRenderer>) ObfuscationReflectionHelper.getPrivateValue(TechneModel.class, model, "parts");
Map<String, GroupObject> res = Maps.newHashMap();
for (Map.Entry<String, ModelRenderer> e : parts.entrySet()) {
GroupObject obj = bakeModel(e.getValue(), scale, m, rotateYFirst).get(0);
res.put(e.getKey(), obj);
}
// Second pass, adjust the UVs to be on a 0-1 interpolation scale
if(uMult + vMult != 2) {
for (GroupObject go : res.values()) {
for (Face f : go.faces) {
for (TextureCoordinate tc : f.textureCoordinates) {
tc.u /= uMult;
tc.v /= vMult;
}
}
}
}
uMult = vMult = 1;
return res;
}
public static Map<String, GroupObject> getModel(String modid, String modelPath) {
TechneModel tm = (TechneModel) modelLoader.loadInstance(new ResourceLocation(modid.toLowerCase(), modelPath + ".tcn"));
return TechneUtil.bakeModel(tm, 1f / 16, new Matrix4f().scale(new Vector3f(-1, -1, 1)));
}
public static Collection<GroupObject> getModelAll(String modid, String modelPath) {
TechneModel tm = (TechneModel) modelLoader.loadInstance(new ResourceLocation(modid.toLowerCase(), modelPath + ".tcn"));
return TechneUtil.bakeModel(tm, 1f / 16, new Matrix4f().scale(new Vector3f(-1, -1, 1))).values();
}
public static void renderWithIcon(Collection<GroupObject> model, IIcon icon, IIcon override, Tessellator tes) {
renderWithIcon(model, icon, override, tes, null);
}
public static void renderWithIcon(Collection<GroupObject> model, IIcon icon, IIcon override, Tessellator tes, VertexTransform vt) {
renderWithIcon(model, icon, override, tes, null, 0, 0, 0, vt);
}
public static void renderWithIcon(Collection<GroupObject> model, IIcon icon, IIcon override, Tessellator tes, IBlockAccess world, int x, int y, int z) {
renderWithIcon(model, icon, override, tes, world, x, y, z, null);
}
public static void renderWithIcon(Collection<GroupObject> model, IIcon icon, IIcon override, Tessellator tes, IBlockAccess world, int x, int y, int z,
VertexTransform vt) {
renderWithIcon(model, icon, override, tes, world, x, y, z, vt, true);
}
public static void renderWithIcon(Collection<GroupObject> model, IIcon icon, IIcon override, Tessellator tes, IBlockAccess world, int x, int y, int z,
VertexTransform vt, boolean isbrh) {
for (GroupObject go : model) {
renderWithIcon(go, icon, override, tes, world, x, y, z, vt, isbrh);
}
}
public static void renderWithIcon(GroupObject go, IIcon icon, IIcon override, Tessellator tes, IBlockAccess world, int x, int y, int z, VertexTransform vt,
boolean isbrh) {
for (Face f : go.faces) {
Vertex n = f.faceNormal;
tes.setNormal(n.x, n.y, n.z);
ForgeDirection normal = getNormalFor(n);
ForgeDirection right = normal.getRotation(ForgeDirection.DOWN);
if(normal == right) {
right = ForgeDirection.EAST;
}
ForgeDirection down = normal.getRotation(right.getOpposite());
if(isbrh && world != null && world.getBlock(x, y, z).getLightOpacity() > 0) {
int bx = x + normal.offsetX;
int by = y + normal.offsetY;
int bz = z + normal.offsetZ;
tes.setBrightness(world.getBlock(bx, by, bz).getMixedBrightnessForBlock(world, bx, by, bz));
}
for (int i = 0; i < f.vertices.length; i++) {
Vertex vert = f.vertices[i];
Vector3d v = new Vector3d(vert);
Vector3d tv = new Vector3d(v);
tv.add(0.5, 0, 0.5);
if(vt != null) {
vt.apply(v);
}
if(isbrh) {
float factor = normal.offsetX != 0 ? 0.8f : normal.offsetZ != 0 ? 0.6f : normal.offsetY < 0 ? 0.5f : 1;
int c = (int) (0xFF * factor);
tes.setColorOpaque(c, c, c);
}
if(override != null) {
double interpX = Math.abs(tv.x * right.offsetX + tv.y * right.offsetY + tv.z * right.offsetZ);
double interpY = Math.abs(tv.x * down.offsetX + tv.y * down.offsetY + tv.z * down.offsetZ);
// Handles verts outside block bounds. Modulo fails at 1.0.
while (interpX > 1) {
interpX--;
}
while (interpY > 1) {
interpY--;
}
if(normal == ForgeDirection.SOUTH || normal == ForgeDirection.WEST) {
interpX = 1 - interpX;
}
if(normal != ForgeDirection.UP && normal != ForgeDirection.DOWN) {
interpY = 1 - interpY;
}
tes.addVertexWithUV(v.x, v.y, v.z, override.getInterpolatedU(interpX * 16), override.getInterpolatedV(interpY * 16));
} else {
TextureCoordinate t = f.textureCoordinates[i];
tes.addVertexWithUV(v.x, v.y, v.z, icon.getInterpolatedU(t.u * 16), icon.getInterpolatedV(t.v * 16));
}
}
}
}
private static ForgeDirection getNormalFor(Vertex n) {
if(n.x != 0) {
return n.x > 0 ? ForgeDirection.EAST : ForgeDirection.WEST;
} else if(n.y != 0) {
return n.y > 0 ? ForgeDirection.UP : ForgeDirection.DOWN;
} else {
return n.z > 0 ? ForgeDirection.SOUTH : ForgeDirection.NORTH;
}
}
public static void renderInventoryBlock(Collection<GroupObject> model, Block block, int metadata, RenderBlocks rb) {
renderInventoryBlock(model, getIconFor(block, metadata), block, metadata, rb);
}
public static void renderInventoryBlock(Collection<GroupObject> model, IIcon icon, Block block, int metadata, RenderBlocks rb) {
tes.startDrawingQuads();
tes.setColorOpaque_F(1, 1, 1);
tes.addTranslation(0, -0.47f, 0);
renderWithIcon(model, icon, rb.overrideBlockTexture, tes, vt);
tes.addTranslation(0, 0.47f, 0);
tes.draw();
resetVT();
}
public static boolean renderWorldBlock(Collection<GroupObject> model, IBlockAccess world, int x, int y, int z, Block block, RenderBlocks rb) {
IIcon icon = getIconFor(block, world, x, y, z);
return renderWorldBlock(model, icon, world, x, y, z, block, rb);
}
public static boolean renderWorldBlock(Collection<GroupObject> model, IIcon icon, IBlockAccess world, int x, int y, int z, Block block, RenderBlocks rb) {
tes.setBrightness(block.getMixedBrightnessForBlock(world, x, y, z));
tes.setColorOpaque_F(1, 1, 1);
tes.addTranslation(x + .5F, y + 0.0375f, z + .5F);
renderWithIcon(model, icon, rb.overrideBlockTexture, tes, world, x, y, z, vt);
tes.addTranslation(-x - .5F, -y - 0.0375f, -z - .5F);
resetVT();
return true;
}
private static void resetVT() {
vt = null;
}
private static IIcon getIconFor(Block block, IBlockAccess world, int x, int y, int z) {
if(block instanceof AbstractMachineBlock<?>) {
return ((AbstractMachineBlock<?>) block).getModelIcon(world, x, y, z);
}
return block.getIcon(world, x, y, z, 0);
}
private static IIcon getIconFor(Block block, int metadata) {
if(block instanceof AbstractMachineBlock<?>) {
return ((AbstractMachineBlock<?>) block).getModelIcon();
}
return block.getIcon(0, metadata);
}
}
@@ -0,0 +1,57 @@
package com.enderio.core.client.render;
import com.enderio.core.common.vecmath.Quat4d;
import com.enderio.core.common.vecmath.Vector3d;
import com.enderio.core.common.vecmath.Vector3f;
import com.enderio.core.common.vecmath.Vertex;
public class VertexRotation implements VertexTransform {
private final Vector3d center;
private Quat4d quat;
private double angle;
private final Vector3d axis;
public VertexRotation(double angle, Vector3d axis, Vector3d center) {
this.center = new Vector3d(center);
this.axis = new Vector3d(axis);
this.angle = angle;
quat = Quat4d.makeRotate(angle, axis);
}
@Override
public void apply(Vertex vertex) {
apply(vertex.xyz);
}
@Override
public void apply(Vector3d vec) {
vec.sub(center);
quat.rotate(vec);
vec.add(center);
}
public void setAngle(double angle) {
this.angle = angle;
quat = Quat4d.makeRotate(angle, axis);
}
public double getAngle() {
return angle;
}
public void setAxis(Vector3d axis) {
this.axis.set(axis);
quat = Quat4d.makeRotate(angle, axis);
}
public void setCenter(Vector3d cen) {
center.set(cen);
}
@Override
public void applyToNormal(Vector3f vec) {
quat.rotate(vec);
}
}
@@ -0,0 +1,29 @@
package com.enderio.core.client.render;
import com.enderio.core.common.vecmath.Vector3d;
import net.minecraftforge.common.util.ForgeDirection;
public class VertexRotationFacing extends VertexRotation {
private static final double ROTATION_AMOUNT = Math.PI / 2;
private ForgeDirection defaultDir;
public VertexRotationFacing(ForgeDirection defaultDir) {
super(0, new Vector3d(0, 0.5, 0), new Vector3d(0, 0, 0));
this.defaultDir = defaultDir;
}
public void setRotation(ForgeDirection dir) {
if(dir == defaultDir) {
setAngle(0);
} else if(dir == defaultDir.getOpposite()) {
setAngle(ROTATION_AMOUNT * 2);
} else if(dir == defaultDir.getRotation(ForgeDirection.DOWN)) {
setAngle(ROTATION_AMOUNT);
} else {
setAngle(ROTATION_AMOUNT * 3);
}
}
}
@@ -0,0 +1,15 @@
package com.enderio.core.client.render;
import com.enderio.core.common.vecmath.Vector3d;
import com.enderio.core.common.vecmath.Vector3f;
import com.enderio.core.common.vecmath.Vertex;
public interface VertexTransform {
public abstract void apply(Vertex vertex);
public abstract void apply(Vector3d vec);
public abstract void applyToNormal(Vector3f vec);
}
@@ -0,0 +1,47 @@
package com.enderio.core.client.render;
import java.util.Collection;
import com.enderio.core.common.vecmath.Vector3d;
import com.enderio.core.common.vecmath.Vector3f;
import com.enderio.core.common.vecmath.Vertex;
public class VertexTransformComposite implements VertexTransform {
public final VertexTransform[] xforms;
public VertexTransformComposite(VertexTransform... xforms) {
this.xforms = xforms;
}
VertexTransformComposite(Collection<VertexTransform> xformsIn) {
xforms = new VertexTransform[xformsIn.size()];
int i = 0;
for (VertexTransform xform : xformsIn) {
xforms[i] = xform;
i++;
}
}
@Override
public void apply(Vertex vertex) {
for (VertexTransform xform : xforms) {
xform.apply(vertex);
}
}
@Override
public void apply(Vector3d vec) {
for (VertexTransform xform : xforms) {
xform.apply(vec);
}
}
@Override
public void applyToNormal(Vector3f vec) {
for (VertexTransform xform : xforms) {
xform.applyToNormal(vec);
}
}
}
@@ -0,0 +1,60 @@
package com.enderio.core.client.render;
import com.enderio.core.common.vecmath.Vector3d;
import com.enderio.core.common.vecmath.Vector3f;
import com.enderio.core.common.vecmath.Vertex;
public class VertexTranslation implements VertexTransform {
private double x;
private double y;
private double z;
public VertexTranslation(double x, double y, double z) {
this.x = x;
this.y = y;
this.z = z;
}
public VertexTranslation(float x, float y, float z) {
this.x = x;
this.y = y;
this.z = z;
}
public VertexTranslation(Vector3d trans) {
this(trans.x, trans.y, trans.z);
}
public VertexTranslation(Vector3f trans) {
this(trans.x, trans.y, trans.z);
}
@Override
public void apply(Vertex vertex) {
apply(vertex.xyz);
}
@Override
public void apply(Vector3d vec) {
vec.x += x;
vec.y += y;
vec.z += z;
}
public void set(double x, double y, double z) {
this.x = x;
this.y = y;
this.z = z;
}
public void set(Vector3d trans) {
set(trans.x, trans.y, trans.z);
}
@Override
public void applyToNormal(Vector3f vec) {
}
}
@@ -60,7 +60,7 @@ public class FireworkHandler
if (fireworksLeft > 0 && (!player.getEntityData().getBoolean("fireworkDelay") || player.worldObj.getTotalWorldTime() % 20 == 0))
{
BlockCoord pos = getBlockCoord(player);
pos.y += 2;
pos = pos.withY(pos.y + 2);
EnderEntityUtils.spawnFirework(pos, player.worldObj.provider.dimensionId, 12);
player.getEntityData().setInteger("fireworksLeft", fireworksLeft - 1);
@@ -0,0 +1,84 @@
package com.enderio.core.common.util;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
public class ArrayInventory implements IInventory {
protected ItemStack[] items;
public ArrayInventory(ItemStack[] items) {
this.items = items;
}
public ArrayInventory(int size) {
items = new ItemStack[size];
}
@Override
public int getSizeInventory() {
return items.length;
}
@Override
public ItemStack getStackInSlot(int slot) {
return items[slot];
}
@Override
public ItemStack decrStackSize(int slot, int amount) {
return Util.decrStackSize(this, slot, amount);
}
@Override
public ItemStack getStackInSlotOnClosing(int slot) {
return null;
}
@Override
public void setInventorySlotContents(int slot, ItemStack stack) {
items[slot] = stack;
markDirty();
}
@Override
public int getInventoryStackLimit() {
return 64;
}
@Override
public boolean isUseableByPlayer(EntityPlayer var1) {
return true;
}
@Override
public boolean isItemValidForSlot(int i, ItemStack itemstack) {
return true;
}
@Override
public String getInventoryName() {
return "ArrayInventory";
}
@Override
public boolean hasCustomInventoryName() {
return false;
}
@Override
public void markDirty() {
}
@Override
public void openInventory() {
}
@Override
public void closeInventory() {
}
}
@@ -1,91 +1,123 @@
package com.enderio.core.common.util;
import io.netty.buffer.ByteBuf;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.experimental.Wither;
import net.minecraft.block.Block;
import net.minecraft.entity.Entity;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.EnumChatFormatting;
import net.minecraft.util.MathHelper;
import net.minecraft.util.MovingObjectPosition;
import net.minecraft.world.World;
import net.minecraftforge.common.util.ForgeDirection;
import com.google.common.base.Strings;
@AllArgsConstructor
@EqualsAndHashCode
public class BlockCoord
{
@Wither
public int x, y, z;
public class BlockCoord {
@Wither
public final int x, y, z;
public BlockCoord(Entity e)
{
this(MathHelper.floor_double(e.posX), MathHelper.floor_double(e.posY), MathHelper.floor_double(e.posZ));
}
public BlockCoord() {
this(0, 0, 0);
}
public BlockCoord(TileEntity te)
{
this(te.xCoord, te.yCoord, te.zCoord);
}
public BlockCoord(double x, double y, double z) {
this(MathHelper.floor_double(x), MathHelper.floor_double(y), MathHelper.floor_double(z));
}
public BlockCoord(BlockCoord other)
{
this(other.x, other.y, other.z);
}
public BlockCoord(TileEntity tile) {
this(tile.xCoord, tile.yCoord, tile.zCoord);
}
public Block getBlock(World world)
{
return world.getBlock(x, y, z);
}
public BlockCoord(Entity e) {
this(e.posX, e.posY, e.posZ);
}
public int getMetadata(World world)
{
return world.getBlockMetadata(x, y, z);
}
public BlockCoord(BlockCoord bc) {
this(bc.x, bc.y, bc.z);
}
public TileEntity getTileEntity(World world)
{
return world.getTileEntity(x, y, z);
}
public BlockCoord getLocation(ForgeDirection dir) {
return new BlockCoord(x + dir.offsetX, y + dir.offsetY, z + dir.offsetZ);
}
public double getDistSq(BlockCoord other)
{
double xDiff = x + 0.5D - other.x;
double yDiff = y + 0.5D - other.y;
double zDiff = z + 0.5D - other.z;
return xDiff * xDiff + yDiff * yDiff + zDiff * zDiff;
}
public BlockCoord(String x, String y, String z) {
this(Strings.isNullOrEmpty(x) ? 0 : Integer.parseInt(x), Strings.isNullOrEmpty(y) ? 0 : Integer.parseInt(y), Strings.isNullOrEmpty(z) ? 0 : Integer
.parseInt(z));
}
public double getDistSq(TileEntity other)
{
return other.getDistanceFrom(x + 0.5, y + 0.5, z + 0.5);
}
public BlockCoord(MovingObjectPosition mop) {
this(mop.blockX, mop.blockY, mop.blockZ);
}
public void writeToNBT(NBTTagCompound tag)
{
tag.setInteger("blockCoordx", x);
tag.setInteger("blockCoordy", y);
tag.setInteger("blockCoordz", z);
}
public int getMetadata(World world) {
return world.getBlockMetadata(x, y, z);
}
public static BlockCoord readFromNBT(NBTTagCompound tag)
{
int x = tag.getInteger("blockCoordx");
int y = tag.getInteger("blockCoordy");
int z = tag.getInteger("blockCoordz");
public TileEntity getTileEntity(World world) {
return world.getTileEntity(x, y, z);
}
return new BlockCoord(x, y, z);
}
public double getDistSq(BlockCoord other) {
double xDiff = x + 0.5D - other.x;
double yDiff = y + 0.5D - other.y;
double zDiff = z + 0.5D - other.z;
return xDiff * xDiff + yDiff * yDiff + zDiff * zDiff;
}
public void setPosition(double x, double y, double z)
{
this.x = MathHelper.floor_double(x);
this.y = MathHelper.floor_double(y);
this.z = MathHelper.floor_double(z);
}
public double getDistSq(TileEntity other) {
return other.getDistanceFrom(x + 0.5, y + 0.5, z + 0.5);
}
@Override
public String toString()
{
return "X: " + x + " Y: " + y + " Z: " + z;
}
public int getDist(BlockCoord other) {
double dsq = getDistSq(other);
return (int) Math.ceil(Math.sqrt(dsq));
}
public int getDist(TileEntity other) {
double dsq = getDistSq(other);
return (int) Math.ceil(Math.sqrt(dsq));
}
public void writeToBuf(ByteBuf buf) {
buf.writeInt(x);
buf.writeInt(y);
buf.writeInt(z);
}
public static BlockCoord readFromBuf(ByteBuf buf) {
return new BlockCoord(buf.readInt(), buf.readInt(), buf.readInt());
}
public void writeToNBT(NBTTagCompound tag) {
tag.setInteger("bc:x", x);
tag.setInteger("bc:y", y);
tag.setInteger("bc:z", z);
}
public static BlockCoord readFromNBT(NBTTagCompound tag) {
return new BlockCoord(tag.getInteger("bc:x"), tag.getInteger("bc:y"), tag.getInteger("bc:z"));
}
public String chatString() {
return chatString(EnumChatFormatting.WHITE);
}
public String chatString(EnumChatFormatting defaultColor) {
return String.format(
"x%s%d%s y%s%d%s z%s%d",
EnumChatFormatting.GREEN, x, defaultColor,
EnumChatFormatting.GREEN, y, defaultColor,
EnumChatFormatting.GREEN, z
);
}
@Override
public String toString() {
return "X: " + x + " Y: " + y + " Z: " + z;
}
}
@@ -0,0 +1,115 @@
package com.enderio.core.common.util;
import net.minecraft.item.ItemDye;
import net.minecraft.item.ItemStack;
import net.minecraftforge.oredict.OreDictionary;
public enum DyeColor {
BLACK,
RED,
GREEN,
BROWN,
BLUE,
PURPLE,
CYAN,
SILVER,
GRAY,
PINK,
LIME,
YELLOW,
LIGHT_BLUE,
MAGENTA,
ORANGE,
WHITE;
public static final String[] DYE_ORE_NAMES = {
"dyeBlack",
"dyeRed",
"dyeGreen",
"dyeBrown",
"dyeBlue",
"dyePurple",
"dyeCyan",
"dyeLightGray",
"dyeGray",
"dyePink",
"dyeLime",
"dyeYellow",
"dyeLightBlue",
"dyeMagenta",
"dyeOrange",
"dyeWhite"
};
public static final String[] DYE_ORE_UNLOCAL_NAMES = {
"item.fireworksCharge.black",
"item.fireworksCharge.red",
"item.fireworksCharge.green",
"item.fireworksCharge.brown",
"item.fireworksCharge.blue",
"item.fireworksCharge.purple",
"item.fireworksCharge.cyan",
"item.fireworksCharge.silver",
"item.fireworksCharge.gray",
"item.fireworksCharge.pink",
"item.fireworksCharge.lime",
"item.fireworksCharge.yellow",
"item.fireworksCharge.lightBlue",
"item.fireworksCharge.magenta",
"item.fireworksCharge.orange",
"item.fireworksCharge.white"
};
public static DyeColor getNext(DyeColor col) {
int ord = col.ordinal() + 1;
if(ord >= DyeColor.values().length) {
ord = 0;
}
return DyeColor.values()[ord];
}
public static DyeColor getColorFromDye(ItemStack dye) {
if(dye == null) {
return null;
}
int oreId = OreDictionary.getOreID(dye);
if(oreId < 0) {
return null;
}
for (int i = 0; i < DYE_ORE_NAMES.length; i++) {
String dyeName = DYE_ORE_NAMES[i];
if(OreDictionary.getOreID(dyeName) == oreId) {
return DyeColor.values()[i];
}
}
return null;
}
public static DyeColor fromIndex(int index) {
return DyeColor.values()[index];
}
private DyeColor() {
}
public int getColor() {
return ItemDye.field_150922_c[ordinal()];
}
public String getName() {
return ItemDye.field_150921_b[ordinal()];
}
public String getLocalisedName() {
return Lang.localize(DYE_ORE_UNLOCAL_NAMES[ordinal()], false);
}
@Override
public String toString() {
return getName();
}
}
@@ -69,13 +69,12 @@ public class EnderEntityUtils
{
World world = DimensionManager.getWorld(dimID);
BlockCoord pos = new BlockCoord(0, 0, 0);
pos.setPosition(block.x, block.y, block.z);
BlockCoord pos = new BlockCoord(block.x, block.y, block.z);
// don't bother if there's no randomness at all
if (range > 0)
{
pos.setPosition(moveRandomly(block.x, range), block.y, moveRandomly(block.z, range));
pos = new BlockCoord(moveRandomly(block.x, range), block.y, moveRandomly(block.z, range));
int tries = -1;
while (!world.isAirBlock(pos.x, pos.y, pos.z) && !world.getBlock(pos.x, pos.y, pos.z).isReplaceable(world, pos.x, pos.y, pos.z))
@@ -0,0 +1,95 @@
package com.enderio.core.common.util;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import net.minecraft.block.Block;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityList;
import net.minecraft.entity.EntityLiving;
import net.minecraft.entity.boss.IBossDisplayData;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.item.ItemStack;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.MathHelper;
import net.minecraft.util.StatCollector;
import net.minecraft.world.World;
import com.enderio.core.common.vecmath.Vector3d;
public class EntityUtil {
public static String getDisplayNameForEntity(String mobName) {
return StatCollector.translateToLocal("entity." + mobName + ".name");
}
public static List<String> getAllRegisteredMobNames(boolean excludeBosses) {
List<String> result = new ArrayList<String>();
Set<Map.Entry<Class, String>> entries = EntityList.classToStringMapping.entrySet();
for(Map.Entry<Class, String> entry : entries) {
if(EntityLiving.class.isAssignableFrom(entry.getKey()) ) {
if(!excludeBosses || !IBossDisplayData.class.isAssignableFrom(entry.getKey())) {
result.add(entry.getValue());
}
}
}
return result;
}
private EntityUtil() {
}
public static Vector3d getEntityPosition(Entity ent) {
return new Vector3d(ent.posX, ent.posY, ent.posZ);
}
public static List<AxisAlignedBB> getCollidingBlockGeometry(World world, Entity entity) {
AxisAlignedBB entityBounds = entity.boundingBox;
ArrayList collidingBoundingBoxes = new ArrayList();
int minX = MathHelper.floor_double(entityBounds.minX);
int minY = MathHelper.floor_double(entityBounds.minY);
int minZ = MathHelper.floor_double(entityBounds.minZ);
int maxX = MathHelper.floor_double(entityBounds.maxX + 1.0D);
int maxY = MathHelper.floor_double(entityBounds.maxY + 1.0D);
int maxZ = MathHelper.floor_double(entityBounds.maxZ + 1.0D);
for (int x = minX; x < maxX; x++) {
for (int z = minZ; z < maxZ; z++) {
for (int y = minY; y < maxY; y++) {
Block block = world.getBlock(x, y, z);
if(block != null) {
block.addCollisionBoxesToList(world, x, y, z, entityBounds, collidingBoundingBoxes, entity);
}
}
}
}
return collidingBoundingBoxes;
}
public static void spawnItemInWorldWithRandomMotion(World world, ItemStack item, int x, int y, int z) {
if(item != null) {
spawnItemInWorldWithRandomMotion(world, item, x + 0.5, y + 0.5, z + 0.5);
}
}
public static void spawnItemInWorldWithRandomMotion(World world, ItemStack item, double x, double y, double z) {
if(item != null) {
spawnItemInWorldWithRandomMotion(new EntityItem(world, x, y, z, item));
}
}
public static void spawnItemInWorldWithRandomMotion(EntityItem entity) {
entity.delayBeforeCanPickup = 10;
float f = (entity.worldObj.rand.nextFloat() * 0.1f) - 0.05f;
float f1 = (entity.worldObj.rand.nextFloat() * 0.1f) - 0.05f;
float f2 = (entity.worldObj.rand.nextFloat() * 0.1f) - 0.05f;
entity.motionX += f;
entity.motionY += f1;
entity.motionZ += f2;
entity.worldObj.spawnEntityInWorld(entity);
}
}
@@ -0,0 +1,460 @@
package com.enderio.core.common.util;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.minecraft.block.Block;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Items;
import net.minecraft.item.ItemPotion;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidContainerRegistry;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.FluidTank;
import net.minecraftforge.fluids.FluidTankInfo;
import net.minecraftforge.fluids.IFluidBlock;
import net.minecraftforge.fluids.IFluidContainerItem;
import net.minecraftforge.fluids.IFluidHandler;
import net.minecraftforge.fluids.IFluidTank;
import cpw.mods.fml.common.Loader;
public class FluidUtil {
public static final List<IFluidReceptor> fluidReceptors = new ArrayList<IFluidReceptor>();
static {
try {
Class.forName("crazypants.util.BuildcraftUtil");
} catch (Exception e) {
if(Loader.isModLoaded("BuildCraft|Transport")) {
Log.warn("ItemUtil: Could not register Build Craft pipe handler. Fluid conduits will show connections to all Build Craft pipes.");
} //Don't log if BC isn't installed, but we still check in case another mod is using their API
}
}
public static Map<ForgeDirection, IFluidHandler> getNeighbouringFluidHandlers(IBlockAccess world, BlockCoord bc) {
Map<ForgeDirection, IFluidHandler> res = new HashMap<ForgeDirection, IFluidHandler>();
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) {
IFluidHandler fh = getFluidHandler(world, bc.getLocation(dir));
if(fh != null) {
res.put(dir, fh);
}
}
return res;
}
// public static IFluidHandler getExternalFluidHandler(IBlockAccess world, BlockCoord bc) {
// IFluidHandler con = getFluidHandler(world, bc);
// return (con != null && !(con instanceof IConduitBundle)) ? con : null;
// }
public static IFluidHandler getFluidHandler(IBlockAccess world, BlockCoord bc) {
return getFluidHandler(world, bc.x, bc.y, bc.z);
}
public static IFluidHandler getFluidHandler(IBlockAccess world, int x, int y, int z) {
TileEntity te = world.getTileEntity(x, y, z);
return getFluidHandler(te);
}
public static IFluidHandler getFluidHandler(TileEntity te) {
if(te instanceof IFluidHandler) {
IFluidHandler res = (IFluidHandler) te;
for (IFluidReceptor rec : fluidReceptors) {
if(!rec.isValidReceptor(res)) {
return null;
}
}
return res;
}
return null;
}
public static FluidStack getFluidFromItem(ItemStack stack) {
if(stack != null) {
FluidStack fluidStack = null;
if(stack.getItem() instanceof IFluidContainerItem) {
fluidStack = ((IFluidContainerItem) stack.getItem()).getFluid(stack);
}
if(fluidStack == null) {
fluidStack = FluidContainerRegistry.getFluidForFilledItem(stack);
}
if(fluidStack == null && Block.getBlockFromItem(stack.getItem()) instanceof IFluidBlock) {
Fluid fluid = ((IFluidBlock) Block.getBlockFromItem(stack.getItem())).getFluid();
if(fluid != null) {
return new FluidStack(fluid, 1000);
}
}
return fluidStack;
}
return null;
}
public static boolean doPull(IFluidHandler into, ForgeDirection fromDir, int maxVolume) {
TileEntity te = (TileEntity) into;
BlockCoord loc = new BlockCoord(te).getLocation(fromDir);
IFluidHandler target = FluidUtil.getFluidHandler(te.getWorldObj(), loc);
if(target != null) {
FluidTankInfo[] infos = target.getTankInfo(fromDir.getOpposite());
if(infos != null) {
for (FluidTankInfo info : infos) {
if(info.fluid != null && info.fluid.amount > 0) {
if(into.canFill(fromDir, info.fluid.getFluid())) {
FluidStack canPull = info.fluid.copy();
canPull.amount = Math.min(maxVolume, canPull.amount);
FluidStack drained = target.drain(fromDir.getOpposite(), canPull, false);
if(drained != null && drained.amount > 0) {
int filled = into.fill(fromDir, drained, false);
if(filled > 0) {
drained = target.drain(fromDir.getOpposite(), filled, true);
into.fill(fromDir, drained, true);
return true;
}
}
}
}
}
}
}
return false;
}
public static boolean doPush(IFluidHandler from, ForgeDirection fromDir, int maxVolume) {
TileEntity te = (TileEntity) from;
BlockCoord loc = new BlockCoord(te).getLocation(fromDir);
IFluidHandler target = getFluidHandler(te.getWorldObj(), loc);
if(target == null) {
return false;
}
FluidTankInfo[] infos = from.getTankInfo(fromDir);
boolean res = false;
if(infos != null) {
for (FluidTankInfo info : infos) {
if(info.fluid != null && info.fluid.amount > 0 && from.canDrain(fromDir, info.fluid.getFluid())) {
FluidStack maxDrain = new FluidStack(info.fluid.getFluid(), maxVolume);
FluidStack canDrain = from.drain(fromDir, maxDrain, false);
if(canDrain != null && canDrain.amount > 0) {
int filled = target.fill(fromDir.getOpposite(), canDrain, true);
from.drain(fromDir, new FluidStack(info.fluid.getFluid(), filled), true);
res |= true;
}
}
}
}
return res;
}
public static FluidAndStackResult tryFillContainer(ItemStack target, FluidStack source) {
if (target != null && target.getItem() != null && source != null && source.getFluid() != null && source.amount > 0) {
if (target.getItem() instanceof IFluidContainerItem) {
ItemStack resultStack = target.copy();
resultStack.stackSize = 1;
int amount = ((IFluidContainerItem) target.getItem()).fill(resultStack, source, true);
if (amount <= 0) {
return new FluidAndStackResult(null, null, target, source);
}
FluidStack resultFluid = source.copy();
resultFluid.amount = amount;
ItemStack remainderStack = target.copy();
remainderStack.stackSize--;
if (remainderStack.stackSize <= 0) {
remainderStack = null;
}
FluidStack remainderFluid = source.copy();
remainderFluid.amount -= amount;
if (remainderFluid.amount <= 0) {
remainderFluid = null;
}
return new FluidAndStackResult(resultStack, resultFluid, remainderStack, remainderFluid);
}
ItemStack resultStack = FluidContainerRegistry.fillFluidContainer(source.copy(), target);
if (resultStack != null) {
FluidStack resultFluid = FluidContainerRegistry.getFluidForFilledItem(resultStack);
if (resultFluid != null) {
ItemStack remainderStack = target.copy();
remainderStack.stackSize--;
if (remainderStack.stackSize <= 0) {
remainderStack = null;
}
FluidStack remainderFluid = source.copy();
remainderFluid.amount -= resultFluid.amount;
if (remainderFluid.amount <= 0) {
remainderFluid = null;
}
return new FluidAndStackResult(resultStack, resultFluid, remainderStack, remainderFluid);
}
}
}
return new FluidAndStackResult(null, null, target, source);
}
public static FluidAndStackResult tryDrainContainer(ItemStack source, FluidStack target, int capacity) {
if (source != null && source.getItem() != null) {
int maxDrain = capacity - (target != null ? target.amount : 0);
if (source.getItem() instanceof IFluidContainerItem) {
ItemStack resultStack = source.copy();
resultStack.stackSize = 1;
FluidStack resultFluid = ((IFluidContainerItem) source.getItem()).drain(resultStack, maxDrain, true);
if (resultFluid == null || resultFluid.amount <= 0 || (target != null && resultFluid.getFluid() != target.getFluid())) {
return new FluidAndStackResult(null, null, source, target);
}
ItemStack remainderStack = source.copy();
remainderStack.stackSize--;
if (remainderStack.stackSize <= 0) {
remainderStack = null;
}
FluidStack remainderFluid = target != null ? target.copy() : new FluidStack(resultFluid.getFluid(), 0);
remainderFluid.amount += resultFluid.amount;
return new FluidAndStackResult(resultStack, resultFluid, remainderStack, remainderFluid);
}
FluidStack resultFluid = FluidContainerRegistry.getFluidForFilledItem(source);
if (resultFluid != null && resultFluid.amount > 0 && resultFluid.amount <= maxDrain
&& (target == null || resultFluid.getFluid() == target.getFluid())) {
ItemStack resultStack = source.getItem().getContainerItem(source);
// TODO
// if (resultStack == null && Config.enableWaterFromBottles && source.getItem() instanceof ItemPotion
// && source.stackTagCompound == null) {
// resultStack = new ItemStack(Items.glass_bottle);
// }
ItemStack remainderStack = source.copy();
remainderStack.stackSize--;
if (remainderStack.stackSize <= 0) {
remainderStack = null;
}
FluidStack remainderFluid = target != null ? target.copy() : new FluidStack(resultFluid.getFluid(), 0);
remainderFluid.amount += resultFluid.amount;
return new FluidAndStackResult(resultStack, resultFluid, remainderStack, remainderFluid);
}
}
return new FluidAndStackResult(null, null, source, target);
}
public static FluidAndStackResult tryDrainContainer(ItemStack source, ITankAccess tank) {
if (source != null && source.getItem() != null) {
if (source.getItem() instanceof IFluidContainerItem) {
IFluidTank targetTank = tank.getInputTank(((IFluidContainerItem) source.getItem()).getFluid(source));
if (targetTank != null) {
FluidStack target = targetTank.getFluid();
int maxDrain = targetTank.getCapacity() - (target != null ? target.amount : 0);
ItemStack resultStack = source.copy();
resultStack.stackSize = 1;
FluidStack resultFluid = ((IFluidContainerItem) source.getItem()).drain(resultStack, maxDrain, true);
if (resultFluid == null || resultFluid.amount <= 0 || (target != null && resultFluid.getFluid() != target.getFluid())) {
return new FluidAndStackResult(null, null, source, target);
}
ItemStack remainderStack = source.copy();
remainderStack.stackSize--;
if (remainderStack.stackSize <= 0) {
remainderStack = null;
}
FluidStack remainderFluid = target != null ? target.copy() : new FluidStack(resultFluid.getFluid(), 0);
remainderFluid.amount += resultFluid.amount;
return new FluidAndStackResult(resultStack, resultFluid, remainderStack, remainderFluid);
}
}
FluidStack resultFluid = FluidContainerRegistry.getFluidForFilledItem(source);
if (resultFluid != null && resultFluid.amount > 0) {
IFluidTank targetTank = tank.getInputTank(resultFluid);
if (targetTank != null) {
FluidStack target = targetTank.getFluid();
int maxDrain = targetTank.getCapacity() - (target != null ? target.amount : 0);
if (resultFluid.amount <= maxDrain && (target == null || resultFluid.getFluid() == target.getFluid())) {
ItemStack resultStack = source.getItem().getContainerItem(source);
// if (resultStack == null && Config.enableWaterFromBottles && source.getItem() instanceof ItemPotion
// && source.stackTagCompound == null) {
// resultStack = new ItemStack(Items.glass_bottle);
// }
ItemStack remainderStack = source.copy();
remainderStack.stackSize--;
if (remainderStack.stackSize <= 0) {
remainderStack = null;
}
FluidStack remainderFluid = target != null ? target.copy() : new FluidStack(resultFluid.getFluid(), 0);
remainderFluid.amount += resultFluid.amount;
return new FluidAndStackResult(resultStack, resultFluid, remainderStack, remainderFluid);
}
}
}
}
return new FluidAndStackResult(null, null, source, null);
}
/**
* If the currently held item of the given player can be filled with the
* liquid in the given tank's output tank, do so and put the resultant filled
* container item where it can go. This will also drain the tank and set it to
* dirty.
*
* <p>
* Cases handled for the the filled container:
*
* <ul>
* <li>If the stacksize of the held item is one, then it will be replaced by
* the filled container unless the player in in creative.
* <li>If the filled container is stackable and the player already has a
* non-maxed stack in the inventory, it is put there.
* <li>If the player has space in his inventory, it is put there.
* <li>Otherwise it will be dropped on the ground between the position given
* as parameter and the player's position.
* </ul>
*
* @param world
* @param x
* @param y
* @param z
* @param entityPlayer
* @param tank
* @return true if a container was filled, false otherwise
*/
public static boolean fillPlayerHandItemFromInternalTank(World world, int x, int y, int z, EntityPlayer entityPlayer,
ITankAccess tank) {
for (FluidTank subTank : tank.getOutputTanks()) {
FluidAndStackResult fill = tryFillContainer(entityPlayer.inventory.getCurrentItem(), subTank.getFluid());
if(fill.result.fluidStack != null) {
subTank.setFluid(fill.remainder.fluidStack);
tank.setTanksDirty();
if(!entityPlayer.capabilities.isCreativeMode) {
if(fill.remainder.itemStack == null) {
entityPlayer.inventory.setInventorySlotContents(entityPlayer.inventory.currentItem, fill.result.itemStack);
return true;
} else {
entityPlayer.inventory.setInventorySlotContents(entityPlayer.inventory.currentItem, fill.remainder.itemStack);
}
if(fill.result.itemStack.isStackable()) {
for (int i = 0; i < entityPlayer.inventory.mainInventory.length; i++) {
ItemStack inventoryItem = entityPlayer.inventory.mainInventory[i];
if(ItemUtil.areStackMergable(inventoryItem, fill.result.itemStack) && inventoryItem.stackSize < inventoryItem.getMaxStackSize()) {
fill.result.itemStack.stackSize += inventoryItem.stackSize;
entityPlayer.inventory.setInventorySlotContents(i, fill.result.itemStack);
return true;
}
}
}
for (int i = 0; i < entityPlayer.inventory.mainInventory.length; i++) {
if(entityPlayer.inventory.mainInventory[i] == null) {
entityPlayer.inventory.setInventorySlotContents(i, fill.result.itemStack);
return true;
}
}
if(!world.isRemote) {
double x0 = (x + entityPlayer.posX) / 2.0D;
double y0 = (y + entityPlayer.posY) / 2.0D + 0.5D;
double z0 = (z + entityPlayer.posZ) / 2.0D;
Util.dropItems(world, fill.result.itemStack, x0, y0, z0, true);
}
}
return true;
}
}
return false;
}
public static boolean fillInternalTankFromPlayerHandItem(World world, int x, int y, int z, EntityPlayer entityPlayer,
ITankAccess tank) {
FluidAndStackResult fill = tryDrainContainer(entityPlayer.inventory.getCurrentItem(), tank);
if(fill.result.fluidStack == null) {
return false;
}
tank.getInputTank(fill.result.fluidStack).setFluid(fill.remainder.fluidStack);
tank.setTanksDirty();
if(!entityPlayer.capabilities.isCreativeMode) {
if(fill.remainder.itemStack == null) {
entityPlayer.inventory.setInventorySlotContents(entityPlayer.inventory.currentItem, fill.result.itemStack);
return true;
} else {
entityPlayer.inventory.setInventorySlotContents(entityPlayer.inventory.currentItem, fill.remainder.itemStack);
}
if(fill.result.itemStack.isStackable()) {
for (int i = 0; i < entityPlayer.inventory.mainInventory.length; i++) {
ItemStack inventoryItem = entityPlayer.inventory.mainInventory[i];
if(ItemUtil.areStackMergable(inventoryItem, fill.result.itemStack) && inventoryItem.stackSize < inventoryItem.getMaxStackSize()) {
fill.result.itemStack.stackSize += inventoryItem.stackSize;
entityPlayer.inventory.setInventorySlotContents(i, fill.result.itemStack);
return true;
}
}
}
for (int i = 0; i < entityPlayer.inventory.mainInventory.length; i++) {
if(entityPlayer.inventory.mainInventory[i] == null) {
entityPlayer.inventory.setInventorySlotContents(i, fill.result.itemStack);
return true;
}
}
if(!world.isRemote) {
double x0 = (x + entityPlayer.posX) / 2.0D;
double y0 = (y + entityPlayer.posY) / 2.0D + 0.5D;
double z0 = (z + entityPlayer.posZ) / 2.0D;
Util.dropItems(world, fill.result.itemStack, x0, y0, z0, true);
}
}
return true;
}
public static class FluidAndStack {
public final FluidStack fluidStack;
public final ItemStack itemStack;
public FluidAndStack(FluidStack fluidStack, ItemStack itemStack) {
this.fluidStack = fluidStack;
this.itemStack = itemStack;
}
public FluidAndStack(ItemStack itemStack, FluidStack fluidStack) {
this.fluidStack = fluidStack;
this.itemStack = itemStack;
}
}
public static class FluidAndStackResult {
public final FluidAndStack result;
public final FluidAndStack remainder;
public FluidAndStackResult(FluidAndStack result, FluidAndStack remainder) {
this.result = result;
this.remainder = remainder;
}
public FluidAndStackResult(FluidStack fluidStackResult, ItemStack itemStackResult, FluidStack fluidStackRemainder,
ItemStack itemStackRemainder) {
this.result = new FluidAndStack(fluidStackResult, itemStackResult);
this.remainder = new FluidAndStack(fluidStackRemainder, itemStackRemainder);
}
public FluidAndStackResult(ItemStack itemStackResult, FluidStack fluidStackResult, ItemStack itemStackRemainder,
FluidStack fluidStackRemainder) {
this.result = new FluidAndStack(fluidStackResult, itemStackResult);
this.remainder = new FluidAndStack(fluidStackRemainder, itemStackRemainder);
}
}
}
@@ -0,0 +1,60 @@
package com.enderio.core.common.util;
import net.minecraftforge.common.util.ForgeDirection;
import com.enderio.core.common.vecmath.Vector3d;
public final class ForgeDirectionOffsets {
public static final Vector3d[] OFFSETS = new Vector3d[ForgeDirection.values().length];
static {
for (ForgeDirection dir : ForgeDirection.values()) {
OFFSETS[dir.ordinal()] = new Vector3d(dir.offsetX, dir.offsetY, dir.offsetZ);
}
}
public static Vector3d forDir(ForgeDirection dir) {
return OFFSETS[dir.ordinal()];
}
public static Vector3d forDirCopy(ForgeDirection dir) {
return new Vector3d(OFFSETS[dir.ordinal()]);
}
public static Vector3d offsetScaled(ForgeDirection dir, double scale) {
Vector3d res = forDirCopy(dir);
res.scale(scale);
return res;
}
public static Vector3d absolueOffset(ForgeDirection dir) {
Vector3d res = forDirCopy(dir);
res.x = Math.abs(res.x);
res.y = Math.abs(res.y);
res.z = Math.abs(res.z);
return res;
}
public ForgeDirection closest(float x, float y, float z) {
float ax = Math.abs(x);
float ay = Math.abs(y);
float az = Math.abs(z);
if(ax >= ay && ax >= az) {
return x > 0 ? ForgeDirection.EAST : ForgeDirection.WEST;
}
if(ay >= ax && ay >= az) {
return y > 0 ? ForgeDirection.UP : ForgeDirection.DOWN;
}
return z > 0 ? ForgeDirection.SOUTH : ForgeDirection.NORTH;
}
private ForgeDirectionOffsets() {
}
public static boolean isPositiveOffset(ForgeDirection dir) {
return dir == ForgeDirection.SOUTH || dir == ForgeDirection.EAST || dir == ForgeDirection.UP;
}
}
@@ -0,0 +1,78 @@
package com.enderio.core.common.util;
import net.minecraft.block.Block;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.biome.BiomeGenBase;
import net.minecraftforge.common.util.ForgeDirection;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class IBlockAccessWrapper implements IBlockAccess {
protected IBlockAccess wrapped;
public IBlockAccessWrapper(IBlockAccess ba) {
wrapped = ba;
}
@Override
public boolean isSideSolid(int x, int y, int z, ForgeDirection side, boolean _default) {
return wrapped.isSideSolid(x, y, z, side, _default);
}
@Override
public int isBlockProvidingPowerTo(int var1, int var2, int var3, int var4) {
return wrapped.isBlockProvidingPowerTo(var1, var2, var3, var4);
}
@Override
public boolean isAirBlock(int var1, int var2, int var3) {
return wrapped.isAirBlock(var1, var2, var3);
}
@Override
public TileEntity getTileEntity(int var1, int var2, int var3) {
if (var2 >= 0 && var2 < 256) {
return wrapped.getTileEntity(var1, var2, var3);
} else {
return null;
}
}
@Override
@SideOnly(Side.CLIENT)
public int getLightBrightnessForSkyBlocks(int var1, int var2, int var3, int var4) {
return 15 << 20 | 15 << 4;
}
@Override
@SideOnly(Side.CLIENT)
public int getHeight() {
return wrapped.getHeight();
}
@Override
public int getBlockMetadata(int var1, int var2, int var3) {
return wrapped.getBlockMetadata(var1, var2, var3);
}
@Override
public Block getBlock(int var1, int var2, int var3) {
return wrapped.getBlock(var1, var2, var3);
}
@Override
@SideOnly(Side.CLIENT)
public BiomeGenBase getBiomeGenForCoords(int var1, int var2) {
return wrapped.getBiomeGenForCoords(var1, var2);
}
@Override
@SideOnly(Side.CLIENT)
public boolean extendedLevelsInChunkCache() {
return wrapped.extendedLevelsInChunkCache();
}
}
@@ -0,0 +1,9 @@
package com.enderio.core.common.util;
import net.minecraftforge.fluids.IFluidHandler;
public interface IFluidReceptor {
boolean isValidReceptor(IFluidHandler handler);
}
@@ -0,0 +1,12 @@
package com.enderio.core.common.util;
import net.minecraft.item.ItemStack;
import net.minecraftforge.common.util.ForgeDirection;
public interface IItemReceptor {
boolean canInsertIntoObject(Object into, ForgeDirection side);
int doInsertItem(Object into, ItemStack item, ForgeDirection side);
}
@@ -0,0 +1,22 @@
package com.enderio.core.common.util;
import net.minecraft.tileentity.TileEntity;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public interface IProgressTile {
float getProgress();
/**
* Client-only. Called to set clientside progress for syncing/rendering
* purposes.
*
* @param progress
* The % progress.
*/
@SideOnly(Side.CLIENT)
void setProgress(float progress);
TileEntity getTileEntity();
}
@@ -0,0 +1,33 @@
package com.enderio.core.common.util;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.FluidTank;
public interface ITankAccess {
/**
* Find tank to insert fluid.
*
* @param forFluidType
* The type of fluid that should be inserted. May be null.
* @return An internal tank that can take the given type of fluid. If multiple
* tanks can take the fluid, the first one that is not full will be
* returned. If no tank can take the fluid, returns null.
*/
FluidTank getInputTank(FluidStack forFluidType);
/**
* Get tank(s) to remove liquid from.
*
* @return Tank that can be drained. Tanks are returned in order or priority.
* If there's no tank, an empty array is returned.
*/
FluidTank[] getOutputTanks();
/**
* Will be called after a tank that was returned by one of the other methods
* was manipulated.
*/
void setTanksDirty();
}
@@ -0,0 +1,118 @@
package com.enderio.core.common.util;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.ISidedInventory;
import net.minecraft.item.ItemStack;
public class InventoryWrapper implements ISidedInventory {
public static ISidedInventory asSidedInventory(IInventory inv) {
if(inv == null) {
return null;
}
if(inv instanceof ISidedInventory) {
return (ISidedInventory) inv;
}
return new InventoryWrapper(inv);
}
private IInventory inv;
public InventoryWrapper(IInventory inventory) {
this.inv = ItemUtil.getInventory(inventory);
}
public IInventory getWrappedInv() {
return inv;
}
@Override
public int getSizeInventory() {
return inv.getSizeInventory();
}
@Override
public ItemStack getStackInSlot(int slot) {
if(slot < 0 || slot >= inv.getSizeInventory()) {
return null;
}
return inv.getStackInSlot(slot);
}
@Override
public ItemStack decrStackSize(int slot, int amount) {
return inv.decrStackSize(slot, amount);
}
@Override
public ItemStack getStackInSlotOnClosing(int slot) {
return inv.getStackInSlotOnClosing(slot);
}
@Override
public void setInventorySlotContents(int slot, ItemStack itemStack) {
if(slot >= 0 && slot < inv.getSizeInventory()) {
inv.setInventorySlotContents(slot, itemStack);
}
}
@Override
public String getInventoryName() {
return inv.getInventoryName();
}
@Override
public int getInventoryStackLimit() {
return inv.getInventoryStackLimit();
}
@Override
public void markDirty() {
inv.markDirty();
}
@Override
public boolean isUseableByPlayer(EntityPlayer entityplayer) {
return inv.isUseableByPlayer(entityplayer);
}
@Override
public void openInventory() {
inv.openInventory();
}
@Override
public void closeInventory() {
inv.closeInventory();
}
@Override
public boolean isItemValidForSlot(int slot, ItemStack itemStack) {
return slot >= 0 && slot < getSizeInventory() && inv.isItemValidForSlot(slot, itemStack);
}
@Override
public int[] getAccessibleSlotsFromSide(int var1) {
int[] slots = new int[inv.getSizeInventory()];
for (int i = 0; i < slots.length; i++) {
slots[i] = i;
}
return slots;
}
@Override
public boolean canInsertItem(int slot, ItemStack itemStack, int side) {
return isItemValidForSlot(slot, itemStack);
}
@Override
public boolean canExtractItem(int slot, ItemStack itemStack, int side) {
return slot >= 0 && slot < getSizeInventory();
}
@Override
public boolean hasCustomInventoryName() {
return false;
}
}
@@ -0,0 +1,256 @@
package com.enderio.core.common.util;
import java.util.ArrayList;
import java.util.List;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.ISidedInventory;
import net.minecraft.inventory.InventoryLargeChest;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntityChest;
import net.minecraftforge.common.util.ForgeDirection;
import cofh.api.transport.IItemDuct;
import cpw.mods.fml.common.Loader;
public class ItemUtil {
public static final List<IItemReceptor> receptors = new ArrayList<IItemReceptor>();
static {
try {
Class.forName("crazypants.util.BuildcraftUtil");
} catch (Exception e) {
if(Loader.isModLoaded("BuildCraft|Transport")) {
Log.warn("ItemUtil: Could not register Build Craft pipe handler. Machines will not be able to output to BC pipes.");
} //Don't log if BC isn't installed, but we still check in case another mod is using their API
}
}
public static String getDurabilityString(ItemStack item) {
if(item == null) {
return null;
}
return Lang.localize("item.darkSteel.tooltip.durability") + " " + (item.getMaxDamage() - item.getItemDamage()) + "/" + item.getMaxDamage();
}
public static NBTTagCompound getOrCreateNBT(ItemStack stack) {
if(stack.stackTagCompound == null) {
stack.stackTagCompound = new NBTTagCompound();
}
return stack.stackTagCompound;
}
public static int doInsertItem(Object into, ItemStack item, ForgeDirection side) {
if(into == null || item == null) {
return 0;
}
if(into instanceof ISidedInventory) {
return ItemUtil.doInsertItemInv((ISidedInventory) into, item, side);
} else if(into instanceof IInventory) {
return ItemUtil.doInsertItemInv(getInventory((IInventory) into), item, side);
} else if(into instanceof IItemDuct) {
return ItemUtil.doInsertItem((IItemDuct) into, item, side);
}
for (IItemReceptor rec : receptors) {
if(rec.canInsertIntoObject(into, side)) {
return rec.doInsertItem(into, item, side);
}
}
return 0;
}
public static int doInsertItem(IItemDuct con, ItemStack item, ForgeDirection inventorySide) {
int startedWith = item.stackSize;
ItemStack remaining = con.insertItem(inventorySide, item);
if(remaining == null) {
return startedWith;
}
return startedWith - remaining.stackSize;
}
public static int doInsertItem(IInventory inv, int startSlot, int endSlot, ItemStack item) {
return doInsertItemInv(inv, null, invSlotter.getInstance(startSlot, endSlot), item, ForgeDirection.UNKNOWN);
}
/*
* Insert items into an IInventory or an ISidedInventory.
*/
private static int doInsertItemInv(IInventory inv, ItemStack item, ForgeDirection inventorySide) {
final ISidedInventory sidedInv = inv instanceof ISidedInventory ? (ISidedInventory) inv : null;
ISlotIterator slots;
if (sidedInv != null) {
if(inventorySide == null) {
inventorySide = ForgeDirection.UNKNOWN;
}
// Note: This is not thread-safe. Change to getInstance() to constructor when needed (1.8++?).
slots = sidedSlotter.getInstance(sidedInv.getAccessibleSlotsFromSide(inventorySide.ordinal()));
} else {
slots = invSlotter.getInstance(0, inv.getSizeInventory());
}
return doInsertItemInv(inv, sidedInv, slots, item, inventorySide);
}
private static int doInsertItemInv(IInventory inv, ISidedInventory sidedInv, ISlotIterator slots, ItemStack item, ForgeDirection inventorySide) {
int numInserted = 0;
int numToInsert = item.stackSize;
int firstFreeSlot = -1;
// PASS1: Try to add to an existing stack
while (numToInsert > 0 && slots.hasNext()) {
final int slot = slots.nextSlot();
if(sidedInv == null || sidedInv.canInsertItem(slot, item, inventorySide.ordinal())) {
final ItemStack contents = inv.getStackInSlot(slot);
if(contents != null) {
if (areStackMergable(contents, item)) {
final int freeSpace = Math.min(inv.getInventoryStackLimit(), contents.getMaxStackSize()) - contents.stackSize; // some inventories like using itemstacks with invalid stack sizes
if (freeSpace > 0) {
final int noToInsert = Math.min(numToInsert, freeSpace);
final ItemStack toInsert = item.copy();
toInsert.stackSize = contents.stackSize + noToInsert;
// isItemValidForSlot() may check the stacksize, so give it the number the stack would have in the end.
// If it does something funny, like "only even numbers", we are screwed.
if(sidedInv != null || inv.isItemValidForSlot(slot, toInsert)) {
numInserted += noToInsert;
numToInsert -= noToInsert;
inv.setInventorySlotContents(slot, toInsert);
}
}
}
} else if (firstFreeSlot == -1) {
firstFreeSlot = slot;
}
}
}
// PASS2: Try to insert into an empty slot
if (numToInsert > 0 && firstFreeSlot != -1) {
final ItemStack toInsert = item.copy();
toInsert.stackSize = min(numToInsert, inv.getInventoryStackLimit(), toInsert.getMaxStackSize()); // some inventories like using itemstacks with invalid stack sizes
if(sidedInv != null || inv.isItemValidForSlot(firstFreeSlot, toInsert)) {
numInserted += toInsert.stackSize;
numToInsert -= toInsert.stackSize;
inv.setInventorySlotContents(firstFreeSlot, toInsert);
}
}
if(numInserted > 0) {
inv.markDirty();
}
return numInserted;
}
private final static int min(int i1, int i2, int i3) {
return i1 < i2 ? (i1 < i3 ? i1 : i3) : (i2 < i3 ? i2 : i3);
}
public static boolean isStackFull(ItemStack contents) {
if(contents == null) {
return false;
}
return contents.stackSize >= contents.getMaxStackSize();
}
public static IInventory getInventory(IInventory inv) {
if(inv instanceof TileEntityChest) {
TileEntityChest chest = (TileEntityChest) inv;
TileEntityChest neighbour = null;
if(chest.adjacentChestXNeg != null) {
neighbour = chest.adjacentChestXNeg;
} else if(chest.adjacentChestXPos != null) {
neighbour = chest.adjacentChestXPos;
} else if(chest.adjacentChestZNeg != null) {
neighbour = chest.adjacentChestZNeg;
} else if(chest.adjacentChestZPos != null) {
neighbour = chest.adjacentChestZPos;
}
if(neighbour != null) {
return new InventoryLargeChest("", inv, neighbour);
}
return inv;
}
return inv;
}
/**
* Checks if items, damage and NBT are equal and the items are stackable.
*
* @param s1
* @param s2
* @return
*/
public static boolean areStackMergable(ItemStack s1, ItemStack s2) {
if(s1 == null || s2 == null || !s1.isStackable() || !s2.isStackable()) {
return false;
}
if(!s1.isItemEqual(s2)) {
return false;
}
return ItemStack.areItemStackTagsEqual(s1, s2);
}
/**
* Checks if items, damage and NBT are equal.
*
* @param s1
* @param s2
* @return
*/
public static boolean areStacksEqual(ItemStack s1, ItemStack s2) {
if(s1 == null || s2 == null) {
return false;
}
if(!s1.isItemEqual(s2)) {
return false;
}
return ItemStack.areItemStackTagsEqual(s1, s2);
}
private interface ISlotIterator {
int nextSlot();
boolean hasNext();
}
private final static class invSlotter implements ISlotIterator {
private static final invSlotter me = new invSlotter();
private int end;
private int current;
public final static invSlotter getInstance(int start, int end) {
me.end = end;
me.current = start;
return me;
}
@Override
public final int nextSlot() {
return current++;
}
@Override
public final boolean hasNext() {
return current < end;
}
}
private final static class sidedSlotter implements ISlotIterator {
private static final sidedSlotter me = new sidedSlotter();
private int[] slots;
private int current;
public final static sidedSlotter getInstance(int[] slots) {
me.slots = slots;
me.current = 0;
return me;
}
@Override
public final int nextSlot() {
return slots[current++];
}
@Override
public final boolean hasNext() {
return slots != null && current < slots.length;
}
}
}
@@ -0,0 +1,31 @@
package com.enderio.core.common.util;
import java.util.IllegalFormatException;
import net.minecraft.util.StatCollector;
public class Lang {
public static final String prefix = "enderio.";
public static String localize(String s, String... args) {
return localize(s, true, args);
}
public static String localize(String s, boolean appendEIO, String... args) {
if(appendEIO) {
s = prefix + s;
}
String ret = StatCollector.translateToLocal(s);
try {
return String.format(ret, (Object[]) args);
} catch (IllegalFormatException e) {
return ret;
}
}
public static String[] localizeList(String string) {
String s = localize(string);
return s.split("\\|");
}
}
@@ -0,0 +1,32 @@
package com.enderio.core.common.util;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import com.enderio.core.EnderCore;
public final class Log {
public static final Logger LOGGER = LogManager.getLogger(EnderCore.MODID);
public static void warn(String msg) {
LOGGER.warn(msg);
}
public static void error(String msg) {
LOGGER.error(msg);
}
public static void info(String msg) {
LOGGER.info(msg);
}
public static void debug(String msg) {
LOGGER.debug(msg);
}
private Log() {
}
}
@@ -0,0 +1,43 @@
package com.enderio.core.common.util;
public class MetadataUtil {
public static void printBits(int meta) {
for (int k = 0; k < 4; k++) {
if(((meta >> k) & 1) == 1) {
System.out.print(1);
} else {
System.out.print(0);
}
}
System.out.println();
}
public static String toBitString(int meta) {
StringBuilder sb = new StringBuilder();
for (int k = 0; k < 4; k++) {
if(((meta >> k) & 1) == 1) {
sb.append(1);
} else {
sb.append(0);
}
}
return sb.toString();
}
public static boolean isBitSet(int position, int meta) {
return ((meta >> position) & 1) == 1;
}
public static int setBit(int position, boolean value, int meta) {
if(value) {
return meta | (1 << position);
}
return meta & ~(1 << position);
}
public static int toggleBit(int position, int meta) {
return setBit(position, !isBitSet(position, meta), meta);
}
}
@@ -0,0 +1,45 @@
package com.enderio.core.common.util;
import java.util.List;
import net.minecraft.item.ItemStack;
import net.minecraftforge.oredict.OreDictionary;
public final class OreDictionaryHelper {
public static final String INGOT_COPPER = "ingotCopper";
public static final String INGOT_TIN = "ingotTin";
public static final String DUST_ENDERPEARL = "dustEnderPearl";
public static final String INGOT_ENDERIUM = "ingotEnderium";
public static boolean isRegistered(String name) {
if(!getOres(name).isEmpty()) {
return true;
}
return false;
}
public static List<ItemStack> getOres(String name) {
return OreDictionary.getOres(name);
}
public static boolean hasCopper() {
return isRegistered(INGOT_COPPER);
}
public static boolean hasTin() {
return isRegistered(INGOT_TIN);
}
public static boolean hasEnderPearlDust() {
return isRegistered(DUST_ENDERPEARL);
}
private OreDictionaryHelper() {
}
public static boolean hasEnderium() {
return isRegistered(INGOT_ENDERIUM);
}
}
@@ -0,0 +1,31 @@
package com.enderio.core.common.util;
import java.util.Map;
import java.util.UUID;
import net.minecraftforge.common.UsernameCache;
public class PlayerUtil {
public static UUID getPlayerUUID(String username) {
for (Map.Entry<UUID, String> entry : UsernameCache.getMap().entrySet()) {
if(entry.getValue().equalsIgnoreCase(username)) {
return entry.getKey();
}
}
return null;
}
public static UUID getPlayerUIDUnstable(String possibleUUID) {
if(possibleUUID == null || possibleUUID.isEmpty())
return null;
UUID uuid = null;
try {
uuid = UUID.fromString(possibleUUID);
} catch (IllegalArgumentException e) {
uuid = getPlayerUUID(possibleUUID);
}
return uuid;
}
}
@@ -0,0 +1,44 @@
package com.enderio.core.common.util;
import java.util.Iterator;
import java.util.List;
public class RoundRobinIterator<T> implements Iterable<T>, Iterator<T> {
private int index = -1;
private int currentCount = 0;
private final List<T> itOver;
public RoundRobinIterator(List<T> itOver) {
this.itOver = itOver;
}
@Override
public Iterator<T> iterator() {
currentCount = 0;
return this;
}
@Override
public boolean hasNext() {
return !itOver.isEmpty() && currentCount < itOver.size();
}
@Override
public T next() {
if(itOver.isEmpty()) {
return null;
}
currentCount++;
index++;
if(index >= itOver.size()) {
index = 0;
}
return itOver.get(index);
}
@Override
public void remove() {
}
}
@@ -4,12 +4,13 @@ import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import lombok.AllArgsConstructor;
import com.enderio.core.EnderCore;
import com.enderio.core.common.Handlers.Handler;
import com.enderio.core.common.Handlers.Handler.HandlerType;
import com.enderio.core.common.Handlers.Handler.Inst;
import lombok.AllArgsConstructor;
import cpw.mods.fml.common.eventhandler.SubscribeEvent;
import cpw.mods.fml.common.gameevent.TickEvent;
import cpw.mods.fml.common.gameevent.TickEvent.ClientTickEvent;
@@ -0,0 +1,17 @@
package com.enderio.core.common.util;
import net.minecraft.client.Minecraft;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class SoundUtil {
@SideOnly(Side.CLIENT)
public static void playClientSoundFX(String name, TileEntity te) {
World world = Minecraft.getMinecraft().thePlayer.worldObj;
Minecraft.getMinecraft().theWorld.playSound(te.xCoord + 0.5, te.yCoord + 0.5, te.zCoord + 0.5, name, 0.1F, 0.5F * ((world.rand.nextFloat() - world.rand.nextFloat()) * 0.7F + 1.8F),true);
}
}
@@ -0,0 +1,528 @@
package com.enderio.core.common.util;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import net.minecraft.block.Block;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.entity.item.EntityXPOrb;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.Item;
import net.minecraft.item.ItemBlock;
import net.minecraft.item.ItemPotion;
import net.minecraft.item.ItemStack;
import net.minecraft.util.MathHelper;
import net.minecraft.util.MovingObjectPosition;
import net.minecraft.util.Vec3;
import net.minecraft.world.World;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraftforge.oredict.OreDictionary;
import com.enderio.core.common.vecmath.Vector3d;
import com.google.common.base.Charsets;
import com.google.common.base.Joiner;
import com.google.common.io.Files;
public class Util {
public static Block getBlockFromItemId(ItemStack itemId) {
Item item = itemId.getItem();
if(item instanceof ItemBlock) {
return ((ItemBlock) item).field_150939_a;
}
return null;
}
public static ItemStack consumeItem(ItemStack stack) {
if(stack.getItem() instanceof ItemPotion) {
if(stack.stackSize == 1) {
return new ItemStack(Items.glass_bottle);
} else {
stack.splitStack(1);
return stack;
}
}
if(stack.stackSize == 1) {
if(stack.getItem().hasContainerItem(stack)) {
return stack.getItem().getContainerItem(stack);
} else {
return null;
}
} else {
stack.splitStack(1);
return stack;
}
}
public static void giveExperience(EntityPlayer thePlayer, float experience) {
if(experience < 1.0F) {
int rndRound = MathHelper.floor_float(experience);
if(rndRound < MathHelper.ceiling_float_int(experience) && (float) Math.random() < experience) {
++rndRound;
}
experience = rndRound;
}
int intExp = Math.round(experience);
while (intExp > 0) {
int j = EntityXPOrb.getXPSplit(intExp);
intExp -= j;
thePlayer.worldObj.spawnEntityInWorld(new EntityXPOrb(thePlayer.worldObj, thePlayer.posX, thePlayer.posY + 0.5D, thePlayer.posZ + 0.5D, j));
}
}
// derived from ItemBlock.onItemUse
public static BlockCoord canPlaceItem(ItemStack itemUsed, Block blockIdToBePlaced, EntityPlayer player, World world, int x, int y, int z, int side) {
if(blockIdToBePlaced == null) {
return null;
}
Block block = world.getBlock(x, y, z);
if(block == Blocks.snow_layer && (world.getBlockMetadata(x, y, z) & 7) < 1) {
side = 1;
} else if(block != Blocks.vine && block != Blocks.tallgrass && block != Blocks.deadbush
&& (block == null || !block.isReplaceable(world, x, y, z))) {
if(side == 0) {
--y;
} else if(side == 1) {
++y;
} else if(side == 2) {
--z;
} else if(side == 3) {
++z;
} else if(side == 4) {
--x;
} else if(side == 5) {
++x;
}
}
if(itemUsed.stackSize == 0) {
return null;
} else if(!player.canPlayerEdit(x, y, z, side, itemUsed)) {
return null;
} else if(y == 255 && blockIdToBePlaced.getMaterial().isSolid()) {
return null;
} else if(world.canPlaceEntityOnSide(blockIdToBePlaced, x, y, z, false, side, player, itemUsed)) {
return new BlockCoord(x, y, z);
}
return null;
}
public static EntityItem createDrop(World world, ItemStack stack, double x, double y, double z, boolean doRandomSpread) {
if(stack == null || stack.stackSize <= 0) {
return null;
}
if(doRandomSpread) {
float f1 = 0.7F;
double d = (world.rand.nextFloat() * f1) + (1.0F - f1) * 0.5D;
double d1 = (world.rand.nextFloat() * f1) + (1.0F - f1) * 0.5D;
double d2 = (world.rand.nextFloat() * f1) + (1.0F - f1) * 0.5D;
EntityItem entityitem = new EntityItem(world, x + d, y + d1, z + d2, stack);
entityitem.delayBeforeCanPickup = 10;
return entityitem;
} else {
EntityItem entityitem = new EntityItem(world, x, y, z, stack);
entityitem.motionX = 0;
entityitem.motionY = 0;
entityitem.motionZ = 0;
entityitem.delayBeforeCanPickup = 0;
return entityitem;
}
}
public static void dropItems(World world, ItemStack stack, double x, double y, double z, boolean doRandomSpread) {
if(stack == null || stack.stackSize <= 0) {
return;
}
EntityItem entityitem = createEntityItem(world, stack, x, y, z, doRandomSpread);
world.spawnEntityInWorld(entityitem);
}
public static EntityItem createEntityItem(World world, ItemStack stack, double x, double y, double z) {
return createEntityItem(world, stack, x, y, z, true);
}
public static EntityItem createEntityItem(World world, ItemStack stack, double x, double y, double z, boolean doRandomSpread) {
EntityItem entityitem;
if(doRandomSpread) {
float f1 = 0.7F;
double d = (world.rand.nextFloat() * f1) + (1.0F - f1) * 0.5D;
double d1 = (world.rand.nextFloat() * f1) + (1.0F - f1) * 0.5D;
double d2 = (world.rand.nextFloat() * f1) + (1.0F - f1) * 0.5D;
entityitem = new EntityItem(world, x + d, y + d1, z + d2, stack);
entityitem.delayBeforeCanPickup = 10;
} else {
entityitem = new EntityItem(world, x, y, z, stack);
entityitem.motionX = 0;
entityitem.motionY = 0;
entityitem.motionZ = 0;
entityitem.delayBeforeCanPickup = 0;
}
return entityitem;
}
public static void dropItems(World world, ItemStack stack, int x, int y, int z, boolean doRandomSpread) {
if(stack == null || stack.stackSize <= 0) {
return;
}
if(doRandomSpread) {
float f1 = 0.7F;
double d = (world.rand.nextFloat() * f1) + (1.0F - f1) * 0.5D;
double d1 = (world.rand.nextFloat() * f1) + (1.0F - f1) * 0.5D;
double d2 = (world.rand.nextFloat() * f1) + (1.0F - f1) * 0.5D;
EntityItem entityitem = new EntityItem(world, x + d, y + d1, z + d2, stack);
entityitem.delayBeforeCanPickup = 10;
world.spawnEntityInWorld(entityitem);
} else {
EntityItem entityitem = new EntityItem(world, x + 0.5, y + 0.5, z + 0.5, stack);
entityitem.motionX = 0;
entityitem.motionY = 0;
entityitem.motionZ = 0;
entityitem.delayBeforeCanPickup = 0;
world.spawnEntityInWorld(entityitem);
}
}
public static void dropItems(World world, ItemStack[] inventory, int x, int y, int z, boolean doRandomSpread) {
if(inventory == null) {
return;
}
for (ItemStack stack : inventory) {
if(stack != null && stack.stackSize > 0) {
dropItems(world, stack.copy(), x, y, z, doRandomSpread);
}
}
}
public static void dropItems(World world, IInventory inventory, int x, int y, int z, boolean doRandomSpread) {
for (int l = 0; l < inventory.getSizeInventory(); ++l) {
ItemStack items = inventory.getStackInSlot(l);
if(items != null && items.stackSize > 0) {
dropItems(world, inventory.getStackInSlot(l).copy(), x, y, z, doRandomSpread);
}
}
}
public static boolean dumpModObjects(File file) {
StringBuilder sb = new StringBuilder();
for (Object key : Block.blockRegistry.getKeys()) {
if(key != null) {
sb.append(key.toString());
sb.append("\n");
}
}
for (Object key : Item.itemRegistry.getKeys()) {
if(key != null) {
sb.append(key.toString());
sb.append("\n");
}
}
try {
Files.write(sb, file, Charsets.UTF_8);
return true;
} catch (IOException e) {
Log.warn("Error dumping ore dictionary entries: " + e.getMessage());
e.printStackTrace();
return false;
}
}
public static boolean dumpOreNames(File file) {
try {
String[] oreNames = OreDictionary.getOreNames();
Files.write(Joiner.on("\n").join(oreNames), file, Charsets.UTF_8);
return true;
} catch (IOException e) {
Log.warn("Error dumping ore dictionary entries: " + e.getMessage());
e.printStackTrace();
return false;
}
}
public static ItemStack decrStackSize(IInventory inventory, int slot, int size) {
ItemStack item = inventory.getStackInSlot(slot);
if(item != null) {
if(item.stackSize <= size) {
ItemStack result = item;
inventory.setInventorySlotContents(slot, null);
inventory.markDirty();
return result;
}
ItemStack split = item.splitStack(size);
if(item.stackSize == 0) {
inventory.setInventorySlotContents(slot, null);
}
inventory.markDirty();
return split;
}
return null;
}
public static Vec3 getEyePosition(EntityPlayer player) {
Vec3 v = Vec3.createVectorHelper(player.posX, player.posY, player.posZ);
if(player.worldObj.isRemote) {
//take into account any eye changes done by mods.
v.yCoord += player.getEyeHeight() - player.getDefaultEyeHeight();
} else {
v.yCoord += player.getEyeHeight();
if(player instanceof EntityPlayerMP && player.isSneaking()) {
v.yCoord -= 0.08;
}
}
return v;
}
public static Vector3d getEyePositionEio(EntityPlayer player) {
Vector3d res = new Vector3d(player.posX, player.posY, player.posZ);
if(player.worldObj.isRemote) {
//take into account any eye changes done by mods.
res.y += player.getEyeHeight() - player.getDefaultEyeHeight();
} else {
res.y += player.getEyeHeight();
if(player instanceof EntityPlayerMP && player.isSneaking()) {
res.y -= 0.08;
}
}
return res;
}
public static Vector3d getLookVecEio(EntityPlayer player) {
Vec3 lv = player.getLookVec();
return new Vector3d(lv.xCoord, lv.yCoord, lv.zCoord);
}
public static boolean isEquipped(EntityPlayer player, Class<? extends Item> class1) {
if(player == null || player.inventory == null || player.inventory.getCurrentItem() == null) {
return false;
}
//player.inventory.getCurrentItem().getClass().getItem().isAssignableFrom(class1)
return class1.isAssignableFrom(player.inventory.getCurrentItem().getItem().getClass());
}
public static boolean isType(ItemStack stack, Class<?> class1) {
if(stack == null || class1 == null) {
return false;
}
return class1.isAssignableFrom(stack.getItem().getClass());
}
//Code adapted from World.func_147447_a (rayTraceBlocks) to return all collided blocks
public static List<MovingObjectPosition> raytraceAll(World world, Vec3 startVec, Vec3 endVec, boolean includeLiquids) {
List<MovingObjectPosition> result = new ArrayList<MovingObjectPosition>();
boolean p_147447_4_ = false;
boolean p_147447_5_ = false;
if(!Double.isNaN(startVec.xCoord) && !Double.isNaN(startVec.yCoord) && !Double.isNaN(startVec.zCoord)) {
if(!Double.isNaN(endVec.xCoord) && !Double.isNaN(endVec.yCoord) && !Double.isNaN(endVec.zCoord)) {
int i = MathHelper.floor_double(endVec.xCoord);
int j = MathHelper.floor_double(endVec.yCoord);
int k = MathHelper.floor_double(endVec.zCoord);
int l = MathHelper.floor_double(startVec.xCoord);
int i1 = MathHelper.floor_double(startVec.yCoord);
int j1 = MathHelper.floor_double(startVec.zCoord);
Block block = world.getBlock(l, i1, j1);
int k1 = world.getBlockMetadata(l, i1, j1);
if((!p_147447_4_ || block.getCollisionBoundingBoxFromPool(world, l, i1, j1) != null) && block.canCollideCheck(k1, includeLiquids)) {
MovingObjectPosition movingobjectposition = block.collisionRayTrace(world, l, i1, j1, startVec, endVec);
if(movingobjectposition != null) {
result.add(movingobjectposition);
}
}
MovingObjectPosition movingobjectposition2 = null;
k1 = 200;
while (k1-- >= 0) {
if(Double.isNaN(startVec.xCoord) || Double.isNaN(startVec.yCoord) || Double.isNaN(startVec.zCoord)) {
return null;
}
if(l == i && i1 == j && j1 == k) {
if(p_147447_5_) {
result.add(movingobjectposition2);
} else {
return result;
}
}
boolean flag6 = true;
boolean flag3 = true;
boolean flag4 = true;
double d0 = 999.0D;
double d1 = 999.0D;
double d2 = 999.0D;
if(i > l) {
d0 = l + 1.0D;
} else if(i < l) {
d0 = l + 0.0D;
} else {
flag6 = false;
}
if(j > i1) {
d1 = i1 + 1.0D;
} else if(j < i1) {
d1 = i1 + 0.0D;
} else {
flag3 = false;
}
if(k > j1) {
d2 = j1 + 1.0D;
} else if(k < j1) {
d2 = j1 + 0.0D;
} else {
flag4 = false;
}
double d3 = 999.0D;
double d4 = 999.0D;
double d5 = 999.0D;
double d6 = endVec.xCoord - startVec.xCoord;
double d7 = endVec.yCoord - startVec.yCoord;
double d8 = endVec.zCoord - startVec.zCoord;
if(flag6) {
d3 = (d0 - startVec.xCoord) / d6;
}
if(flag3) {
d4 = (d1 - startVec.yCoord) / d7;
}
if(flag4) {
d5 = (d2 - startVec.zCoord) / d8;
}
boolean flag5 = false;
byte b0;
if(d3 < d4 && d3 < d5) {
if(i > l) {
b0 = 4;
} else {
b0 = 5;
}
startVec.xCoord = d0;
startVec.yCoord += d7 * d3;
startVec.zCoord += d8 * d3;
} else if(d4 < d5) {
if(j > i1) {
b0 = 0;
} else {
b0 = 1;
}
startVec.xCoord += d6 * d4;
startVec.yCoord = d1;
startVec.zCoord += d8 * d4;
} else {
if(k > j1) {
b0 = 2;
} else {
b0 = 3;
}
startVec.xCoord += d6 * d5;
startVec.yCoord += d7 * d5;
startVec.zCoord = d2;
}
Vec3 vec32 = Vec3.createVectorHelper(startVec.xCoord, startVec.yCoord, startVec.zCoord);
l = (int) (vec32.xCoord = MathHelper.floor_double(startVec.xCoord));
if(b0 == 5) {
--l;
++vec32.xCoord;
}
i1 = (int) (vec32.yCoord = MathHelper.floor_double(startVec.yCoord));
if(b0 == 1) {
--i1;
++vec32.yCoord;
}
j1 = (int) (vec32.zCoord = MathHelper.floor_double(startVec.zCoord));
if(b0 == 3) {
--j1;
++vec32.zCoord;
}
Block block1 = world.getBlock(l, i1, j1);
int l1 = world.getBlockMetadata(l, i1, j1);
if(!p_147447_4_ || block1.getCollisionBoundingBoxFromPool(world, l, i1, j1) != null) {
if(block1.canCollideCheck(l1, includeLiquids)) {
MovingObjectPosition movingobjectposition1 = block1.collisionRayTrace(world, l, i1, j1, startVec, endVec);
if(movingobjectposition1 != null) {
result.add(movingobjectposition1);
}
} else {
movingobjectposition2 = new MovingObjectPosition(l, i1, j1, b0, startVec, false);
}
}
}
if(p_147447_5_ ) {
result.add(movingobjectposition2);
} else {
return result;
}
} else {
return result;
}
} else {
return result;
}
return result;
}
public static ForgeDirection getDirFromOffset(int xOff, int yOff, int zOff) {
if(xOff != 0 && yOff == 0 && zOff == 0) {
return xOff < 0 ? ForgeDirection.WEST : ForgeDirection.EAST;
}
if(zOff != 0 && yOff == 0 && xOff == 0) {
return zOff < 0 ? ForgeDirection.NORTH : ForgeDirection.SOUTH;
}
if(yOff != 0 && xOff == 0 && zOff == 0) {
return yOff < 0 ? ForgeDirection.DOWN : ForgeDirection.UP;
}
return ForgeDirection.UNKNOWN;
}
public static int getProgressScaled(int scale, IProgressTile tile) {
return (int) (tile.getProgress() * scale);
}
// copied from WAILA source to avoid API dependency
public static String WailaStyle = "\u00A4";
public static String WailaIcon = "\u00A5";
public static String TAB = WailaStyle + WailaStyle +"a";
public static String ALIGNRIGHT = WailaStyle + WailaStyle +"b";
public static String ALIGNCENTER = WailaStyle + WailaStyle +"c";
public static String HEART = WailaStyle + WailaIcon +"a";
public static String HHEART = WailaStyle + WailaIcon +"b";
public static String EHEART = WailaStyle + WailaIcon +"c";
}
@@ -0,0 +1,146 @@
package com.enderio.core.common.vecmath;
import java.awt.Rectangle;
public class Camera {
private Rectangle viewport;
private Matrix4d projectionTranspose;
private Matrix4d projectionMatrix;
private Matrix4d projectionInverse;
private Matrix4d viewTranspose;
private Matrix4d viewMatrix;
private Matrix4d viewInverse;
public boolean isValid() {
return viewMatrix != null && projectionMatrix != null && viewport != null;
}
public void setProjectionMatrixAsPerspective(double fovDegrees, double near, double far, int viewportWidth, int viewportHeight) {
setProjectionMatrix(VecmathUtil.createProjectionMatrixAsPerspective(fovDegrees, near, far, viewportWidth, viewportHeight));
}
public void setViewMatrixAsLookAt(Vector3d eyePos, Vector3d lookAtPos, Vector3d upVec) {
setViewMatrix(VecmathUtil.createMatrixAsLookAt(eyePos, lookAtPos, upVec));
}
public Vector3d getEyePoint() {
Matrix4d vpm = new Matrix4d();
Matrix4d ivm = getInverseViewMatrix();
if(ivm == null) {
return null;
}
Matrix4d ipm = getInverseProjectionMatrix();
if(ipm == null) {
return null;
}
vpm.mul(ivm, ipm);
Vector3d eye = new Vector3d();
ivm.getTranslation(eye);
return eye;
}
public boolean getRayForPixel(int x, int y, Vector3d eyeOut, Vector3d normalOut) {
if(isValid()) {
VecmathUtil.computeRayForPixel(viewport, getInverseProjectionMatrix(), getInverseViewMatrix(), x, y, eyeOut, normalOut);
return true;
}
return false;
}
public Vector2d getScreenPoint(Vector3d point3d) {
Vector4d transPoint = new Vector4d(point3d.x, point3d.y, point3d.z, 1);
viewMatrix.transform(transPoint);
projectionMatrix.transform(transPoint);
int halfWidth = viewport.width / 2;
int halfHeight = viewport.height / 2;
Vector2d screenPos = new Vector2d(transPoint.x, transPoint.y);
screenPos.scale(1 / transPoint.w);
screenPos.x = screenPos.x * halfWidth + halfWidth;
screenPos.y = -screenPos.y * halfHeight + halfHeight;
return screenPos;
}
public void setViewport(Rectangle viewport) {
if(viewport != null) {
setViewport(viewport.x, viewport.y, viewport.width, viewport.height);
}
}
public void setViewport(int x, int y, int width, int height) {
viewport = new Rectangle(x, y, width, height);
}
public Rectangle getViewport() {
return viewport;
}
public Matrix4d getProjectionMatrix() {
return projectionMatrix;
}
public Matrix4d getTransposeProjectionMatrix() {
return projectionTranspose;
}
public Matrix4d getInverseProjectionMatrix() {
if(projectionMatrix != null) {
if(projectionInverse == null) {
projectionInverse = new Matrix4d(projectionMatrix);
projectionInverse.invert();
}
return projectionInverse;
} else {
return null;
}
}
public void setProjectionMatrix(Matrix4d matrix) {
if(projectionMatrix == null) {
projectionMatrix = new Matrix4d();
projectionTranspose = new Matrix4d();
}
projectionMatrix.set(matrix);
projectionTranspose.set(matrix);
projectionTranspose.transpose();
projectionInverse = null;
}
public Matrix4d getViewMatrix() {
return viewMatrix;
}
public Matrix4d getTransposeViewMatrix() {
return viewTranspose;
}
public Matrix4d getInverseViewMatrix() {
if(viewMatrix != null) {
if(viewInverse == null) {
viewInverse = new Matrix4d(viewMatrix);
viewInverse.invert();
}
return viewInverse;
} else {
return null;
}
}
public void setViewMatrix(Matrix4d matrix) {
if(viewMatrix == null) {
viewMatrix = new Matrix4d();
viewTranspose = new Matrix4d();
}
viewMatrix.set(matrix);
viewTranspose.set(matrix);
viewTranspose.transpose();
viewInverse = null;
}
}
@@ -0,0 +1,591 @@
package com.enderio.core.common.vecmath;
import java.nio.FloatBuffer;
public class Matrix4d {
public double m00 = 0;
public double m01 = 0;
public double m02 = 0;
public double m03 = 0;
public double m10 = 0;
public double m11 = 0;
public double m12 = 0;
public double m13 = 0;
public double m20 = 0;
public double m21 = 0;
public double m22 = 0;
public double m23 = 0;
public double m30 = 0;
public double m31 = 0;
public double m32 = 0;
public double m33 = 0;
public Matrix4d() {
}
public Matrix4d(float[] arr) {
m00 = arr[0];
m01 = arr[1];
m02 = arr[2];
m03 = arr[3];
m10 = arr[4];
m11 = arr[5];
m12 = arr[6];
m13 = arr[7];
m20 = arr[8];
m21 = arr[9];
m22 = arr[10];
m23 = arr[11];
m30 = arr[12];
m31 = arr[13];
m32 = arr[14];
m33 = arr[15];
}
public Matrix4d(double[] arr) {
m00 = arr[0];
m01 = arr[1];
m02 = arr[2];
m03 = arr[3];
m10 = arr[4];
m11 = arr[5];
m12 = arr[6];
m13 = arr[7];
m20 = arr[8];
m21 = arr[9];
m22 = arr[10];
m23 = arr[11];
m30 = arr[12];
m31 = arr[13];
m32 = arr[14];
m33 = arr[15];
}
public Matrix4d(Matrix4d other) {
m00 = other.m00;
m01 = other.m01;
m02 = other.m02;
m03 = other.m03;
m10 = other.m10;
m11 = other.m11;
m12 = other.m12;
m13 = other.m13;
m20 = other.m20;
m21 = other.m21;
m22 = other.m22;
m23 = other.m23;
m30 = other.m30;
m31 = other.m31;
m32 = other.m32;
m33 = other.m33;
}
public Matrix4d(double m00, double m01, double m02, double m03,
double m10, double m11, double m12, double m13,
double m20, double m21, double m22, double m23,
double m30, double m31, double m32, double m33) {
this.m00 = m00;
this.m01 = m01;
this.m02 = m02;
this.m03 = m03;
this.m10 = m10;
this.m11 = m11;
this.m12 = m12;
this.m13 = m13;
this.m20 = m20;
this.m21 = m21;
this.m22 = m22;
this.m23 = m23;
this.m30 = m30;
this.m31 = m31;
this.m32 = m32;
this.m33 = m33;
}
public Matrix4d(FloatBuffer modelview) {
m00 = modelview.get(0);
m01 = modelview.get(1);
m02 = modelview.get(2);
m03 = modelview.get(3);
m10 = modelview.get(4);
m11 = modelview.get(5);
m12 = modelview.get(6);
m13 = modelview.get(7);
m20 = modelview.get(8);
m21 = modelview.get(9);
m22 = modelview.get(10);
m23 = modelview.get(11);
m30 = modelview.get(12);
m31 = modelview.get(13);
m32 = modelview.get(14);
m33 = modelview.get(15);
}
public final void setIdentity() {
m00 = 1.0;
m01 = 0.0;
m02 = 0.0;
m03 = 0.0;
m10 = 0.0;
m11 = 1.0;
m12 = 0.0;
m13 = 0.0;
m20 = 0.0;
m21 = 0.0;
m22 = 1.0;
m23 = 0.0;
m30 = 0.0;
m31 = 0.0;
m32 = 0.0;
m33 = 1.0;
}
public void set(Matrix4d other) {
m00 = other.m00;
m01 = other.m01;
m02 = other.m02;
m03 = other.m03;
m10 = other.m10;
m11 = other.m11;
m12 = other.m12;
m13 = other.m13;
m20 = other.m20;
m21 = other.m21;
m22 = other.m22;
m23 = other.m23;
m30 = other.m30;
m31 = other.m31;
m32 = other.m32;
m33 = other.m33;
}
public void set(double[] values) {
m00 = values[0];
m01 = values[1];
m02 = values[2];
m03 = values[3];
m10 = values[4];
m11 = values[5];
m12 = values[6];
m13 = values[7];
m20 = values[8];
m21 = values[9];
m22 = values[10];
m23 = values[11];
m30 = values[12];
m31 = values[13];
m32 = values[14];
m33 = values[15];
}
public double getElement(int row, int col) {
switch (row) {
case 0:
switch (col) {
case 0:
return m00;
case 1:
return m01;
case 2:
return m02;
case 3:
return m03;
default:
break;
}
break;
case 1:
switch (col) {
case 0:
return m10;
case 1:
return m11;
case 2:
return m12;
case 3:
return m13;
default:
break;
}
break;
case 2:
switch (col) {
case 0:
return m20;
case 1:
return m21;
case 2:
return m22;
case 3:
return m23;
default:
break;
}
break;
case 3:
switch (col) {
case 0:
return m30;
case 1:
return m31;
case 2:
return m32;
case 3:
return m33;
default:
break;
}
break;
default:
break;
}
return 0;
}
public void setElement(int row, int column, double val) {
switch (row) {
case 0:
switch (column) {
case 0:
m00 = val;
break;
case 1:
m01 = val;
break;
case 2:
m02 = val;
break;
case 3:
m03 = val;
break;
default:
break;
}
break;
case 1:
switch (column) {
case 0:
m10 = val;
break;
case 1:
m11 = val;
break;
case 2:
m12 = val;
break;
case 3:
m13 = val;
break;
default:
break;
}
break;
case 2:
switch (column) {
case 0:
m20 = val;
break;
case 1:
m21 = val;
break;
case 2:
m22 = val;
break;
case 3:
m23 = val;
break;
default:
break;
}
break;
case 3:
switch (column) {
case 0:
m30 = val;
break;
case 1:
m31 = val;
break;
case 2:
m32 = val;
break;
case 3:
m33 = val;
break;
default:
break;
}
break;
default:
break;
}
}
public void getTranslation(Vector3d trans) {
trans.x = m03;
trans.y = m13;
trans.z = m23;
}
public void setTranslation(Vector3d trans) {
m03 = trans.x;
m13 = trans.y;
m23 = trans.z;
}
public void makeRotationX(double angle) {
setIdentity();
double sin = Math.sin(angle);
double cos = Math.cos(angle);
m11 = cos;
m12 = -sin;
m21 = sin;
m22 = cos;
}
public void makeRotationY(double angle) {
setIdentity();
double sin = Math.sin(angle);
double cos = Math.cos(angle);
m00 = cos;
m02 = sin;
m20 = -sin;
m22 = cos;
}
public void makeRotationZ(double angle) {
setIdentity();
double sin = Math.sin(angle);
double cos = Math.cos(angle);
m00 = cos;
m01 = -sin;
m10 = sin;
m11 = cos;
}
public void transform(Vector3d vec) {
double x = m00 * vec.x + m01 * vec.y + m02 * vec.z + m03;
double y = m10 * vec.x + m11 * vec.y + m12 * vec.z + m13;
vec.z = m20 * vec.x + m21 * vec.y + m22 * vec.z + m23;
vec.x = x;
vec.y = y;
}
public void transform(Vector4d vec) {
double x = m00 * vec.x + m01 * vec.y + m02 * vec.z + m03 * vec.w;
double y = m10 * vec.x + m11 * vec.y + m12 * vec.z + m13 * vec.w;
double z = m20 * vec.x + m21 * vec.y + m22 * vec.z + m23 * vec.w;
vec.w = m30 * vec.x + m31 * vec.y + m32 * vec.z + m33 * vec.w;
vec.x = x;
vec.y = y;
vec.z = z;
}
public void transformNormal(Vector3f normal) {
double x = m00 * normal.x + m01 * normal.y + m02 * normal.z;
double y = m10 * normal.x + m11 * normal.y + m12 * normal.z;
normal.z = (float) (m20 * normal.x + m21 * normal.y + m22 * normal.z);
normal.x = (float) x;
normal.y = (float) y;
}
public void transformNormal(Vector3d normal) {
double x = m00 * normal.x + m01 * normal.y + m02 * normal.z;
double y = m10 * normal.x + m11 * normal.y + m12 * normal.z;
normal.z = m20 * normal.x + m21 * normal.y + m22 * normal.z;
normal.x = x;
normal.y = y;
}
public void mul(Matrix4d m1, Matrix4d m2) {
set(m1);
mul(m2);
}
public void mul(Matrix4d m) {
double m00Tmp = m00 * m.m00 + m01 * m.m10 + m02 * m.m20 + m03 * m.m30;
double m01Tmp = m00 * m.m01 + m01 * m.m11 + m02 * m.m21 + m03 * m.m31;
double m02Tmp = m00 * m.m02 + m01 * m.m12 + m02 * m.m22 + m03 * m.m32;
double m03Tmp = m00 * m.m03 + m01 * m.m13 + m02 * m.m23 + m03 * m.m33;
double m10Tmp = m10 * m.m00 + m11 * m.m10 + m12 * m.m20 + m13 * m.m30;
double m11Tmp = m10 * m.m01 + m11 * m.m11 + m12 * m.m21 + m13 * m.m31;
double m12Tmp = m10 * m.m02 + m11 * m.m12 + m12 * m.m22 + m13 * m.m32;
double m13Tmp = m10 * m.m03 + m11 * m.m13 + m12 * m.m23 + m13 * m.m33;
double m20Tmp = m20 * m.m00 + m21 * m.m10 + m22 * m.m20 + m23 * m.m30;
double m21Tmp = m20 * m.m01 + m21 * m.m11 + m22 * m.m21 + m23 * m.m31;
double m22Tmp = m20 * m.m02 + m21 * m.m12 + m22 * m.m22 + m23 * m.m32;
double m23Tmp = m20 * m.m03 + m21 * m.m13 + m22 * m.m23 + m23 * m.m33;
double m30Tmp = m30 * m.m00 + m31 * m.m10 + m32 * m.m20 + m33 * m.m30;
double m31Tmp = m30 * m.m01 + m31 * m.m11 + m32 * m.m21 + m33 * m.m31;
double m32Tmp = m30 * m.m02 + m31 * m.m12 + m32 * m.m22 + m33 * m.m32;
double m33Tmp = m30 * m.m03 + m31 * m.m13 + m32 * m.m23 + m33 * m.m33;
m00 = m00Tmp;
m01 = m01Tmp;
m02 = m02Tmp;
m03 = m03Tmp;
m10 = m10Tmp;
m11 = m11Tmp;
m12 = m12Tmp;
m13 = m13Tmp;
m20 = m20Tmp;
m21 = m21Tmp;
m22 = m22Tmp;
m23 = m23Tmp;
m30 = m30Tmp;
m31 = m31Tmp;
m32 = m32Tmp;
m33 = m33Tmp;
}
public void transpose() {
double tmp = m10;
m10 = m01;
m01 = tmp;
tmp = m20;
m20 = m02;
m02 = tmp;
tmp = m30;
m30 = m03;
m03 = tmp;
tmp = m21;
m21 = m12;
m12 = tmp;
tmp = m31;
m31 = m13;
m13 = tmp;
tmp = m32;
m32 = m23;
m23 = tmp;
}
public void invert() {
double det = determinant();
if(det == 0) {
throw new RuntimeException("Cannot invert matrix with a determinat of 0.");
}
double detInv = 1f / det;
// first row
double t00 = determinant3x3(m11, m21, m31, m12, m22, m32, m13, m23, m33);
double t01 = -determinant3x3(m01, m21, m31, m02, m22, m32, m03, m23, m33);
double t02 = determinant3x3(m01, m11, m31, m02, m12, m32, m03, m13, m33);
double t03 = -determinant3x3(m01, m11, m21, m02, m12, m22, m03, m13, m23);
// second row
double t10 = -determinant3x3(m10, m20, m30, m12, m22, m32, m13, m23, m33);
double t11 = determinant3x3(m00, m20, m30, m02, m22, m32, m03, m23, m33);
double t12 = -determinant3x3(m00, m10, m30, m02, m12, m32, m03, m13, m33);
double t13 = determinant3x3(m00, m10, m20, m02, m12, m22, m03, m13, m23);
// third row
double t20 = determinant3x3(m10, m20, m30, m11, m21, m31, m13, m23, m33);
double t21 = -determinant3x3(m00, m20, m30, m01, m21, m31, m03, m23, m33);
double t22 = determinant3x3(m00, m10, m30, m01, m11, m31, m03, m13, m33);
double t23 = -determinant3x3(m00, m10, m20, m01, m11, m21, m03, m13, m23);
// fourth row
double t30 = -determinant3x3(m10, m20, m30, m11, m21, m31, m12, m22, m32);
double t31 = determinant3x3(m00, m20, m30, m01, m21, m31, m02, m22, m32);
double t32 = -determinant3x3(m00, m10, m30, m01, m11, m31, m02, m12, m32);
double t33 = determinant3x3(m00, m10, m20, m01, m11, m21, m02, m12, m22);
m00 = t00 * detInv;
m11 = t11 * detInv;
m22 = t22 * detInv;
m33 = t33 * detInv;
m10 = t10 * detInv;
m01 = t01 * detInv;
m02 = t02 * detInv;
m20 = t20 * detInv;
m21 = t21 * detInv;
m12 = t12 * detInv;
m30 = t30 * detInv;
m03 = t03 * detInv;
m31 = t31 * detInv;
m13 = t13 * detInv;
m23 = t23 * detInv;
m32 = t32 * detInv;
}
public double determinant() {
double result =
m00
* ((m11 * m22 * m33 + m21 * m32 * m13 + m31 * m12 * m23)
- m31 * m22 * m13
- m11 * m32 * m23
- m21 * m12 * m33);
result -= m10
* ((m01 * m22 * m33 + m21 * m32 * m03 + m31 * m02 * m23)
- m31 * m22 * m03
- m01 * m32 * m23
- m21 * m02 * m33);
result += m20
* ((m01 * m12 * m33 + m11 * m32 * m03 + m31 * m02 * m13)
- m31 * m12 * m03
- m01 * m32 * m13
- m11 * m02 * m33);
result -= m30
* ((m01 * m12 * m23 + m11 * m22 * m03 + m21 * m02 * m13)
- m21 * m12 * m03
- m01 * m22 * m13
- m11 * m02 * m23);
return result;
}
private double determinant3x3(double e00, double e01, double e02, double e10, double e11, double e12, double e20, double e21, double e22) {
return e00 * (e11 * e22 - e12 * e21) + e01 * (e12 * e20 - e10 * e22) + e02 * (e10 * e21 - e11 * e20);
}
@Override
public String toString() {
return "Matrix4d(\n" +
" " + m00 + ", " + m01 + ", " + m02 + ", " + m03 + "\n" +
" " + m10 + ", " + m11 + ", " + m12 + ", " + m13 + "\n" +
" " + m20 + ", " + m21 + ", " + m22 + ", " + m23 + "\n" +
" " + m30 + ", " + m31 + ", " + m32 + ", " + m33 + "\n" +
")\n";
}
}
@@ -0,0 +1,57 @@
package com.enderio.core.common.vecmath;
public class Quat4d {
public static Quat4d makeRotate(double angle, Vector3d axis) {
double epsilon = 0.0000001;
double x = axis.x;
double y = axis.y;
double z = axis.z;
double length = Math.sqrt(x * x + y * y + z * z);
if(length < epsilon) {
// ~zero length axis, so reset rotation to zero.
return new Quat4d();
}
double inversenorm = 1.0 / length;
double coshalfangle = Math.cos(0.5 * angle);
double sinhalfangle = Math.sin(0.5 * angle);
Quat4d res = new Quat4d();
res.x = x * sinhalfangle * inversenorm;
res.y = y * sinhalfangle * inversenorm;
res.z = z * sinhalfangle * inversenorm;
res.w = coshalfangle;
return res;
}
public double x;
public double y;
public double z;
public double w;
public Quat4d() {
}
public void rotate(Vector3d vec) {
double d = -x * vec.x - y * vec.y - z * vec.z;
double d1 = w * vec.x + y * vec.z - z * vec.y;
double d2 = w * vec.y - x * vec.z + z * vec.x;
double d3 = w * vec.z + x * vec.y - y * vec.x;
vec.x = d1 * w - d * x - d2 * z + d3 * y;
vec.y = d2 * w - d * y + d1 * z - d3 * x;
vec.z = d3 * w - d * z - d1 * y + d2 * x;
}
public void rotate(Vector3f vec) {
double d = -x * vec.x - y * vec.y - z * vec.z;
double d1 = w * vec.x + y * vec.z - z * vec.y;
double d2 = w * vec.y - x * vec.z + z * vec.x;
double d3 = w * vec.z + x * vec.y - y * vec.x;
vec.x = (float) (d1 * w - d * x - d2 * z + d3 * y);
vec.y = (float) (d2 * w - d * y + d1 * z - d3 * x);
vec.z = (float) (d3 * w - d * z - d1 * y + d2 * x);
}
}
@@ -0,0 +1,637 @@
package com.enderio.core.common.vecmath;
import java.awt.Rectangle;
public class VecmathUtil {
/**
* Returns the distance from a point to a plane.
*
* @param plane
* the plane.
* @param point
* the point.
* @return the distance between them.
*/
public static double distanceFromPointToPlane(Vector4d plane, Vector3d point) {
Vector4d newPoint = new Vector4d(point.x, point.y, point.z, 1);
return plane.dot(newPoint);
}
public static void computePlaneEquation(Vector4d a, Vector4d b, Vector4d c, Vector4d result) {
computePlaneEquation(new Vector3d(a.x, a.y, a.z), new Vector3d(b.x, b.y, b.z), new Vector3d(c.x, c.y, c.z), result);
}
public static Vector3d clamp(Vector3d v, double min, double max) {
v.x = clamp(v.x, min, max);
v.y = clamp(v.y, min, max);
v.z = clamp(v.z, min, max);
return v;
}
public static double clamp(double val, double min, double max) {
return val < min ? min : (val > max ? max : val);
}
public static int clamp(int val, int min, int max) {
return val < min ? min : (val > max ? max : val);
}
/**
* Compute the plane equation <code>Ax + By + Cz + D = 0</code> for the plane
* defined by the three points which lie on the plane, a, b, and c, and
* placing the result into r. The plane equation can be summarised as the
* normal vector of the plane (A,B,C) and the distance to the plane from the
* origin (D).
*
* @param a
* vector a.
* @param b
* vector b.
* @param c
* vector c.
* @param result
* the result (A,B,C,D) of plane equation.
*/
public static void computePlaneEquation(Vector3d a, Vector3d b,
Vector3d c, Vector4d result) {
Vector3d i = new Vector3d();
Vector3d j = new Vector3d();
Vector3d k = new Vector3d();
// compute normal vector
i.x = c.x - a.x;
i.y = c.y - a.y;
i.z = c.z - a.z;
j.x = b.x - a.x;
j.y = b.y - a.y;
j.z = b.z - a.z;
k.cross(j, i);
k.normalize();
// plane equation: Ax + By + Cz + D = 0
result.x = k.x; // A
result.y = k.y; // B
result.z = k.z; // C
result.w = -(result.x * a.x + result.y * a.y + result.z * a.z); // D
}
/**
* Projects the point onto the plane.
*
* @param plane
* the plane.
* @param point
* the point.
*/
public static void projectPointOntoPlane(Vector4d plane, Vector4d point) {
double distance = plane.dot(point);
Vector4d newPoint = new Vector4d(point);
Vector3d planeNormal = new Vector3d(plane.x, plane.y, plane.z);
planeNormal.normalize();
planeNormal.scale(distance);
newPoint.sub(new Vector4d(planeNormal.x, planeNormal.y, planeNormal.z, 0));
point.set(newPoint);
}
/**
* This method calculates the intersection between a line and a plane.
*
* @param plane
* the plane (x,y,z = normal, w = distance from origin)
* @param pointInLine
* a point in the line.
* @param lineDirection
* the direction of the line.
* @return the intersection or null if there is no intersection or the line is
* on the plane.
*/
public static Vector3d computeIntersectionBetweenPlaneAndLine(Vector4d plane,
Vector3d pointInLine, Vector3d lineDirection) {
// check for no intersection
Vector3d planeNormal = new Vector3d(plane.x, plane.y, plane.z);
if(planeNormal.dot(lineDirection) == 0) {
// line and plane are perpendicular
return null;
}
// check if line is on the plane
if(planeNormal.dot(pointInLine) + plane.w == 0) {
return null;
}
// we have an intersection
Vector4d point = new Vector4d(pointInLine.x, pointInLine.y, pointInLine.z, 1);
Vector4d lineNorm = new Vector4d(lineDirection.x, lineDirection.y, lineDirection.z, 0);
double t = -(plane.dot(point) / plane.dot(lineNorm));
Vector3d result = new Vector3d(pointInLine);
lineDirection.scale(t);
result.add(lineDirection);
return result;
}
/**
* This function computes the ray that goes from the eye, through the
* specified pixel.
*
* @param x
* the x pixel location (x = 0 is the left most pixel)
* @param y
* the y pixel location (y = 0 is the bottom most pixel)
* @param eyeOut
* the eyes position.
* @param normalOut
* the normal description the directional component of the ray.
*/
public static void computeRayForPixel(Rectangle vp, Matrix4d ipm, Matrix4d ivm, int x, int y,
Vector3d eyeOut, Vector3d normalOut) {
// grab the eye's position
ivm.getTranslation(eyeOut);
Matrix4d vpm = new Matrix4d();
vpm.mul(ivm, ipm);
// Calculate the pixel location in screen clip space (width and height from
// -1 to 1)
double screenX = (x - vp.getX()) / vp.getWidth();
double screenY = (y - vp.getY()) / vp.getHeight();
screenX = (screenX * 2.0) - 1.0;
screenY = (screenY * 2.0) - 1.0;
// Now calculate the XYZ location of this point on the near plane
Vector4d tmp = new Vector4d();
tmp.x = screenX;
tmp.y = screenY;
tmp.z = -1;
tmp.w = 1.0;
vpm.transform(tmp);
double w = tmp.w;
Vector3d nearXYZ = new Vector3d(tmp.x / w, tmp.y / w, tmp.z / w);
// and then on the far plane
tmp.x = screenX;
tmp.y = screenY;
tmp.z = 1;
tmp.w = 1.0;
vpm.transform(tmp);
w = tmp.w;
Vector3d farXYZ = new Vector3d(tmp.x / w, tmp.y / w, tmp.z / w);
normalOut.set(farXYZ);
normalOut.sub(nearXYZ);
normalOut.normalize();
}
// /**
// * Make a rotation Quat which will rotate vec1 to vec2
// * <p/>
// * This routine uses only fast geometric transforms, without costly acos/sin
// computations. It's
// * exact, fast, and with less degenerate cases than the acos/sin method.
// * <p/>
// * For an explanation of the math used, you may see for example:
// * http://logiciels.cnes.fr/MARMOTTES/marmottes-mathematique.pdf
// * <p/>
// * NB: This is the rotation with shortest angle, which is the one equivalent
// to the acos/sin
// * transform method. Other rotations exists, for example to additionally
// keep a local horizontal
// * attitude.
// *
// * @param from
// * rotate from this vector
// * @param to
// * to this one
// * @return the rotation to apply to from to get to to.
// */
//
// public static Quat4d makeRotate( Vector3d from, Vector3d to) {
//
// Quat4d res = new Quat4d();
//
// // This routine takes any vector as argument but normalized
// // vectors are necessary, if only for computing the dot product.
// // Too bad the API is that generic, it leads to performance loss.
// // Even in the case the 2 vectors are not normalized but same length,
// // the sqrt could be shared, but we have no way to know beforehand
// // at this point, while the caller may know.
// // So, we have to test... in the hope of saving at least a sqrt
// Vector3d sourceVector = new Vector3d(from);
// Vector3d targetVector = new Vector3d(to);
//
// double fromLen2 = sourceVector.lengthSquared();
// double fromLen;
// // normalize only when necessary, epsilon test
// if ((fromLen2 < 1.0 - 1e-7) || (fromLen2 > 1.0 + 1e-7)) {
// fromLen = Math.sqrt(fromLen2);
// sourceVector.x /= fromLen;
// sourceVector.y /= fromLen;
// sourceVector.z /= fromLen;
//
// } else {
// fromLen = 1.0;
// }
//
// double toLen2 = targetVector.lengthSquared();
// // normalize only when necessary, epsilon test
// if ((toLen2 < 1.0 - 1e-7) || (toLen2 > 1.0 + 1e-7)) {
// double toLen;
// // re-use fromLen for case of mapping 2 vectors of the same length
// if ((toLen2 > fromLen2 - 1e-7) && (toLen2 < fromLen2 + 1e-7)) {
// toLen = fromLen;
// } else {
// toLen = Math.sqrt(toLen2);
// }
//
// targetVector.x /= toLen;
// targetVector.y /= toLen;
// targetVector.z /= toLen;
// }
//
// // Now let's get into the real stuff
// // Use "dot product plus one" as test as it can be re-used later on
// double dotProdPlus1 = 1.0 + sourceVector.dot(targetVector);
//
// // Check for degenerate case of full u-turn. Use epsilon for detection
// if (dotProdPlus1 < 1e-7) {
//
// // Get an orthogonal vector of the given vector
// // in a plane with maximum vector coordinates.
// // Then use it as quaternion axis with pi angle
// // Trick is to realize one value at least is >0.6 for a normalized vector.
// if (Math.abs(sourceVector.x) < 0.6) {
//
// double norm = Math.sqrt(1.0 - sourceVector.x * sourceVector.x);
// res.x = 0.0;
// res.y = sourceVector.z / norm;
// res.z = -sourceVector.y / norm;
// res.w = 0.0;
// } else if (Math.abs(sourceVector.y) < 0.6) {
// double norm = Math.sqrt(1.0 - sourceVector.y * sourceVector.y);
// res.x = -sourceVector.z / norm;
// res.y = 0.0;
// res.z = sourceVector.x / norm;
// res.w = 0.0;
// } else {
// double norm = Math.sqrt(1.0 - sourceVector.z * sourceVector.z);
// res.x = sourceVector.y / norm;
// res.y = -sourceVector.x / norm;
// res.z = 0.0;
// res.w = 0.0;
// }
// } else {
// // Find the shortest angle quaternion that transforms normalized vectors
// // into one other. Formula is still valid when vectors are colinear
// double s = Math.sqrt(0.5 * dotProdPlus1);
// double val = (2.0 * s);
// targetVector.x /= val;
// targetVector.y /= val;
// targetVector.z /= val;
//
// Vector3d tmp = new Vector3d();
// tmp.cross(sourceVector, targetVector);
//
// res.x = tmp.x;
// res.y = tmp.y;
// res.z = tmp.z;
// res.w = s;
// }
//
// return res;
// }
//
// /**
// * Makes a rotation of angle (radians) around the axis specified by the
// x,y,z values.
// *
// * @param angle
// * the angle in radians for the rotation
// * @param axis
// * the axis to rotate about.
// * @return the quaternion defining the rotation.
// */
/**
* Creates a perspective projection matrix.
*
* @param fovDegrees
* The field of view angle in degrees.
* @param near
* near plane.
* @param far
* far plane.
* @param viewportWidth
* viewport width.
* @param viewportHeight
* viewport height.
* @return the matrix.
*/
public static Matrix4d createProjectionMatrixAsPerspective(double fovDegrees, double near,
double far, int viewportWidth, int viewportHeight) {
Matrix4d matrix = new Matrix4d();
// for impl details see gluPerspective doco in OpenGL reference manual
double aspect = (double) viewportWidth / (double) viewportHeight;
double theta = (Math.toRadians(fovDegrees) / 2d);
double f = Math.cos(theta) / Math.sin(theta);
double a = (far + near) / (near - far);
double b = (2d * far * near) / (near - far);
matrix.set(new double[] { f / aspect, 0, 0, 0, 0, f, 0, 0, 0, 0, a, b, 0, 0, -1, 0 });
return matrix;
}
/**
* Creates a projection matrix as per glFrustrum.
*
* @param left
* coordinate of left clip plane.
* @param right
* coordinate of right clip plane.
* @param bottom
* coordinate of bottom clip plane.
* @param top
* coordinate of left top plane.
* @param zNear
* distance of the near plane.
* @param zFar
* distance of the near plane.
* @return the matrix.
*/
public static Matrix4d createProjectionMatrixAsPerspective(double left, double right,
double bottom, double top, double zNear, double zFar) {
double A = (right + left) / (right - left);
double B = (top + bottom) / (top - bottom);
double C = (Math.abs(zFar) > Double.MAX_VALUE) ? -1. : -(zFar + zNear) / (zFar - zNear);
double D = (Math.abs(zFar) > Double.MAX_VALUE) ? -2. * zNear : -2.0 * zFar * zNear
/ (zFar - zNear);
Matrix4d matrix = new Matrix4d();
matrix.set(new double[] { 2.0 * zNear / (right - left), 0.0, 0.0, 0.0, 0.0,
2.0 * zNear / (top - bottom), 0.0, 0.0, A, B, C, -1.0, 0.0, 0.0, D, 0.0
});
matrix.transpose();
return matrix;
}
/**
* Sets the orthographic projection matrix.
*
* @param left
* the left value.
* @param right
* the right value.
* @param bottom
* the bottom value.
* @param top
* the top value.
* @param near
* near plane.
* @param far
* far plane.
* @return the ortho matrix.
*/
public static Matrix4d createProjectionMatrixAsOrtho(double left, double right, double bottom,
double top, double near, double far) {
Matrix4d matrix = new Matrix4d();
// for impl details see glOrtho doco in OpenGL reference manual
double tx = -((right + left) / (right - left));
double ty = -((top + bottom) / (top - bottom));
double tz = -((far + near) / (far - near));
matrix.set(new double[] { 2d / (right - left), 0, 0, tx, 0, 2d / (top - bottom), 0, ty, 0, 0,
-2d / (far - near), tz, 0, 0, 0, 1 });
return matrix;
}
/**
* Sets the near and far values on an existing perspective projection matrix.
*
* @param projMat
* the matrix to be modified.
* @param near
* the new near value.
* @param far
* the new far value.
*/
public static void setNearFarOnPerspectiveProjectionMatrix(Matrix4d projMat,
double near, double far) {
projMat.transpose();
double transNearPlane = (-near * projMat.getElement(2, 2) + projMat.getElement(3, 2))
/ (-near * projMat.getElement(2, 3) + projMat.getElement(3, 3));
double transFarPlane = (-far * projMat.getElement(2, 2) + projMat.getElement(3, 2))
/ (-far * projMat.getElement(2, 3) + projMat.getElement(3, 3));
double ratio = Math.abs(2.0 / (transNearPlane - transFarPlane));
double center = -(transNearPlane + transFarPlane) / 2.0;
Matrix4d mat = new Matrix4d();
mat.setIdentity();
mat.setElement(2, 2, ratio);
mat.setElement(3, 2, center * ratio);
projMat.mul(mat);
projMat.transpose();
}
/**
* Creates a look at matrix.
*
* @param eyePos
* the position of the eye.
* @param lookAtPos
* the point to look at.
* @param upVec
* the up vector.
* @return the look at matrix.
*/
public static Matrix4d createMatrixAsLookAt(Vector3d eyePos,
Vector3d lookAtPos, Vector3d upVec) {
Vector3d eye = new Vector3d(eyePos);
Vector3d lookAt = new Vector3d(lookAtPos);
Vector3d up = new Vector3d(upVec);
Vector3d forwardVec = new Vector3d(lookAt);
forwardVec.sub(eye);
forwardVec.normalize();
Vector3d sideVec = new Vector3d();
sideVec.cross(forwardVec, up);
sideVec.normalize();
Vector3d upVed = new Vector3d();
upVed.cross(sideVec, forwardVec);
upVed.normalize();
Matrix4d mat = new Matrix4d(sideVec.x, sideVec.y, sideVec.z, 0, upVed.x, upVed.y, upVed.z, 0,
-forwardVec.x, -forwardVec.y, -forwardVec.z, 0, 0, 0, 0, 1);
eye.negate();
// mat.transform(eye);
mat.transformNormal(eye);
mat.setTranslation(eye);
return mat;
}
/**
* Pre-multiplies the vector by the matrix.
*
* @param v
* the vector.
* @param mat
* the matrix.
* @return the result of the multiplication.
*/
public static Vector3d preMultiply(Vector3d v, Matrix4d mat) {
Matrix4d m = new Matrix4d(mat);
m.transpose();
double d = 1.0f / (m.getElement(0, 3) * v.x + m.getElement(1, 3) * v.y + m.getElement(2, 3)
* v.z + m.getElement(3, 3));
double x = (m.getElement(0, 0) * v.x + m.getElement(1, 0) * v.y + m.getElement(2, 0) * v.z + m
.getElement(3, 0)) * d;
double y = (m.getElement(0, 1) * v.x + m.getElement(1, 1) * v.y + m.getElement(2, 1) * v.z + m
.getElement(3, 1)) * d;
double z = (m.getElement(0, 2) * v.x + m.getElement(1, 2) * v.y + m.getElement(2, 2) * v.z + m
.getElement(3, 2) * d);
return new Vector3d(x, y, z);
}
/**
* Extracts the s,t,r and q eye planes from the specified matrix.
*
* @param matrix
* the matrix to extract the planes from.
* @return the s,t,r and q planes from the specified matrix.
*/
public static Vector4d[] getEyePlanesForMatrix(Matrix4d matrix) {
Matrix4d copy = new Matrix4d(matrix);
copy.transpose();
Vector4d[] res = new Vector4d[4];
// s plane
res[0] = new Vector4d(copy.getElement(0, 0), copy.getElement(1, 0), copy.getElement(2, 0),
copy.getElement(3, 0));
// t plane
res[1] = new Vector4d(copy.getElement(0, 1), copy.getElement(1, 1), copy.getElement(2, 1),
copy.getElement(3, 1));
// r plane
res[2] = new Vector4d(copy.getElement(0, 2), copy.getElement(1, 2), copy.getElement(2, 2),
copy.getElement(3, 2));
// q plane
res[3] = new Vector4d(copy.getElement(0, 3), copy.getElement(1, 3), copy.getElement(2, 3),
copy.getElement(3, 3));
return res;
}
/**
* Computes the cross product of the two tuples.
*
* @param vec1
* the first tuple.
* @param vec2
* the second tuple.
* @return the cross product of the two tuples.
*/
public static Vector3d cross(Vector3d vec1, Vector3d vec2) {
Vector3d res = new Vector3d();
res.cross(new Vector3d(vec1), new Vector3d(vec2));
return res;
}
/**
* Returns the distance between the two point from and to.
*
* @param from
* the from point.
* @param to
* the to point.
* @return the distance between the two point from and to.
*/
public static double distance(Vector3d from, Vector3d to) {
return from.distance(to);
}
/**
* Returns the distance squared between the two point from and to.
*
* @param from
* the from point.
* @param to
* the to point.
* @return the distance squared between the two point from and to.
*/
public static double distanceSquared(Vector3d from, Vector3d to) {
return from.distanceSquared(to);
}
/**
* Extracts the directional vectors from the specified view matrix.
*
* @param matrix
* the view matrix.
* @param upVecOut
* the up vector.
* @param sideVecOut
* the side vector.
* @param lookVecOut
* the look vector.
*/
public static void getVectorsForMatrix(Matrix4d matrix, Vector3d upVecOut,
Vector3d sideVecOut, Vector3d lookVecOut) {
sideVecOut.set(matrix.getElement(0, 0), matrix.getElement(0, 1), matrix.getElement(0, 2));
sideVecOut.normalize();
upVecOut.set(matrix.getElement(1, 0), matrix.getElement(1, 1), matrix.getElement(1, 2));
upVecOut.normalize();
lookVecOut.set(matrix.getElement(2, 0), matrix.getElement(2, 1), matrix.getElement(2, 2));
lookVecOut.negate();
lookVecOut.normalize();
}
/**
* Extracts the up vector from the specified view matrix.
*
* @param matrix
* the matrix.
* @return the up vector from the specified view matrix.
*/
public static Vector3d getUpFromMatrix(Matrix4d matrix) {
Vector3d res = new Vector3d(matrix.getElement(1, 0), matrix.getElement(1, 1),
matrix.getElement(1, 2));
res.normalize();
return res;
}
}
@@ -0,0 +1,96 @@
package com.enderio.core.common.vecmath;
public class Vector2d {
public double x;
public double y;
public Vector2d() {
x = 0;
y = 0;
}
public Vector2d(double x, double y) {
this.x = x;
this.y = y;
}
public Vector2d(Vector2d other) {
this(other.x, other.y);
}
public void set(double x, double y) {
this.x = x;
this.y = y;
}
public void set(Vector2f vec) {
x = vec.x;
y = vec.y;
}
public void set(Vector2d vec) {
x = vec.x;
y = vec.y;
}
public void add(Vector2d vec) {
x += vec.x;
y += vec.y;
}
public void sub(Vector2d vec) {
x -= vec.x;
y -= vec.y;
}
public void add(Vector2f vec) {
x += vec.x;
y += vec.y;
}
public void sub(Vector2f vec) {
x -= vec.x;
y -= vec.y;
}
public void negate() {
x = -x;
y = -y;
}
public void scale(double s) {
x *= s;
y *= s;
}
public void normalize() {
double scale = 1.0 / Math.sqrt(x * x + y * y);
scale(scale);
}
public double lengthSquared() {
return x * x + y * y;
}
public double length() {
return Math.sqrt(lengthSquared());
}
public double distanceSquared(Vector2d v) {
double dx, dy, dz;
dx = x - v.x;
dy = y - v.y;
return (dx * dx + dy * dy);
}
public double distance(Vector2d v) {
return Math.sqrt(distanceSquared(v));
}
@Override
public String toString() {
return "Vector2d(" + x + ", " + y + ")";
}
}
@@ -0,0 +1,95 @@
package com.enderio.core.common.vecmath;
public class Vector2f {
public float x;
public float y;
public Vector2f() {
x = 0;
y = 0;
}
public Vector2f(double x, double y) {
this.x = (float) x;
this.y = (float) y;
}
public Vector2f(float x, float y) {
this.x = x;
this.y = y;
}
public Vector2f(Vector2d other) {
this(other.x, other.y);
}
public Vector2f(Vector2f other) {
this(other.x, other.y);
}
public void set(double x, double y) {
this.x = (float) x;
this.y = (float) y;
}
public void set(float x, float y) {
this.x = x;
this.y = y;
}
public void set(Vector2f vec) {
x = vec.x;
y = vec.y;
}
public void add(Vector2f vec) {
x += vec.x;
y += vec.y;
}
public void sub(Vector2f vec) {
x -= vec.x;
y -= vec.y;
}
public void negate() {
x = -x;
y = -y;
}
public void scale(double s) {
x *= s;
y *= s;
}
public void normalize() {
double scale = 1.0 / Math.sqrt(x * x + y * y);
scale(scale);
}
public double lengthSquared() {
return x * x + y * y;
}
public double length() {
return Math.sqrt(lengthSquared());
}
public double distanceSquared(Vector2f v) {
double dx, dy, dz;
dx = x - v.x;
dy = y - v.y;
return (dx * dx + dy * dy);
}
public double distance(Vector2f v) {
return Math.sqrt(distanceSquared(v));
}
@Override
public String toString() {
return "Vector2f(" + x + ", " + y + ")";
}
}
@@ -0,0 +1,153 @@
package com.enderio.core.common.vecmath;
import net.minecraft.util.Vec3;
import net.minecraftforge.client.model.obj.Vertex;
public class Vector3d {
public double x;
public double y;
public double z;
public Vector3d() {
x = 0;
y = 0;
z = 0;
}
public Vector3d(double x, double y, double z) {
this.x = x;
this.y = y;
this.z = z;
}
public Vector3d(Vector3d other) {
this(other.x, other.y, other.z);
}
public Vector3d(Vector3f corner) {
this(corner.x, corner.y, corner.z);
}
public Vector3d(Vertex vert) {
this(vert.x, vert.y, vert.z);
}
public void set(double x, double y, double z) {
this.x = x;
this.y = y;
this.z = z;
}
public void set(Vector3f v) {
set(v.x, v.y, v.z);
}
public void set(Vector3d vec) {
x = vec.x;
y = vec.y;
z = vec.z;
}
public Vector3d add(Vector3d vec) {
x += vec.x;
y += vec.y;
z += vec.z;
return this;
}
public Vector3d add(Vector3f vec) {
x += vec.x;
y += vec.y;
z += vec.z;
return this;
}
public Vector3d add(double x2, double y2, double z2) {
x += x2;
y += y2;
z += z2;
return this;
}
public void sub(Vector3d vec) {
x -= vec.x;
y -= vec.y;
z -= vec.z;
}
public void sub(Vector3f vec) {
x -= vec.x;
y -= vec.y;
z -= vec.z;
}
public Vector3d negate() {
x = -x;
y = -y;
z = -z;
return this;
}
public void scale(double s) {
x *= s;
y *= s;
z *= s;
}
public void scale(double sx, double sy, double sz) {
x *= sx;
y *= sy;
z *= sz;
}
public void normalize() {
double scale = 1.0 / Math.sqrt(x * x + y * y + z * z);
scale(scale);
}
public double dot(Vector3d other) {
return x * other.x + y * other.y + z * other.z;
}
public void cross(Vector3d v1, Vector3d v2) {
x = v1.y * v2.z - v1.z * v2.y;
y = v2.x * v1.z - v2.z * v1.x;
z = v1.x * v2.y - v1.y * v2.x;
}
public double lengthSquared() {
return x * x + y * y + z * z;
}
public double length() {
return Math.sqrt(lengthSquared());
}
public double distanceSquared(Vector3d v) {
double dx, dy, dz;
dx = x - v.x;
dy = y - v.y;
dz = z - v.z;
return (dx * dx + dy * dy + dz * dz);
}
public double distance(Vector3d v) {
return Math.sqrt(distanceSquared(v));
}
@Override
public String toString() {
return "Vector3d(" + x + ", " + y + ", " + z + ")";
}
public void abs() {
x = Math.abs(x);
y = Math.abs(y);
z = Math.abs(z);
}
public Vec3 getVec3() {
return Vec3.createVectorHelper(x, y, z);
}
}
@@ -0,0 +1,119 @@
package com.enderio.core.common.vecmath;
public class Vector3f {
public float x;
public float y;
public float z;
public Vector3f() {
x = 0;
y = 0;
z = 0;
}
public Vector3f(double x, double y, double z) {
this.x = (float) x;
this.y = (float) y;
this.z = (float) z;
}
public Vector3f(float x, float y, float z) {
this.x = x;
this.y = y;
this.z = z;
}
public Vector3f(Vector3d other) {
this(other.x, other.y, other.z);
}
public Vector3f(Vector3f other) {
this(other.x, other.y, other.z);
}
public void set(float x, float y, float z) {
this.x = x;
this.y = y;
this.z = z;
}
public void set(Vector3f vec) {
x = vec.x;
y = vec.y;
z = vec.z;
}
public void add(Vector3f vec) {
x += vec.x;
y += vec.y;
z += vec.z;
}
public void add(Vector3d vec) {
x += vec.x;
y += vec.y;
z += vec.z;
}
public void add(int x2, int y2, int z2) {
x += x2;
y += y2;
z += z2;
}
public void sub(Vector3f vec) {
x -= vec.x;
y -= vec.y;
z -= vec.z;
}
public void sub(Vector3d vec) {
x -= vec.x;
y -= vec.y;
z -= vec.z;
}
public void negate() {
x = -x;
y = -y;
z = -z;
}
public void scale(float s) {
x *= s;
y *= s;
z *= s;
}
public void normalize() {
double scale = 1.0 / Math.sqrt(x * x + y * y + z * z);
x *= scale;
y *= scale;
z *= scale;
}
public double dot(Vector3f other) {
return x * other.x + y * other.y + z * other.z;
}
public double lengthSquared() {
return x * x + y * y + z * z;
}
public double length() {
return Math.sqrt(lengthSquared());
}
@Override
public String toString() {
return "Vector3f(" + x + ", " + y + ", " + z + ")";
}
public Vector3d asVector3d() {
return new Vector3d(x, y, z);
}
}
@@ -0,0 +1,91 @@
package com.enderio.core.common.vecmath;
public class Vector4d {
public double x;
public double y;
public double z;
public double w;
public Vector4d() {
x = 0;
y = 0;
z = 0;
w = 0;
}
public Vector4d(double x, double y, double z, double w) {
this.x = x;
this.y = y;
this.z = z;
this.w = w;
}
public Vector4d(Vector4d other) {
this(other.x, other.y, other.z, other.w);
}
public void set(Vector4d vec) {
x = vec.x;
y = vec.y;
z = vec.z;
w = vec.w;
}
public void set(double x, double y, double z, double w) {
this.x = x;
this.y = y;
this.z = z;
this.w = w;
}
public void add(Vector4d vec) {
x += vec.x;
y += vec.y;
z += vec.z;
w += vec.w;
}
public void sub(Vector4d vec) {
x -= vec.x;
y -= vec.y;
z -= vec.z;
w -= vec.w;
}
public void negate() {
x = -x;
y = -y;
z = -z;
w = -w;
}
public void scale(double s) {
x *= s;
y *= s;
z *= s;
w *= s;
}
public void normalize() {
double scale = 1.0 / Math.sqrt(x * x + y * y + z * z + w * w);
scale(scale);
}
public double dot(Vector4d other) {
return x * other.x + y * other.y + z * other.z + w * other.w;
}
public double lengthSquared() {
return x * x + y * y + z * z + w * w;
}
public double length() {
return Math.sqrt(lengthSquared());
}
@Override
public String toString() {
return "Vector4d(" + x + ", " + y + ", " + z + ", " + w + ")";
}
}
@@ -0,0 +1,108 @@
package com.enderio.core.common.vecmath;
public class Vector4f {
public float x;
public float y;
public float z;
public float w;
public Vector4f() {
x = 0;
y = 0;
z = 0;
w = 0;
}
public Vector4f(float x, float y, float z, float w) {
this.x = x;
this.y = y;
this.z = z;
this.w = w;
}
public Vector4f(double x, double y, double z, double w) {
this.x = (float) x;
this.y = (float) y;
this.z = (float) z;
this.w = (float) w;
}
public Vector4f(Vector4f other) {
this(other.x, other.y, other.z, other.w);
}
public void interpolate(Vector4f destination, float factor) {
x = (1 - factor) * x + factor * destination.x;
y = (1 - factor) * y + factor * destination.y;
z = (1 - factor) * z + factor * destination.z;
w = (1 - factor) * w + factor * destination.w;
}
public void set(Vector4f vec) {
x = vec.x;
y = vec.y;
z = vec.z;
w = vec.w;
}
public void set(float x, float y, float z, float w) {
this.x = x;
this.y = y;
this.z = z;
this.w = w;
}
public void add(Vector4f vec) {
x += vec.x;
y += vec.y;
z += vec.z;
w += vec.w;
}
public void sub(Vector4f vec) {
x -= vec.x;
y -= vec.y;
z -= vec.z;
w -= vec.w;
}
public void negate() {
x = -x;
y = -y;
z = -z;
w = -w;
}
public void scale(double s) {
x *= s;
y *= s;
z *= s;
w *= s;
}
public void normalize() {
double scale = 1.0 / Math.sqrt(x * x + y * y + z * z + w * w);
scale(scale);
}
public double dot(Vector4f other) {
return x * other.x + y * other.y + z * other.z + w * other.w;
}
public double lengthSquared() {
return x * x + y * y + z * z + w * w;
}
public double length() {
return Math.sqrt(lengthSquared());
}
public Vector3f toVector3f() {
return new Vector3f(x, y, z);
}
@Override
public String toString() {
return "Vector4f(" + x + ", " + y + ", " + z + ", " + w + ")";
}
}
@@ -0,0 +1,149 @@
package com.enderio.core.common.vecmath;
public class Vertex {
public Vector3d xyz = new Vector3d();
public Vector2f uv = null;
public Vector3f normal = null;
public Vector4f color = null;
public int brightness = -1;
public Vertex() {
}
public Vertex(Vertex other) {
xyz.set(other.xyz);
if(other.uv != null) {
uv = new Vector2f(other.uv);
}
if(other.normal != null) {
normal = new Vector3f(other.normal);
}
if(other.color != null) {
color = new Vector4f(other.color);
}
brightness = other.brightness;
}
public Vertex(Vector3d xyz, Vector3f normal, Vector2f uv) {
this.xyz.set(xyz);
this.normal = new Vector3f(normal);
this.uv = new Vector2f(uv);
}
public Vertex(double x, double y, double z, double u, double v, int brightness, float r, float g, float b, float a) {
xyz.set(x, y, z);
uv = new Vector2f(u, v);
this.brightness = brightness;
color = new Vector4f(r, g, b, a);
}
public Vertex(double x, double y, double z, double u, double v) {
xyz.set(x, y, z);
uv = new Vector2f(u, v);
}
public void setXYZ(double x, double y, double z) {
xyz.set(x, y, z);
}
public void setUV(double u, double v) {
if(uv == null) {
uv = new Vector2f(u, v);
} else {
uv.set(u, v);
}
}
public void setNormal(double x, double y, double z) {
if(normal == null) {
normal = new Vector3f();
}
normal.set((float) x, (float) y, (float) z);
normal.normalize();
}
public void setNormal(Vector3f normal2) {
if(normal2 == null) {
normal = null;
return;
}
setNormal(normal2.x, normal2.y, normal2.z);
}
public void setBrightness(int brightness) {
this.brightness = brightness;
}
public Vector4f getColor() {
return color;
}
public void setColor(Vector4f color) {
this.color = color;
}
public void transform(Matrix4d xform) {
xform.transform(xyz);
xform.transformNormal(normal);
}
public void translate(Vector3d trans) {
xyz.add(trans);
}
public double x() {
return xyz.x;
}
public double y() {
return xyz.y;
}
public double z() {
return xyz.z;
}
public float nx() {
return normal.x;
}
public float ny() {
return normal.y;
}
public float nz() {
return normal.z;
}
public float u() {
return uv.x;
}
public float v() {
return uv.y;
}
public float r() {
return color.x;
}
public float g() {
return color.y;
}
public float b() {
return color.z;
}
public float a() {
return color.w;
}
@Override
public String toString() {
return "Vertex [xyz=" + xyz + ", uv=" + uv + ", normal=" + normal + ", color=" + color + ", brightness=" + brightness + "]";
}
}
@@ -0,0 +1,172 @@
package com.enderio.core.common.vecmath;
public class ViewFrustum {
public static final int LTN = 0;
public static final int LTF = 1;
public static final int LBN = 2;
public static final int LBF = 3;
public static final int RTN = 4;
public static final int RTF = 5;
public static final int RBN = 6;
public static final int RBF = 7;
public static final int VERTEX_COUNT = 8;
public static final int PLANE_COUNT = 6;
private static final int TOP = 0;
private static final int BOTTOM = 1;
private static final int LEFT = 2;
private static final int RIGHT = 3;
private static final int NEAR = 4;
private static final int FAR = 5;
private Vector4d vertices[] = new Vector4d[8];
private Vector4d planes[] = new Vector4d[6];
private Vector3d eye;
private Vector3d min;
private Vector3d max;
public ViewFrustum() {
eye = new Vector3d();
min = new Vector3d();
max = new Vector3d();
for (int i = 0; i < VERTEX_COUNT; i++) {
vertices[i] = new Vector4d();
}
for (int i = 0; i < PLANE_COUNT; i++) {
planes[i] = new Vector4d();
}
}
public ViewFrustum(ViewFrustum other) {
eye = new Vector3d(other.eye);
min = new Vector3d(other.min);
max = new Vector3d(other.max);
for (int i = 0; i < VERTEX_COUNT; i++) {
vertices[i] = new Vector4d(other.vertices[i]);
}
for (int i = 0; i < PLANE_COUNT; i++) {
planes[i] = new Vector4d(other.planes[i]);
}
}
public boolean containsPoint(Vector3d point) {
for (Vector4d plane : planes) {
if(distanceFromPointToPlane(plane, point) < 0) {
return false;
}
}
return true;
}
private Vector3d toThreeComponent(Vector3d from) {
return new Vector3d(from.x, from.y, from.z);
}
private double distanceFromPointToPlane(Vector4d plane, Vector3d point) {
Vector4d newPoint = new Vector4d(point.x, point.y, point.z, 1);
return plane.dot(newPoint);
}
public Vector4d getVertex(int index) {
return vertices[index];
}
public Vector3d getEye() {
return eye;
}
public Vector3d getMin() {
return min;
}
public Vector3d getMax() {
return max;
}
public Vector4d getLeftPlane() {
return getPlane(LEFT);
}
public Vector4d getRightPlane() {
return getPlane(RIGHT);
}
public Vector4d getTopPlane() {
return getPlane(TOP);
}
public Vector4d getBottomPlane() {
return getPlane(BOTTOM);
}
public Vector4d getNearPlane() {
return getPlane(NEAR);
}
public Vector4d getFarPlane() {
return getPlane(FAR);
}
/**
* @param ivm
* the inverse view transformation matrix
* @param ipm
* the inverse projection matrix
*/
public void computeFrustum(Matrix4d ivm, Matrix4d ipm) {
Matrix4d vpm = new Matrix4d();
vpm.mul(ivm, ipm);
ivm.getTranslation(eye);
vertices[LBF].set(-1, -1, 1, 1);
vertices[LTF].set(-1, 1, 1, 1);
vertices[RTF].set(1, 1, 1, 1);
vertices[RBF].set(1, -1, 1, 1);
vertices[LBN].set(-1, -1, -1, 1);
vertices[LTN].set(-1, 1, -1, 1);
vertices[RTN].set(1, 1, -1, 1);
vertices[RBN].set(1, -1, -1, 1);
min.set(Double.MAX_VALUE, Double.MAX_VALUE, Double.MAX_VALUE);
max.set(-Double.MAX_VALUE, -Double.MAX_VALUE, -Double.MAX_VALUE);
for (int i = 0; i < VERTEX_COUNT; i++) {
vpm.transform(vertices[i]);
double w = vertices[i].w;
// apply perspective
vertices[i].x /= w;
vertices[i].y /= w;
vertices[i].z /= w;
min.x = Math.min(min.x, vertices[i].x);
min.y = Math.min(min.y, vertices[i].y);
min.z = Math.min(min.z, vertices[i].z);
max.x = Math.max(max.x, vertices[i].x);
max.y = Math.max(max.y, vertices[i].y);
max.z = Math.max(max.z, vertices[i].z);
}
VecmathUtil.computePlaneEquation(vertices[LBN], vertices[LBF], vertices[LTF], planes[LEFT]);
VecmathUtil.computePlaneEquation(vertices[LBN], vertices[LBF], vertices[LTF], planes[LEFT]);
VecmathUtil.computePlaneEquation(vertices[RBN], vertices[RTF], vertices[RBF], planes[RIGHT]);
VecmathUtil.computePlaneEquation(vertices[LTN], vertices[LTF], vertices[RTF], planes[TOP]);
VecmathUtil.computePlaneEquation(vertices[LBN], vertices[RBF], vertices[LBF], planes[BOTTOM]);
VecmathUtil.computePlaneEquation(vertices[LBN], vertices[LTN], vertices[RTN], planes[NEAR]);
VecmathUtil.computePlaneEquation(vertices[LBF], vertices[RTF], vertices[LTF], planes[FAR]);
}
private final Vector4d getPlane(int index) {
assert ((index >= 0) && (index < PLANE_COUNT)) : "Illegal index : 0 <= index < " + PLANE_COUNT;
return planes[index];
}
}