From 7224ac4299098c70efae9dbd04c50a97e3f5f583 Mon Sep 17 00:00:00 2001 From: Blood Asp Date: Thu, 23 Apr 2015 18:14:22 +0200 Subject: Initial Commit --- .../gregtech/common/render/GT_CapeRenderer.java | 111 ++++ .../render/GT_MetaGenerated_Item_Renderer.java | 190 ++++++ .../render/GT_MetaGenerated_Tool_Renderer.java | 214 +++++++ .../java/gregtech/common/render/GT_RenderUtil.java | 42 ++ .../gregtech/common/render/GT_Renderer_Block.java | 657 +++++++++++++++++++++ .../common/render/GT_Renderer_Entity_Arrow.java | 29 + 6 files changed, 1243 insertions(+) create mode 100644 main/java/gregtech/common/render/GT_CapeRenderer.java create mode 100644 main/java/gregtech/common/render/GT_MetaGenerated_Item_Renderer.java create mode 100644 main/java/gregtech/common/render/GT_MetaGenerated_Tool_Renderer.java create mode 100644 main/java/gregtech/common/render/GT_RenderUtil.java create mode 100644 main/java/gregtech/common/render/GT_Renderer_Block.java create mode 100644 main/java/gregtech/common/render/GT_Renderer_Entity_Arrow.java (limited to 'main/java/gregtech/common/render') diff --git a/main/java/gregtech/common/render/GT_CapeRenderer.java b/main/java/gregtech/common/render/GT_CapeRenderer.java new file mode 100644 index 0000000000..efa384aa59 --- /dev/null +++ b/main/java/gregtech/common/render/GT_CapeRenderer.java @@ -0,0 +1,111 @@ +/* 1: */ package gregtech.common.render; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.util.GT_Log; +/* 5: */ import gregtech.api.util.GT_Utility; + +/* 6: */ import java.util.Collection; + +/* 7: */ import net.minecraft.client.entity.AbstractClientPlayer; +/* 8: */ import net.minecraft.client.model.ModelBiped; +/* 9: */ import net.minecraft.client.renderer.entity.RenderManager; +/* 10: */ import net.minecraft.client.renderer.entity.RenderPlayer; +/* 11: */ import net.minecraft.potion.Potion; +/* 12: */ import net.minecraft.util.MathHelper; +/* 13: */ import net.minecraft.util.ResourceLocation; +import net.minecraftforge.client.event.RenderPlayerEvent; +/* 14: */ import net.minecraftforge.client.event.RenderPlayerEvent.Specials.Pre; + +/* 15: */ import org.lwjgl.opengl.GL11; +/* 16: */ +/* 17: */ public class GT_CapeRenderer +/* 18: */ extends RenderPlayer +/* 19: */ { +/* 20:22 */ private final ResourceLocation[] mCapes = { new ResourceLocation("gregtech:textures/BrainTechCape.png"), new ResourceLocation("gregtech:textures/GregTechCape.png"), new ResourceLocation("gregtech:textures/MrBrainCape.png"), new ResourceLocation("gregtech:textures/GregoriusCape.png") }; +/* 21: */ private final Collection mCapeList; +/* 22: */ +/* 23: */ public GT_CapeRenderer(Collection aCapeList) +/* 24: */ { +/* 25:26 */ this.mCapeList = aCapeList; +/* 26:27 */ setRenderManager(RenderManager.instance); +/* 27: */ } +/* 28: */ +/* 29: */ public void receiveRenderSpecialsEvent(RenderPlayerEvent.Specials.Pre aEvent) +/* 30: */ { +/* 31:31 */ AbstractClientPlayer aPlayer = (AbstractClientPlayer)aEvent.entityPlayer; +/* 32:32 */ if (GT_Utility.getFullInvisibility(aPlayer)) +/* 33: */ { +/* 34:32 */ aEvent.setCanceled(true);return; +/* 35: */ } +/* 36:33 */ float aPartialTicks = aEvent.partialRenderTick; +/* 37:35 */ if (aPlayer.isInvisible()) { +/* 38:35 */ return; +/* 39: */ } +/* 40:36 */ if (GT_Utility.getPotion(aPlayer, Integer.valueOf(Potion.invisibility.id).intValue())) { +/* 41:36 */ return; +/* 42: */ } +/* 43: */ try +/* 44: */ { +/* 45:39 */ ResourceLocation tResource = null; +/* 46:41 */ if (aPlayer.getDisplayName().equalsIgnoreCase("Friedi4321")) { +/* 47:41 */ tResource = this.mCapes[0]; +/* 48: */ } +/* 49:42 */ if (this.mCapeList.contains(aPlayer.getDisplayName().toLowerCase())) { +/* 50:42 */ tResource = this.mCapes[1]; +/* 51: */ } +/* 52:43 */ if (aPlayer.getDisplayName().equalsIgnoreCase("Mr_Brain")) { +/* 53:43 */ tResource = this.mCapes[2]; +/* 54: */ } +/* 55:44 */ if (aPlayer.getDisplayName().equalsIgnoreCase("GregoriusT")) { +/* 56:44 */ tResource = this.mCapes[3]; +/* 57: */ } +/* 58:46 */ if ((tResource != null) && (!aPlayer.getHideCape())) +/* 59: */ { +/* 60:47 */ bindTexture(tResource); +/* 61:48 */ GL11.glPushMatrix(); +/* 62:49 */ GL11.glTranslatef(0.0F, 0.0F, 0.125F); +/* 63:50 */ double d0 = aPlayer.field_71091_bM + (aPlayer.field_71094_bP - aPlayer.field_71091_bM) * aPartialTicks - (aPlayer.prevPosX + (aPlayer.posX - aPlayer.prevPosX) * aPartialTicks); +/* 64:51 */ double d1 = aPlayer.field_71096_bN + (aPlayer.field_71095_bQ - aPlayer.field_71096_bN) * aPartialTicks - (aPlayer.prevPosY + (aPlayer.posY - aPlayer.prevPosY) * aPartialTicks); +/* 65:52 */ double d2 = aPlayer.field_71097_bO + (aPlayer.field_71085_bR - aPlayer.field_71097_bO) * aPartialTicks - (aPlayer.prevPosZ + (aPlayer.posZ - aPlayer.prevPosZ) * aPartialTicks); +/* 66:53 */ float f6 = aPlayer.prevRenderYawOffset + (aPlayer.renderYawOffset - aPlayer.prevRenderYawOffset) * aPartialTicks; +/* 67:54 */ double d3 = MathHelper.sin(f6 * 3.141593F / 180.0F); +/* 68:55 */ double d4 = -MathHelper.cos(f6 * 3.141593F / 180.0F); +/* 69:56 */ float f7 = (float)d1 * 10.0F; +/* 70:57 */ float f8 = (float)(d0 * d3 + d2 * d4) * 100.0F; +/* 71:58 */ float f9 = (float)(d0 * d4 - d2 * d3) * 100.0F; +/* 72:59 */ if (f7 < -6.0F) { +/* 73:59 */ f7 = -6.0F; +/* 74: */ } +/* 75:60 */ if (f7 > 32.0F) { +/* 76:60 */ f7 = 32.0F; +/* 77: */ } +/* 78:61 */ if (f8 < 0.0F) { +/* 79:61 */ f8 = 0.0F; +/* 80: */ } +/* 81:62 */ float f10 = aPlayer.prevCameraYaw + (aPlayer.cameraYaw - aPlayer.prevCameraYaw) * aPartialTicks; +/* 82:63 */ f7 += MathHelper.sin((aPlayer.prevDistanceWalkedModified + (aPlayer.distanceWalkedModified - aPlayer.prevDistanceWalkedModified) * aPartialTicks) * 6.0F) * 32.0F * f10; +/* 83:64 */ if (aPlayer.isSneaking()) { +/* 84:65 */ f7 += 25.0F; +/* 85: */ } +/* 86:67 */ GL11.glRotatef(6.0F + f8 / 2.0F + f7, 1.0F, 0.0F, 0.0F); +/* 87:68 */ GL11.glRotatef(f9 / 2.0F, 0.0F, 0.0F, 1.0F); +/* 88:69 */ GL11.glRotatef(-f9 / 2.0F, 0.0F, 1.0F, 0.0F); +/* 89:70 */ GL11.glRotatef(180.0F, 0.0F, 1.0F, 0.0F); +/* 90:71 */ ((ModelBiped)this.mainModel).renderCloak(0.0625F); +/* 91:72 */ GL11.glPopMatrix(); +/* 92: */ } +/* 93: */ } +/* 94: */ catch (Throwable e) +/* 95: */ { +/* 96:75 */ if (GT_Values.D1) { +/* 97:75 */ e.printStackTrace(GT_Log.err); +/* 98: */ } +/* 99: */ } +/* :0: */ } +/* :1: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.render.GT_CapeRenderer + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/common/render/GT_MetaGenerated_Item_Renderer.java b/main/java/gregtech/common/render/GT_MetaGenerated_Item_Renderer.java new file mode 100644 index 0000000000..1c17737cc5 --- /dev/null +++ b/main/java/gregtech/common/render/GT_MetaGenerated_Item_Renderer.java @@ -0,0 +1,190 @@ +/* 1: */ package gregtech.common.render; +/* 2: */ +/* 3: */ import gregtech.api.interfaces.IIconContainer; +/* 4: */ import gregtech.api.items.GT_MetaGenerated_Item; +/* 5: */ import gregtech.api.util.GT_Utility; +/* 6: */ import java.util.Collection; +/* 7: */ import java.util.HashMap; +/* 8: */ import java.util.Iterator; +/* 9: */ import net.minecraft.client.Minecraft; +/* 10: */ import net.minecraft.client.renderer.ItemRenderer; +/* 11: */ import net.minecraft.client.renderer.Tessellator; +/* 12: */ import net.minecraft.client.renderer.entity.RenderItem; +/* 13: */ import net.minecraft.client.renderer.texture.TextureManager; +/* 14: */ import net.minecraft.client.renderer.texture.TextureMap; +/* 15: */ import net.minecraft.item.ItemStack; +/* 16: */ import net.minecraft.util.IIcon; +/* 17: */ import net.minecraftforge.client.IItemRenderer; +/* 18: */ import net.minecraftforge.client.IItemRenderer.ItemRenderType; +/* 19: */ import net.minecraftforge.client.IItemRenderer.ItemRendererHelper; +/* 20: */ import net.minecraftforge.client.MinecraftForgeClient; +/* 21: */ import net.minecraftforge.fluids.Fluid; +/* 22: */ import net.minecraftforge.fluids.FluidStack; +/* 23: */ import org.lwjgl.opengl.GL11; +/* 24: */ +/* 25: */ public class GT_MetaGenerated_Item_Renderer +/* 26: */ implements IItemRenderer +/* 27: */ { +/* 28: */ public GT_MetaGenerated_Item_Renderer() +/* 29: */ { +/* 30: */ GT_MetaGenerated_Item tItem; +/* 31: 21 */ for (Iterator i$ = GT_MetaGenerated_Item.sInstances.values().iterator(); i$.hasNext(); MinecraftForgeClient.registerItemRenderer(tItem, this)) +/* 32: */ { +/* 33: 21 */ tItem = (GT_MetaGenerated_Item)i$.next(); +/* 34: 21 */ if ((tItem == null) || (!tItem.useStandardMetaItemRenderer())) {} +/* 35: */ } +/* 36: */ } +/* 37: */ +/* 38: */ public boolean handleRenderType(ItemStack aStack, IItemRenderer.ItemRenderType aType) +/* 39: */ { +/* 40: 26 */ if ((GT_Utility.isStackInvalid(aStack)) || (aStack.getItemDamage() < 0)) { +/* 41: 26 */ return false; +/* 42: */ } +/* 43: 27 */ return (aType == IItemRenderer.ItemRenderType.EQUIPPED_FIRST_PERSON) || (aType == IItemRenderer.ItemRenderType.INVENTORY) || (aType == IItemRenderer.ItemRenderType.EQUIPPED) || (aType == IItemRenderer.ItemRenderType.ENTITY); +/* 44: */ } +/* 45: */ +/* 46: */ public boolean shouldUseRenderHelper(IItemRenderer.ItemRenderType aType, ItemStack aStack, IItemRenderer.ItemRendererHelper aHelper) +/* 47: */ { +/* 48: 32 */ if (GT_Utility.isStackInvalid(aStack)) { +/* 49: 32 */ return false; +/* 50: */ } +/* 51: 33 */ return aType == IItemRenderer.ItemRenderType.ENTITY; +/* 52: */ } +/* 53: */ +/* 54: */ public void renderItem(IItemRenderer.ItemRenderType type, ItemStack aStack, Object... data) +/* 55: */ { +/* 56: 38 */ if (GT_Utility.isStackInvalid(aStack)) { +/* 57: 38 */ return; +/* 58: */ } +/* 59: 39 */ short aMetaData = (short)aStack.getItemDamage(); +/* 60: 40 */ if (aMetaData < 0) { +/* 61: 40 */ return; +/* 62: */ } +/* 63: 41 */ GT_MetaGenerated_Item aItem = (GT_MetaGenerated_Item)aStack.getItem(); +/* 64: */ +/* 65: */ +/* 66: 44 */ GL11.glEnable(3042); +/* 67: 46 */ if (type == IItemRenderer.ItemRenderType.ENTITY) { +/* 68: 47 */ if (RenderItem.renderInFrame) +/* 69: */ { +/* 70: 48 */ GL11.glScalef(0.85F, 0.85F, 0.85F); +/* 71: 49 */ GL11.glRotatef(-90.0F, 0.0F, 1.0F, 0.0F); +/* 72: 50 */ GL11.glTranslated(-0.5D, -0.42D, 0.0D); +/* 73: */ } +/* 74: */ else +/* 75: */ { +/* 76: 52 */ GL11.glTranslated(-0.5D, -0.42D, 0.0D); +/* 77: */ } +/* 78: */ } +/* 79: 56 */ GL11.glColor3f(1.0F, 1.0F, 1.0F); +/* 80: 58 */ if (aMetaData < aItem.mOffset) +/* 81: */ { +/* 82: 59 */ IIconContainer aIcon = aItem.getIconContainer(aMetaData); +/* 83: 60 */ IIcon tOverlay = null;IIcon tFluidIcon = null; +/* 84: */ IIcon tIcon; +/* 86: 61 */ if (aIcon == null) +/* 87: */ { +/* 88: 62 */ tIcon = aStack.getIconIndex(); +/* 89: */ } +/* 90: */ else +/* 91: */ { +/* 92: 64 */ tIcon = aIcon.getIcon(); +/* 93: 65 */ tOverlay = aIcon.getOverlayIcon(); +/* 94: */ } +/* 95: 67 */ if (tIcon == null) { +/* 96: 67 */ return; +/* 97: */ } +/* 98: 68 */ FluidStack tFluid = GT_Utility.getFluidForFilledItem(aStack, true); +/* 99: 69 */ if ((tOverlay != null) && (tFluid != null) && (tFluid.getFluid() != null)) { +/* 100: 69 */ tFluidIcon = tFluid.getFluid().getIcon(tFluid); +/* 101: */ } +/* 102: 70 */ Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.locationItemsTexture); +/* 103: 71 */ GL11.glBlendFunc(770, 771); +/* 104: 72 */ if (tFluidIcon == null) +/* 105: */ { +/* 106: 73 */ short[] tModulation = aItem.getRGBa(aStack); +/* 107: 74 */ GL11.glColor3f(tModulation[0] / 255.0F, tModulation[1] / 255.0F, tModulation[2] / 255.0F); +/* 108: */ } +/* 109: 76 */ if (type.equals(IItemRenderer.ItemRenderType.INVENTORY)) { +/* 110: 76 */ GT_RenderUtil.renderItemIcon(tIcon, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F); +/* 111: */ } else { +/* 112: 76 */ ItemRenderer.renderItemIn2D(Tessellator.instance, tIcon.getMaxU(), tIcon.getMinV(), tIcon.getMinU(), tIcon.getMaxV(), tIcon.getIconWidth(), tIcon.getIconHeight(), 0.0625F); +/* 113: */ } +/* 114: 77 */ if (tFluidIcon != null) +/* 115: */ { +/* 116: 78 */ assert (tFluid != null); +/* 117: 79 */ int tColor = tFluid.getFluid().getColor(tFluid); +/* 118: 80 */ GL11.glColor3f((tColor >> 16 & 0xFF) / 255.0F, (tColor >> 8 & 0xFF) / 255.0F, (tColor & 0xFF) / 255.0F); +/* 119: 81 */ Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.locationBlocksTexture); +/* 120: 82 */ GL11.glBlendFunc(770, 771); +/* 121: 83 */ GL11.glDepthFunc(514); +/* 122: 84 */ if (type.equals(IItemRenderer.ItemRenderType.INVENTORY)) { +/* 123: 84 */ GT_RenderUtil.renderItemIcon(tFluidIcon, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F); +/* 124: */ } else { +/* 125: 84 */ ItemRenderer.renderItemIn2D(Tessellator.instance, tFluidIcon.getMaxU(), tFluidIcon.getMinV(), tFluidIcon.getMinU(), tFluidIcon.getMaxV(), tFluidIcon.getIconWidth(), tFluidIcon.getIconHeight(), 0.0625F); +/* 126: */ } +/* 127: 85 */ GL11.glDepthFunc(515); +/* 128: */ } +/* 129: 87 */ GL11.glColor3f(1.0F, 1.0F, 1.0F); +/* 130: 88 */ if (tOverlay != null) +/* 131: */ { +/* 132: 89 */ Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.locationItemsTexture); +/* 133: 90 */ GL11.glBlendFunc(770, 771); +/* 134: 91 */ if (type.equals(IItemRenderer.ItemRenderType.INVENTORY)) { +/* 135: 91 */ GT_RenderUtil.renderItemIcon(tOverlay, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F); +/* 136: */ } else { +/* 137: 91 */ ItemRenderer.renderItemIn2D(Tessellator.instance, tOverlay.getMaxU(), tOverlay.getMinV(), tOverlay.getMinU(), tOverlay.getMaxV(), tOverlay.getIconWidth(), tOverlay.getIconHeight(), 0.0625F); +/* 138: */ } +/* 139: */ } +/* 140: */ } +/* 141: */ else +/* 142: */ { +/* 143: */ IIcon tIcon; +/* 145: 94 */ if (aItem.mIconList[(aMetaData - aItem.mOffset)].length > 1) +/* 146: */ { +/* 147: 95 */ Long[] tStats = (Long[])aItem.mElectricStats.get(Short.valueOf(aMetaData)); +/* 148: */ +/* 149: 96 */ if ((tStats != null) && (tStats[3].longValue() < 0L)) +/* 150: */ { +/* 151: 97 */ long tCharge = aItem.getRealCharge(aStack); +/* 152: */ +/* 153: 98 */ if (tCharge <= 0L) +/* 154: */ { +/* 155: 99 */ tIcon = aItem.mIconList[(aMetaData - aItem.mOffset)][1]; +/* 156: */ } +/* 157: */ else +/* 158: */ { +/* 159: */ +/* 160:100 */ if (tCharge >= tStats[0].longValue()) { +/* 161:101 */ tIcon = aItem.mIconList[(aMetaData - aItem.mOffset)][8]; +/* 162: */ } else { +/* 163:103 */ tIcon = aItem.mIconList[(aMetaData - aItem.mOffset)][(7 - (int)java.lang.Math.max(0L, java.lang.Math.min(5L, (tStats[0].longValue() - tCharge) * 6L / tStats[0].longValue())))]; +/* 164: */ } +/* 165: */ } +/* 166: */ } +/* 167: */ else +/* 168: */ { +/* 169:105 */ tIcon = aItem.mIconList[(aMetaData - aItem.mOffset)][0]; +/* 170: */ } +/* 171: */ } +/* 172: */ else +/* 173: */ { +/* 174:108 */ tIcon = aItem.mIconList[(aMetaData - aItem.mOffset)][0]; +/* 175: */ } +/* 176:110 */ Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.locationItemsTexture); +/* 177:111 */ GL11.glBlendFunc(770, 771); +/* 178:112 */ if (type.equals(IItemRenderer.ItemRenderType.INVENTORY)) { +/* 179:112 */ GT_RenderUtil.renderItemIcon(tIcon, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F); +/* 180: */ } else { +/* 181:112 */ ItemRenderer.renderItemIn2D(Tessellator.instance, tIcon.getMaxU(), tIcon.getMinV(), tIcon.getMinU(), tIcon.getMaxV(), tIcon.getIconWidth(), tIcon.getIconHeight(), 0.0625F); +/* 182: */ } +/* 183: */ } +/* 184:115 */ GL11.glDisable(3042); +/* 185: */ } +/* 186: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.render.GT_MetaGenerated_Item_Renderer + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/common/render/GT_MetaGenerated_Tool_Renderer.java b/main/java/gregtech/common/render/GT_MetaGenerated_Tool_Renderer.java new file mode 100644 index 0000000000..dca5de6342 --- /dev/null +++ b/main/java/gregtech/common/render/GT_MetaGenerated_Tool_Renderer.java @@ -0,0 +1,214 @@ +/* 1: */ package gregtech.common.render; +/* 2: */ +/* 3: */ import gregtech.api.enums.Materials; +/* 4: */ import gregtech.api.interfaces.IIconContainer; +/* 5: */ import gregtech.api.interfaces.IToolStats; +/* 6: */ import gregtech.api.items.GT_MetaGenerated_Tool; +/* 7: */ import gregtech.api.util.GT_Utility; +/* 8: */ import java.util.HashMap; +/* 9: */ import net.minecraft.client.Minecraft; +/* 10: */ import net.minecraft.client.renderer.ItemRenderer; +/* 11: */ import net.minecraft.client.renderer.Tessellator; +/* 12: */ import net.minecraft.client.renderer.entity.RenderItem; +/* 13: */ import net.minecraft.client.renderer.texture.TextureManager; +/* 14: */ import net.minecraft.item.ItemStack; +/* 15: */ import net.minecraft.util.IIcon; +/* 16: */ import net.minecraftforge.client.IItemRenderer; +/* 17: */ import net.minecraftforge.client.IItemRenderer.ItemRenderType; +/* 18: */ import net.minecraftforge.client.IItemRenderer.ItemRendererHelper; +/* 19: */ import net.minecraftforge.client.MinecraftForgeClient; +/* 20: */ import org.lwjgl.opengl.GL11; +/* 21: */ +/* 22: */ public class GT_MetaGenerated_Tool_Renderer +/* 23: */ implements IItemRenderer +/* 24: */ { +/* 25: */ public GT_MetaGenerated_Tool_Renderer() +/* 26: */ { +/* 27: 24 */ for (GT_MetaGenerated_Tool tItem : GT_MetaGenerated_Tool.sInstances.values()) { +/* 28: 24 */ if (tItem != null) { +/* 29: 24 */ MinecraftForgeClient.registerItemRenderer(tItem, this); +/* 30: */ } +/* 31: */ } +/* 32: */ } +/* 33: */ +/* 34: */ public boolean handleRenderType(ItemStack aStack, IItemRenderer.ItemRenderType aType) +/* 35: */ { +/* 36: 29 */ if ((GT_Utility.isStackInvalid(aStack)) || (aStack.getItemDamage() < 0)) { +/* 37: 29 */ return false; +/* 38: */ } +/* 39: 30 */ return (aType == IItemRenderer.ItemRenderType.EQUIPPED_FIRST_PERSON) || (aType == IItemRenderer.ItemRenderType.INVENTORY) || (aType == IItemRenderer.ItemRenderType.EQUIPPED) || (aType == IItemRenderer.ItemRenderType.ENTITY); +/* 40: */ } +/* 41: */ +/* 42: */ public boolean shouldUseRenderHelper(IItemRenderer.ItemRenderType aType, ItemStack aStack, IItemRenderer.ItemRendererHelper aHelper) +/* 43: */ { +/* 44: 35 */ if (GT_Utility.isStackInvalid(aStack)) { +/* 45: 35 */ return false; +/* 46: */ } +/* 47: 36 */ return aType == IItemRenderer.ItemRenderType.ENTITY; +/* 48: */ } +/* 49: */ +/* 50: */ public void renderItem(IItemRenderer.ItemRenderType aType, ItemStack aStack, Object... data) +/* 51: */ { +/* 52: 41 */ if (GT_Utility.isStackInvalid(aStack)) { +/* 53: 41 */ return; +/* 54: */ } +/* 55: 42 */ GT_MetaGenerated_Tool aItem = (GT_MetaGenerated_Tool)aStack.getItem(); +/* 56: 43 */ GL11.glEnable(3042); +/* 57: 45 */ if (aType == IItemRenderer.ItemRenderType.ENTITY) { +/* 58: 46 */ if (RenderItem.renderInFrame) +/* 59: */ { +/* 60: 47 */ GL11.glScalef(0.85F, 0.85F, 0.85F); +/* 61: 48 */ GL11.glRotatef(-90.0F, 0.0F, 1.0F, 0.0F); +/* 62: 49 */ GL11.glTranslated(-0.5D, -0.42D, 0.0D); +/* 63: */ } +/* 64: */ else +/* 65: */ { +/* 66: 51 */ GL11.glTranslated(-0.5D, -0.42D, 0.0D); +/* 67: */ } +/* 68: */ } +/* 69: 55 */ GL11.glColor3f(1.0F, 1.0F, 1.0F); +/* 70: */ +/* 71: 57 */ IToolStats tToolStats = aItem.getToolStats(aStack); +/* 72: 58 */ if (tToolStats != null) +/* 73: */ { +/* 74: 59 */ IIconContainer aIcon = tToolStats.getIcon(false, aStack); +/* 75: 60 */ if (aIcon != null) +/* 76: */ { +/* 77: 61 */ IIcon tIcon = aIcon.getIcon();IIcon tOverlay = aIcon.getOverlayIcon(); +/* 78: 62 */ if (tIcon != null) +/* 79: */ { +/* 80: 63 */ Minecraft.getMinecraft().renderEngine.bindTexture(aIcon.getTextureFile()); +/* 81: 64 */ GL11.glBlendFunc(770, 771); +/* 82: 65 */ short[] tModulation = tToolStats.getRGBa(false, aStack); +/* 83: 66 */ GL11.glColor3f(tModulation[0] / 255.0F, tModulation[1] / 255.0F, tModulation[2] / 255.0F); +/* 84: 67 */ if (aType.equals(IItemRenderer.ItemRenderType.INVENTORY)) { +/* 85: 67 */ GT_RenderUtil.renderItemIcon(tIcon, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F); +/* 86: */ } else { +/* 87: 67 */ ItemRenderer.renderItemIn2D(Tessellator.instance, tIcon.getMaxU(), tIcon.getMinV(), tIcon.getMinU(), tIcon.getMaxV(), tIcon.getIconWidth(), tIcon.getIconHeight(), 0.0625F); +/* 88: */ } +/* 89: 68 */ GL11.glColor3f(1.0F, 1.0F, 1.0F); +/* 90: */ } +/* 91: 70 */ if (tOverlay != null) +/* 92: */ { +/* 93: 71 */ Minecraft.getMinecraft().renderEngine.bindTexture(aIcon.getTextureFile()); +/* 94: 72 */ GL11.glBlendFunc(770, 771); +/* 95: 73 */ if (aType.equals(IItemRenderer.ItemRenderType.INVENTORY)) { +/* 96: 73 */ GT_RenderUtil.renderItemIcon(tOverlay, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F); +/* 97: */ } else { +/* 98: 73 */ ItemRenderer.renderItemIn2D(Tessellator.instance, tOverlay.getMaxU(), tOverlay.getMinV(), tOverlay.getMinU(), tOverlay.getMaxV(), tOverlay.getIconWidth(), tOverlay.getIconHeight(), 0.0625F); +/* 99: */ } +/* 100: */ } +/* 101: */ } +/* 102: 77 */ aIcon = tToolStats.getIcon(true, aStack); +/* 103: 78 */ if (aIcon != null) +/* 104: */ { +/* 105: 79 */ IIcon tIcon = aIcon.getIcon();IIcon tOverlay = aIcon.getOverlayIcon(); +/* 106: 80 */ if (tIcon != null) +/* 107: */ { +/* 108: 81 */ Minecraft.getMinecraft().renderEngine.bindTexture(aIcon.getTextureFile()); +/* 109: 82 */ GL11.glBlendFunc(770, 771); +/* 110: 83 */ short[] tModulation = tToolStats.getRGBa(true, aStack); +/* 111: 84 */ GL11.glColor3f(tModulation[0] / 255.0F, tModulation[1] / 255.0F, tModulation[2] / 255.0F); +/* 112: 85 */ if (aType.equals(IItemRenderer.ItemRenderType.INVENTORY)) { +/* 113: 85 */ GT_RenderUtil.renderItemIcon(tIcon, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F); +/* 114: */ } else { +/* 115: 85 */ ItemRenderer.renderItemIn2D(Tessellator.instance, tIcon.getMaxU(), tIcon.getMinV(), tIcon.getMinU(), tIcon.getMaxV(), tIcon.getIconWidth(), tIcon.getIconHeight(), 0.0625F); +/* 116: */ } +/* 117: 86 */ GL11.glColor3f(1.0F, 1.0F, 1.0F); +/* 118: */ } +/* 119: 88 */ if (tOverlay != null) +/* 120: */ { +/* 121: 89 */ Minecraft.getMinecraft().renderEngine.bindTexture(aIcon.getTextureFile()); +/* 122: 90 */ GL11.glBlendFunc(770, 771); +/* 123: 91 */ if (aType.equals(IItemRenderer.ItemRenderType.INVENTORY)) { +/* 124: 91 */ GT_RenderUtil.renderItemIcon(tOverlay, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F); +/* 125: */ } else { +/* 126: 91 */ ItemRenderer.renderItemIn2D(Tessellator.instance, tOverlay.getMaxU(), tOverlay.getMinV(), tOverlay.getMinU(), tOverlay.getMaxV(), tOverlay.getIconWidth(), tOverlay.getIconHeight(), 0.0625F); +/* 127: */ } +/* 128: */ } +/* 129: */ } +/* 130: 94 */ if ((aType == IItemRenderer.ItemRenderType.INVENTORY) && (GT_MetaGenerated_Tool.getPrimaryMaterial(aStack) != Materials._NULL)) +/* 131: */ { +/* 132: 95 */ long tDamage = GT_MetaGenerated_Tool.getToolDamage(aStack);long tMaxDamage = GT_MetaGenerated_Tool.getToolMaxDamage(aStack); +/* 133: 96 */ if (tDamage <= 0L) { +/* 134: 97 */ aIcon = gregtech.api.enums.Textures.ItemIcons.DURABILITY_BAR[8]; +/* 135: 98 */ } else if (tDamage >= tMaxDamage) { +/* 136: 99 */ aIcon = gregtech.api.enums.Textures.ItemIcons.DURABILITY_BAR[0]; +/* 137: */ } else { +/* 138:101 */ aIcon = gregtech.api.enums.Textures.ItemIcons.DURABILITY_BAR[((int)java.lang.Math.max(0L, java.lang.Math.min(7L, (tMaxDamage - tDamage) * 8L / tMaxDamage)))]; +/* 139: */ } +/* 140:103 */ if (aIcon != null) +/* 141: */ { +/* 142:104 */ IIcon tIcon = aIcon.getIcon();IIcon tOverlay = aIcon.getOverlayIcon(); +/* 143:105 */ if (tIcon != null) +/* 144: */ { +/* 145:106 */ Minecraft.getMinecraft().renderEngine.bindTexture(aIcon.getTextureFile()); +/* 146:107 */ GL11.glBlendFunc(770, 771); +/* 147:108 */ if (aType.equals(IItemRenderer.ItemRenderType.INVENTORY)) { +/* 148:108 */ GT_RenderUtil.renderItemIcon(tIcon, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F); +/* 149: */ } else { +/* 150:108 */ ItemRenderer.renderItemIn2D(Tessellator.instance, tIcon.getMaxU(), tIcon.getMinV(), tIcon.getMinU(), tIcon.getMaxV(), tIcon.getIconWidth(), tIcon.getIconHeight(), 0.0625F); +/* 151: */ } +/* 152: */ } +/* 153:110 */ if (tOverlay != null) +/* 154: */ { +/* 155:111 */ Minecraft.getMinecraft().renderEngine.bindTexture(aIcon.getTextureFile()); +/* 156:112 */ GL11.glBlendFunc(770, 771); +/* 157:113 */ if (aType.equals(IItemRenderer.ItemRenderType.INVENTORY)) { +/* 158:113 */ GT_RenderUtil.renderItemIcon(tOverlay, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F); +/* 159: */ } else { +/* 160:113 */ ItemRenderer.renderItemIn2D(Tessellator.instance, tOverlay.getMaxU(), tOverlay.getMinV(), tOverlay.getMinU(), tOverlay.getMaxV(), tOverlay.getIconWidth(), tOverlay.getIconHeight(), 0.0625F); +/* 161: */ } +/* 162: */ } +/* 163: */ } +/* 164:117 */ Long[] tStats = aItem.getElectricStats(aStack); +/* 165:118 */ if ((tStats != null) && (tStats[3].longValue() < 0L)) +/* 166: */ { +/* 167:119 */ long tCharge = aItem.getRealCharge(aStack); +/* 168:120 */ if (tCharge <= 0L) { +/* 169:121 */ aIcon = gregtech.api.enums.Textures.ItemIcons.ENERGY_BAR[0]; +/* 170:122 */ } else if (tCharge >= tStats[0].longValue()) { +/* 171:123 */ aIcon = gregtech.api.enums.Textures.ItemIcons.ENERGY_BAR[8]; +/* 172: */ } else { +/* 173:125 */ aIcon = gregtech.api.enums.Textures.ItemIcons.ENERGY_BAR[(7 - (int)java.lang.Math.max(0L, java.lang.Math.min(6L, (tStats[0].longValue() - tCharge) * 7L / tStats[0].longValue())))]; +/* 174: */ } +/* 175: */ } +/* 176: */ else +/* 177: */ { +/* 178:127 */ aIcon = null; +/* 179: */ } +/* 180:130 */ if (aIcon != null) +/* 181: */ { +/* 182:131 */ IIcon tIcon = aIcon.getIcon();IIcon tOverlay = aIcon.getOverlayIcon(); +/* 183:132 */ if (tIcon != null) +/* 184: */ { +/* 185:133 */ Minecraft.getMinecraft().renderEngine.bindTexture(aIcon.getTextureFile()); +/* 186:134 */ GL11.glBlendFunc(770, 771); +/* 187:135 */ if (aType.equals(IItemRenderer.ItemRenderType.INVENTORY)) { +/* 188:135 */ GT_RenderUtil.renderItemIcon(tIcon, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F); +/* 189: */ } else { +/* 190:135 */ ItemRenderer.renderItemIn2D(Tessellator.instance, tIcon.getMaxU(), tIcon.getMinV(), tIcon.getMinU(), tIcon.getMaxV(), tIcon.getIconWidth(), tIcon.getIconHeight(), 0.0625F); +/* 191: */ } +/* 192: */ } +/* 193:137 */ if (tOverlay != null) +/* 194: */ { +/* 195:138 */ Minecraft.getMinecraft().renderEngine.bindTexture(aIcon.getTextureFile()); +/* 196:139 */ GL11.glBlendFunc(770, 771); +/* 197:140 */ if (aType.equals(IItemRenderer.ItemRenderType.INVENTORY)) { +/* 198:140 */ GT_RenderUtil.renderItemIcon(tOverlay, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F); +/* 199: */ } else { +/* 200:140 */ ItemRenderer.renderItemIn2D(Tessellator.instance, tOverlay.getMaxU(), tOverlay.getMinV(), tOverlay.getMinU(), tOverlay.getMaxV(), tOverlay.getIconWidth(), tOverlay.getIconHeight(), 0.0625F); +/* 201: */ } +/* 202: */ } +/* 203: */ } +/* 204: */ } +/* 205: */ } +/* 206:145 */ GL11.glDisable(3042); +/* 207: */ } +/* 208: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.render.GT_MetaGenerated_Tool_Renderer + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/common/render/GT_RenderUtil.java b/main/java/gregtech/common/render/GT_RenderUtil.java new file mode 100644 index 0000000000..5eb73c4eca --- /dev/null +++ b/main/java/gregtech/common/render/GT_RenderUtil.java @@ -0,0 +1,42 @@ +/* 1: */ package gregtech.common.render; +/* 2: */ +/* 3: */ import net.minecraft.client.renderer.Tessellator; +/* 4: */ import net.minecraft.util.IIcon; +/* 5: */ +/* 6: */ public class GT_RenderUtil +/* 7: */ { +/* 8: */ public static void renderItemIcon(IIcon icon, double size, double z, float nx, float ny, float nz) +/* 9: */ { +/* 10: 8 */ renderItemIcon(icon, 0.0D, 0.0D, size, size, z, nx, ny, nz); +/* 11: */ } +/* 12: */ +/* 13: */ public static void renderItemIcon(IIcon icon, double xStart, double yStart, double xEnd, double yEnd, double z, float nx, float ny, float nz) +/* 14: */ { +/* 15:12 */ if (icon == null) { +/* 16:12 */ return; +/* 17: */ } +/* 18:13 */ Tessellator.instance.startDrawingQuads(); +/* 19:14 */ Tessellator.instance.setNormal(nx, ny, nz); +/* 20:15 */ if (nz > 0.0F) +/* 21: */ { +/* 22:16 */ Tessellator.instance.addVertexWithUV(xStart, yStart, z, icon.getMinU(), icon.getMinV()); +/* 23:17 */ Tessellator.instance.addVertexWithUV(xEnd, yStart, z, icon.getMaxU(), icon.getMinV()); +/* 24:18 */ Tessellator.instance.addVertexWithUV(xEnd, yEnd, z, icon.getMaxU(), icon.getMaxV()); +/* 25:19 */ Tessellator.instance.addVertexWithUV(xStart, yEnd, z, icon.getMinU(), icon.getMaxV()); +/* 26: */ } +/* 27: */ else +/* 28: */ { +/* 29:21 */ Tessellator.instance.addVertexWithUV(xStart, yEnd, z, icon.getMinU(), icon.getMaxV()); +/* 30:22 */ Tessellator.instance.addVertexWithUV(xEnd, yEnd, z, icon.getMaxU(), icon.getMaxV()); +/* 31:23 */ Tessellator.instance.addVertexWithUV(xEnd, yStart, z, icon.getMaxU(), icon.getMinV()); +/* 32:24 */ Tessellator.instance.addVertexWithUV(xStart, yStart, z, icon.getMinU(), icon.getMinV()); +/* 33: */ } +/* 34:26 */ Tessellator.instance.draw(); +/* 35: */ } +/* 36: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.render.GT_RenderUtil + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/common/render/GT_Renderer_Block.java b/main/java/gregtech/common/render/GT_Renderer_Block.java new file mode 100644 index 0000000000..b71c5abf97 --- /dev/null +++ b/main/java/gregtech/common/render/GT_Renderer_Block.java @@ -0,0 +1,657 @@ +package gregtech.common.render; + +import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler; +import cpw.mods.fml.client.registry.RenderingRegistry; +import gregtech.api.GregTech_API; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.interfaces.tileentity.IPipeRenderedTileEntity; +import gregtech.api.interfaces.tileentity.ITexturedTileEntity; +import gregtech.common.blocks.GT_Block_Machines; +import gregtech.common.blocks.GT_Block_Ores; +import gregtech.common.blocks.GT_TileEntity_Ores; +import net.minecraft.block.Block; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.IBlockAccess; +import org.lwjgl.opengl.GL11; + +public class GT_Renderer_Block + implements ISimpleBlockRenderingHandler +{ + public final int mRenderID; + public static GT_Renderer_Block INSTANCE; + + public GT_Renderer_Block() + { + this.mRenderID = RenderingRegistry.getNextAvailableRenderId(); + INSTANCE = this;RenderingRegistry.registerBlockHandler(this); + } + + public void renderInventoryBlock(Block aBlock, int aMeta, int aModelID, RenderBlocks aRenderer) + { + if ((aBlock instanceof GT_Block_Machines)) + { + if ((aMeta > 0) && (aMeta < GregTech_API.METATILEENTITIES.length) && (GregTech_API.METATILEENTITIES[aMeta] != null) && + (!GregTech_API.METATILEENTITIES[aMeta].renderInInventory(aBlock, aMeta, aRenderer))) { + renderNormalInventoryMetaTileEntity(aBlock, aMeta, aRenderer); + } + } + else if ((aBlock instanceof GT_Block_Ores)) + { + GT_TileEntity_Ores tTileEntity = new GT_TileEntity_Ores(); + tTileEntity.mMetaData = ((short)aMeta); + + aBlock.setBlockBoundsForItemRender(); + aRenderer.setRenderBoundsFromBlock(aBlock); + + GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F); + GL11.glTranslatef(-0.5F, -0.5F, -0.5F); + + Tessellator.instance.startDrawingQuads(); + Tessellator.instance.setNormal(0.0F, -1.0F, 0.0F); + renderNegativeYFacing(null, aRenderer, aBlock, 0, 0, 0, tTileEntity.getTexture((byte)0), true); + Tessellator.instance.draw(); + + Tessellator.instance.startDrawingQuads(); + Tessellator.instance.setNormal(0.0F, 1.0F, 0.0F); + renderPositiveYFacing(null, aRenderer, aBlock, 0, 0, 0, tTileEntity.getTexture((byte)1), true); + Tessellator.instance.draw(); + + Tessellator.instance.startDrawingQuads(); + Tessellator.instance.setNormal(0.0F, 0.0F, -1.0F); + renderNegativeZFacing(null, aRenderer, aBlock, 0, 0, 0, tTileEntity.getTexture((byte)2), true); + Tessellator.instance.draw(); + + Tessellator.instance.startDrawingQuads(); + Tessellator.instance.setNormal(0.0F, 0.0F, 1.0F); + renderPositiveZFacing(null, aRenderer, aBlock, 0, 0, 0, tTileEntity.getTexture((byte)3), true); + Tessellator.instance.draw(); + + Tessellator.instance.startDrawingQuads(); + Tessellator.instance.setNormal(-1.0F, 0.0F, 0.0F); + renderNegativeXFacing(null, aRenderer, aBlock, 0, 0, 0, tTileEntity.getTexture((byte)4), true); + Tessellator.instance.draw(); + + Tessellator.instance.startDrawingQuads(); + Tessellator.instance.setNormal(1.0F, 0.0F, 0.0F); + renderPositiveXFacing(null, aRenderer, aBlock, 0, 0, 0, tTileEntity.getTexture((byte)5), true); + Tessellator.instance.draw(); + } + aBlock.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F); + aRenderer.setRenderBoundsFromBlock(aBlock); + GL11.glTranslatef(0.5F, 0.5F, 0.5F); + } + + private static void renderNormalInventoryMetaTileEntity(Block aBlock, int aMeta, RenderBlocks aRenderer) + { + if ((aMeta <= 0) || (aMeta >= GregTech_API.METATILEENTITIES.length)) { + return; + } + IMetaTileEntity tMetaTileEntity = GregTech_API.METATILEENTITIES[aMeta]; + if (tMetaTileEntity == null) { + return; + } + aBlock.setBlockBoundsForItemRender(); + aRenderer.setRenderBoundsFromBlock(aBlock); + + GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F); + GL11.glTranslatef(-0.5F, -0.5F, -0.5F); + if ((tMetaTileEntity.getBaseMetaTileEntity() instanceof IPipeRenderedTileEntity)) + { + float tThickness = ((IPipeRenderedTileEntity)tMetaTileEntity.getBaseMetaTileEntity()).getThickNess();float sp = (1.0F - tThickness) / 2.0F; + + aBlock.setBlockBounds(0.0F, sp, sp, 1.0F, sp + tThickness, sp + tThickness); + aRenderer.setRenderBoundsFromBlock(aBlock); + + Tessellator.instance.startDrawingQuads(); + Tessellator.instance.setNormal(0.0F, -1.0F, 0.0F); + renderNegativeYFacing(null, aRenderer, aBlock, 0, 0, 0, tMetaTileEntity.getTexture(tMetaTileEntity.getBaseMetaTileEntity(), (byte)0, (byte)9, (byte)-1, false, false), true); + Tessellator.instance.draw(); + + Tessellator.instance.startDrawingQuads(); + Tessellator.instance.setNormal(0.0F, 1.0F, 0.0F); + renderPositiveYFacing(null, aRenderer, aBlock, 0, 0, 0, tMetaTileEntity.getTexture(tMetaTileEntity.getBaseMetaTileEntity(), (byte)1, (byte)9, (byte)-1, false, false), true); + Tessellator.instance.draw(); + + Tessellator.instance.startDrawingQuads(); + Tessellator.instance.setNormal(0.0F, 0.0F, -1.0F); + renderNegativeZFacing(null, aRenderer, aBlock, 0, 0, 0, tMetaTileEntity.getTexture(tMetaTileEntity.getBaseMetaTileEntity(), (byte)2, (byte)9, (byte)-1, false, false), true); + Tessellator.instance.draw(); + + Tessellator.instance.startDrawingQuads(); + Tessellator.instance.setNormal(0.0F, 0.0F, 1.0F); + renderPositiveZFacing(null, aRenderer, aBlock, 0, 0, 0, tMetaTileEntity.getTexture(tMetaTileEntity.getBaseMetaTileEntity(), (byte)3, (byte)9, (byte)-1, false, false), true); + Tessellator.instance.draw(); + + Tessellator.instance.startDrawingQuads(); + Tessellator.instance.setNormal(-1.0F, 0.0F, 0.0F); + renderNegativeXFacing(null, aRenderer, aBlock, 0, 0, 0, tMetaTileEntity.getTexture(tMetaTileEntity.getBaseMetaTileEntity(), (byte)4, (byte)9, (byte)-1, true, false), true); + Tessellator.instance.draw(); + + Tessellator.instance.startDrawingQuads(); + Tessellator.instance.setNormal(1.0F, 0.0F, 0.0F); + renderPositiveXFacing(null, aRenderer, aBlock, 0, 0, 0, tMetaTileEntity.getTexture(tMetaTileEntity.getBaseMetaTileEntity(), (byte)5, (byte)9, (byte)-1, true, false), true); + Tessellator.instance.draw(); + } + else + { + Tessellator.instance.startDrawingQuads(); + Tessellator.instance.setNormal(0.0F, -1.0F, 0.0F); + renderNegativeYFacing(null, aRenderer, aBlock, 0, 0, 0, tMetaTileEntity.getTexture(tMetaTileEntity.getBaseMetaTileEntity(), (byte)0, (byte)4, (byte)-1, true, false), true); + Tessellator.instance.draw(); + + Tessellator.instance.startDrawingQuads(); + Tessellator.instance.setNormal(0.0F, 1.0F, 0.0F); + renderPositiveYFacing(null, aRenderer, aBlock, 0, 0, 0, tMetaTileEntity.getTexture(tMetaTileEntity.getBaseMetaTileEntity(), (byte)1, (byte)4, (byte)-1, true, false), true); + Tessellator.instance.draw(); + + Tessellator.instance.startDrawingQuads(); + Tessellator.instance.setNormal(0.0F, 0.0F, -1.0F); + renderNegativeZFacing(null, aRenderer, aBlock, 0, 0, 0, tMetaTileEntity.getTexture(tMetaTileEntity.getBaseMetaTileEntity(), (byte)2, (byte)4, (byte)-1, true, false), true); + Tessellator.instance.draw(); + + Tessellator.instance.startDrawingQuads(); + Tessellator.instance.setNormal(0.0F, 0.0F, 1.0F); + renderPositiveZFacing(null, aRenderer, aBlock, 0, 0, 0, tMetaTileEntity.getTexture(tMetaTileEntity.getBaseMetaTileEntity(), (byte)3, (byte)4, (byte)-1, true, false), true); + Tessellator.instance.draw(); + + Tessellator.instance.startDrawingQuads(); + Tessellator.instance.setNormal(-1.0F, 0.0F, 0.0F); + renderNegativeXFacing(null, aRenderer, aBlock, 0, 0, 0, tMetaTileEntity.getTexture(tMetaTileEntity.getBaseMetaTileEntity(), (byte)4, (byte)4, (byte)-1, true, false), true); + Tessellator.instance.draw(); + + Tessellator.instance.startDrawingQuads(); + Tessellator.instance.setNormal(1.0F, 0.0F, 0.0F); + renderPositiveXFacing(null, aRenderer, aBlock, 0, 0, 0, tMetaTileEntity.getTexture(tMetaTileEntity.getBaseMetaTileEntity(), (byte)5, (byte)4, (byte)-1, true, false), true); + Tessellator.instance.draw(); + } + aBlock.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F); + aRenderer.setRenderBoundsFromBlock(aBlock); + GL11.glTranslatef(0.5F, 0.5F, 0.5F); + } + + public boolean renderWorldBlock(IBlockAccess aWorld, int aX, int aY, int aZ, Block aBlock, int aModelID, RenderBlocks aRenderer) + { + TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + if (aTileEntity == null) { + return false; + } + if (((aTileEntity instanceof IGregTechTileEntity)) && (((IGregTechTileEntity)aTileEntity).getMetaTileEntity() != null) && (((IGregTechTileEntity)aTileEntity).getMetaTileEntity().renderInWorld(aWorld, aX, aY, aZ, aBlock, aRenderer))) { + return true; + } + if ((aTileEntity instanceof IPipeRenderedTileEntity)) { + return renderPipeBlock(aWorld, aX, aY, aZ, aBlock, (IPipeRenderedTileEntity)aTileEntity, aRenderer); + } + return renderStandardBlock(aWorld, aX, aY, aZ, aBlock, aRenderer); + } + + public static boolean renderStandardBlock(IBlockAccess aWorld, int aX, int aY, int aZ, Block aBlock, RenderBlocks aRenderer) + { + TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ); + if ((tTileEntity instanceof ITexturedTileEntity)) { + return renderStandardBlock(aWorld, aX, aY, aZ, aBlock, aRenderer, new ITexture[][] { ((ITexturedTileEntity)tTileEntity).getTexture((byte) 0), ((ITexturedTileEntity)tTileEntity).getTexture((byte) 1), ((ITexturedTileEntity)tTileEntity).getTexture((byte) 2), ((ITexturedTileEntity)tTileEntity).getTexture((byte) 3), ((ITexturedTileEntity)tTileEntity).getTexture((byte) 4), ((ITexturedTileEntity)tTileEntity).getTexture((byte) 5) }); + } + return false; + } + + public static boolean renderStandardBlock(IBlockAccess aWorld, int aX, int aY, int aZ, Block aBlock, RenderBlocks aRenderer, ITexture[][] aTextures) + { + aBlock.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F); + aRenderer.setRenderBoundsFromBlock(aBlock); + + renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, aTextures[0], true); + renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, aTextures[1], true); + renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, aTextures[2], true); + renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, aTextures[3], true); + renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, aTextures[4], true); + renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, aTextures[5], true); + return true; + } + + public static boolean renderPipeBlock(IBlockAccess aWorld, int aX, int aY, int aZ, Block aBlock, IPipeRenderedTileEntity aTileEntity, RenderBlocks aRenderer) + { + byte aConnections = aTileEntity.getConnections(); + if ((aConnections & 0xC0) != 0) { + return renderStandardBlock(aWorld, aX, aY, aZ, aBlock, aRenderer); + } + float tThickness = aTileEntity.getThickNess(); + if (tThickness >= 0.99F) { + return renderStandardBlock(aWorld, aX, aY, aZ, aBlock, aRenderer); + } + float sp = (1.0F - tThickness) / 2.0F; + + byte tConnections = 0; + for (byte i = 0; i < 6; i = (byte)(i + 1)) { + if ((aConnections & 1 << i) != 0) { + tConnections = (byte)(tConnections | 1 << (i + 2) % 6); + } + } + boolean[] tIsCovered = new boolean[6]; + for (byte i = 0; i < 6; i = (byte)(i + 1)) { + tIsCovered[i] = (aTileEntity.getCoverIDAtSide(i) != 0 ? true : false); + } + if ((tIsCovered[0]) && (tIsCovered[1]) && (tIsCovered[2]) && (tIsCovered[3]) && (tIsCovered[4]) && (tIsCovered[5])) { + return renderStandardBlock(aWorld, aX, aY, aZ, aBlock, aRenderer); + } + ITexture[][] tIcons = new ITexture[6][];ITexture[][] tCovers = new ITexture[6][]; + for (byte i = 0; i < 6; i = (byte)(i + 1)) + { + tCovers[i] = aTileEntity.getTexture(i); + tIcons[i] = aTileEntity.getTextureUncovered(i); + } + if (tConnections == 0) + { + aBlock.setBlockBounds(sp, sp, sp, sp + tThickness, sp + tThickness, sp + tThickness); + aRenderer.setRenderBoundsFromBlock(aBlock); + renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[0], false); + renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[1], false); + renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[2], false); + renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[3], false); + renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[4], false); + renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[5], false); + } + else if (tConnections == 3) + { + aBlock.setBlockBounds(0.0F, sp, sp, 1.0F, sp + tThickness, sp + tThickness); + aRenderer.setRenderBoundsFromBlock(aBlock); + renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[0], false); + renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[1], false); + renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[2], false); + renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[3], false); + if (!tIsCovered[4]) { + renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[4], false); + } + if (!tIsCovered[5]) { + renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[5], false); + } + } + else if (tConnections == 12) + { + aBlock.setBlockBounds(sp, 0.0F, sp, sp + tThickness, 1.0F, sp + tThickness); + aRenderer.setRenderBoundsFromBlock(aBlock); + renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[2], false); + renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[3], false); + renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[4], false); + renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[5], false); + if (!tIsCovered[0]) { + renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[0], false); + } + if (!tIsCovered[1]) { + renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[1], false); + } + } + else if (tConnections == 48) + { + aBlock.setBlockBounds(sp, sp, 0.0F, sp + tThickness, sp + tThickness, 1.0F); + aRenderer.setRenderBoundsFromBlock(aBlock); + renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[0], false); + renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[1], false); + renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[4], false); + renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[5], false); + if (!tIsCovered[2]) { + renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[2], false); + } + if (!tIsCovered[3]) { + renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[3], false); + } + } + else + { + if ((tConnections & 0x1) == 0) + { + aBlock.setBlockBounds(sp, sp, sp, sp + tThickness, sp + tThickness, sp + tThickness); + aRenderer.setRenderBoundsFromBlock(aBlock); + renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[4], false); + } + else + { + aBlock.setBlockBounds(0.0F, sp, sp, sp, sp + tThickness, sp + tThickness); + aRenderer.setRenderBoundsFromBlock(aBlock); + renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[0], false); + renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[1], false); + renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[2], false); + renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[3], false); + if (!tIsCovered[4]) { + renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[4], false); + } + } + if ((tConnections & 0x2) == 0) + { + aBlock.setBlockBounds(sp, sp, sp, sp + tThickness, sp + tThickness, sp + tThickness); + aRenderer.setRenderBoundsFromBlock(aBlock); + renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[5], false); + } + else + { + aBlock.setBlockBounds(sp + tThickness, sp, sp, 1.0F, sp + tThickness, sp + tThickness); + aRenderer.setRenderBoundsFromBlock(aBlock); + renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[0], false); + renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[1], false); + renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[2], false); + renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[3], false); + if (!tIsCovered[5]) { + renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[5], false); + } + } + if ((tConnections & 0x4) == 0) + { + aBlock.setBlockBounds(sp, sp, sp, sp + tThickness, sp + tThickness, sp + tThickness); + aRenderer.setRenderBoundsFromBlock(aBlock); + renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[0], false); + } + else + { + aBlock.setBlockBounds(sp, 0.0F, sp, sp + tThickness, sp, sp + tThickness); + aRenderer.setRenderBoundsFromBlock(aBlock); + renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[2], false); + renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[3], false); + renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[4], false); + renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[5], false); + if (!tIsCovered[0]) { + renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[0], false); + } + } + if ((tConnections & 0x8) == 0) + { + aBlock.setBlockBounds(sp, sp, sp, sp + tThickness, sp + tThickness, sp + tThickness); + aRenderer.setRenderBoundsFromBlock(aBlock); + renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[1], false); + } + else + { + aBlock.setBlockBounds(sp, sp + tThickness, sp, sp + tThickness, 1.0F, sp + tThickness); + aRenderer.setRenderBoundsFromBlock(aBlock); + renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[2], false); + renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[3], false); + renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[4], false); + renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[5], false); + if (!tIsCovered[1]) { + renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[1], false); + } + } + if ((tConnections & 0x10) == 0) + { + aBlock.setBlockBounds(sp, sp, sp, sp + tThickness, sp + tThickness, sp + tThickness); + aRenderer.setRenderBoundsFromBlock(aBlock); + renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[2], false); + } + else + { + aBlock.setBlockBounds(sp, sp, 0.0F, sp + tThickness, sp + tThickness, sp); + aRenderer.setRenderBoundsFromBlock(aBlock); + renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[0], false); + renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[1], false); + renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[4], false); + renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[5], false); + if (!tIsCovered[2]) { + renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[2], false); + } + } + if ((tConnections & 0x20) == 0) + { + aBlock.setBlockBounds(sp, sp, sp, sp + tThickness, sp + tThickness, sp + tThickness); + aRenderer.setRenderBoundsFromBlock(aBlock); + renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[3], false); + } + else + { + aBlock.setBlockBounds(sp, sp, sp + tThickness, sp + tThickness, sp + tThickness, 1.0F); + aRenderer.setRenderBoundsFromBlock(aBlock); + renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[0], false); + renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[1], false); + renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[4], false); + renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[5], false); + if (!tIsCovered[3]) { + renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[3], false); + } + } + } + if (tIsCovered[0]) + { + aBlock.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.125F, 1.0F); + aRenderer.setRenderBoundsFromBlock(aBlock); + renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[0], false); + renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[0], false); + if (!tIsCovered[2]) { + renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[0], false); + } + if (!tIsCovered[3]) { + renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[0], false); + } + if (!tIsCovered[4]) { + renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[0], false); + } + if (!tIsCovered[5]) { + renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[0], false); + } + } + if (tIsCovered[1]) + { + aBlock.setBlockBounds(0.0F, 0.875F, 0.0F, 1.0F, 1.0F, 1.0F); + aRenderer.setRenderBoundsFromBlock(aBlock); + renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[1], false); + renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[1], false); + if (!tIsCovered[2]) { + renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[1], false); + } + if (!tIsCovered[3]) { + renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[1], false); + } + if (!tIsCovered[4]) { + renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[1], false); + } + if (!tIsCovered[5]) { + renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[1], false); + } + } + if (tIsCovered[2]) + { + aBlock.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 0.125F); + aRenderer.setRenderBoundsFromBlock(aBlock); + if (!tIsCovered[0]) { + renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[2], false); + } + if (!tIsCovered[1]) { + renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[2], false); + } + renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[2], false); + renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[2], false); + if (!tIsCovered[4]) { + renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[2], false); + } + if (!tIsCovered[5]) { + renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[2], false); + } + } + if (tIsCovered[3]) + { + aBlock.setBlockBounds(0.0F, 0.0F, 0.875F, 1.0F, 1.0F, 1.0F); + aRenderer.setRenderBoundsFromBlock(aBlock); + if (!tIsCovered[0]) { + renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[3], false); + } + if (!tIsCovered[1]) { + renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[3], false); + } + renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[3], false); + renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[3], false); + if (!tIsCovered[4]) { + renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[3], false); + } + if (!tIsCovered[5]) { + renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[3], false); + } + } + if (tIsCovered[4]) + { + aBlock.setBlockBounds(0.0F, 0.0F, 0.0F, 0.125F, 1.0F, 1.0F); + aRenderer.setRenderBoundsFromBlock(aBlock); + if (!tIsCovered[0]) { + renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[4], false); + } + if (!tIsCovered[1]) { + renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[4], false); + } + if (!tIsCovered[2]) { + renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[4], false); + } + if (!tIsCovered[3]) { + renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[4], false); + } + renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[4], false); + renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[4], false); + } + if (tIsCovered[5]) + { + aBlock.setBlockBounds(0.875F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F); + aRenderer.setRenderBoundsFromBlock(aBlock); + if (!tIsCovered[0]) { + renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[5], false); + } + if (!tIsCovered[1]) { + renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[5], false); + } + if (!tIsCovered[2]) { + renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[5], false); + } + if (!tIsCovered[3]) { + renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[5], false); + } + renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[5], false); + renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[5], false); + } + aBlock.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F); + aRenderer.setRenderBoundsFromBlock(aBlock); + + return true; + } + + public static void renderNegativeYFacing(IBlockAccess aWorld, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, ITexture[] aIcon, boolean aFullBlock) + { + if (aWorld != null) + { + if ((aFullBlock) && (!aBlock.shouldSideBeRendered(aWorld, aX, aY - 1, aZ, 0))) { + return; + } + Tessellator.instance.setBrightness(aBlock.getMixedBrightnessForBlock(aWorld, aX, aFullBlock ? aY - 1 : aY, aZ)); + } + if (aIcon != null) { + for (int i = 0; i < aIcon.length; i++) { + if (aIcon[i] != null) { + aIcon[i].renderYNeg(aRenderer, aBlock, aX, aY, aZ); + } + } + } + aRenderer.flipTexture = false; + } + + public static void renderPositiveYFacing(IBlockAccess aWorld, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, ITexture[] aIcon, boolean aFullBlock) + { + if (aWorld != null) + { + if ((aFullBlock) && (!aBlock.shouldSideBeRendered(aWorld, aX, aY + 1, aZ, 1))) { + return; + } + Tessellator.instance.setBrightness(aBlock.getMixedBrightnessForBlock(aWorld, aX, aFullBlock ? aY + 1 : aY, aZ)); + } + if (aIcon != null) { + for (int i = 0; i < aIcon.length; i++) { + if (aIcon[i] != null) { + aIcon[i].renderYPos(aRenderer, aBlock, aX, aY, aZ); + } + } + } + aRenderer.flipTexture = false; + } + + public static void renderNegativeZFacing(IBlockAccess aWorld, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, ITexture[] aIcon, boolean aFullBlock) + { + if (aWorld != null) + { + if ((aFullBlock) && (!aBlock.shouldSideBeRendered(aWorld, aX, aY, aZ - 1, 2))) { + return; + } + Tessellator.instance.setBrightness(aBlock.getMixedBrightnessForBlock(aWorld, aX, aY, aFullBlock ? aZ - 1 : aZ)); + } + aRenderer.flipTexture = (!aFullBlock); + if (aIcon != null) { + for (int i = 0; i < aIcon.length; i++) { + if (aIcon[i] != null) { + aIcon[i].renderZNeg(aRenderer, aBlock, aX, aY, aZ); + } + } + } + aRenderer.flipTexture = false; + } + + public static void renderPositiveZFacing(IBlockAccess aWorld, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, ITexture[] aIcon, boolean aFullBlock) + { + if (aWorld != null) + { + if ((aFullBlock) && (!aBlock.shouldSideBeRendered(aWorld, aX, aY, aZ + 1, 3))) { + return; + } + Tessellator.instance.setBrightness(aBlock.getMixedBrightnessForBlock(aWorld, aX, aY, aFullBlock ? aZ + 1 : aZ)); + } + if (aIcon != null) { + for (int i = 0; i < aIcon.length; i++) { + if (aIcon[i] != null) { + aIcon[i].renderZPos(aRenderer, aBlock, aX, aY, aZ); + } + } + } + aRenderer.flipTexture = false; + } + + public static void renderNegativeXFacing(IBlockAccess aWorld, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, ITexture[] aIcon, boolean aFullBlock) + { + if (aWorld != null) + { + if ((aFullBlock) && (!aBlock.shouldSideBeRendered(aWorld, aX - 1, aY, aZ, 4))) { + return; + } + Tessellator.instance.setBrightness(aBlock.getMixedBrightnessForBlock(aWorld, aFullBlock ? aX - 1 : aX, aY, aZ)); + } + if (aIcon != null) { + for (int i = 0; i < aIcon.length; i++) { + if (aIcon[i] != null) { + aIcon[i].renderXNeg(aRenderer, aBlock, aX, aY, aZ); + } + } + } + aRenderer.flipTexture = false; + } + + public static void renderPositiveXFacing(IBlockAccess aWorld, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, ITexture[] aIcon, boolean aFullBlock) + { + if (aWorld != null) + { + if ((aFullBlock) && (!aBlock.shouldSideBeRendered(aWorld, aX + 1, aY, aZ, 5))) { + return; + } + Tessellator.instance.setBrightness(aBlock.getMixedBrightnessForBlock(aWorld, aFullBlock ? aX + 1 : aX, aY, aZ)); + } + aRenderer.flipTexture = (!aFullBlock); + if (aIcon != null) { + for (int i = 0; i < aIcon.length; i++) { + if (aIcon[i] != null) { + aIcon[i].renderXPos(aRenderer, aBlock, aX, aY, aZ); + } + } + } + aRenderer.flipTexture = false; + } + + public boolean shouldRender3DInInventory(int aModel) + { + return true; + } + + public int getRenderId() + { + return this.mRenderID; + } +} diff --git a/main/java/gregtech/common/render/