diff options
| author | Foghrye4 <foghrye4@gmail.com> | 2016-04-11 19:44:54 +0300 |
|---|---|---|
| committer | Foghrye4 <foghrye4@gmail.com> | 2016-04-11 19:44:54 +0300 |
| commit | 05c78126859231a68e199dc34613689bd0978e2f (patch) | |
| tree | 050bea104a18c72905095d29f31bec2935a27a24 /ihl/utils/IHLRenderUtils.java | |
Initial commit
Diffstat (limited to 'ihl/utils/IHLRenderUtils.java')
| -rw-r--r-- | ihl/utils/IHLRenderUtils.java | 820 |
1 files changed, 820 insertions, 0 deletions
diff --git a/ihl/utils/IHLRenderUtils.java b/ihl/utils/IHLRenderUtils.java new file mode 100644 index 0000000..6cf8fa8 --- /dev/null +++ b/ihl/utils/IHLRenderUtils.java @@ -0,0 +1,820 @@ +package ihl.utils;
+
+import java.nio.FloatBuffer;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.lwjgl.opengl.GL11;
+
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import ic2.core.util.DrawUtil;
+import ihl.IHLMod;
+import net.minecraft.block.Block;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.ScaledResolution;
+import net.minecraft.client.gui.inventory.GuiContainer;
+import net.minecraft.client.multiplayer.WorldClient;
+import net.minecraft.client.renderer.GLAllocation;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.texture.TextureMap;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.util.StatCollector;
+import net.minecraftforge.client.event.DrawBlockHighlightEvent;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+
+public class IHLRenderUtils
+{
+ private FloatBuffer colorBuffer;
+ private Map<Long, Integer> frameTooltipMap;
+ private int displayScaledWidth=-1;
+ private int displayScaledHeight=-1;
+ private int guiXPos=-1;
+ private int guiYPos=-1;
+ private int prevDisplayWidth=-1;
+ private int prevDisplayHeight=-1;
+ private final int guiContainerWidth = 166;
+ private final int guiContainerHeight = 176;
+ private float lastPlayerYaw;
+ private float lastPlayerPitch;
+ private double lastPlayerPosY;
+ private double lastPlayerPosZ;
+ private double lastPlayerPosX;
+ private double renderMinX=0d;
+ private double renderMaxX=1d;
+ private double renderMinY=0d;
+ private double renderMaxY=1d;
+ private double renderMinZ=0d;
+ private double renderMaxZ=1d;
+ public boolean renderFromInside=false;
+ private float rotationPointX;
+ private float rotationPointY;
+ private float rotationPointZ;
+ private double renderPositionX;
+ private double renderPositionY;
+ private double renderPositionZ;
+ private float rotationX;
+ private float rotationY;
+ private float rotationZ;
+ private float scale=1/16f;
+ public boolean swapXandZ=false;
+ public boolean swapXandY=false;
+ public boolean swapYandZ=false;
+ public boolean swapRenderBoundsX=false;
+ public boolean swapRenderBoundsY=false;
+ public boolean swapRenderBoundsZ=false;
+ public int scaleFactor=1;
+ public static IHLRenderUtils instance;
+
+ public IHLRenderUtils()
+ {
+ instance=this;
+ colorBuffer = GLAllocation.createDirectFloatBuffer(16);
+ frameTooltipMap = new HashMap();
+ }
+
+ public void renderIHLFluidTank(IHLFluidTank fluidTank, int x1, int y1, int x2, int y2, float zLevel, int par1, int par2, int xOffset, int yOffset)
+ {
+ int liquidHeight = 0;
+ int prevLiquidHeight = 0;
+ int i = y2-y1;
+ Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.locationBlocksTexture);
+ GL11.glEnable(GL11.GL_BLEND);
+ GL11.glColor4f(1f, 1f, 1f, 1f);
+ for(int i2 = 0;i2<fluidTank.getNumberOfFluids();i2++)
+ {
+ FluidStack fluidStack = fluidTank.getFluid(i2);
+ if(fluidStack!=null)
+ {
+ Fluid fluid = fluidStack.getFluid();
+ if(fluid!=null)
+ {
+ IIcon fluidIcon = fluid.getIcon();
+ if (fluidIcon != null)
+ {
+ liquidHeight = fluidTank.getFluidAmount(i2) * i /fluidTank.getCapacity();
+ DrawUtil.drawRepeated(fluidIcon, x1, y2 - liquidHeight-prevLiquidHeight, x2-x1, liquidHeight, zLevel);
+ prevLiquidHeight+=liquidHeight;
+ }
+ }
+ }
+ }
+ drawIHLFluidTankTooltip(par1, par2, x1+guiXPos-6, y1+guiYPos+6, x2+guiXPos-6, y2+guiYPos+6, fluidTank);
+ }
+
+ public void drawMissingEngineTooltip(GuiContainer gui, int par1, int par2, int xPos, int yPos, int xOffset, int yOffset)
+ {
+ gui.drawTexturedModalRect(xPos, yPos, 194, 0, 3, 14);
+ drawTooltip(par1,par2,3,14,xPos+xOffset,yPos+yOffset,StatCollector.translateToLocal("ihl.gui.missing.engine"));
+ }
+
+ public void drawWorkspaceElementTooltip(int par1, int par2, int xPos, int yPos, ItemStack workSpaceElement)
+ {
+ drawTooltip(par1,par2,16,16,xPos,yPos,StatCollector.translateToLocal(workSpaceElement.getUnlocalizedName()+".tooltip"));
+ }
+
+ public void drawIHLFluidTankTooltip(int par1, int par2, int x1, int y1, int x2, int y2, IHLFluidTank fluidTank)
+ {
+ String fluidListNames="";
+ List<FluidStack> fli = fluidTank.getFluidList();
+ for(int i=fli.size()-1;i>=0;i--)
+ {
+ FluidStack fluidStack = fli.get(i);
+ fluidListNames+=StatCollector.translateToLocal(fluidStack.getUnlocalizedName())+": "+fluidStack.amount+"mB /n ";
+ }
+ drawTooltip(par1,par2,x2-x1,y2-y1,x1,y1,fluidListNames);
+ }
+
+ public boolean drawTooltip(int cursorPosX, int cursorPosY, int width, int height, int xPos, int yPos, String text)
+ {
+ updateScreenSize();
+ long key = xPos+yPos*1024;
+ Integer frame=0;
+ if(frameTooltipMap.containsKey(key))
+ {
+ frame=frameTooltipMap.get(key);
+ }
+ boolean showString=true;
+ if(cursorPosX<xPos || cursorPosX>xPos+width||
+ cursorPosY<yPos || cursorPosY>yPos+height)
+ {
+ if(frame>0)
+ {
+ frame-=20;
+ frameTooltipMap.put(key, frame);
+ }
+ showString=false;
+ }
+ else
+ {
+ frame+=10;
+ frameTooltipMap.put(key, frame);
+ }
+ if(frame>0)
+ {
+ int strokeHeight=15;
+ int i,x1,x2,y1,y2,tooltipWidth,tooltipHeight;
+ tooltipWidth=tooltipHeight=0;
+ String[] splittedText = text.split(" /n ");
+ for(i=0;i<splittedText.length;i++)
+ {
+ if(Minecraft.getMinecraft().fontRenderer.getStringWidth(splittedText[i])+8>tooltipWidth)
+ {
+ tooltipWidth=Math.min(frame,Minecraft.getMinecraft().fontRenderer.getStringWidth(splittedText[i])+8);
+ }
+ }
+ tooltipHeight=Math.min(Math.max(frame-tooltipWidth,strokeHeight),strokeHeight*splittedText.length);
+ x1=cursorPosX-xPos;
+ x2=x1+tooltipWidth;
+ y1=cursorPosY-guiYPos+18;
+ y2=y1+tooltipHeight;
+ GL11.glPushAttrib(16704);
+ GL11.glDisable(GL11.GL_DEPTH_TEST);
+ GL11.glDisable(GL11.GL_TEXTURE_2D);
+ GL11.glEnable(GL11.GL_BLEND);
+ GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+ if(showString)
+ {
+ drawRectangle(Tessellator.instance, x1,y1,x2,y2,128);
+ GL11.glEnable(GL11.GL_TEXTURE_2D);
+ for(i=0;i<splittedText.length;i++)
+ {
+ if(i<tooltipHeight/strokeHeight)
+ {
+ Minecraft.getMinecraft().fontRenderer.drawStringWithShadow(splittedText[i], x1+4, y1+i*strokeHeight+4, 16768125);
+ }
+ }
+ }
+ else
+ {
+ drawRectangle(Tessellator.instance, x1,y1,x2,y2,Math.min(128,frame/2));
+ GL11.glEnable(GL11.GL_TEXTURE_2D);
+ }
+ GL11.glPopAttrib();
+ frame=Math.min(tooltipWidth+tooltipHeight,frame);
+ frameTooltipMap.put(key, frame);
+ return true;
+ }
+ return false;
+ }
+
+ public void enableAmbientLighting()
+ {
+ GL11.glDisable(GL11.GL_LIGHT0);
+ GL11.glDisable(GL11.GL_LIGHT1);
+ GL11.glLightModel(GL11.GL_LIGHT_MODEL_AMBIENT, setColorBuffer(1.0f, 1.0f, 1.0f, 1.0F));
+ }
+
+ public void disableAmbientLighting()
+ {
+ GL11.glEnable(GL11.GL_LIGHT0);
+ GL11.glEnable(GL11.GL_LIGHT1);
+ GL11.glLightModel(GL11.GL_LIGHT_MODEL_AMBIENT, setColorBuffer(0.0f, 0.0f, 0.0f, 1.0F));
+ }
+
+ /**
+ * Update and return colorBuffer with the RGBA values passed as arguments
+ */
+ private FloatBuffer setColorBuffer(float par0, float par1, float par2, float par3)
+ {
+ colorBuffer.clear();
+ colorBuffer.put(par0).put(par1).put(par2).put(par3);
+ colorBuffer.flip();
+ return colorBuffer;
+ }
+
+ private void drawRectangle(Tessellator tessellator, int x1, int y1, int x2, int y2, int color)
+ {
+ tessellator.startDrawingQuads();
+ tessellator.setColorRGBA(color >>> 24 & 255, color >>> 16 & 255, color >>> 8 & 255, color & 255);
+ tessellator.addVertex(x2, y1, 300.0D);
+ tessellator.addVertex(x1, y1, 300.0D);
+ tessellator.addVertex(x1, y2, 300.0D);
+ tessellator.addVertex(x2, y2, 300.0D);
+ tessellator.draw();
+ }
+
+ public void drawThermometerTemperature(long temperature, boolean show)
+ {
+ updateScreenSize();
+ long key = 0;
+ int frame=0;
+ if(frameTooltipMap.containsKey(key))
+ {
+ frame=frameTooltipMap.get(key);
+ }
+ if(frame<=0)
+ {
+ updatePlayerView();
+ }
+ boolean showString=true;
+ if(show && frame<=122)
+ {
+ frame+=1;
+ frameTooltipMap.put(key, frame);
+ }
+ else
+ {
+ if(frame>0)
+ {
+ frame-=2;
+ frameTooltipMap.put(key, frame);
+ }
+ showString=false;
+ }
+ if(frame>0)
+ {
+ int width=Math.min(frame, 122);
+ int height=Math.min(frame, 48);
+ int xShift = Math.round(displayScaledWidth/100*(lastPlayerYaw - Minecraft.getMinecraft().renderViewEntity.prevRotationYaw));
+ int yShift = Math.round(displayScaledHeight/64*(lastPlayerPitch - Minecraft.getMinecraft().renderViewEntity.prevRotationPitch));
+ int xPos = displayScaledWidth/2+xShift;
+ int yPos = displayScaledHeight/2-48+yShift;
+ GL11.glEnable(GL11.GL_BLEND);
+ GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+ drawTexturedModalRect(xPos,yPos,0,0,width,height);
+ GL11.glDisable(GL11.GL_DEPTH_TEST);
+ if(showString)
+ {
+ Minecraft.getMinecraft().fontRenderer.drawStringWithShadow(temperature+"\u00B0K", xPos+35, yPos+3, 16768125);
+ }
+ GL11.glEnable(GL11.GL_DEPTH_TEST);
+ GL11.glDisable(GL11.GL_BLEND);
+ }
+ }
+
+ public void drawTexturedModalRect(int x1, int y1, int u, int v, int x2, int y2) {
+ float f = 0.00390625F;
+ float f1 = 0.00390625F;
+ Tessellator tessellator = Tessellator.instance;
+ tessellator.startDrawingQuads();
+ tessellator.setColorRGBA_F(1f, 1f, 1f, 0.5f);
+ tessellator.addVertexWithUV(x1 + 0, y1 + y2, 300D, (u + 0) * f, (v + y2) * f1);
+ tessellator.addVertexWithUV(x1 + x2, y1 + y2, 300D, (u + x2) * f, (v + y2) * f1);
+ tessellator.addVertexWithUV(x1 + x2, y1 + 0, 300D, (u + x2) * f, (v + 0) * f1);
+ tessellator.addVertexWithUV(x1 + 0, y1 + 0, 300D, (u + 0) * f, (v + 0) * f1);
+ tessellator.draw();
+ }
+
+
+ public void updateScreenSize()
+ {
+ if(prevDisplayHeight!=Minecraft.getMinecraft().displayHeight || prevDisplayWidth!=Minecraft.getMinecraft().displayWidth)
+ {
+ ScaledResolution var2 = new ScaledResolution(Minecraft.getMinecraft(), Minecraft.getMinecraft().displayWidth, Minecraft.getMinecraft().displayHeight);
+ displayScaledWidth = var2.getScaledWidth();
+ displayScaledHeight = var2.getScaledHeight();
+ scaleFactor=var2.getScaleFactor();
+ guiXPos = (displayScaledWidth - guiContainerWidth)/2;
+ guiYPos = (displayScaledHeight - guiContainerHeight)/2;
+ prevDisplayWidth=Minecraft.getMinecraft().displayWidth;
+ prevDisplayHeight=Minecraft.getMinecraft().displayHeight;
+ }
+ }
+
+ public void updatePlayerView()
+ {
+ lastPlayerYaw = Minecraft.getMinecraft().renderViewEntity.prevRotationYaw;
+ lastPlayerPitch = Minecraft.getMinecraft().renderViewEntity.prevRotationPitch;
+ lastPlayerPosX = Minecraft.getMinecraft().renderViewEntity.prevPosX;
+ lastPlayerPosY = Minecraft.getMinecraft().renderViewEntity.prevPosY;
+ lastPlayerPosZ = Minecraft.getMinecraft().renderViewEntity.prevPosZ;
+ }
+
+ public void drawKnee(double xPos, double yPos, double zPos, ForgeDirection direction12, ForgeDirection direction22, double radius1, double radius2, IIcon icon)
+ {
+ ForgeDirection direction1=direction12;
+ ForgeDirection direction2=direction22;
+ if(this.swapRenderBoundsX)
+ {
+ if(direction1.offsetX!=0)
+ {
+ direction1=direction1.getOpposite();
+ }
+ if(direction2.offsetX!=0)
+ {
+ direction2=direction2.getOpposite();
+ }
+ }
+ if(this.swapRenderBoundsY)
+ {
+ if(direction1.offsetY!=0)
+ {
+ direction1=direction1.getOpposite();
+ }
+ if(direction2.offsetY!=0)
+ {
+ direction2=direction2.getOpposite();
+ }
+ }
+ if(this.swapRenderBoundsZ)
+ {
+ if(direction1.offsetZ!=0)
+ {
+ direction1=direction1.getOpposite();
+ }
+ if(direction2.offsetZ!=0)
+ {
+ direction2=direction2.getOpposite();
+ }
+ }
+ double[][] outervertexes1 = new double[8][3];
+ double[][] innervertexes1 = new double[8][3];
+ double[][] outervertexes2 = new double[8][3];
+ double[][] innervertexes2 = new double[8][3];
+ int i=0;
+ for(i=0;i<8;i++)
+ {
+ if(direction1.equals(direction2))
+ {
+ switch(direction1)
+ {
+ case UP:
+ outervertexes1[i] = new double[] {0.5F+0.5F*(float)Math.cos(2D*Math.PI/8D*i), 0d, 0.5F+0.5F*(float)Math.sin(2D*Math.PI/8D*i)};
+ innervertexes1[i] = new double[] {0.5F+radius1*0.5F*(float)Math.cos(2D*Math.PI/8D*i), 0d, 0.5F+0.5F*radius1*(float)Math.sin(2D*Math.PI/8D*i)};
+ outervertexes2[i] = new double[] {0.5F+0.5F*radius2*(float)Math.cos(2D*Math.PI/8D*i), 1d, 0.5F+0.5F*radius2*(float)Math.sin(2D*Math.PI/8D*i)};
+ innervertexes2[i] = new double[] {0.5F+radius1*radius2*0.5F*(float)Math.cos(2D*Math.PI/8D*i), 1d, 0.5F+0.5F*radius2*radius1*(float)Math.sin(2D*Math.PI/8D*i)};
+ break;
+ case DOWN:
+ outervertexes1[i] = new double[] {0.5F+0.5F*radius2*(float)Math.cos(2D*Math.PI/8D*i), 0d, 0.5F+0.5F*radius2*(float)Math.sin(2D*Math.PI/8D*i)};
+ innervertexes1[i] = new double[] {0.5F+radius1*radius2*0.5F*(float)Math.cos(2D*Math.PI/8D*i), 0d, 0.5F+0.5F*radius1*radius2*(float)Math.sin(2D*Math.PI/8D*i)};
+ outervertexes2[i] = new double[] {0.5F+0.5F*(float)Math.cos(2D*Math.PI/8D*i), 1d, 0.5F+0.5F*(float)Math.sin(2D*Math.PI/8D*i)};
+ innervertexes2[i] = new double[] {0.5F+radius1*0.5F*(float)Math.cos(2D*Math.PI/8D*i), 1d, 0.5F+0.5F*radius1*(float)Math.sin(2D*Math.PI/8D*i)};
+ break;
+ case SOUTH:
+ outervertexes1[i] = new double[] {0.5F+0.5F*(float)Math.cos(2D*Math.PI/8D*i), 0.5F+0.5F*(float)Math.sin(2D*Math.PI/8D*i), 1d};
+ innervertexes1[i] = new double[] {0.5F+radius1*0.5F*(float)Math.cos(2D*Math.PI/8D*i), 0.5F+0.5F*radius1*(float)Math.sin(2D*Math.PI/8D*i), 1d};
+ outervertexes2[i] = new double[] {0.5F+0.5F*radius2*(float)Math.cos(2D*Math.PI/8D*i), 0.5F+0.5F*radius2*(float)Math.sin(2D*Math.PI/8D*i), 0d};
+ innervertexes2[i] = new double[] {0.5F+radius1*radius2*0.5F*(float)Math.cos(2D*Math.PI/8D*i), 0.5F+0.5F*radius1*radius2*(float)Math.sin(2D*Math.PI/8D*i), 0d};
+ break;
+ case NORTH:
+ outervertexes1[i] = new double[] {0.5F+0.5F*radius2*(float)Math.cos(2D*Math.PI/8D*i), 0.5F+0.5F*radius2*(float)Math.sin(2D*Math.PI/8D*i), 1d};
+ innervertexes1[i] = new double[] {0.5F+radius1*radius2*0.5F*(float)Math.cos(2D*Math.PI/8D*i), 0.5F+0.5F*radius1*radius2*(float)Math.sin(2D*Math.PI/8D*i), 1d};
+ outervertexes2[i] = new double[] {0.5F+0.5F*(float)Math.cos(2D*Math.PI/8D*i), 0.5F+0.5F*(float)Math.sin(2D*Math.PI/8D*i), 0d};
+ innervertexes2[i] = new double[] {0.5F+radius1*0.5F*(float)Math.cos(2D*Math.PI/8D*i), 0.5F+0.5F*radius1*(float)Math.sin(2D*Math.PI/8D*i), 0d};
+ break;
+ case EAST:
+ outervertexes1[i] = new double[] {0d, 0.5F+0.5F*(float)Math.sin(2D*Math.PI/8D*i), 0.5F+0.5F*(float)Math.cos(2D*Math.PI/8D*i)};
+ innervertexes1[i] = new double[] {0d, 0.5F+0.5F*radius1*(float)Math.sin(2D*Math.PI/8D*i), 0.5F+radius1*0.5F*(float)Math.cos(2D*Math.PI/8D*i)};
+ outervertexes2[i] = new double[] {1d, 0.5F+0.5F*radius2*(float)Math.sin(2D*Math.PI/8D*i), 0.5F+0.5F*radius2*(float)Math.cos(2D*Math.PI/8D*i)};
+ innervertexes2[i] = new double[] {1d, 0.5F+0.5F*radius1*radius2*(float)Math.sin(2D*Math.PI/8D*i), 0.5F+radius1*radius2*0.5F*(float)Math.cos(2D*Math.PI/8D*i)};
+ break;
+ case WEST:
+ outervertexes1[i] = new double[] {0d, 0.5F+0.5F*radius2*(float)Math.sin(2D*Math.PI/8D*i), 0.5F+0.5F*radius2*(float)Math.cos(2D*Math.PI/8D*i)};
+ innervertexes1[i] = new double[] {0d, 0.5F+0.5F*radius2*radius1*(float)Math.sin(2D*Math.PI/8D*i), 0.5F+radius1*0.5F*radius2*(float)Math.cos(2D*Math.PI/8D*i)};
+ outervertexes2[i] = new double[] {1d, 0.5F+0.5F*(float)Math.sin(2D*Math.PI/8D*i), 0.5F+0.5F*(float)Math.cos(2D*Math.PI/8D*i)};
+ innervertexes2[i] = new double[] {1d, 0.5F+0.5F*radius1*(float)Math.sin(2D*Math.PI/8D*i), 0.5F+radius1*0.5F*(float)Math.cos(2D*Math.PI/8D*i)};
+ break;
+ default:
+ outervertexes1[i] = new double[] {0.5F+0.5F*(float)Math.cos(2D*Math.PI/8D*i), 0d, 0.5F+0.5F*(float)Math.sin(2D*Math.PI/8D*i)};
+ innervertexes1[i] = new double[] {0.5F+radius1*0.5F*(float)Math.cos(2D*Math.PI/8D*i), 0d, 0.5F+0.5F*radius1*(float)Math.sin(2D*Math.PI/8D*i)};
+ outervertexes2[i] = new double[] {0.5F+0.5F*radius2*(float)Math.cos(2D*Math.PI/8D*i), 1d, 0.5F+0.5F*radius2*(float)Math.sin(2D*Math.PI/8D*i)};
+ innervertexes2[i] = new double[] {0.5F+radius1*radius2*0.5F*(float)Math.cos(2D*Math.PI/8D*i), 1d, 0.5F+0.5F*radius2*radius1*(float)Math.sin(2D*Math.PI/8D*i)};
+ break;
+ }
+
+ }
+ else
+ {
+ switch(direction1)
+ {
+ case UP:
+ outervertexes1[i] = new double[] {0.5F+0.25F*radius2*(float)Math.cos(2D*Math.PI/8D*i+Math.PI), 1d, 0.5F-0.25F*radius2*(float)Math.sin(2D*Math.PI/8D*i+Math.PI)};
+ innervertexes1[i] = new double[] {0.5F+radius1*radius2*0.25F*(float)Math.cos(2D*Math.PI/8D*i+Math.PI), 1d, 0.5F-0.25F*radius1*radius2*(float)Math.sin(2D*Math.PI/8D*i+Math.PI)};
+ break;
+ case DOWN:
+ outervertexes1[i] = new double[] {0.5F+0.25F*(float)Math.cos(2D*Math.PI/8D*i), 0d, 0.5F+0.25F*(float)Math.sin(2D*Math.PI/8D*i)};
+ innervertexes1[i] = new double[] {0.5F+radius1*0.25F*(float)Math.cos(2D*Math.PI/8D*i), 0d, 0.5F+0.25F*radius1*(float)Math.sin(2D*Math.PI/8D*i)};
+ break;
+ case SOUTH:
+ outervertexes1[i] = new double[] {0.5F+0.25F*(float)Math.cos(2D*Math.PI/8D*i), 0.5F+0.25F*(float)Math.sin(2D*Math.PI/8D*i), 1d};
+ innervertexes1[i] = new double[] {0.5F+radius1*0.25F*(float)Math.cos(2D*Math.PI/8D*i), 0.5F+0.25F*radius1*(float)Math.sin(2D*Math.PI/8D*i), 1d};
+ break;
+ case NORTH:
+ outervertexes1[i] = new double[] {0.5F+0.25F*radius2*(float)Math.cos(2D*Math.PI/8D*i), 0.5F+0.25F*radius2*(float)Math.sin(2D*Math.PI/8D*i), 1d};
+ innervertexes1[i] = new double[] {0.5F+radius1*radius2*0.25F*(float)Math.cos(2D*Math.PI/8D*i), 0.5F+0.25F*radius1*radius2*(float)Math.sin(2D*Math.PI/8D*i), 1d};
+ break;
+ case EAST:
+ outervertexes1[i] = new double[] {0d, 0.5F+0.25F*(float)Math.sin(2D*Math.PI/8D*i), 0.5F+0.25F*(float)Math.cos(2D*Math.PI/8D*i)};
+ innervertexes1[i] = new double[] {0d, 0.5F+0.25F*radius1*(float)Math.sin(2D*Math.PI/8D*i), 0.5F+radius1*0.25F*(float)Math.cos(2D*Math.PI/8D*i)};
+ break;
+ case WEST:
+ outervertexes1[i] = new double[] {0d, 0.5F+0.25F*radius2*(float)Math.sin(2D*Math.PI/8D*i), 0.5F+0.52F*radius2*(float)Math.cos(2D*Math.PI/8D*i)};
+ innervertexes1[i] = new double[] {0d, 0.5F+0.25F*radius2*radius1*(float)Math.sin(2D*Math.PI/8D*i), 0.5F+radius1*0.25F*radius2*(float)Math.cos(2D*Math.PI/8D*i)};
+ break;
+ default:
+ outervertexes1[i] = new double[] {0d, 0.5F+0.25F*radius2*(float)Math.sin(2D*Math.PI/8D*i), 0.5F+0.52F*radius2*(float)Math.cos(2D*Math.PI/8D*i)};
+ innervertexes1[i] = new double[] {0d, 0.5F+0.25F*radius2*radius1*(float)Math.sin(2D*Math.PI/8D*i), 0.5F+radius1*0.25F*radius2*(float)Math.cos(2D*Math.PI/8D*i)};
+ break;
+ }
+
+ switch(direction2)
+ {
+ case UP:
+ outervertexes2[i] = new double[] {0.5F+0.5F*radius2*(float)Math.cos(2D*Math.PI/8D*i), 1d, 0.5F+0.5F*radius2*(float)Math.sin(2D*Math.PI/8D*i)};
+ innervertexes2[i] = new double[] {0.5F+radius1*radius2*0.5F*(float)Math.cos(2D*Math.PI/8D*i), 1d, 0.5F+0.5F*radius2*radius1*(float)Math.sin(2D*Math.PI/8D*i)};
+ break;
+ case DOWN:
+ outervertexes2[i] = new double[] {0.5F+0.5F*(float)Math.cos(2D*Math.PI/8D*i), 1d, 0.5F+0.5F*(float)Math.sin(2D*Math.PI/8D*i)};
+ innervertexes2[i] = new double[] {0.5F+radius1*0.5F*(float)Math.cos(2D*Math.PI/8D*i), 1d, 0.5F+0.5F*radius1*(float)Math.sin(2D*Math.PI/8D*i)};
+ break;
+ case WEST:
+ outervertexes2[i] = new double[] {1d, 0.5F+0.25F*(float)Math.cos(2D*Math.PI/8D*i), 0.5F-0.25F*(float)Math.sin(2D*Math.PI/8D*i)};
+ innervertexes2[i] = new double[] {1d, 0.5F+radius1*0.25F*(float)Math.cos(2D*Math.PI/8D*i), 0.5F-0.25F*radius1*(float)Math.sin(2D*Math.PI/8D*i)};
+ break;
+ case EAST:
+ outervertexes2[i] = new double[] {0d, 0.5F+0.25F*(float)Math.cos(2D*Math.PI/8D*i), 0.5F+0.25F*(float)Math.sin(2D*Math.PI/8D*i)};
+ innervertexes2[i] = new double[] {0d, 0.5F+radius1*0.25F*(float)Math.cos(2D*Math.PI/8D*i), 0.5F+0.25F*radius1*(float)Math.sin(2D*Math.PI/8D*i)};
+ break;
+ case NORTH:
+ outervertexes2[i] = new double[] {0.5F+0.25F*(float)Math.cos(2D*Math.PI/8D*i), 1d-0.5F-0.25F*(float)Math.sin(2D*Math.PI/8D*i), 1d};
+ innervertexes2[i] = new double[] {0.5F+radius1*0.25F*(float)Math.cos(2D*Math.PI/8D*i), 1d-0.5F-0.25F*radius1*(float)Math.sin(2D*Math.PI/8D*i), 1d};
+ break;
+ case SOUTH:
+ outervertexes2[i] = new double[] {0.5F+0.25F*(float)Math.cos(2D*Math.PI/8D*i), 0.5F+0.25F*(float)Math.sin(2D*Math.PI/8D*i), 0d};
+ innervertexes2[i] = new double[] {0.5F+radius1*0.25F*(float)Math.cos(2D*Math.PI/8D*i), 0.5F+0.25F*radius1*(float)Math.sin(2D*Math.PI/8D*i), 0d};
+ break;
+ default:
+ outervertexes2[i] = new double[] {0.5F+0.5F*radius2*(float)Math.cos(2D*Math.PI/8D*i), 1d, 0.5F+0.5F*radius2*(float)Math.sin(2D*Math.PI/8D*i)};
+ innervertexes2[i] = new double[] {0.5F+radius1*radius2*0.5F*(float)Math.cos(2D*Math.PI/8D*i), 1d, 0.5F+0.5F*radius2*radius1*(float)Math.sin(2D*Math.PI/8D*i)};
+ break;
+ }
+
+ }
+ }
+ double[][][] quadList = new double[32][4][3];
+ for(i=0;i<32;i++)
+ {
+ if(i<7)
+ {
+ quadList[i]=new double[][] {outervertexes1[i],outervertexes1[i+1],innervertexes1[i+1],innervertexes1[i]};
+ }
+ else if(i==7)
+ {
+ quadList[i]=new double[][] {outervertexes1[i],outervertexes1[0],innervertexes1[0],innervertexes1[i]};
+ }
+ else if(i<15)
+ {
+ quadList[i]=new double[][] {innervertexes2[i-8],innervertexes2[i+1-8],outervertexes2[i+1-8],outervertexes2[i-8]};
+ }
+ else if(i==15)
+ {
+ quadList[i]=new double[][] {innervertexes2[i-8],innervertexes2[0],outervertexes2[0],outervertexes2[i-8]};
+ }
+ else if(i<23)
+ {
+ quadList[i]=new double[][] {outervertexes1[i-16],outervertexes2[i-16],outervertexes2[i-16+1],outervertexes1[i-16+1]};
+ }
+ else if(i==23)
+ {
+ quadList[i]=new double[][] {outervertexes1[i-16],outervertexes2[i-16],outervertexes2[0],outervertexes1[0]};
+ }
+ else if(i<31)
+ {
+ quadList[i]=new double[][] {innervertexes1[i-24+1],innervertexes2[i-24+1], innervertexes2[i-24], innervertexes1[i-24]};
+ }
+ else if(i==31)
+ {
+ quadList[i]=new double[][] {innervertexes1[0],innervertexes2[0],innervertexes2[i-24],innervertexes1[i-24]};
+ }
+ }
+ for(i=0;i<32;i++)
+ {
+ this.drawSquare(xPos, yPos, zPos, quadList[i], icon);
+ }
+
+
+ }
+ public void drawPipe(double xPos, double yPos, double zPos, ForgeDirection direction1, double radius1, double radius2, IIcon icon)
+ {
+ this.drawKnee(xPos, yPos, zPos, direction1, direction1, radius1, radius2, icon);
+ }
+
+ public void drawSquare(double xPos, double yPos, double zPos, double[][] vertexes, IIcon icon)
+ {
+ Tessellator var9 = Tessellator.instance;
+ double u1 = icon.getInterpolatedU(this.renderMinZ * 16.0D);
+ double u2 = icon.getInterpolatedU(this.renderMaxZ * 16.0D);
+ double v2 = icon.getInterpolatedV(16.0D - this.renderMaxY * 16.0D);
+ double v1 = icon.getInterpolatedV(16.0D - this.renderMinY * 16.0D);
+ if (this.renderMinZ < 0.0D || this.renderMaxZ > 1.0D)
+ {
+ u1 = icon.getMinU();
+ u2 = icon.getMaxU();
+ }
+ if (this.renderMinY < 0.0D || this.renderMaxY > 1.0D)
+ {
+ v2 = icon.getMinV();
+ v1 = icon.getMaxV();
+ }
+ double[] us = new double[]{u1,u1,u2,u2};
+ double[] vs = new double[]{v1,v2,v2,v1};
+ double xDelta=this.renderMaxX-this.renderMinX;
+ double yDelta=this.renderMaxY-this.renderMinY;
+ double zDelta=this.renderMaxZ-this.renderMinZ;
+ int startFrom=0;
+ int endTo=3;
+ if(this.renderFromInside)
+ {
+ startFrom=3;
+ endTo=0;
+ }
+ for(int i=startFrom;(i<=endTo&&!this.renderFromInside)||(i>=endTo&&this.renderFromInside);i+=(endTo-startFrom)/3)
+ {
+ double vX=vertexes[i][0]*xDelta+this.renderMinX;
+ double vY=vertexes[i][1]*yDelta+this.renderMinY;
+ double vZ=vertexes[i][2]*zDelta+this.renderMinZ;
+ double[] vYZ=null;
+ double[] vXZ=null;
+ double[] vXY=null;
+ if(this.rotationX!=0)
+ {
+ vYZ = this.rotateCoordinateByAngle(vY-(this.rotationPointY-8f)*scale, vZ-(this.rotationPointZ+8f)*scale, this.rotationX);
+ vY=vYZ[0]+(this.rotationPointY-8f)*scale;
+ vZ=vYZ[1]+(this.rotationPointZ+8f)*scale;
+ }
+ if(this.rotationY!=0)
+ {
+ vXZ = this.rotateCoordinateByAngle(vX-(this.rotationPointX+8f)*scale, vZ-(this.rotationPointZ+8f)*scale, this.rotationY);
+ vX=vXZ[0]+(this.rotationPointX+8f)*scale;
+ vZ=vXZ[1]-(this.rotationPointZ+8f)*scale;
+ }
+ if(this.rotationZ!=0)
+ {
+ vXY = this.rotateCoordinateByAngle(vX-(this.rotationPointX+8f)*scale, vY-(this.rotationPointY-8f)*scale, this.rotationZ);
+ vX=vXY[0]+(this.rotationPointX+8f)*scale;
+ vY=vXY[1]+(this.rotationPointY-8f)*scale;
+ if(swappingAxisOrBoundsAffectRotationOnAxisZ())
+ {
+ vY-=(this.renderMaxZ-(this.rotationPointZ+8f))*scale*Math.sin(this.rotationZ);
+ }
+ }
+ if(this.swapXandY)
+ {
+ double var0 = vX;
+ vX=vY;
+ vY=var0;
+ }
+ if(this.swapXandZ)
+ {
+ double var0 = vX;
+ vX=vZ;
+ vZ=var0;
+ }
+ if(this.swapYandZ)
+ {
+ double var0 = vY;
+ vY=vZ;
+ vZ=var0;
+ }
+ var9.addVertexWithUV(xPos+vX, yPos+vY, zPos+vZ, us[i], vs[i]);
+ }
+ }
+
+ public void setRenderBounds(double minX, double minY, double minZ, double maxX, double maxY, double maxZ)
+ {
+ if(this.swapRenderBoundsX)
+ {
+ this.renderMinX = 1-maxX;
+ this.renderMaxX = 1-minX;
+ }
+ else
+ {
+ this.renderMinX = minX;
+ this.renderMaxX = maxX;
+ }
+ if(this.swapRenderBoundsY)
+ {
+ this.renderMinY = 1-maxY;
+ this.renderMaxY = 1-minY;
+ }
+ else
+ {
+ this.renderMinY = minY;
+ this.renderMaxY = maxY;
+ }
+ if(this.swapRenderBoundsZ)
+ {
+ this.renderMinZ = 1-maxZ;
+ this.renderMaxZ = 1-minZ;
+ }
+ else
+ {
+ this.renderMinZ = minZ;
+ this.renderMaxZ = maxZ;
+ }
+ }
+
+ public void setRotationPoint(float rX, float rY, float rZ)
+ {
+ this.rotationPointX=rX;
+ this.rotationPointY=rY;
+ this.rotationPointZ=rZ;
+ }
+
+ public void setPosition(double xPos, double yPos, double zPos)
+ {
+ this.renderPositionX=xPos;
+ this.renderPositionY=yPos;
+ this.renderPositionZ=zPos;
+ }
+
+ public void drawPipe(float fx,float fy,float fz, int xSize,int ySize,int zSize, float radius1, float radius2, ForgeDirection direction, IIcon icon)
+ {
+ this.setRenderBoundsFromModel(fx, fy, fz, xSize, ySize, zSize);
+ this.drawPipe(renderPositionX,renderPositionY, renderPositionZ, direction, radius1, radius2, icon);
+ }
+
+ public void drawKnee(float fx,float fy,float fz, int xSize,int ySize,int zSize, float radius1, float radius2, ForgeDirection direction1, ForgeDirection direction2, IIcon icon)
+ {
+ this.setRenderBoundsFromModel(fx, fy, fz, xSize, ySize, zSize);
+ this.drawKnee(renderPositionX,renderPositionY, renderPositionZ, direction1, direction2, radius1, radius2, icon);
+ }
+
+ public void drawBox(float fx,float fy,float fz, int xSize,int ySize,int zSize, Block block, int meta, RenderBlocks blockRenderer)
+ {
+ this.setRenderBoundsFromModel(fx, fy, fz, xSize, ySize, zSize);
+ blockRenderer.renderStandardBlock(block, (int)this.renderPositionX, (int)this.renderPositionY, (int)this.renderPositionZ);
+ }
+
+ public void setRenderBoundsFromModel(float fx,float fy,float fz, int xSize,int ySize,int zSize)
+ {
+ float boundMinX=(-this.rotationPointX+8f-fx-xSize)*scale;
+ float boundMaxX=(-this.rotationPointX+8f-fx)*scale;
+ float boundMinZ=(-this.rotationPointZ+8f-fz-zSize)*scale;
+ float boundMaxZ=(-this.rotationPointZ+8f-fz)*scale;
+ float boundMinY=(this.rotationPointY-8f-fy-ySize)*scale;
+ float boundMaxY=(this.rotationPointY-8f-fy)*scale;
+ this.setRenderBounds(boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ);
+ }
+
+ public double[] rotateCoordinateByAngle(double coord1, double coord2, double angle)
+ {
+ double r = Math.sqrt(coord2*coord2+coord1*coord1);
+ double alpha0=Math.asin(coord2/r);
+ if(coord1<0d)
+ {
+ alpha0=Math.PI-Math.asin(coord2/r);
+ }
+ double alpha2=alpha0+angle;
+ double coord21=Math.sin(alpha2)*r;
+ double coord11=Math.cos(alpha2)*r;
+ return new double[]{coord11,coord21};
+ }
+
+ public void setRotation(float rotationX1, float rotationY1, float rotationZ1)
+ {
+ if(this.swapRenderBoundsX)
+ {
+ this.rotationX=-rotationX1;
+ }
+ else
+ {
+ this.rotationX=rotationX1;
+ }
+ if(this.swapRenderBoundsY)
+ {
+ this.rotationY=-rotationY1;
+ }
+ else
+ {
+ this.rotationY=rotationY1;
+ }
+ if(swappingAxisOrBoundsAffectRotationOnAxisZ())
+ {
+ this.rotationZ=-rotationZ1;
+ }
+ else
+ {
+ this.rotationZ=rotationZ1;
+ }
+// this.rotationX=rotationX1;
+ // this.rotationY=rotationY1;
+ //this.rotationZ=rotationZ1;
+ }
+
+ public void reset()
+ {
+ this.renderFromInside=false;
+ this.swapXandZ=false;
+ this.swapXandY=false;
+ this.swapYandZ=false;
+ this.swapRenderBoundsX=false;
+ this.swapRenderBoundsY=false;
+ this.swapRenderBoundsZ=false;
+ this.setRotation(0f, 0f, 0f);
+ this.setRotationPoint(0f, 0f, 0f);
+ }
+
+ private boolean swappingAxisOrBoundsAffectRotationOnAxisZ()
+ {
+ return (this.swapRenderBoundsZ && !this.swapXandZ && !this.swapYandZ)||
+ (this.swapRenderBoundsX && this.swapXandZ) ||
+ (this.swapRenderBoundsY && this.swapYandZ);
+ }
+
+ public List<String> splitStringByWidth(String string, int stringWidth)
+ {
+ List<String> output = new ArrayList();
+ StringBuffer sb = new StringBuffer();
+ String[] splittedBySpaces = string.split(" ");
+ int arrayIndex=0;
+ for(String word:splittedBySpaces)
+ {
+ if(!word.contains("/n") && getStringWidth(sb)+getStringWidth(word)<stringWidth)
+ {
+ sb.append(word);
+ sb.append(" ");
+ }
+ else
+ {
+ output.add(sb.toString());
+ sb.delete(0, sb.length());
+ arrayIndex++;
+ if(!word.contains("/n"))
+ {
+ sb.append(word);
+ sb.append(" ");
+ }
+ else
+ {
+ sb.append(" ");
+ }
+ }
+ }
+ output.add(sb.toString());
+ return output;
+ }
+
+ public int getStringWidth(StringBuffer sb)
+ {
+ return getStringWidth(sb.toString());
+ }
+
+ public int getStringWidth(String sb)
+ {
+ return Minecraft.getMinecraft().fontRenderer.getStringWidth(sb);
+ }
+
+ @SubscribeEvent
+ public void drawBlockSelectionBox(DrawBlockHighlightEvent event)
+ {
+ if(event.target!=null && event.target.typeOfHit.equals(MovingObjectPosition.MovingObjectType.BLOCK))
+ {
+ WorldClient world = Minecraft.getMinecraft().theWorld;
+ TileEntity te = world.getTileEntity(event.target.blockX, event.target.blockY, event.target.blockZ);
+ if(te!=null)
+ {
+ IHLMod.proxy.renderTESpecialSelectionBox(te, event.player,event.currentItem,event.target,event.partialTicks) ;
+ }
+ }
+ }
+
+}
|