package com.mkpk.customhud.hud; import com.mojang.blaze3d.systems.RenderSystem; import com.mkpk.customhud.config.HudConfig; import net.fabricmc.api.EnvType; import net.fabricmc.api.Environment; import net.minecraft.client.MinecraftClient; import net.minecraft.client.gui.DrawContext; import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.Identifier; @Environment(EnvType.CLIENT) public class CircleHudRenderer { private static final Identifier HEART_ICON = new Identifier("customcirclehud", "textures/gui/heart_icon.png"); private static final Identifier FOOD_ICON = new Identifier("customcirclehud", "textures/gui/food_icon.png"); private static final Identifier ARMOR_ICON = new Identifier("customcirclehud", "textures/gui/armor_icon.png"); // Zachowane dla kompatybilności / odwołań zewnętrznych - domyślny rozmiar i ikona. public static final int BOX_SIZE = 28; public static final int ICON_SIZE = 14; // Domyślne kolory wypełnienia (ARGB), używane gdy config ma -1 (brak nadpisania). public static final int DEFAULT_HEALTH_COLOR = 0xDDE63C3C; public static final int DEFAULT_FOOD_COLOR = 0xDDD89A32; public static final int DEFAULT_ARMOR_COLOR = 0xDDA9D2E0; public static void render(DrawContext context, HudConfig config) { MinecraftClient client = MinecraftClient.getInstance(); if (client.player == null) { return; } PlayerEntity player = client.player; int sw = client.getWindow().getScaledWidth(); int sh = client.getWindow().getScaledHeight(); config.initDefaults(sw, sh); float health = player.getHealth(); float maxHealth = player.getMaxHealth(); int food = player.getHungerManager().getFoodLevel(); int armor = player.getArmor(); int healthColor = config.healthColor != -1 ? config.healthColor : DEFAULT_HEALTH_COLOR; int foodColor = config.foodColor != -1 ? config.foodColor : DEFAULT_FOOD_COLOR; int armorColor = config.armorColor != -1 ? config.armorColor : DEFAULT_ARMOR_COLOR; renderStatBox(context, config.healthX, config.healthY, config.healthSize, health, maxHealth, healthColor, HEART_ICON, false); renderStatBox(context, config.foodX, config.foodY, config.foodSize, (float) food, 20.0f, foodColor, FOOD_ICON, false); if (armor > 0) { renderStatBox(context, config.armorX, config.armorY, config.armorSize, (float) armor, 20.0f, armorColor, ARMOR_ICON, false); } } public static void renderStatBox(DrawContext context, int x, int y, int boxSize, float current, float max, int fillColor, Identifier icon, boolean highlight) { float pct = (max > 0.0f) ? Math.max(0.0f, Math.min(1.0f, current / max)) : 0.0f; int bs = boxSize; int r = cornerRadiusFor(bs); // Tło: delikatna "winieta" - dwa nakładające się półprzezroczyste prostokąty // zamiast jednej płaskiej warstwy. Daje wrażenie lekkiego rozmycia/głębi // bez kosztu prawdziwego shader-blur. fillRounded(context, x, y, bs, bs, r, 0x99101014); fillRounded(context, x, y, bs, bs, r, 0x40000000); int fillHeight = (int) (bs * pct); int fillTop = y + (bs - fillHeight); if (fillHeight > 0) { boolean roundTop = fillTop <= y + r; boolean roundBottom = true; fillRoundedClipped(context, x, fillTop, bs, fillHeight, r, fillColor, roundTop, roundBottom, x, y, bs, bs); } int borderColor = highlight ? 0xFFFFFFFF : 0x88787878; drawRoundedBorder(context, x, y, bs, r, borderColor); RenderSystem.setShaderColor(1.0f, 1.0f, 1.0f, 1.0f); int iconSize = Math.max(8, (int) (bs * 0.5f)); int ix = x + (bs - iconSize) / 2; int iy = y + (bs - iconSize) / 2; context.drawTexture(icon, ix, iy, 0.0f, 0.0f, iconSize, iconSize, iconSize, iconSize); } private static int cornerRadiusFor(int boxSize) { // Promień skaluje się proporcjonalnie do rozmiaru, ale trzymamy się // dostępnych precyzyjnych tabel narożników (3, 4, 5) gdy to możliwe. int r = Math.round(boxSize * (4.0f / 28.0f)); return Math.max(2, Math.min(10, r)); } public static void fillRounded(DrawContext ctx, int x, int y, int w, int h, int r, int color) { ctx.fill(x + r, y, x + w - r, y + h, color); ctx.fill(x, y + r, x + r, y + h - r, color); ctx.fill(x + w - r, y + r, x + w, y + h - r, color); fillCorner(ctx, x, y, r, 0, color); fillCorner(ctx, x + w - r, y, r, 1, color); fillCorner(ctx, x, y + h - r, r, 2, color); fillCorner(ctx, x + w - r, y + h - r, r, 3, color); } private static void fillRoundedClipped(DrawContext ctx, int x, int y, int w, int h, int r, int color, boolean roundTop, boolean roundBottom, int clipX, int clipY, int clipW, int clipH) { int x2 = x + w; int y2 = y + h; int cx1 = Math.max(x, clipX); int cy1 = Math.max(y, clipY); int cx2 = Math.min(x2, clipX + clipW); int cy2 = Math.min(y2, clipY + clipH); if (!roundTop && !roundBottom) { ctx.fill(cx1, cy1, cx2, cy2, color); return; } int innerY1 = roundTop ? Math.max(cy1, y + r) : cy1; int innerY2 = roundBottom ? Math.min(cy2, y2 - r) : cy2; if (innerY1 < innerY2) { ctx.fill(cx1 + r, innerY1, cx2 - r, innerY2, color); ctx.fill(cx1, innerY1, cx1 + r, innerY2, color); ctx.fill(cx2 - r, innerY1, cx2, innerY2, color); } if (roundTop && cy1 < y + r) { int rowH = Math.min(y + r, cy2) - cy1; if (rowH > 0) { fillCornerClipped(ctx, cx1, cy1, r, 0, color, cy1, cy2); fillCornerClipped(ctx, cx2 - r, cy1, r, 1, color, cy1, cy2); ctx.fill(cx1 + r, cy1, cx2 - r, Math.min(y + r, cy2), color); } } else if (!roundTop) { ctx.fill(cx1, cy1, cx2, Math.min(y + r, cy2), color); } if (roundBottom && cy2 > y2 - r) { int startY = Math.max(cy1, y2 - r); if (startY < cy2) { fillCornerClipped(ctx, cx1, y2 - r, r, 2, color, startY, cy2); fillCornerClipped(ctx, cx2 - r, y2 - r, r, 3, color, startY, cy2); ctx.fill(cx1 + r, startY, cx2 - r, cy2, color); } } else if (!roundBottom) { ctx.fill(cx1, Math.max(cy1, y2 - r), cx2, cy2, color); } } private static void fillCorner(DrawContext ctx, int ox, int oy, int r, int quadrant, int color) { if (r <= 0) { return; } int[] offsets = cornerOffsets(r); for (int row = 0; row < r; row++) { int skip = offsets[row]; int rowY = (quadrant < 2) ? (oy + r - 1 - row) : (oy + row); int x1, x2; if (quadrant == 0 || quadrant == 2) { x1 = ox + skip; x2 = ox + r; } else { x1 = ox; x2 = ox + r - skip; } if (x1 < x2) { ctx.fill(x1, rowY, x2, rowY + 1, color); } } } private static void fillCornerClipped(DrawContext ctx, int ox, int oy, int r, int quadrant, int color, int clipY1, int clipY2) { if (r <= 0) { return; } int[] offsets = cornerOffsets(r); for (int row = 0; row < r; row++) { int skip = offsets[row]; int rowY = (quadrant < 2) ? (oy + r - 1 - row) : (oy + row); if (rowY >= clipY1 && rowY < clipY2) { int x1, x2; if (quadrant == 0 || quadrant == 2) { x1 = ox + skip; x2 = ox + r; } else { x1 = ox; x2 = ox + r - skip; } if (x1 < x2) { ctx.fill(x1, rowY, x2, rowY + 1, color); } } } } // Tabela przybliżonego ćwiartkowego okręgu - generowana dla dowolnego promienia, // a precyzyjne wartości ręczne zachowane dla typowych małych promieni (3-5), // gdzie wygląda to najlepiej wizualnie. private static int[] cornerOffsets(int r) { if (r == 3) return new int[]{2, 1, 0}; if (r == 4) return new int[]{3, 1, 0, 0}; if (r == 5) return new int[]{3, 2, 1, 0, 0}; int[] arr = new int[r]; for (int i = 0; i < r; i++) { double y = i + 0.5; double x = Math.sqrt(Math.max(0, r * r - y * y)); arr[i] = Math.max(0, (int) Math.round(r - x)); } return arr; } private static void drawRoundedBorder(DrawContext ctx, int x, int y, int size, int r, int color) { int x2 = x + size; int y2 = y + size; ctx.fill(x + r, y, x2 - r, y + 1, color); ctx.fill(x + r, y2 - 1, x2 - r, y2, color); ctx.fill(x, y + r, x + 1, y2 - r, color); ctx.fill(x2 - 1, y + r, x2, y2 - r, color); ctx.fill(x + 1, y + 1, x + 2, y + 2, color); ctx.fill(x2 - 2, y + 1, x2 - 1, y + 2, color); ctx.fill(x + 1, y2 - 2, x + 2, y2 - 1, color); ctx.fill(x2 - 2, y2 - 2, x2 - 1, y2 - 1, color); } }