Clamp delta reset state on world change and fade only the bar

src/main/java/mcp/mobius/waila/client/ProxyClient.java

@@ -16,7 +16,7 @@ import mcp.mobius.waila.handlers.HUDHandlerBlocks;
 import mcp.mobius.waila.handlers.HUDHandlerEntities;
 import mcp.mobius.waila.handlers.VanillaTooltipHandler;
 import mcp.mobius.waila.handlers.nei.NEIHandler;
-import mcp.mobius.waila.overlay.BlockIconRenderer;
+import mcp.mobius.waila.overlay.BreakProgressRenderer;
 import mcp.mobius.waila.overlay.tooltiprenderers.TTRenderAspectString;
 import mcp.mobius.waila.overlay.tooltiprenderers.TTRenderBar;
 import mcp.mobius.waila.overlay.tooltiprenderers.TTRenderFluidBar;
@@ -54,7 +54,8 @@ public class ProxyClient extends ProxyServer {
         ModuleRegistrar.instance().addConfig("General", "general.showents");
         ModuleRegistrar.instance().addConfig("General", "general.showhp");
         ModuleRegistrar.instance().addConfig("General", "general.showcrop");
-        ModuleRegistrar.instance().addConfig("General", BlockIconRenderer.CFG_SHOW, true);
+        ModuleRegistrar.instance().addConfig("General", BreakProgressRenderer.CFG_ENABLED, true);
+        ModuleRegistrar.instance().addConfig("General", BreakProgressRenderer.CFG_TOP, false);
 
         ModuleRegistrar.instance().registerTooltipRenderer("waila.health", new TTRenderHealth());
         ModuleRegistrar.instance().registerTooltipRenderer("waila.stack", new TTRenderStack());

src/main/java/mcp/mobius/waila/overlay/BlockIconRenderer.java

@@ -1,164 +0,0 @@
-package mcp.mobius.waila.overlay;
-
-import java.util.HashSet;
-import java.util.Set;
-
-import net.minecraft.block.Block;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.ScaledResolution;
-import net.minecraft.client.renderer.RenderBlocks;
-import net.minecraft.client.renderer.RenderHelper;
-import net.minecraft.client.renderer.Tessellator;
-import net.minecraft.client.renderer.texture.TextureMap;
-import net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher;
-import net.minecraft.tileentity.TileEntity;
-import net.minecraft.tileentity.TileEntityChest;
-import net.minecraft.world.World;
-import net.minecraftforge.client.ForgeHooksClient;
-
-import org.lwjgl.opengl.GL11;
-import org.lwjgl.opengl.GL12;
-
-import mcp.mobius.waila.api.impl.ConfigHandler;
-import mcp.mobius.waila.utils.WailaExceptionHandler;
-
-/**
- * Draws a small turning 3D model of the block in the world as the tooltip icon. Based on {@code GuiBlockDraw} of WDMla
- * (https://github.com/GTNewHorizons/WDMla), which is based on the {@code WorldSceneRenderer} of BlockRenderer6343.
- * <p>
- * The block is drawn from the real world, so the icon shows the same state (facing, connections, TESR content) as the
- * block that the player looks at.
- */
-public final class BlockIconRenderer {
-
-    public static final String CFG_SHOW = "general.showblockicon3d";
-
-    /** Degrees per second */
-    private static final float TURN_SPEED = 45f;
-    private static final float PITCH = 30f;
-
-    private static final RenderBlocks renderBlocks = new RenderBlocks();
-    private static final Set<Class<?>> failedClasses = new HashSet<>();
-
-    private BlockIconRenderer() {}
-
-    public static boolean isEnabled() {
-        return ConfigHandler.instance().getConfig(CFG_SHOW, true);
-    }
-
-    /**
-     * Draws the block at (bx, by, bz) in the square with the top left corner (x, y) and the side length size.
-     *
-     * @return false if nothing was drawn, then the caller must draw the normal item icon.
-     */
-    public static boolean render(int x, int y, int size, int bx, int by, int bz) {
-        final Minecraft mc = Minecraft.getMinecraft();
-        final World world = mc.theWorld;
-        if (world == null) return false;
-
-        Block block = world.getBlock(bx, by, bz);
-        if (block == null || block.isAir(world, bx, by, bz) || failedClasses.contains(block.getClass())) return false;
-
-        TileEntity tile = world.getTileEntity(bx, by, bz);
-        TileEntityRendererDispatcher tesr = TileEntityRendererDispatcher.instance;
-        boolean hasTesr = tile != null && tesr.hasSpecialRenderer(tile);
-        if (block.getRenderType() == -1 && !hasTesr) return false;
-        // A double chest is drawn as one large model by one of its halves, use the item icon for it
-        if (tile instanceof TileEntityChest chest && (chest.adjacentChestXNeg != null || chest.adjacentChestXPos != null
-                || chest.adjacentChestZNeg != null
-                || chest.adjacentChestZPos != null))
-            return false;
-
-        float angle = (Minecraft.getSystemTime() % 360000L) / 1000f * TURN_SPEED;
-        // A turning cube is at most about 1.6 blocks wide or high on the screen with this pitch
-        float scale = size / 1.6f;
-
-        Tessellator tessellator = Tessellator.instance;
-
-        int matrixDepth = GL11.glGetInteger(GL11.GL_MODELVIEW_STACK_DEPTH);
-        int attribDepth = GL11.glGetInteger(GL11.GL_ATTRIB_STACK_DEPTH);
-        GL11.glPushMatrix();
-        GL11.glPushAttrib(GL11.GL_ALL_ATTRIB_BITS);
-        try {
-            // Some models are larger than one block, do not draw over the text
-            ScaledResolution res = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight);
-            float factor = res.getScaleFactor() * OverlayConfig.scale;
-            int margin = 3;
-            GL11.glEnable(GL11.GL_SCISSOR_TEST);
-            GL11.glScissor(
-                    (int) ((x - margin) * factor),
-                    (int) (mc.displayHeight - (y + size + margin) * factor),
-                    (int) ((size + 2 * margin) * factor),
-                    (int) ((size + 2 * margin) * factor));
-
-            GL11.glTranslatef(x + size / 2f, y + size / 2f, 150f);
-            GL11.glScalef(scale, -scale, scale);
-            GL11.glRotatef(PITCH, 1f, 0f, 0f);
-            GL11.glRotatef(angle, 0f, 1f, 0f);
-            GL11.glTranslated(-bx - 0.5d, -by - 0.5d, -bz - 0.5d);
-
-            GL11.glColor4f(1f, 1f, 1f, 1f);
-            GL11.glEnable(GL11.GL_DEPTH_TEST);
-            GL11.glDepthMask(true);
-            GL11.glDisable(GL11.GL_CULL_FACE);
-            GL11.glEnable(GL12.GL_RESCALE_NORMAL);
-            GL11.glEnable(GL11.GL_TEXTURE_2D);
-            GL11.glEnable(GL11.GL_ALPHA_TEST);
-            GL11.glAlphaFunc(GL11.GL_GREATER, 0.1f);
-            GL11.glEnable(GL11.GL_BLEND);
-            GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
-
-            // Normal block model. The face shading of RenderBlocks gives the 3D look, so no GL lighting here.
-            if (block.getRenderType() != -1) {
-                RenderHelper.disableStandardItemLighting();
-                GL11.glDisable(GL11.GL_LIGHTING);
-                mc.renderEngine.bindTexture(TextureMap.locationBlocksTexture);
-                renderBlocks.blockAccess = world;
-                renderBlocks.renderAllFaces = true;
-                // The offsets of the tessellator are global and are not reset by draw
-                tessellator.setTranslation(0, 0, 0);
-                tessellator.startDrawingQuads();
-                try {
-                    for (int pass = 0; pass < 2; pass++) {
-                        if (!block.canRenderInPass(pass)) continue;
-                        ForgeHooksClient.setRenderPass(pass);
-                        renderBlocks.renderBlockByRenderType(block, bx, by, bz);
-                    }
-                } finally {
-                    ForgeHooksClient.setRenderPass(-1);
-                    try {
-                        tessellator.draw();
-                    } catch (IllegalStateException alreadyDrawn) {
-                        // A renderer can end the batch itself, draw would throw then
-                    }
-                    tessellator.setTranslation(0, 0, 0);
-                }
-            }
-
-            // Special renderer, also drawn on top of the block model above
-            if (hasTesr) {
-                RenderHelper.enableStandardItemLighting();
-                for (int pass = 0; pass < 2; pass++) {
-                    if (!tile.shouldRenderInPass(pass)) continue;
-                    ForgeHooksClient.setRenderPass(pass);
-                    GL11.glColor4f(1f, 1f, 1f, 1f);
-                    tesr.renderTileEntityAt(tile, bx, by, bz, 0f);
-                }
-                ForgeHooksClient.setRenderPass(-1);
-                RenderHelper.disableStandardItemLighting();
-            }
-            return true;
-        } catch (Exception e) {
-            failedClasses.add(block.getClass());
-            WailaExceptionHandler.handleErr(e, "BlockIconRenderer | " + block.getClass().getName(), null);
-            return false;
-        } finally {
-            renderBlocks.blockAccess = null;
-            renderBlocks.renderAllFaces = false;
-            // A renderer can leave unbalanced pushes behind, but should never pop the caller's. Query each
-            // stack once and pop down to where it started.
-            for (int i = GL11.glGetInteger(GL11.GL_ATTRIB_STACK_DEPTH) - attribDepth; i > 0; i--) GL11.glPopAttrib();
-            for (int i = GL11.glGetInteger(GL11.GL_MODELVIEW_STACK_DEPTH) - matrixDepth; i > 0; i--) GL11.glPopMatrix();
-        }
-    }
-}

src/main/java/mcp/mobius/waila/overlay/BreakProgressRenderer.java

@@ -0,0 +1,131 @@
+package mcp.mobius.waila.overlay;
+
+import java.lang.reflect.Field;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.PlayerControllerMP;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import net.minecraftforge.common.ForgeHooks;
+
+import cpw.mods.fml.relauncher.ReflectionHelper;
+import mcp.mobius.waila.Waila;
+import mcp.mobius.waila.api.impl.ConfigHandler;
+import mcp.mobius.waila.utils.ColorUtils;
+
+/**
+ * Draws the block break progress as a thin line on the edge of the tooltip box (Jade style). Based on the break
+ * progress of WDMla (https://github.com/GTNewHorizons/WDMla).
+ */
+public final class BreakProgressRenderer {
+
+    public static final String CFG_ENABLED = "general.breakprogress";
+    public static final String CFG_TOP = "general.breakprogresstop";
+
+    /** Alpha change per game tick */
+    private static final float FADE_PER_TICK = 0.1f;
+    /** Alpha while mining. The line is fully opaque only in the last tick before the block breaks. */
+    private static final float MAX_ALPHA = 0.6f;
+
+    private static float progress;
+    private static float alpha;
+    private static boolean canHarvest = true;
+    private static long lastFrame;
+    private static World lastWorld;
+    private static int lastX, lastY, lastW, lastH;
+
+    private static Field curBlockDamageField;
+    private static boolean fieldFailed;
+
+    private BreakProgressRenderer() {}
+
+    private static boolean isEnabled() {
+        return ConfigHandler.instance().getConfig(CFG_ENABLED, true);
+    }
+
+    /**
+     * Updates the progress state. Call this one time per frame before you draw.
+     */
+    public static void update(float partialTicks) {
+        final Minecraft mc = Minecraft.getMinecraft();
+        long now = Minecraft.getSystemTime();
+        // A paused or lagging client must not fade out in one step
+        float deltaTicks = Math.min((now - lastFrame) / 50f, 1f);
+        lastFrame = now;
+
+        if (mc.theWorld != lastWorld) {
+            lastWorld = mc.theWorld;
+            progress = alpha = 0;
+        }
+        if (!isEnabled() || mc.playerController == null || mc.theWorld == null || mc.thePlayer == null) {
+            progress = alpha = 0;
+            return;
+        }
+
+        float damage = getBlockDamage(mc.playerController);
+        MovingObjectPosition target = RayTracing.instance().getTarget();
+        if (damage <= 0 || target == null || target.typeOfHit != MovingObjectPosition.MovingObjectType.BLOCK) {
+            // Not mining (anymore), fade out the last progress
+            alpha = Math.max(alpha - deltaTicks * FADE_PER_TICK, 0f);
+            return;
+        }
+
+        int x = target.blockX, y = target.blockY, z = target.blockZ;
+        Block block = mc.theWorld.getBlock(x, y, z);
+        canHarvest = ForgeHooks.canHarvestBlock(block, mc.thePlayer, mc.theWorld.getBlockMetadata(x, y, z));
+        alpha = Math.min(alpha + deltaTicks * FADE_PER_TICK, MAX_ALPHA);
+        float perTick = block.getPlayerRelativeBlockHardness(mc.thePlayer, mc.theWorld, x, y, z);
+        if (damage + perTick >= 1f) {
+            // The block breaks in the next tick
+            alpha = progress = 1f;
+        } else {
+            progress = MathHelper.clamp_float(damage + partialTicks * perTick, 0f, 1f);
+        }
+    }
+
+    private static float getBlockDamage(PlayerControllerMP controller) {
+        if (fieldFailed) return 0f;
+        try {
+            if (curBlockDamageField == null) {
+                curBlockDamageField = ReflectionHelper
+                        .findField(PlayerControllerMP.class, "curBlockDamageMP", "field_78770_f");
+            }
+            return curBlockDamageField.getFloat(controller);
+        } catch (Exception e) {
+            fieldFailed = true;
+            Waila.log.error("Cannot read the block damage, break progress is disabled", e);
+            return 0f;
+        }
+    }
+
+    /**
+     * Draws the line on the outer row of the tooltip box. The arguments are the box geometry from {@link Tooltip}.
+     */
+    public static void draw(int x, int y, int w, int h) {
+        lastX = x;
+        lastY = y;
+        lastW = w;
+        lastH = h;
+        if (!isEnabled() || alpha <= 0) return;
+
+        int width = (int) ((w - 1) * progress);
+        if (width <= 0) return;
+
+        // Transparent as the box background
+        float boxAlpha = (OverlayConfig.alpha >>> 24) / 255f;
+        int base = canHarvest ? ColorUtils.breakProgress.getColor() : ColorUtils.breakProgressFailure.getColor();
+        int color = ((int) (((base >>> 24) & 0xFF) * alpha * boxAlpha) << 24) | (base & 0xFFFFFF);
+
+        boolean top = ConfigHandler.instance().getConfig(CFG_TOP, false);
+        DisplayUtil.drawGradientRect(x + 1, top ? y : y + h, width, 1, color, color);
+    }
+
+    /**
+     * Draws only the fading line, for when the tooltip itself is already gone.
+     */
+    public static void drawLast() {
+        draw(lastX, lastY, lastW, lastH);
+    }
+}

src/main/java/mcp/mobius/waila/overlay/OverlayRenderer.java

@@ -11,6 +11,8 @@ import mcp.mobius.waila.api.impl.ConfigHandler;
 
 public class OverlayRenderer {
 
+    private static boolean hasBlending;
+    private static boolean hasDepthTest;
     private static int boundTexIndex;
 
     public static boolean isOverlayVisible() {
@@ -21,8 +23,17 @@ public class OverlayRenderer {
                 && ConfigHandler.instance().showTooltip());
     }
 
-    public static void renderOverlay(Tooltip tooltip) {
-        if (!isOverlayVisible() || RayTracing.instance().getTarget() == null) return;
+    public static void renderOverlay(Tooltip tooltip, float partialTicks) {
+        if (!isOverlayVisible()) return;
+
+        BreakProgressRenderer.update(partialTicks);
+
+        if (RayTracing.instance().getTarget() == null
+                || RayTracing.instance().getTarget().typeOfHit == MovingObjectPosition.MovingObjectType.MISS) {
+            // Keep drawing the progress bar while it fades out after the block was broken
+            BreakProgressRenderer.drawLast();
+            return;
+        }
 
         if (RayTracing.instance().getTarget().typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK
                 && RayTracing.instance().getTargetStack() != null) {
@@ -56,6 +67,8 @@ public class OverlayRenderer {
                 OverlayConfig.gradient1,
                 OverlayConfig.gradient2);
 
+        BreakProgressRenderer.draw(tooltip.x, tooltip.y, tooltip.w, tooltip.h);
+
         GL11.glEnable(GL11.GL_BLEND);
         GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
         tooltip.draw();
@@ -67,16 +80,7 @@ public class OverlayRenderer {
 
         GL11.glEnable(GL12.GL_RESCALE_NORMAL);
 
-        boolean drawn3D = tooltip.hasIcon && tooltip.hasBlockPos
-                && BlockIconRenderer.isEnabled()
-                && BlockIconRenderer.render(
-                        tooltip.x + 5,
-                        tooltip.y + tooltip.h / 2 - 8,
-                        16,
-                        tooltip.blockX,
-                        tooltip.blockY,
-                        tooltip.blockZ);
-        if (!drawn3D && tooltip.hasIcon && tooltip.stack != null && tooltip.stack.getItem() != null)
+        if (tooltip.hasIcon && tooltip.stack != null && tooltip.stack.getItem() != null)
             DisplayUtil.renderStack(tooltip.x + 5, tooltip.y + tooltip.h / 2 - 8, tooltip.stack);
 
         loadGLState();
@@ -85,12 +89,17 @@ public class OverlayRenderer {
     }
 
     private static void saveGLState() {
+        hasBlending = GL11.glGetBoolean(GL11.GL_BLEND);
+        hasDepthTest = GL11.glGetBoolean(GL11.GL_DEPTH_TEST);
         boundTexIndex = GL11.glGetInteger(GL11.GL_TEXTURE_BINDING_2D);
-        // Icons turn on lighting, lights, color material and rescale normal; the box changes blend func and shade model
-        GL11.glPushAttrib(GL11.GL_CURRENT_BIT | GL11.GL_ENABLE_BIT | GL11.GL_LIGHTING_BIT | GL11.GL_COLOR_BUFFER_BIT);
+        GL11.glPushAttrib(GL11.GL_CURRENT_BIT);
     }
 
     private static void loadGLState() {
+        if (hasBlending) GL11.glEnable(GL11.GL_BLEND);
+        else GL11.glDisable(GL11.GL_BLEND);
+        if (hasDepthTest) GL11.glEnable(GL11.GL_DEPTH_TEST);
+        else GL11.glDisable(GL11.GL_DEPTH_TEST);
         GL11.glBindTexture(GL11.GL_TEXTURE_2D, boundTexIndex);
         GL11.glPopAttrib();
     }

src/main/java/mcp/mobius/waila/overlay/Tooltip.java

@@ -49,8 +49,6 @@ public class Tooltip {
     Point pos;
     boolean hasIcon = false;
     ItemStack stack;
-    boolean hasBlockPos = false;
-    int blockX, blockY, blockZ;
 
     IWailaCommonAccessor accessor = DataAccessorCommon.instance;
 
@@ -108,16 +106,6 @@ public class Tooltip {
         this.stack = stack;
     }
 
-    /**
-     * Sets the position of the block, so that the icon can show the block from the world.
-     */
-    public void setBlockPos(int x, int y, int z) {
-        this.hasBlockPos = true;
-        this.blockX = x;
-        this.blockY = y;
-        this.blockZ = z;
-    }
-
     public Tooltip(List<String> textData, boolean hasIcon) {
 
         if (hasIcon) hasIcon = ConfigHandler.instance().showIcon();

src/main/java/mcp/mobius/waila/overlay/WailaTickHandler.java

@@ -14,11 +14,9 @@ import net.minecraftforge.common.config.Configuration;
 
 import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import cpw.mods.fml.common.gameevent.TickEvent;
-import mcp.mobius.waila.api.IWailaBlock;
 import mcp.mobius.waila.api.impl.ConfigHandler;
 import mcp.mobius.waila.api.impl.DataAccessorCommon;
 import mcp.mobius.waila.api.impl.MetaDataProvider;
-import mcp.mobius.waila.api.impl.ModuleRegistrar;
 import mcp.mobius.waila.api.impl.TipList;
 import mcp.mobius.waila.cbcore.Layout;
 import mcp.mobius.waila.utils.Constants;
@@ -31,7 +29,7 @@ public class WailaTickHandler {
     @SubscribeEvent
     public void tickRender(TickEvent.RenderTickEvent event) {
         if (event.phase == TickEvent.Phase.END) {
-            OverlayRenderer.renderOverlay(tooltip);
+            OverlayRenderer.renderOverlay(tooltip, event.renderTickTime);
         }
     }
 
@@ -99,10 +97,6 @@ public class WailaTickHandler {
                 currenttip.addAll(currenttipTail);
 
                 this.tooltip = new Tooltip(currenttip, targetStack);
-                // Only show the world block when no provider chose another stack (camo blocks, multiparts, ...)
-                if (!(accessor.getBlock() instanceof IWailaBlock)
-                        && !ModuleRegistrar.instance().hasStackProviders(accessor.getBlock()))
-                    this.tooltip.setBlockPos(target.blockX, target.blockY, target.blockZ);
             }
         } else if (target != null && target.typeOfHit == MovingObjectPosition.MovingObjectType.ENTITY) {
             DataAccessorCommon accessor = DataAccessorCommon.instance;

src/main/java/mcp/mobius/waila/utils/ColorUtils.java

@@ -11,7 +11,9 @@ public class ColorUtils {
             fuelFurnaceBarTop       = color.argb("fuelFurnaceBarTop",    "0xFFFF8800"),
             fuelFurnaceBarBottom    = color.argb("fuelFurnaceBarBottom", "0xFFFFCC00"),
             progressBarTop          = color.argb("progressBarTop",       "0xFFFF0000"),
-            progressBarBottom       = color.argb("progressBarBottom",    "0xFF8B0000");
+            progressBarBottom       = color.argb("progressBarBottom",    "0xFF8B0000"),
+            breakProgress           = color.argb("breakProgress",        "0xFFFFFFFF"),
+            breakProgressFailure    = color.argb("breakProgressFailure", "0xFFAA0000");
     // spotless:on
 
 }

src/main/resources/assets/waila/lang/en_US.lang

@@ -153,7 +153,8 @@ option.stevescarts.shifttoggle=Shift toggle
 option.general.showents=Show entities
 option.general.showhp=Show entities health
 option.general.showcrop=Show crop growth
-option.general.showblockicon3d=Show 3D block icon
+option.general.breakprogress=Show break progress
+option.general.breakprogresstop=Break progress on top
 option.thaumcraft.aspects=Show aspects
 
 nei.options.keys.showenchant=Show enchanting values