src/main/java/com/irtimaled/bbor/client/renderers/AbstractRenderer.java

   1 package com.irtimaled.bbor.client.renderers;
   2
   3 import com.irtimaled.bbor.client.config.ConfigManager;
   4 import com.irtimaled.bbor.client.models.Point;
   5 import com.irtimaled.bbor.common.models.AbstractBoundingBox;
   6 import com.mojang.blaze3d.platform.GLX;
   7 import net.minecraft.client.Minecraft;
   8 import net.minecraft.client.gui.FontRenderer;
   9 import org.lwjgl.opengl.GL11;
  10
  11 import java.awt.*;
  12 import java.util.function.Supplier;
  13
  14 public abstract class AbstractRenderer<T extends AbstractBoundingBox> {
  15     private static final double TAU = 6.283185307179586D;
  16     private static final double PI = TAU / 2D;
  17
  18     public abstract void render(T boundingBox);
  19
  20     void renderCuboid(OffsetBox bb, Color color) {
  21         OffsetBox nudge = bb.nudge();
  22         renderOutlinedCuboid(nudge, color);
  23         renderFilledFaces(nudge.getMin(), nudge.getMax(), color, 30);
  24     }
  25
  26     void renderOutlinedCuboid(OffsetBox bb, Color color) {
  27         GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_LINE);
  28         OffsetPoint min = bb.getMin();
  29         OffsetPoint max = bb.getMax();
  30         renderFaces(min, max, color, 255, min.getY() == max.getY() ? Renderer::startLineLoop : Renderer::startLines);
  31     }
  32
  33     private void renderFaces(OffsetPoint min, OffsetPoint max, Color color, int alpha, Supplier<Renderer> rendererSupplier) {
  34         double minX = min.getX();
  35         double minY = min.getY();
  36         double minZ = min.getZ();
  37
  38         double maxX = max.getX();
  39         double maxY = max.getY();
  40         double maxZ = max.getZ();
  41
  42         if (ConfigManager.invertBoxColorPlayerInside.get() &&
  43                 playerInsideBoundingBox(minX, minY, minZ, maxX, maxY, maxZ)) {
  44             color = new Color(255 - color.getRed(), 255 - color.getGreen(), 255 - color.getBlue());
  45         }
  46
  47         Renderer renderer = rendererSupplier.get()
  48                 .setColor(color)
  49                 .setAlpha(alpha);
  50
  51         if (minX != maxX && minZ != maxZ) {
  52             renderer.addPoint(minX, minY, minZ)
  53                     .addPoint(maxX, minY, minZ)
  54                     .addPoint(maxX, minY, maxZ)
  55                     .addPoint(minX, minY, maxZ);
  56
  57             if (minY != maxY) {
  58                 renderer.addPoint(minX, maxY, minZ)
  59                         .addPoint(maxX, maxY, minZ)
  60                         .addPoint(maxX, maxY, maxZ)
  61                         .addPoint(minX, maxY, maxZ);
  62             }
  63         }
  64
  65         if (minX != maxX && minY != maxY) {
  66             renderer.addPoint(minX, minY, maxZ)
  67                     .addPoint(minX, maxY, maxZ)
  68                     .addPoint(maxX, maxY, maxZ)
  69                     .addPoint(maxX, minY, maxZ);
  70
  71             if (minZ != maxZ) {
  72                 renderer.addPoint(minX, minY, minZ)
  73                         .addPoint(minX, maxY, minZ)
  74                         .addPoint(maxX, maxY, minZ)
  75                         .addPoint(maxX, minY, minZ);
  76             }
  77         }
  78         if (minY != maxY && minZ != maxZ) {
  79             renderer.addPoint(minX, minY, minZ)
  80                     .addPoint(minX, minY, maxZ)
  81                     .addPoint(minX, maxY, maxZ)
  82                     .addPoint(minX, maxY, minZ);
  83
  84             if (minX != maxX) {
  85                 renderer.addPoint(maxX, minY, minZ)
  86                         .addPoint(maxX, minY, maxZ)
  87                         .addPoint(maxX, maxY, maxZ)
  88                         .addPoint(maxX, maxY, minZ);
  89             }
  90         }
  91         renderer.render();
  92     }
  93
  94     private boolean playerInsideBoundingBox(double minX, double minY, double minZ, double maxX, double maxY, double maxZ) {
  95         return minX < 0 && maxX > 0 && minY < 0 && maxY > 0 && minZ < 0 && maxZ > 0;
  96     }
  97
  98     void renderLine(OffsetPoint startPoint, OffsetPoint endPoint, Color color) {
  99         GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_LINE);
 100         Renderer.startLines()
 101                 .setColor(color)
 102                 .addPoint(startPoint)
 103                 .addPoint(endPoint)
 104                 .render();
 105     }
 106
 107     void renderFilledFaces(OffsetPoint min, OffsetPoint max, Color color, int alpha) {
 108         if (!ConfigManager.fill.get()) return;
 109
 110         GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_FILL);
 111         GL11.glEnable(GL11.GL_BLEND);
 112         renderFaces(min, max, color, alpha, Renderer::startQuads);
 113         GL11.glDisable(GL11.GL_BLEND);
 114         GL11.glEnable(GL11.GL_POLYGON_OFFSET_LINE);
 115         GL11.glPolygonOffset(-1.f, -1.f);
 116     }
 117
 118     void renderText(OffsetPoint offsetPoint, String... texts) {
 119         FontRenderer fontRenderer = Minecraft.getInstance().fontRenderer;
 120
 121         GL11.glDisable(GL11.GL_DEPTH_TEST);
 122         GL11.glPushMatrix();
 123         GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_FILL);
 124         GL11.glTranslated(offsetPoint.getX(), offsetPoint.getY() + 0.002D, offsetPoint.getZ());
 125         GL11.glNormal3f(0.0F, 1.0F, 0.0F);
 126         GL11.glRotatef(0.0F, 0.0F, 1.0F, 0.0F);
 127         GL11.glRotatef(90.0F, 1.0F, 0.0F, 0.0F);
 128         GL11.glScalef(-0.0175F, -0.0175F, 0.0175F);
 129         GL11.glEnable(GL11.GL_TEXTURE_2D);
 130         GL11.glEnable(GL11.GL_BLEND);
 131         GLX.glBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO);
 132
 133         GL11.glDepthMask(true);
 134         float top = -(fontRenderer.FONT_HEIGHT * texts.length) / 2f;
 135         for (String text : texts) {
 136             float left = fontRenderer.getStringWidth(text) / 2f;
 137             fontRenderer.drawString(text, -left, top, -1);
 138             top += fontRenderer.FONT_HEIGHT;
 139         }
 140         GL11.glDisable(GL11.GL_TEXTURE_2D);
 141         GL11.glDisable(GL11.GL_BLEND);
 142         GL11.glPopMatrix();
 143         GL11.glEnable(GL11.GL_DEPTH_TEST);
 144     }
 145
 146     void renderSphere(Point center, double radius, Color color, int density, int dotSize) {
 147         if (ConfigManager.renderSphereAsDots.get()) {
 148             renderDotSphere(center, radius, color, density, dotSize);
 149         } else {
 150             renderLineSphere(center, radius, color, density);
 151         }
 152     }
 153
 154     private void renderLineSphere(Point center, double radius, Color color, int density) {
 155         GL11.glLineWidth(2f);
 156         int segments = 24 + (density * 8);
 157
 158         double offset = ((radius - (int) radius) == 0) ? center.getY() - (int) center.getY() : 0;
 159         for (double dy = offset - radius; dy <= radius + 1; dy++) {
 160             double circleRadius = Math.sqrt((radius * radius) - (dy * dy));
 161             if (circleRadius == 0) circleRadius = Math.sqrt(2) / 2;
 162             renderCircle(center, circleRadius, color, segments, dy + 0.001F);
 163         }
 164     }
 165
 166     private void renderCircle(Point center, double radius, Color color, int segments, double dy) {
 167         Renderer renderer = Renderer.startLineLoop()
 168                 .setColor(color);
 169
 170         for (int a = 0; a < 360; a += 360 / segments) {
 171             double heading = a * PI / 180;
 172             renderer.addPoint(new OffsetPoint(center.offset(Math.cos(heading) * radius, dy, Math.sin(heading) * radius)));
 173         }
 174
 175         renderer.render();
 176     }
 177
 178     private void renderDotSphere(Point center, double radius, Color color, int density, int dotSize) {
 179         GL11.glEnable(GL11.GL_POINT_SMOOTH);
 180         GL11.glPointSize(dotSize);
 181         Renderer renderer = Renderer.startPoints()
 182                 .setColor(color);
 183         int segments = 24 + (density * 8);
 184
 185         double thetaSegment = PI / (double) segments;
 186         double phiSegment = TAU / (double) segments;
 187
 188         for (double phi = 0.0D; phi < TAU; phi += phiSegment) {
 189             for (double theta = 0.0D; theta < PI; theta += thetaSegment) {
 190                 double dx = radius * Math.sin(phi) * Math.cos(theta);
 191                 double dz = radius * Math.sin(phi) * Math.sin(theta);
 192                 double dy = radius * Math.cos(phi);
 193
 194                 renderer.addPoint(new OffsetPoint(center.offset(dx, dy, dz)));
 195             }
 196         }
 197         renderer.render();
 198     }
 199 }