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

   1 package com.irtimaled.bbor.client.renderers;
   2
   3 import com.irtimaled.bbor.client.Camera;
   4 import com.irtimaled.bbor.client.RenderCulling;
   5 import com.irtimaled.bbor.client.config.ConfigManager;
   6 import com.irtimaled.bbor.client.models.Point;
   7 import com.irtimaled.bbor.common.MathHelper;
   8 import com.irtimaled.bbor.common.models.AbstractBoundingBox;
   9 import com.mojang.blaze3d.systems.RenderSystem;
  10 import net.minecraft.client.MinecraftClient;
  11 import net.minecraft.client.font.TextRenderer;
  12 import net.minecraft.client.gl.VertexBuffer;
  13 import net.minecraft.client.render.BufferBuilder;
  14 import net.minecraft.client.render.BufferRenderer;
  15 import net.minecraft.client.render.GameRenderer;
  16 import net.minecraft.client.render.Shader;
  17 import net.minecraft.client.render.Tessellator;
  18 import net.minecraft.client.render.VertexFormat;
  19 import net.minecraft.client.render.VertexFormats;
  20 import net.minecraft.client.util.math.MatrixStack;
  21 import net.minecraft.util.math.BlockPos;
  22 import net.minecraft.util.math.Box;
  23 import net.minecraft.util.math.Matrix4f;
  24 import org.lwjgl.opengl.GL11;
  25
  26 import java.awt.*;
  27
  28 public abstract class AbstractRenderer<T extends AbstractBoundingBox> {
  29     private static final double TAU = 6.283185307179586D;
  30     public static final double PHI_SEGMENT = TAU / 90D;
  31     private static final double PI = TAU / 2D;
  32     public static final double THETA_SEGMENT = PHI_SEGMENT / 2D;
  33     private static final float DEFAULT_LINE_WIDTH = 0.0025f;
  34
  35     private final VertexBuffer solidBox = new VertexBuffer();
  36     private final VertexBuffer outlinedBox = new VertexBuffer();
  37
  38     {
  39         final Box box = new Box(BlockPos.ORIGIN);
  40         RenderHelper.drawSolidBox(box, solidBox);
  41         RenderHelper.drawOutlinedBox(box, outlinedBox);
  42     }
  43
  44     public abstract void render(MatrixStack matrixStack, T boundingBox);
  45
  46     void renderCuboid(MatrixStack matrixStack, OffsetBox bb, Color color, boolean fillOnly, int fillAlpha) {
  47         OffsetBox nudge = bb.nudge();
  48
  49         GL11.glEnable(GL11.GL_CULL_FACE);
  50         RenderHelper.polygonModeFill();
  51         matrixStack.push();
  52
  53         RenderSystem.depthMask(false);
  54         renderCuboid0(matrixStack, nudge, color, fillOnly, fillAlpha);
  55         RenderSystem.depthMask(true);
  56
  57         matrixStack.pop();
  58         RenderSystem.setShaderColor(1, 1, 1, 1);
  59     }
  60
  61     private void renderCuboid0(MatrixStack stack, OffsetBox nudge, Color color, boolean fillOnly, int fillAlpha) {
  62         if (!RenderCulling.isVisibleCulling(nudge.toBox())) return;
  63         if (ConfigManager.invertBoxColorPlayerInside.get() &&
  64                 playerInsideBoundingBox(nudge)) {
  65             color = new Color(255 - color.getRed(), 255 - color.getGreen(), 255 - color.getBlue());
  66         }
  67         final MatrixStack.Entry lastStack = stack.peek();
  68         stack.push();
  69         int regionX = (((int) Camera.getX()) >> 9) << 9;
  70         int regionZ = (((int) Camera.getZ()) >> 9) << 9;
  71         RenderHelper.applyRegionalRenderOffset(stack);
  72         RenderSystem.setShader(GameRenderer::getPositionShader);
  73         final double minX = nudge.getMin().getX();
  74         final double minY = nudge.getMin().getY();
  75         final double minZ = nudge.getMin().getZ();
  76         final double maxX = nudge.getMax().getX();
  77         final double maxY = nudge.getMax().getY();
  78         final double maxZ = nudge.getMax().getZ();
  79         stack.translate(minX - regionX, minY, minZ - regionZ);
  80         stack.scale((float) (maxX - minX),
  81                 (float) (maxY - minY),
  82                 (float) (maxZ - minZ));
  83
  84         Matrix4f viewMatrix = stack.peek().getModel();
  85         Matrix4f projMatrix = RenderSystem.getProjectionMatrix();
  86         Shader shader = RenderSystem.getShader();
  87         if (fillOnly || ConfigManager.fill.get()) {
  88             RenderSystem.setShaderColor(color.getRed() / 255F, color.getGreen() / 255F, color.getBlue() / 255F, fillAlpha / 255F);
  89             solidBox.setShader(viewMatrix, projMatrix, shader);
  90         }
  91         if (!fillOnly) {
  92             RenderSystem.setShaderColor(color.getRed() / 255F, color.getGreen() / 255F, color.getBlue() / 255F, 1F);
  93 //            outlinedBox.setShader(viewMatrix, projMatrix, shader);
  94             final double minXL = minX - getLineWidth();
  95             final double minYL = minY - getLineWidth();
  96             final double minZL = minZ - getLineWidth();
  97             final double maxXL = maxX + getLineWidth();
  98             final double maxYL = maxY + getLineWidth();
  99             final double maxZL = maxZ + getLineWidth();
 100             stack.push();
 101             stack.peek().getModel().load(lastStack.getModel());
 102             stack.peek().getNormal().load(lastStack.getNormal());
 103             renderLine(stack, new OffsetPoint(minXL, minYL, minZL), new OffsetPoint(maxXL, minYL, minZL), color);
 104             renderLine(stack, new OffsetPoint(maxXL, minYL, minZL), new OffsetPoint(maxXL, minYL, maxZL), color);
 105             renderLine(stack, new OffsetPoint(maxXL, minYL, maxZL), new OffsetPoint(minXL, minYL, maxZL), color);
 106             renderLine(stack, new OffsetPoint(minXL, minYL, maxZL), new OffsetPoint(minXL, minYL, minZL), color);
 107             renderLine(stack, new OffsetPoint(minXL, minYL, minZL), new OffsetPoint(minXL, maxYL, minZL), color);
 108             renderLine(stack, new OffsetPoint(maxXL, minYL, minZL), new OffsetPoint(maxXL, maxYL, minZL), color);
 109             renderLine(stack, new OffsetPoint(maxXL, minYL, maxZL), new OffsetPoint(maxXL, maxYL, maxZL), color);
 110             renderLine(stack, new OffsetPoint(minXL, minYL, maxZL), new OffsetPoint(minXL, maxYL, maxZL), color);
 111             renderLine(stack, new OffsetPoint(minXL, maxYL, minZL), new OffsetPoint(maxXL, maxYL, minZL), color);
 112             renderLine(stack, new OffsetPoint(maxXL, maxYL, minZL), new OffsetPoint(maxXL, maxYL, maxZL), color);
 113             renderLine(stack, new OffsetPoint(maxXL, maxYL, maxZL), new OffsetPoint(minXL, maxYL, maxZL), color);
 114             renderLine(stack, new OffsetPoint(minXL, maxYL, maxZL), new OffsetPoint(minXL, maxYL, minZL), color);
 115             stack.pop();
 116         }
 117
 118         stack.pop();
 119     }
 120
 121     private boolean playerInsideBoundingBox(OffsetBox nudge) {
 122         return nudge.getMin().getX() < 0 && nudge.getMax().getX() > 0 &&
 123                 nudge.getMin().getY() < 0 && nudge.getMax().getY() > 0 &&
 124                 nudge.getMin().getZ() < 0 && nudge.getMax().getZ() > 0;
 125     }
 126
 127     private double getLineWidth() {
 128         return DEFAULT_LINE_WIDTH * ConfigManager.lineWidthModifier.get();
 129     }
 130
 131     void renderLine(MatrixStack matrixStack, OffsetPoint startPoint, OffsetPoint endPoint, Color color) {
 132         if ((startPoint.getY() == endPoint.getY() && startPoint.getZ() == endPoint.getZ()) ||
 133                 (startPoint.getX() == endPoint.getX() && startPoint.getZ() == endPoint.getZ()) ||
 134                 (startPoint.getX() == endPoint.getX() && startPoint.getY() == endPoint.getY())) {
 135             RenderSystem.depthMask(true);
 136             renderCuboid0(matrixStack, new OffsetBox(startPoint.offset(-getLineWidth(), -getLineWidth(), -getLineWidth()), endPoint.offset(getLineWidth(), getLineWidth(), getLineWidth())), color, true, 255);
 137             RenderSystem.depthMask(false);
 138             return;
 139         }
 140
 141         if (!RenderCulling.isVisibleCulling(new OffsetBox(startPoint, endPoint).toBox())) return; // TODO better culling
 142
 143         matrixStack.push();
 144
 145         RenderHelper.applyRegionalRenderOffset(matrixStack);
 146         RenderSystem.setShader(GameRenderer::getPositionShader);
 147         RenderSystem.setShaderColor(color.getRed() / 255F, color.getGreen() / 255F, color.getBlue() / 255F, 1F);
 148         int regionX = (((int) Camera.getX()) >> 9) * 512;
 149         int regionZ = (((int) Camera.getZ()) >> 9) * 512;
 150
 151         BufferBuilder bufferBuilder = Tessellator.getInstance().getBuffer();
 152         bufferBuilder.begin(VertexFormat.DrawMode.DEBUG_LINES,
 153                 VertexFormats.POSITION);
 154         bufferBuilder
 155                 .vertex(matrixStack.peek().getModel(),
 156                         (float) startPoint.getX() - regionX,
 157                         (float) startPoint.getY(),
 158                         (float) startPoint.getZ() - regionZ)
 159                 .next();
 160         bufferBuilder
 161                 .vertex(matrixStack.peek().getModel(),
 162                         (float) endPoint.getX() - regionX,
 163                         (float) endPoint.getY(),
 164                         (float) endPoint.getZ() - regionZ)
 165                 .next();
 166         bufferBuilder.end();
 167         BufferRenderer.draw(bufferBuilder);
 168
 169         matrixStack.pop();
 170     }
 171
 172     void renderText(MatrixStack matrixStack, OffsetPoint offsetPoint, String... texts) {
 173         TextRenderer fontRenderer = MinecraftClient.getInstance().textRenderer;
 174         RenderHelper.beforeRenderFont(matrixStack, offsetPoint);
 175         float top = -(fontRenderer.fontHeight * texts.length) / 2f;
 176         for (String text : texts) {
 177             float left = fontRenderer.getWidth(text) / 2f;
 178             fontRenderer.draw(new MatrixStack(), text, -left, top, -1);
 179             top += fontRenderer.fontHeight;
 180         }
 181         RenderHelper.afterRenderFont(matrixStack);
 182     }
 183
 184     void renderSphere(MatrixStack matrixStack, Point center, double radius, Color color) {
 185         if (ConfigManager.renderSphereAsDots.get()) {
 186             renderDotSphere(matrixStack, center, radius, color);
 187         } else {
 188             renderLineSphere(matrixStack, center, radius, color);
 189         }
 190     }
 191
 192     private void renderLineSphere(MatrixStack matrixStack, Point center, double radius, Color color) {
 193         if (!RenderCulling.isVisibleCulling(new Box(new BlockPos(center.getX(), center.getY(), center.getZ())).expand(radius))) return;
 194         RenderHelper.lineWidth2();
 195
 196         double offset = ((radius - (int) radius) == 0) ? center.getY() - (int) center.getY() : 0;
 197         int dyStep = radius < 64 ? 1 : MathHelper.floor(radius / 32);
 198         for (double dy = offset - radius; dy <= radius + 1; dy += dyStep) {
 199             double circleRadius = Math.sqrt((radius * radius) - (dy * dy));
 200             if (circleRadius == 0) circleRadius = Math.sqrt(2) / 2;
 201             renderCircle(matrixStack, center, circleRadius, color, dy + 0.001F);
 202         }
 203     }
 204
 205     private void renderCircle(MatrixStack matrixStack, Point center, double radius, Color color, double dy) {
 206         matrixStack.push();
 207
 208         RenderHelper.applyRegionalRenderOffset(matrixStack);
 209         RenderSystem.setShader(GameRenderer::getPositionShader);
 210         RenderSystem.setShaderColor(color.getRed() / 255F, color.getGreen() / 255F, color.getBlue() / 255F, 0.55f);
 211         int regionX = (((int) Camera.getX()) >> 9) * 512;
 212         int regionZ = (((int) Camera.getZ()) >> 9) * 512;
 213
 214         BufferBuilder bufferBuilder = Tessellator.getInstance().getBuffer();
 215         bufferBuilder.begin(VertexFormat.DrawMode.DEBUG_LINE_STRIP,
 216                 VertexFormats.POSITION);
 217
 218         Point firstPoint = null;
 219
 220         for (double phi = 0.0D; phi < TAU; phi += PHI_SEGMENT) {
 221             final Point point = center.offset(Math.cos(phi) * radius, dy, Math.sin(phi) * radius);
 222             if (firstPoint == null) firstPoint = point;
 223             bufferBuilder.vertex(matrixStack.peek().getModel(),
 224                     (float) point.getX() - regionX,
 225                     (float) point.getY(),
 226                     (float) point.getZ() - regionZ)
 227                     .next();
 228         }
 229
 230         bufferBuilder.vertex(matrixStack.peek().getModel(),
 231                 (float) firstPoint.getX() - regionX,
 232                 (float) firstPoint.getY(),
 233                 (float) firstPoint.getZ() - regionZ)
 234                 .next();
 235
 236         bufferBuilder.end();
 237         BufferRenderer.draw(bufferBuilder);
 238         matrixStack.pop();
 239     }
 240
 241     private void renderDotSphere(MatrixStack matrixStack, Point center, double radius, Color color) {
 242         if (!RenderCulling.isVisibleCulling(new Box(new BlockPos(center.getX(), center.getY(), center.getZ())).expand(radius))) return;
 243         matrixStack.push();
 244         RenderHelper.applyRegionalRenderOffset(matrixStack);
 245         RenderSystem.setShader(GameRenderer::getPositionShader);
 246         RenderSystem.setShaderColor(color.getRed() / 255F, color.getGreen() / 255F, color.getBlue() / 255F, 0.55f);
 247         int regionX = (((int) Camera.getX()) >> 9) * 512;
 248         int regionZ = (((int) Camera.getZ()) >> 9) * 512;
 249
 250         BufferBuilder bufferBuilder = Tessellator.getInstance().getBuffer();
 251         bufferBuilder.begin(VertexFormat.DrawMode.QUADS,
 252                 VertexFormats.POSITION);
 253
 254         for (double phi = 0.0D; phi < TAU; phi += PHI_SEGMENT) {
 255             double dy = radius * Math.cos(phi);
 256             double radiusBySinPhi = radius * Math.sin(phi);
 257             for (double theta = 0.0D; theta < PI; theta += THETA_SEGMENT) {
 258                 double dx = radiusBySinPhi * Math.cos(theta);
 259                 double dz = radiusBySinPhi * Math.sin(theta);
 260
 261                 final Point point = center.offset(dx, dy, dz);
 262                 bufferBuilder
 263                         .vertex(matrixStack.peek().getModel(),
 264                                 (float) point.getX() - regionX,
 265                                 (float) point.getY(),
 266                                 (float) point.getZ() - regionZ)
 267                         .next();
 268             }
 269         }
 270         bufferBuilder.end();
 271         BufferRenderer.draw(bufferBuilder);
 272         matrixStack.pop();
 273     }
 274 }