import com.irtimaled.bbor.common.models.DimensionId;
import org.lwjgl.opengl.GL11;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
+import java.util.stream.Stream;
public class ClientRenderer {
private static final int CHUNK_SIZE = 16;
public static void render(DimensionId dimensionId) {
if (!active) return;
- Set<AbstractBoundingBox> boundingBoxes = getBoundingBoxes(dimensionId);
-
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
GL11.glLineWidth(2.0f);
GL11.glDisable(GL11.GL_TEXTURE_2D);
GL11.glClear(GL11.GL_DEPTH_BUFFER_BIT);
}
- for (AbstractBoundingBox key : boundingBoxes) {
+ getBoundingBoxes(dimensionId).forEach(key -> {
AbstractRenderer renderer = boundingBoxRendererMap.get(key.getClass());
- if (renderer == null) continue;
-
- renderer.render(key);
- }
+ if (renderer != null) renderer.render(key);
+ });
GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_FILL);
GL11.glEnable(GL11.GL_CULL_FACE);
GL11.glEnable(GL11.GL_TEXTURE_2D);
}
- p
rivate static Set<AbstractBoundingBox> getBoundingBoxes(DimensionId dimensionId) {
- Set<AbstractBoundingBox> boundingBoxes = new HashSet<>();
+ p
ublic static Stream<AbstractBoundingBox> getBoundingBoxes(DimensionId dimensionId) {
+ Stream.Builder<AbstractBoundingBox> boundingBoxes = Stream.builder();
for (IBoundingBoxProvider<?> provider : providers) {
if (provider.canProvide(dimensionId)) {
for (AbstractBoundingBox boundingBox : provider.get(dimensionId)) {
if (isWithinRenderDistance(boundingBox)) {
- boundingBoxes.add(boundingBox);
+ boundingBoxes.accept(boundingBox);
}
}
}
}
- return boundingBoxes;
+
+ Point point = Player.getPoint();
+ return boundingBoxes.build()
+ .sorted(Comparator
+ .comparingDouble((AbstractBoundingBox boundingBox) -> boundingBox.getDistance(point.getX(), point.getY(), point.getZ())).reversed());
}
+
}
coords.getZ() <= maxZ;
}
+ @Override
+ protected double getDistanceX(double x) {
+ return x - coords.getX();
+ }
+
+ @Override
+ protected double getDistanceY(double y) {
+ return y - coords.getY();
+ }
+
+ @Override
+ protected double getDistanceZ(double z) {
+ return z - coords.getZ();
+ }
+
public Coords getCoords() {
return coords;
}
package com.irtimaled.bbor.client.models;
import com.irtimaled.bbor.common.BoundingBoxType;
+import com.irtimaled.bbor.common.MathHelper;
import com.irtimaled.bbor.common.TypeHelper;
import com.irtimaled.bbor.common.models.AbstractBoundingBox;
(maxXWithinBounds && minZWithinBounds);
}
+ @Override
+ protected double getDistanceX(double x) {
+ return x - MathHelper.clamp(x, minPoint.getX(), maxPoint.getX());
+ }
+
+ @Override
+ protected double getDistanceY(double y) {
+ return y - MathHelper.clamp(y, minPoint.getY(), maxPoint.getY());
+ }
+
+ @Override
+ protected double getDistanceZ(double z) {
+ return z - MathHelper.clamp(z, minPoint.getZ(), maxPoint.getZ());
+ }
+
private boolean isBetween(double val, int min, int max) {
return val >= min && val <= max;
}
public Boolean intersectsBounds(int minX, int minZ, int maxX, int maxZ) {
return true;
}
+
+ @Override
+ protected double getDistanceX(double x) {
+ return 0;
+ }
+
+ @Override
+ protected double getDistanceY(double y) {
+ return 0;
+ }
+
+ @Override
+ protected double getDistanceZ(double z) {
+ return 0;
+ }
}
this.minZ <= maxZ;
}
+ @Override
+ protected double getDistanceX(double x) {
+ return x - point.getX();
+ }
+
+ @Override
+ protected double getDistanceY(double y) {
+ return y - point.getY();
+ }
+
+ @Override
+ protected double getDistanceZ(double z) {
+ return z - point.getZ();
+ }
+
public double getRadius() {
return radius;
}
void renderCuboid(OffsetBox bb, Color color) {
OffsetBox nudge = bb.nudge();
+ renderOutlinedCuboid(nudge, color);
if (ConfigManager.fill.get()) {
renderFilledFaces(nudge.getMin(), nudge.getMax(), color, 30);
}
- renderOutlinedCuboid(nudge, color);
}
void renderOutlinedCuboid(OffsetBox bb, Color color) {
Point point = boundingBox.getPoint();
Color color = BoundingBoxTypeHelper.getColor(boundingBox.getType());
+ if (level != 0) {
+ renderSphere(point, boundingBox.getRadius() + 0.5, color, 5, 5);
+ }
+
OffsetPoint center = new OffsetPoint(point);
OffsetBox centerBox = new OffsetBox(center, center).grow(0.5, 0.5, 0.5);
renderCuboid(centerBox, color);
renderCuboid(centerBox.grow(8, 8, 8),
ColorHelper.getColor(ConfigManager.colorConduitMobHarmArea));
}
- if (level != 0) {
- renderSphere(point, boundingBox.getRadius() + 0.5, color, 5, 5);
- }
}
}
package com.irtimaled.bbor.client.renderers;
+import com.irtimaled.bbor.client.Camera;
import net.minecraft.client.renderer.BufferBuilder;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
import java.awt.*;
public class Renderer {
+ private final int glMode;
+
static Renderer startLines() {
return new Renderer(GL11.GL_LINES, DefaultVertexFormats.POSITION_COLOR);
}
return new Renderer(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX_COLOR);
}
- private final Tessellator tessellator;
- private final BufferBuilder bufferBuilder;
+ private static final Tessellator tessellator = new Tessellator(2097152);
+ private static final BufferBuilder bufferBuilder = tessellator.getBuffer();
private int red;
private int green;
private int alpha;
private Renderer(int glMode, VertexFormat vertexFormat) {
- tessellator = Tessellator.getInstance();
- bufferBuilder = tessellator.getBuffer();
bufferBuilder.begin(glMode, vertexFormat);
+ this.glMode = glMode;
}
public Renderer setColor(Color color) {
}
public void render() {
+ if (glMode == GL11.GL_QUADS) {
+ bufferBuilder.sortVertexData((float) Camera.getX(), (float) Camera.getY(), (float) Camera.getZ());
+ }
tessellator.draw();
}
Point point = boundingBox.getPoint();
OffsetPoint sphereCenter = new OffsetPoint(point);
- OffsetBox offsetBox = new OffsetBox(sphereCenter, sphereCenter).grow(0.5, 0, 0.5);
Color safeAreaColor = ColorHelper.getColor(ConfigManager.colorAFKSpheresSafeArea);
+ renderSphere(point, BoundingBoxSpawningSphere.SAFE_RADIUS, safeAreaColor, 5, 5);
+
+ renderOuterSphere(boundingBox, point);
+
+ OffsetBox offsetBox = new OffsetBox(sphereCenter, sphereCenter).grow(0.5, 0, 0.5);
renderCuboid(offsetBox, safeAreaColor);
Integer spawnableSpacesCount = boundingBox.getSpawnableSpacesCount();
String.format("%,d", spawnableSpacesCount));
}
- renderSphere(point, BoundingBoxSpawningSphere.SAFE_RADIUS, safeAreaColor, 5, 5);
-
- renderOuterSphere(boundingBox, point);
-
if (ConfigManager.renderAFKSpawnableBlocks.get() && boundingBox.isWithinSphere(Player.getPoint())) {
renderSpawnableSpaces(boundingBox);
}
if (fraction % midpoint == 1) fraction++;
return floor + (fraction / multiplier);
}
+
+ public static int clamp(int value, int min, int max) {
+ if (value < min) return min;
+ return Math.min(value, max);
+ }
+
+ public static double clamp(double value, double min, double max) {
+ if (value < min) return min;
+ return Math.min(value, max);
+ }
}
public BoundingBoxType getType() {
return type;
}
+
+ public double getDistance(double x, double y, double z) {
+ double dX = getDistanceX(x);
+ double dY = getDistanceY(y);
+ double dZ = getDistanceZ(z);
+ return Math.cbrt(dX * dX + dY * dY + dZ * dZ);
+ }
+
+ protected abstract double getDistanceX(double x);
+
+ protected abstract double getDistanceY(double y);
+
+ protected abstract double getDistanceZ(double z);
}
package com.irtimaled.bbor.common.models;
import com.irtimaled.bbor.common.BoundingBoxType;
+import com.irtimaled.bbor.common.MathHelper;
import com.irtimaled.bbor.common.TypeHelper;
public class BoundingBoxCuboid extends AbstractBoundingBox {
private boolean isBetween(int val, int min, int max) {
return val >= min && val <= max;
}
+
+ @Override
+ public double getDistanceX(double x) {
+ return x - MathHelper.clamp(x, minCoords.getX(), maxCoords.getX());
+ }
+
+ @Override
+ public double getDistanceY(double y) {
+ return y - MathHelper.clamp(y, minCoords.getY(), maxCoords.getY());
+ }
+
+ @Override
+ public double getDistanceZ(double z) {
+ return z - MathHelper.clamp(z, minCoords.getZ(), maxCoords.getZ());
+ }
}
projects / BoundingBoxOutlineReloaded.git / commitdiff