diff options
Diffstat (limited to 'src/main/java/gregtech/common/render/items')
9 files changed, 1040 insertions, 0 deletions
diff --git a/src/main/java/gregtech/common/render/items/CosmicNeutroniumRenderer.java b/src/main/java/gregtech/common/render/items/CosmicNeutroniumRenderer.java new file mode 100644 index 0000000000..acb830de58 --- /dev/null +++ b/src/main/java/gregtech/common/render/items/CosmicNeutroniumRenderer.java @@ -0,0 +1,109 @@ +package gregtech.common.render.items; + +import static gregtech.common.render.GT_RenderUtil.colorGTItem; + +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.client.renderer.entity.RenderItem; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraftforge.client.IItemRenderer; + +import org.lwjgl.opengl.GL11; +import org.lwjgl.opengl.GL12; + +import com.gtnewhorizons.modularui.api.math.Pos2d; + +import gregtech.api.enums.Textures; +import gregtech.common.render.GT_RenderUtil; + +public class CosmicNeutroniumRenderer extends GT_GeneratedMaterial_Renderer { + + // spotless:off + private static final Pos2d point0 = new Pos2d(0 - 10, 0 - 10); + private static final Pos2d point1 = new Pos2d(17 + 10, 0 - 10); + private static final Pos2d point2 = new Pos2d(17 + 10, 17 + 10); + private static final Pos2d point3 = new Pos2d(0 - 10, 17 + 10); + // spotless:on + + // TODO: Render halo outside of inventory. + private void drawHalo(ItemRenderType type) { + // Because when this class is instantiated, making this a static field will cause it to set to null. + final IIcon haloFuzzy = Textures.ItemIcons.HALO_FUZZY.getIcon(); + + if (haloFuzzy == null) { + return; + } + + markNeedsAnimationUpdate(haloFuzzy); + GL11.glPushMatrix(); + + // Ideally this magic haloColour number should scale depending on the # of transparent pixels, + // but I'm not sure how to determine this with OpenGL. + // This is from Avaritia code, but modified to untangle the interfaces. + int haloColour = 0x4DFFFFFF; + float ca = (float) (haloColour >> 24 & 255) / 255.0F; + float cr = (float) (0x99FFFFFF >> 16 & 255) / 255.0F; + float cg = (float) (0x99FFFFFF >> 8 & 255) / 255.0F; + float cb = (float) (0x99FFFFFF & 255) / 255.0F; + GL11.glColor4f(cr, cg, cb, ca); + + // spotless:off + // For those following in my footsteps, this may be of use - Colen 25th dec 2022. + // http://greyminecraftcoder.blogspot.com/2013/08/the-tessellator.html + + Tessellator t = Tessellator.instance; + + if (type.equals(IItemRenderer.ItemRenderType.INVENTORY)) { + t.startDrawingQuads(); + t.addVertexWithUV(point0.x, point0.y, 0, haloFuzzy.getMinU(), haloFuzzy.getMinV()); + t.addVertexWithUV(point3.x, point3.y, 0, haloFuzzy.getMinU(), haloFuzzy.getMaxV()); + t.addVertexWithUV(point2.x, point2.y, 0, haloFuzzy.getMaxU(), haloFuzzy.getMaxV()); + t.addVertexWithUV(point1.x, point1.y, 0, haloFuzzy.getMaxU(), haloFuzzy.getMinV()); + t.draw(); + } + + GL11.glPopMatrix(); + } + + @Override + protected void renderRegularItem(ItemRenderType type, ItemStack item, IIcon icon, boolean shouldModulateColor, int pass, Object... data) { + RenderItem r = RenderItem.getInstance(); + + GL11.glPushMatrix(); + + if (type.equals(IItemRenderer.ItemRenderType.INVENTORY)) { + GL11.glEnable(GL11.GL_BLEND); + GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + GL11.glDisable(GL11.GL_ALPHA_TEST); + GL11.glDisable(GL11.GL_DEPTH_TEST); + } + + if (pass == 0) { + drawHalo(type); + } + + //spotless:on + { + // Draw actual cosmic Nt item. + GL11.glPushMatrix(); + + colorGTItem(item); + + if (type.equals(IItemRenderer.ItemRenderType.INVENTORY)) { + GT_RenderUtil.renderItemIcon(icon, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F); + } else { + GL11.glEnable(GL11.GL_DEPTH_TEST); + GT_RenderUtil.renderItem(type, icon); + } + GL11.glPopMatrix(); + } + + // GL11.glEnable(GL11.GL_ALPHA_TEST); + GL11.glEnable(GL12.GL_RESCALE_NORMAL); + GL11.glEnable(GL11.GL_DEPTH_TEST); + + r.renderWithColor = true; + + GL11.glPopMatrix(); + } +} diff --git a/src/main/java/gregtech/common/render/items/GT_DataStick_Renderer.java b/src/main/java/gregtech/common/render/items/GT_DataStick_Renderer.java new file mode 100644 index 0000000000..668b1daa6c --- /dev/null +++ b/src/main/java/gregtech/common/render/items/GT_DataStick_Renderer.java @@ -0,0 +1,42 @@ +package gregtech.common.render.items; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.RenderHelper; +import net.minecraft.client.renderer.entity.RenderItem; +import net.minecraft.item.ItemStack; +import net.minecraftforge.client.IItemRenderer; + +import org.lwjgl.input.Keyboard; +import org.lwjgl.opengl.GL11; + +import gregtech.api.util.GT_AssemblyLineUtils; + +// borrow form ae2 + +public class GT_DataStick_Renderer implements IItemRenderer { + + private final RenderItem ri = new RenderItem(); + + @Override + public boolean handleRenderType(ItemStack item, ItemRenderType type) { + final boolean isShiftHeld = Keyboard.isKeyDown(Keyboard.KEY_LSHIFT) || Keyboard.isKeyDown(Keyboard.KEY_RSHIFT); + return type == ItemRenderType.INVENTORY && isShiftHeld; + } + + @Override + public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper) { + return false; + } + + @Override + public void renderItem(ItemRenderType type, ItemStack item, Object... data) { + final ItemStack is = GT_AssemblyLineUtils.getDataStickOutput(item); + final Minecraft mc = Minecraft.getMinecraft(); + + GL11.glPushAttrib(GL11.GL_ENABLE_BIT | GL11.GL_COLOR_BUFFER_BIT); + RenderHelper.enableGUIStandardItemLighting(); + this.ri.renderItemAndEffectIntoGUI(mc.fontRenderer, mc.getTextureManager(), is, 0, 0); + RenderHelper.disableStandardItemLighting(); + GL11.glPopAttrib(); + } +} diff --git a/src/main/java/gregtech/common/render/items/GT_GeneratedItem_Renderer.java b/src/main/java/gregtech/common/render/items/GT_GeneratedItem_Renderer.java new file mode 100644 index 0000000000..84045446c2 --- /dev/null +++ b/src/main/java/gregtech/common/render/items/GT_GeneratedItem_Renderer.java @@ -0,0 +1,166 @@ +package gregtech.common.render.items; + +import static gregtech.api.enums.ItemList.Large_Fluid_Cell_Aluminium; +import static gregtech.api.enums.ItemList.Large_Fluid_Cell_Chrome; +import static gregtech.api.enums.ItemList.Large_Fluid_Cell_Iridium; +import static gregtech.api.enums.ItemList.Large_Fluid_Cell_Neutronium; +import static gregtech.api.enums.ItemList.Large_Fluid_Cell_Osmium; +import static gregtech.api.enums.ItemList.Large_Fluid_Cell_StainlessSteel; +import static gregtech.api.enums.ItemList.Large_Fluid_Cell_Steel; +import static gregtech.api.enums.ItemList.Large_Fluid_Cell_Titanium; +import static gregtech.api.enums.ItemList.Large_Fluid_Cell_TungstenSteel; +import static gregtech.api.enums.Mods.HodgePodge; + +import javax.annotation.Nullable; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.texture.TextureMap; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraftforge.client.IItemRenderer; +import net.minecraftforge.fluids.FluidStack; + +import org.lwjgl.opengl.GL11; + +import com.mitchej123.hodgepodge.textures.IPatchedTextureAtlasSprite; + +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Textures; +import gregtech.api.items.GT_MetaGenerated_Item; +import gregtech.api.util.GT_Utility; +import gregtech.common.render.GT_RenderUtil; +import gregtech.loaders.ExtraIcons; + +public class GT_GeneratedItem_Renderer implements IItemRenderer { + + @Override + public boolean handleRenderType(ItemStack item, ItemRenderType type) { + return type == ItemRenderType.EQUIPPED || type == ItemRenderType.EQUIPPED_FIRST_PERSON + || type == ItemRenderType.INVENTORY + || type == ItemRenderType.ENTITY; + } + + @Override + public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper) { + return type == ItemRenderType.ENTITY && helper == ItemRendererHelper.ENTITY_BOBBING + || (helper == ItemRendererHelper.ENTITY_ROTATION && Minecraft.getMinecraft().gameSettings.fancyGraphics); + } + + @Override + public void renderItem(ItemRenderType type, ItemStack aStack, Object... data) { + short aMetaData = (short) aStack.getItemDamage(); + if (!(aStack.getItem() instanceof GT_MetaGenerated_Item aItem)) return; + + GL11.glEnable(GL11.GL_BLEND); + GL11.glColor3f(1.0F, 1.0F, 1.0F); + IIcon tIcon; + if (aItem.mIconList[(aMetaData - aItem.mOffset)].length > 1) { + Long[] tStats = aItem.mElectricStats.get(aMetaData); + + if ((tStats != null) && (tStats[3] < 0L)) { + long tCharge = aItem.getRealCharge(aStack); + + if (tCharge <= 0L) { + tIcon = aItem.mIconList[(aMetaData - aItem.mOffset)][1]; + } else { + + if (tCharge >= tStats[0]) { + tIcon = aItem.mIconList[(aMetaData - aItem.mOffset)][8]; + } else { + tIcon = aItem.mIconList[(aMetaData - aItem.mOffset)][(7 + - (int) Math.max(0L, Math.min(5L, (tStats[0] - tCharge) * 6L / tStats[0])))]; + } + } + } else { + tIcon = aItem.mIconList[(aMetaData - aItem.mOffset)][0]; + } + } else { + tIcon = aItem.mIconList[(aMetaData - aItem.mOffset)][0]; + } + + if (tIcon == null) tIcon = Textures.ItemIcons.RENDERING_ERROR.getIcon(); + + markNeedsAnimationUpdate(tIcon); + + ItemList largeFluidCell = getLargeFluidCell(aStack); + if (largeFluidCell != null) { + renderLargeFluidCellExtraParts(type, largeFluidCell, aStack); + } + + Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.locationItemsTexture); + GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + GT_RenderUtil.renderItem(type, tIcon); + GL11.glDisable(GL11.GL_BLEND); + } + + @Nullable + private static ItemList getLargeFluidCell(ItemStack stack) { + if (isSame(Large_Fluid_Cell_Steel, stack)) return Large_Fluid_Cell_Steel; + if (isSame(Large_Fluid_Cell_Aluminium, stack)) return Large_Fluid_Cell_Aluminium; + if (isSame(Large_Fluid_Cell_TungstenSteel, stack)) return Large_Fluid_Cell_TungstenSteel; + if (isSame(Large_Fluid_Cell_StainlessSteel, stack)) return Large_Fluid_Cell_StainlessSteel; + if (isSame(Large_Fluid_Cell_Titanium, stack)) return Large_Fluid_Cell_Titanium; + if (isSame(Large_Fluid_Cell_Chrome, stack)) return Large_Fluid_Cell_Chrome; + if (isSame(Large_Fluid_Cell_Iridium, stack)) return Large_Fluid_Cell_Iridium; + if (isSame(Large_Fluid_Cell_Osmium, stack)) return Large_Fluid_Cell_Osmium; + if (isSame(Large_Fluid_Cell_Neutronium, stack)) return Large_Fluid_Cell_Neutronium; + + return null; + } + + private void renderLargeFluidCellExtraParts(IItemRenderer.ItemRenderType type, ItemList item, ItemStack stack) { + + IIcon inner = switch (item) { + case Large_Fluid_Cell_Steel -> ExtraIcons.steelLargeCellInner; + case Large_Fluid_Cell_Aluminium -> ExtraIcons.aluminiumLargeCellInner; + case Large_Fluid_Cell_StainlessSteel -> ExtraIcons.stainlesssteelLargeCellInner; + case Large_Fluid_Cell_Titanium -> ExtraIcons.titaniumLargeCellInner; + case Large_Fluid_Cell_TungstenSteel -> ExtraIcons.tungstensteelLargeCellInner; + case Large_Fluid_Cell_Iridium -> ExtraIcons.iridiumLargeCellInner; + case Large_Fluid_Cell_Osmium -> ExtraIcons.osmiumLargeCellInner; + case Large_Fluid_Cell_Chrome -> ExtraIcons.chromiumLargeCellInner; + case Large_Fluid_Cell_Neutronium -> ExtraIcons.neutroniumLargeCellInner; + default -> Textures.ItemIcons.RENDERING_ERROR.getIcon(); + }; + + // Empty inner side + Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.locationItemsTexture); + markNeedsAnimationUpdate(inner); + GT_RenderUtil.renderItem(type, inner); + + FluidStack fluidStack = GT_Utility.getFluidForFilledItem(stack, true); + + if (fluidStack != null && fluidStack.getFluid() != null) { + IIcon fluidIcon = fluidStack.getFluid() + .getIcon(fluidStack); + if (fluidIcon == null) { + fluidIcon = Textures.ItemIcons.RENDERING_ERROR.getIcon(); + } + int fluidColor = fluidStack.getFluid() + .getColor(fluidStack); + + Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.locationBlocksTexture); + markNeedsAnimationUpdate(fluidIcon); + GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + GL11.glDepthFunc(GL11.GL_EQUAL); + GL11.glColor3ub((byte) (fluidColor >> 16), (byte) (fluidColor >> 8), (byte) fluidColor); + GT_RenderUtil.renderItem(type, fluidIcon); + + GL11.glColor3ub((byte) -1, (byte) -1, (byte) -1); + GL11.glDepthFunc(GL11.GL_LEQUAL); + } + } + + private static boolean isSame(ItemList item, ItemStack stack) { + ItemStack internal = item.getInternalStack_unsafe(); + if (GT_Utility.isStackInvalid(internal)) return false; + + return internal.getItem() == stack.getItem() && internal.getItemDamage() == stack.getItemDamage(); + } + + protected void markNeedsAnimationUpdate(IIcon icon) { + if (HodgePodge.isModLoaded() && icon instanceof IPatchedTextureAtlasSprite) { + ((IPatchedTextureAtlasSprite) icon).markNeedsAnimationUpdate(); + } + } +} diff --git a/src/main/java/gregtech/common/render/items/GT_GeneratedMaterial_Renderer.java b/src/main/java/gregtech/common/render/items/GT_GeneratedMaterial_Renderer.java new file mode 100644 index 0000000000..a67d5512ed --- /dev/null +++ b/src/main/java/gregtech/common/render/items/GT_GeneratedMaterial_Renderer.java @@ -0,0 +1,130 @@ +package gregtech.common.render.items; + +import static gregtech.api.enums.Mods.HodgePodge; + +import net.minecraft.client.Minecraft; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraftforge.client.IItemRenderer; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; + +import org.lwjgl.opengl.GL11; + +import com.mitchej123.hodgepodge.textures.IPatchedTextureAtlasSprite; + +import codechicken.lib.render.TextureUtils; +import gregtech.api.interfaces.IGT_ItemWithMaterialRenderer; +import gregtech.api.util.GT_Utility; +import gregtech.common.render.GT_RenderUtil; + +public class GT_GeneratedMaterial_Renderer implements IItemRenderer { + + @Override + public boolean handleRenderType(ItemStack item, ItemRenderType type) { + return type == ItemRenderType.EQUIPPED || type == ItemRenderType.EQUIPPED_FIRST_PERSON + || type == ItemRenderType.INVENTORY + || type == ItemRenderType.ENTITY; + } + + @Override + public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper) { + return type == ItemRenderType.ENTITY && helper == ItemRendererHelper.ENTITY_BOBBING + || (helper == ItemRendererHelper.ENTITY_ROTATION && Minecraft.getMinecraft().gameSettings.fancyGraphics); + } + + /** + * Handle special fluid display rendering. Return false if does not need such kind of handling. Note: annotations + * should not be rendered here. Only render the fluid texture. Parameters are values passed from + * {@link IItemRenderer#renderItem(ItemRenderType, ItemStack, Object...)} verbatim. Do not modify the argument. + * <p> + * While this is called, BLEND and ALPHA_TEST is on. It is expected that these remain enabled while exit. + * + * @return true if did special fluid display rendering. false otherwise. + */ + public boolean renderFluidDisplayItem(ItemRenderType type, ItemStack aStack, Object... data) { + return false; + } + + @Override + public void renderItem(ItemRenderType type, ItemStack aStack, Object... data) { + short aMetaData = (short) aStack.getItemDamage(); + if (!(aStack.getItem() instanceof IGT_ItemWithMaterialRenderer aItem)) return; + + int passes = 1; + if (aItem.requiresMultipleRenderPasses()) { + passes = aItem.getRenderPasses(aMetaData); + } + + for (int pass = 0; pass < passes; pass++) { + IIcon tIcon = aItem.getIcon(aMetaData, pass); + IIcon tOverlay = aItem.getOverlayIcon(aMetaData, pass); + FluidStack aFluid = GT_Utility.getFluidForFilledItem(aStack, true); + + GL11.glEnable(GL11.GL_BLEND); + GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + GL11.glEnable(GL11.GL_ALPHA_TEST); + + if (tIcon != null) { + markNeedsAnimationUpdate(tIcon); + renderRegularItem(type, aStack, tIcon, aFluid == null, pass, data); + } + + if (tOverlay != null && aFluid != null && aFluid.getFluid() != null) { + IIcon fluidIcon = aFluid.getFluid() + .getIcon(aFluid); + if (fluidIcon != null) { + markNeedsAnimationUpdate(fluidIcon); + // Adds colour to a cells fluid. Does not colour full fluid icons as shown in NEI etc. + renderContainedFluid(type, aFluid, fluidIcon); + } + } + + if (tOverlay != null) { + GL11.glColor3f(1.0F, 1.0F, 1.0F); + TextureUtils.bindAtlas(aItem.getSpriteNumber()); + markNeedsAnimationUpdate(tOverlay); + renderItemOverlay(type, tOverlay); + } + + GL11.glDisable(GL11.GL_BLEND); + } + } + + protected void renderRegularItem(ItemRenderType type, ItemStack aStack, IIcon icon, boolean shouldModulateColor, + int pass, Object... data) { + renderRegularItem(type, aStack, icon, shouldModulateColor); + } + + protected void renderRegularItem(ItemRenderType type, ItemStack aStack, IIcon icon, boolean shouldModulateColor) { + if (!(aStack.getItem() instanceof IGT_ItemWithMaterialRenderer aItem)) return; + + if (shouldModulateColor) { + short[] tModulation = aItem.getRGBa(aStack); + GL11.glColor3f(tModulation[0] / 255.0F, tModulation[1] / 255.0F, tModulation[2] / 255.0F); + } + + GT_RenderUtil.renderItem(type, icon); + } + + protected void renderContainedFluid(ItemRenderType type, FluidStack aFluidStack, IIcon fluidIcon) { + Fluid aFluid = aFluidStack.getFluid(); + int tColor = aFluid.getColor(aFluidStack); + GL11.glColor3f((tColor >> 16 & 0xFF) / 255.0F, (tColor >> 8 & 0xFF) / 255.0F, (tColor & 0xFF) / 255.0F); + TextureUtils.bindAtlas(aFluid.getSpriteNumber()); + + GL11.glDepthFunc(GL11.GL_EQUAL); + GT_RenderUtil.renderItem(type, fluidIcon); + GL11.glDepthFunc(GL11.GL_LEQUAL); + } + + protected void renderItemOverlay(ItemRenderType type, IIcon overlay) { + GT_RenderUtil.renderItem(type, overlay); + } + + protected void markNeedsAnimationUpdate(IIcon icon) { + if (HodgePodge.isModLoaded() && icon instanceof IPatchedTextureAtlasSprite) { + ((IPatchedTextureAtlasSprite) icon).markNeedsAnimationUpdate(); + } + } +} diff --git a/src/main/java/gregtech/common/render/items/GT_MetaGenerated_Item_Renderer.java b/src/main/java/gregtech/common/render/items/GT_MetaGenerated_Item_Renderer.java new file mode 100644 index 0000000000..d7425c2fcb --- /dev/null +++ b/src/main/java/gregtech/common/render/items/GT_MetaGenerated_Item_Renderer.java @@ -0,0 +1,85 @@ +package gregtech.common.render.items; + +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraftforge.client.IItemRenderer; +import net.minecraftforge.client.MinecraftForgeClient; + +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.interfaces.IGT_ItemWithMaterialRenderer; +import gregtech.api.objects.ItemData; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import gregtech.common.render.GT_RenderUtil; + +public class GT_MetaGenerated_Item_Renderer implements IItemRenderer { + + private final IItemRenderer mItemRenderer = new GT_GeneratedItem_Renderer(); + private final IItemRenderer mMaterialRenderer = new GT_GeneratedMaterial_Renderer(); + + private final IItemRenderer mDataStickRenderer = new GT_DataStick_Renderer(); + + public GT_MetaGenerated_Item_Renderer() {} + + public <T extends Item & IGT_ItemWithMaterialRenderer> void registerItem(T item) { + MinecraftForgeClient.registerItemRenderer(item, this); + } + + @Override + public boolean handleRenderType(ItemStack aStack, ItemRenderType aType) { + if ((GT_Utility.isStackInvalid(aStack)) || (aStack.getItemDamage() < 0) + || !(aStack.getItem() instanceof IGT_ItemWithMaterialRenderer) + || !((IGT_ItemWithMaterialRenderer) aStack.getItem()).shouldUseCustomRenderer(aStack.getItemDamage())) { + return false; + } + return getRendererForItemStack(aStack).handleRenderType(aStack, aType); + } + + @Override + public boolean shouldUseRenderHelper(ItemRenderType aType, ItemStack aStack, ItemRendererHelper aHelper) { + if (GT_Utility.isStackInvalid(aStack)) { + return false; + } + return getRendererForItemStack(aStack).shouldUseRenderHelper(aType, aStack, aHelper); + } + + @Override + public void renderItem(ItemRenderType type, ItemStack aStack, Object... data) { + GT_RenderUtil.applyStandardItemTransform(type); + + IItemRenderer itemRenderer = getRendererForItemStack(aStack); + itemRenderer.renderItem(type, aStack, data); + } + + private IItemRenderer getRendererForItemStack(ItemStack aStack) { + short aMetaData = (short) aStack.getItemDamage(); + IGT_ItemWithMaterialRenderer aItem = (IGT_ItemWithMaterialRenderer) aStack.getItem(); + + if (aItem != null && aItem.allowMaterialRenderer(aMetaData)) { + IItemRenderer aMaterialRenderer = aItem.getMaterialRenderer(aMetaData); + + // Handle fluid rendering. + if (aMaterialRenderer == null) { + ItemData itemData = GT_OreDictUnificator.getAssociation(aStack); + if (itemData != null) { + Materials material = itemData.mMaterial.mMaterial; + if (material.renderer != null) { + aMaterialRenderer = material.renderer; + } + } + } + + return aMaterialRenderer != null ? aMaterialRenderer : mMaterialRenderer; + } + + // handle data stick + if (aStack.getItem() == ItemList.Tool_DataStick.getItem() && aStack.hasTagCompound() + && aStack.getTagCompound() + .hasKey("output")) { + return mDataStickRenderer; + } + + return mItemRenderer; + } +} diff --git a/src/main/java/gregtech/common/render/items/GaiaSpiritRenderer.java b/src/main/java/gregtech/common/render/items/GaiaSpiritRenderer.java new file mode 100644 index 0000000000..08663adf4d --- /dev/null +++ b/src/main/java/gregtech/common/render/items/GaiaSpiritRenderer.java @@ -0,0 +1,27 @@ +package gregtech.common.render.items; + +import java.awt.Color; + +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; + +import org.lwjgl.opengl.GL11; + +import gregtech.GT_Mod; +import gregtech.common.render.GT_RenderUtil; + +public class GaiaSpiritRenderer extends GT_GeneratedMaterial_Renderer { + + @Override + protected void renderRegularItem(ItemRenderType type, ItemStack aStack, IIcon icon, boolean shouldModulateColor) { + long animationTicks = GT_Mod.gregtechproxy.getAnimationTicks(); + float partialTicks = GT_Mod.gregtechproxy.getPartialRenderTicks(); + + if (shouldModulateColor) { + Color color = Color.getHSBColor((animationTicks % 360 + partialTicks) % 180 / 180f, 0.4f, 0.9f); + GL11.glColor3f(color.getRed() / 255.0F, color.getGreen() / 255.0F, color.getBlue() / 255.0F); + } + + GT_RenderUtil.renderItem(type, icon); + } +} diff --git a/src/main/java/gregtech/common/render/items/InfinityRenderer.java b/src/main/java/gregtech/common/render/items/InfinityRenderer.java new file mode 100644 index 0000000000..3a98898b8a --- /dev/null +++ b/src/main/java/gregtech/common/render/items/InfinityRenderer.java @@ -0,0 +1,139 @@ +package gregtech.common.render.items; + +import java.util.Random; + +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraftforge.fluids.FluidStack; + +import org.lwjgl.opengl.GL11; + +import codechicken.lib.render.TextureUtils; +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.IGT_ItemWithMaterialRenderer; +import gregtech.api.util.GT_Utility; + +// TODO: Render effects outside inventory. + +public class InfinityRenderer extends GT_GeneratedMaterial_Renderer { + + public Random rand = new Random(); + + @Override + public void renderItem(ItemRenderType type, ItemStack aStack, Object... data) { + short aMetaData = (short) aStack.getItemDamage(); + if (!(aStack.getItem() instanceof IGT_ItemWithMaterialRenderer aItem)) return; + + int passes = 1; + if (aItem.requiresMultipleRenderPasses()) { + passes = aItem.getRenderPasses(aMetaData); + } + + for (int pass = 0; pass < passes; pass++) { + IIcon tIcon = aItem.getIcon(aMetaData, pass); + IIcon tOverlay = aItem.getOverlayIcon(aMetaData, pass); + FluidStack aFluid = GT_Utility.getFluidForFilledItem(aStack, true); + + GL11.glEnable(GL11.GL_BLEND); + GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + GL11.glEnable(GL11.GL_ALPHA_TEST); + + if (type == ItemRenderType.INVENTORY) { + if (pass == 0) { + renderHalo(); + } + renderPulse(tOverlay, tIcon); + } + + // Workaround for cell and comb: + // 1. BW capsule needs `renderContainedFluid` call as it doesn't have + // `materialicons/CUSTOM/infinity/capsuleMolten` + // 2. Without these 2 GL calls fluid texture leaks out of the cell / capsule + // 3. Comb texture doesn't like depth enabled + if (passes == 1) { + GL11.glEnable(GL11.GL_DEPTH_TEST); + } + GL11.glEnable(GL11.GL_ALPHA_TEST); + + if (tIcon != null) { + markNeedsAnimationUpdate(tIcon); + renderRegularItem(type, aStack, tIcon, aFluid == null); + } + + if (tOverlay != null && aFluid != null && aFluid.getFluid() != null) { + IIcon fluidIcon = aFluid.getFluid() + .getIcon(aFluid); + if (fluidIcon != null) { + markNeedsAnimationUpdate(fluidIcon); + // Adds colour to a cells fluid. Does not colour full fluid icons as shown in NEI etc. + renderContainedFluid(type, aFluid, fluidIcon); + } + } + + if (tOverlay != null) { + GL11.glColor3f(1.0F, 1.0F, 1.0F); + TextureUtils.bindAtlas(aItem.getSpriteNumber()); + markNeedsAnimationUpdate(tOverlay); + renderItemOverlay(type, tOverlay); + } + + GL11.glDisable(GL11.GL_BLEND); + } + } + + private void renderHalo() { + GL11.glPushMatrix(); + IIcon halo = Textures.ItemIcons.HALO.getIcon(); + + int spread = 10; + int haloAlpha = 0xFF000000; + + if (halo == null) { + return; + } + + Tessellator t = Tessellator.instance; + + GL11.glEnable(GL11.GL_BLEND); + GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + + GL11.glDisable(GL11.GL_ALPHA_TEST); + GL11.glDisable(GL11.GL_DEPTH_TEST); + + GL11.glColor4f(20 / 255.0f, 20 / 255.0f, 20 / 255.0f, (float) (haloAlpha >> 24 & 255) / 255.0F); + + t.startDrawingQuads(); + t.addVertexWithUV(-spread, -spread, 0, halo.getMinU(), halo.getMinV()); + t.addVertexWithUV(-spread, 16 + spread, 0, halo.getMinU(), halo.getMaxV()); + t.addVertexWithUV(16 + spread, 16 + spread, 0, halo.getMaxU(), halo.getMaxV()); + t.addVertexWithUV(16 + spread, -spread, 0, halo.getMaxU(), halo.getMinV()); + t.draw(); + GL11.glPopMatrix(); + } + + private void renderPulse(IIcon... icons) { + Tessellator t = Tessellator.instance; + double random = rand.nextGaussian(); + double scale = (random * 0.15) + 0.95; + double offset = (1.0 - scale) / 2.0; + + for (IIcon icon : icons) { + if (icon == null) continue; + GL11.glPushMatrix(); + GL11.glEnable(GL11.GL_BLEND); + GL11.glTranslated(offset * 16.0, offset * 16.0, 1.0); + GL11.glScaled(scale, scale, 1.0); + + t.startDrawingQuads(); + t.setColorRGBA_F(1.0f, 1.0f, 1.0f, 0.6f); + t.addVertexWithUV(0 - offset, 0 - offset, 0, icon.getMinU(), icon.getMinV()); + t.addVertexWithUV(0 - offset, 16 + offset, 0, icon.getMinU(), icon.getMaxV()); + t.addVertexWithUV(16 + offset, 16 + offset, 0, icon.getMaxU(), icon.getMaxV()); + t.addVertexWithUV(16 + offset, 0 - offset, 0, icon.getMaxU(), icon.getMinV()); + t.draw(); + + GL11.glPopMatrix(); + } + } +} diff --git a/src/main/java/gregtech/common/render/items/TranscendentMetalRenderer.java b/src/main/java/gregtech/common/render/items/TranscendentMetalRenderer.java new file mode 100644 index 0000000000..8583033e0f --- /dev/null +++ b/src/main/java/gregtech/common/render/items/TranscendentMetalRenderer.java @@ -0,0 +1,145 @@ +package gregtech.common.render.items; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.ItemRenderer; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.client.renderer.entity.RenderItem; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraftforge.client.IItemRenderer; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; + +import org.lwjgl.opengl.GL11; + +import codechicken.lib.render.TextureUtils; +import gregtech.GT_Mod; +import gregtech.api.interfaces.IGT_ItemWithMaterialRenderer; +import gregtech.api.util.GT_Util; + +public class TranscendentMetalRenderer extends GT_GeneratedMaterial_Renderer { + + @Override + public void renderItem(ItemRenderType type, ItemStack aStack, Object... data) { + if (type == ItemRenderType.ENTITY) { + // Pretend fancy graphics is enabled + if (!Minecraft.getMinecraft().gameSettings.fancyGraphics) { + if (RenderItem.renderInFrame) { + GL11.glRotatef(180.0F, 0.0F, 1.0F, 0.0F); + } + // Magic numbers calculated from vanilla code + GL11.glTranslatef(-0.5F, -0.25F, 0.0421875F); + } + } + super.renderItem(type, aStack, data); + } + + @Override + protected void renderRegularItem(ItemRenderType type, ItemStack itemStack, IIcon icon, + boolean shouldModulateColor) { + + if (!(itemStack.getItem() instanceof final IGT_ItemWithMaterialRenderer itemRenderer)) return; + + GL11.glPushMatrix(); + applyEffect(type, itemRenderer.getRGBa(itemStack), shouldModulateColor); + + if (shouldModulateColor) { + short[] tModulation = itemRenderer.getRGBa(itemStack); + GL11.glColor3f(tModulation[0] / 255.0F, tModulation[1] / 255.0F, tModulation[2] / 255.0F); + } + + if (type.equals(IItemRenderer.ItemRenderType.INVENTORY)) { + GL11.glScalef(16, 16, 32); + } + ItemRenderer.renderItemIn2D( + Tessellator.instance, + icon.getMaxU(), + icon.getMinV(), + icon.getMinU(), + icon.getMaxV(), + icon.getIconWidth(), + icon.getIconHeight(), + 0.0625F); + + GL11.glPopMatrix(); + } + + @Override + protected void renderContainedFluid(ItemRenderType type, FluidStack fluidStack, IIcon fluidIcon) { + GL11.glPushMatrix(); + + Fluid fluid = fluidStack.getFluid(); + applyEffect(type, GT_Util.getRGBaArray(fluid.getColor()), true); + + TextureUtils.bindAtlas(fluid.getSpriteNumber()); + GL11.glDepthFunc(GL11.GL_EQUAL); + if (type.equals(IItemRenderer.ItemRenderType.INVENTORY)) { + GL11.glScalef(16, 16, 32); + } + + ItemRenderer.renderItemIn2D( + Tessellator.instance, + fluidIcon.getMaxU(), + fluidIcon.getMinV(), + fluidIcon.getMinU(), + fluidIcon.getMaxV(), + fluidIcon.getIconWidth(), + fluidIcon.getIconHeight(), + 0.0625F); + + GL11.glDepthFunc(GL11.GL_LEQUAL); + GL11.glPopMatrix(); + } + + @Override + protected void renderItemOverlay(ItemRenderType type, IIcon overlay) { + GL11.glPushMatrix(); + applyEffect(type, null, false); + + if (type.equals(IItemRenderer.ItemRenderType.INVENTORY)) { + GL11.glScalef(16, 16, 32); + } + ItemRenderer.renderItemIn2D( + Tessellator.instance, + overlay.getMaxU(), + overlay.getMinV(), + overlay.getMinU(), + overlay.getMaxV(), + overlay.getIconWidth(), + overlay.getIconHeight(), + 0.0625F); + + GL11.glPopMatrix(); + } + + private void applyEffect(ItemRenderType type, short[] modulation, boolean shouldModulateColor) { + if (RenderItem.renderInFrame) { + // Float in front of item frame + GL11.glTranslatef(0.0f, 0.0f, -0.5f); + } + + if (type.equals(IItemRenderer.ItemRenderType.INVENTORY)) { + GL11.glTranslatef(8f, 8f, 0f); + } else { + GL11.glTranslatef(0.5f, 0.5f, 0.0f); + } + + GL11.glRotatef((GT_Mod.gregtechproxy.getAnimationTicks() * 3.5f) % 360, 0.3f, 0.5f, 0.2f); + GL11.glRotatef(180, 0.5f, 0.0f, 0.0f); + + if (type.equals(IItemRenderer.ItemRenderType.INVENTORY)) { + GL11.glTranslatef(-8f, -8f, 0f); + } else { + GL11.glTranslatef(-0.5f, -0.5f, 0.0f); + } + + // Center on point of rotation + GL11.glTranslatef(0.0f, 0.0f, 0.03125F); + + if (shouldModulateColor) { + GL11.glColor4f(modulation[0] / 255.0F, modulation[1] / 255.0F, modulation[2] / 255.0F, 255); + } else { + GL11.glColor4f(1f, 1f, 1f, 255); + } + } +} diff --git a/src/main/java/gregtech/common/render/items/UniversiumRenderer.java b/src/main/java/gregtech/common/render/items/UniversiumRenderer.java new file mode 100644 index 0000000000..92b86071cf --- /dev/null +++ b/src/main/java/gregtech/common/render/items/UniversiumRenderer.java @@ -0,0 +1,197 @@ +package gregtech.common.render.items; + +import static gregtech.api.enums.Mods.Avaritia; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.RenderHelper; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.client.renderer.entity.RenderItem; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraft.util.MathHelper; +import net.minecraft.util.ResourceLocation; + +import org.lwjgl.opengl.GL11; +import org.lwjgl.opengl.GL12; +import org.lwjgl.opengl.GL20; + +import codechicken.lib.render.TextureUtils; +import fox.spiteful.avaritia.render.CosmicRenderShenanigans; +import gregtech.api.enums.ItemList; +import gregtech.api.interfaces.IGT_ItemWithMaterialRenderer; +import gregtech.common.render.GT_RenderUtil; + +@SuppressWarnings("RedundantLabeledSwitchRuleCodeBlock") +public class UniversiumRenderer extends GT_GeneratedMaterial_Renderer { + + private static final float cosmicOpacity = 2.5f; + + @Override + public boolean renderFluidDisplayItem(ItemRenderType type, ItemStack aStack, Object... data) { + Item item = aStack.getItem(); + if (item == null) return false; + + magicRenderMethod( + type, + ItemList.Emitter_UEV.get(1), // hack to make it render correctly + item.getIconFromDamage(aStack.getItemDamage()), + true, + data); + return true; + } + + @Override + public void renderItem(ItemRenderType type, ItemStack aStack, Object... data) { + short aMetaData = (short) aStack.getItemDamage(); + if (!(aStack.getItem() instanceof IGT_ItemWithMaterialRenderer aItem)) return; + + int passes = 1; + if (aItem.requiresMultipleRenderPasses()) { + passes = aItem.getRenderPasses(aMetaData); + } + + for (int pass = 0; pass < passes; pass++) { + IIcon tIcon = aItem.getIcon(aMetaData, pass); + IIcon tOverlay = aItem.getOverlayIcon(aMetaData, pass); + + GL11.glEnable(GL11.GL_BLEND); + GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + GL11.glEnable(GL11.GL_ALPHA_TEST); + + if (tIcon != null) { + markNeedsAnimationUpdate(tIcon); + magicRenderMethod(type, aStack, tIcon, false, data); + } + + GL11.glDisable(GL11.GL_LIGHTING); + + if (tOverlay != null) { + GL11.glColor3f(1.0F, 1.0F, 1.0F); + TextureUtils.bindAtlas(aItem.getSpriteNumber()); + markNeedsAnimationUpdate(tOverlay); + renderItemOverlay(type, tOverlay); + } + + GL11.glDisable(GL11.GL_BLEND); + } + } + + private void magicRenderMethod(ItemRenderType type, ItemStack aStack, IIcon tIcon, boolean fluidDisplay, + Object... data) { + if (!Avaritia.isModLoaded()) { + return; + } + + RenderItem r = RenderItem.getInstance(); + Minecraft mc = Minecraft.getMinecraft(); + Tessellator t = Tessellator.instance; + float minU = tIcon.getMinU(); + float maxU = tIcon.getMaxU(); + float minV = tIcon.getMinV(); + float maxV = tIcon.getMaxV(); + + processLightLevel(type, data); + + GL11.glPushMatrix(); + GL11.glEnable(GL11.GL_BLEND); + GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + + if (type == ItemRenderType.INVENTORY) { + RenderHelper.enableGUIStandardItemLighting(); + + GL11.glDisable(GL11.GL_ALPHA_TEST); + GL11.glDisable(GL11.GL_DEPTH_TEST); + + if (fluidDisplay) { + // this somehow makes shader render correctly + ResourceLocation resourcelocation = mc.getTextureManager() + .getResourceLocation(aStack.getItemSpriteNumber()); + mc.getTextureManager() + .bindTexture(resourcelocation); + } else { + GT_RenderUtil.renderItem(type, tIcon); + } + + GL11.glEnable(GL11.GL_BLEND); + GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + RenderHelper.enableGUIStandardItemLighting(); + + GL11.glDisable(GL11.GL_ALPHA_TEST); + GL11.glDisable(GL11.GL_DEPTH_TEST); + + if (fluidDisplay) { + GL11.glDisable(GL11.GL_BLEND); + } + + CosmicRenderShenanigans.cosmicOpacity = cosmicOpacity; + CosmicRenderShenanigans.inventoryRender = true; + CosmicRenderShenanigans.useShader(); + + GL11.glColor4d(1, 1, 1, 1); + + // Draw cosmic overlay + GT_RenderUtil.renderItem(type, tIcon); + + CosmicRenderShenanigans.releaseShader(); + CosmicRenderShenanigans.inventoryRender = false; + + GL11.glEnable(GL12.GL_RESCALE_NORMAL); + } else { + // RENDER ITEM + GT_RenderUtil.renderItem(type, tIcon); + + int program = GL11.glGetInteger(GL20.GL_CURRENT_PROGRAM); + + GL11.glDisable(GL11.GL_ALPHA_TEST); + GL11.glDepthFunc(GL11.GL_EQUAL); + CosmicRenderShenanigans.cosmicOpacity = cosmicOpacity; + CosmicRenderShenanigans.useShader(); + + // RENDER COSMIC OVERLAY + GT_RenderUtil.renderItem(type, tIcon); + CosmicRenderShenanigans.releaseShader(); + GL11.glDepthFunc(GL11.GL_LEQUAL); + + GL20.glUseProgram(program); + } + + GL11.glEnable(GL11.GL_DEPTH_TEST); + GL11.glEnable(GL11.GL_ALPHA_TEST); + GL11.glDisable(GL11.GL_BLEND); + GL11.glPopMatrix(); + } + + private void processLightLevel(ItemRenderType type, Object... data) { + switch (type) { + case ENTITY -> { + EntityItem ent = (EntityItem) (data[1]); + if (ent != null) { + CosmicRenderShenanigans.setLightFromLocation( + ent.worldObj, + MathHelper.floor_double(ent.posX), + MathHelper.floor_double(ent.posY), + MathHelper.floor_double(ent.posZ)); + } + } + case EQUIPPED, EQUIPPED_FIRST_PERSON -> { + EntityLivingBase ent = (EntityLivingBase) (data[1]); + if (ent != null) { + CosmicRenderShenanigans.setLightFromLocation( + ent.worldObj, + MathHelper.floor_double(ent.posX), + MathHelper.floor_double(ent.posY), + MathHelper.floor_double(ent.posZ)); + } + } + case INVENTORY -> { + CosmicRenderShenanigans.setLightLevel(10.2f); + } + default -> { + CosmicRenderShenanigans.setLightLevel(1.0f); + } + } + } +} |