import com.irtimaled.bbor.client.renderers.*;
import com.irtimaled.bbor.common.BoundingBoxCache;
import com.irtimaled.bbor.common.BoundingBoxType;
+import com.irtimaled.bbor.common.MathHelper;
import com.irtimaled.bbor.common.models.*;
import com.irtimaled.bbor.config.ConfigManager;
import net.minecraft.client.Minecraft;
-import net.minecraft.util.math.ChunkPos;
-import net.minecraft.util.math.MathHelper;
import net.minecraft.world.dimension.DimensionType;
import org.lwjgl.opengl.GL11;
import java.util.*;
-import static com.irtimaled.bbor.client.Constants.CHUNK_SIZE;
-
public class ClientRenderer {
- private final GetCache getCache;
+ private static final int CHUNK_SIZE = 16;
private static final Map<Class<? extends BoundingBox>, Renderer> boundingBoxRendererMap = new HashMap<>();
+
+ private final GetCache getCache;
private long seed;
private Set<BoundingBox> spawnChunkBoundingBoxes = new HashSet<>();
boundingBoxRendererMap.put(BoundingBoxMobSpawner.class, new MobSpawnerRenderer());
}
- private boolean isWithinRenderDistance(Coords minCoords, Coords maxCoords) {
- int renderDistanceBlocks = Minecraft.getInstance().gameSettings.renderDistanceChunks * CHUNK_SIZE;
+ private boolean isWithinRenderDistance(BoundingBox boundingBox) {
+ Coords minCoords = boundingBox.getMinCoords();
+ Coords maxCoords = boundingBox.getMaxCoords();
+ int renderDistanceBlocks = getRenderDistanceChunks() * CHUNK_SIZE;
int minX = MathHelper.floor(PlayerCoords.getX() - renderDistanceBlocks);
int maxX = MathHelper.floor(PlayerCoords.getX() + renderDistanceBlocks);
int minZ = MathHelper.floor(PlayerCoords.getZ() - renderDistanceBlocks);
minCoords.getZ() <= maxZ;
}
- private boolean isWithinRenderDistance(BoundingBox boundingBox) {
- return isWithinRenderDistance(boundingBox.getMinCoords(), boundingBox.getMaxCoords());
- }
-
public void render(DimensionType dimensionType, Boolean outerBoxesOnly) {
Map<BoundingBox, Set<BoundingBox>> boundingBoxes = getBoundingBoxes(dimensionType);
}
private void addSlimeChunks(Map<BoundingBox, Set<BoundingBox>> boundingBoxes) {
- Minecraft minecraft = Minecraft.getInstance();
- int renderDistanceChunks = minecraft.gameSettings.renderDistanceChunks;
+ int renderDistanceChunks = getRenderDistanceChunks();
int playerChunkX = MathHelper.floor(PlayerCoords.getX() / 16.0D);
int playerChunkZ = MathHelper.floor(PlayerCoords.getZ() / 16.0D);
for (int chunkX = playerChunkX - renderDistanceChunks; chunkX <= playerChunkX + renderDistanceChunks; ++chunkX) {
for (int chunkZ = playerChunkZ - renderDistanceChunks; chunkZ <= playerChunkZ + renderDistanceChunks; ++chunkZ) {
if (isSlimeChunk(chunkX, chunkZ)) {
- ChunkPos chunk = new ChunkPos(chunkX, chunkZ);
- Coords minCoords = new Coords(chunk.getXStart(), 1, chunk.getZStart());
- Coords maxCoords = new Coords(chunk.getXEnd(), 38, chunk.getZEnd());
+ int chunkXStart = chunkX << 4;
+ int chunkZStart = chunkZ << 4;
+ Coords minCoords = new Coords(chunkXStart, 1, chunkZStart);
+ Coords maxCoords = new Coords(chunkXStart + 15, 38, chunkZStart + 15);
boundingBoxes.put(BoundingBoxSlimeChunk.from(minCoords, maxCoords), null);
}
}
}
}
+ private int getRenderDistanceChunks() {
+ return Minecraft.getInstance().gameSettings.renderDistanceChunks;
+ }
+
private boolean isSlimeChunk(int chunkX, int chunkZ) {
Random r = new Random(seed +
(long) (chunkX * chunkX * 4987142) +
+++ /dev/null
-package com.irtimaled.bbor.client;
-
-public class Constants {
- public static final int CHUNK_SIZE = 16;
-}
if (ConfigManager.renderMobSpawnerSpawnArea.get()) {
renderBoundingBox(boundingBox);
} else {
- renderCuboid(getAxisAlignedBB(coords, coords, true), color, fill());
+ renderCuboid(new OffsetBox(coords, coords), color, fill());
}
if (!ConfigManager.renderMobSpawnerActivationLines.get()) return;
- renderActivationLines(coords);
+ renderActivationLine(new OffsetPoint(coords).offset(0.5, 0.5, 0.5));
}
- private void renderActivationLines(Coords coords) {
- OffsetPoint centerPoint = new OffsetPoint(coords).add(0.5, 0.5, 0.5);
+ private void renderActivationLine(OffsetPoint centerPoint) {
OffsetPoint playerPos = new OffsetPoint(PlayerCoords.getX(), PlayerCoords.getY(), PlayerCoords.getZ());
double distance = centerPoint.getDistance(playerPos);
- if (distance > 20.0) return;
-
- Color color = distance <= 18.0 ? distance <= 16.0 ? Color.GREEN : Colors.DARK_ORANGE : Color.RED;
- renderLine(centerPoint, playerPos.add(0, 0.1, 0), color);
-
+ if (distance <= 20) {
+ Color color = distance > 18 ? Color.RED : distance > 16 ? Colors.DARK_ORANGE : Color.GREEN;
+ renderLine(centerPoint, playerPos.offset(0, 0.1, 0), color);
+ }
}
}
--- /dev/null
+package com.irtimaled.bbor.client.renderers;
+
+import com.irtimaled.bbor.common.models.Coords;
+
+class OffsetBox {
+ private final OffsetPoint min;
+ private final OffsetPoint max;
+
+ OffsetBox(Coords minCoords, Coords maxCoords) {
+ this.min = new OffsetPoint(minCoords);
+ this.max = new OffsetPoint(maxCoords).offset(1, 1, 1);
+ }
+
+ OffsetBox(double minX, double minY, double minZ, double maxX, double maxY, double maxZ) {
+ this.min = new OffsetPoint(minX, minY, minZ);
+ this.max = new OffsetPoint(maxX, maxY, maxZ);
+ }
+
+ OffsetBox(OffsetPoint min, OffsetPoint max) {
+ this.min = min;
+ this.max = max;
+ }
+
+ OffsetBox grow(double x, double y, double z) {
+ return new OffsetBox(min.offset(-x, -y, -z), max.offset(x, y, z));
+ }
+
+ OffsetBox nudge() {
+ double growXZ = 0.001F;
+ double growY = 0;
+ if (min.getY() != max.getY()) {
+ growY = growXZ;
+ }
+ return grow(growXZ, growY, growXZ);
+ }
+
+ OffsetPoint getMin() {
+ return min;
+ }
+
+ OffsetPoint getMax() {
+ return max;
+ }
+}
import com.irtimaled.bbor.client.PlayerCoords;
import com.irtimaled.bbor.common.models.Coords;
-public class OffsetPoint {
+class OffsetPoint {
private final double x;
private final double y;
private final double z;
this.z = z;
}
- OffsetPoint(Coords coords) {
- this.x = coords.getX();
- this.y = coords.getY();
- this.z = coords.getZ();
+ OffsetPoint(Coords Coords) {
+ this.x = Coords.getX();
+ this.y = Coords.getY();
+ this.z = Coords.getZ();
}
double getX() {
return z - PlayerCoords.getZ();
}
- public OffsetPoint add(double x, double y, double z) {
+ OffsetPoint offset(double x, double y, double z) {
return new OffsetPoint(this.x + x, this.y + y, this.z + z);
}
- public double getDistance(OffsetPoint point) {
+ double getDistance(OffsetPoint point) {
double dx = this.x - point.x;
double dy = this.y - point.y;
double dz = this.z - point.z;
return Math.sqrt(dx * dx + dy * dy + dz * dz);
}
-
- public double getDistanceFromPlayer() {
- double dx = this.x - PlayerCoords.getX();
- double dy = this.y - PlayerCoords.getY();
- double dz = this.z - PlayerCoords.getZ();
- return Math.sqrt(dx * dx + dy * dy + dz * dz);
- }
}
package com.irtimaled.bbor.client.renderers;
-import com.irtimaled.bbor.client.PlayerCoords;
import com.irtimaled.bbor.common.models.BoundingBox;
-import com.irtimaled.bbor.common.models.Coords;
import com.irtimaled.bbor.config.ConfigManager;
import net.minecraft.client.renderer.BufferBuilder;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
-import net.minecraft.util.math.AxisAlignedBB;
import org.lwjgl.opengl.GL11;
import java.awt.*;
public abstract void render(T boundingBox);
void renderBoundingBox(T boundingBox) {
- renderCuboid(getAxisAlignedBB(boundingBox), boundingBox.getColor(), fill());
- }
-
- AxisAlignedBB getAxisAlignedBB(T boundingBox) {
- return getAxisAlignedBB(boundingBox, true);
- }
-
- AxisAlignedBB getAxisAlignedBB(T boundingBox, boolean extendMaxByOne) {
- Coords min = boundingBox.getMinCoords();
- Coords max = boundingBox.getMaxCoords();
- return getAxisAlignedBB(min, max, extendMaxByOne);
- }
-
- AxisAlignedBB getAxisAlignedBB(Coords min, Coords max, boolean extendMaxByOne) {
- AxisAlignedBB bb = new AxisAlignedBB(min.getX(), min.getY(), min.getZ(), max.getX(), max.getY(), max.getZ());
- if (extendMaxByOne)
- return bb.expand(1, 1, 1);
- return bb;
+ OffsetBox bb = new OffsetBox(boundingBox.getMinCoords(), boundingBox.getMaxCoords());
+ renderCuboid(bb, boundingBox.getColor(), fill());
}
boolean fill() {
return ConfigManager.fill.get();
}
- void renderRectangle(AxisAlignedBB aaBB, double minY, double maxY, Color color, Boolean fill) {
- aaBB = new AxisAlignedBB(aaBB.minX, minY, aaBB.minZ, aaBB.maxX, maxY, aaBB.maxZ);
- renderCuboid(aaBB, color, fill);
- }
-
void renderLine(OffsetPoint point1, OffsetPoint point2, Color color) {
int colorR = color.getRed();
int colorG = color.getGreen();
tessellator.draw();
}
- void renderCuboid(AxisAlignedBB aaBB, Color color, boolean fill) {
- aaBB = offsetAxisAlignedBB(aaBB);
+ void renderCuboid(OffsetBox bb, Color color, boolean fill) {
+ bb = bb.nudge();
if (fill) {
- renderFilledCuboid(aaBB, color);
- }
- renderUnfilledCuboid(aaBB, color);
- }
-
- private AxisAlignedBB offsetAxisAlignedBB(AxisAlignedBB axisAlignedBB) {
- double growXZ = 0.001F;
- double growY = 0;
- if (axisAlignedBB.minY != axisAlignedBB.maxY) {
- growY = growXZ;
+ renderFilledCuboid(bb, color);
}
- return axisAlignedBB
- .grow(growXZ, growY, growXZ)
- .offset(-PlayerCoords.getX(), -PlayerCoords.getY(), -PlayerCoords.getZ());
+ renderUnfilledCuboid(bb, color);
}
- private void renderFilledCuboid(AxisAlignedBB aaBB, Color color) {
+ private void renderFilledCuboid(OffsetBox bb, Color color) {
GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_FILL);
GL11.glEnable(GL11.GL_BLEND);
- renderCuboid(aaBB, 30, color);
+ renderCuboid(bb, 30, color);
GL11.glDisable(GL11.GL_BLEND);
GL11.glEnable(GL11.GL_POLYGON_OFFSET_LINE);
GL11.glPolygonOffset(-1.f, -1.f);
}
- private void renderUnfilledCuboid(AxisAlignedBB aaBB, Color color) {
+ private void renderUnfilledCuboid(OffsetBox bb, Color color) {
GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_LINE);
- renderCuboid(aaBB, 255, color);
+ renderCuboid(bb, 255, color);
}
- private void renderCuboid(AxisAlignedBB bb, int alphaChannel, Color color) {
- Tessellator tessellator = Tessellator.getInstance();
- BufferBuilder worldRenderer = tessellator.getBuffer();
-
+ private void renderCuboid(OffsetBox bb, int alphaChannel, Color color) {
int colorR = color.getRed();
int colorG = color.getGreen();
int colorB = color.getBlue();
+ OffsetPoint min = bb.getMin();
+ OffsetPoint max = bb.getMax();
+
+ Tessellator tessellator = Tessellator.getInstance();
+ BufferBuilder worldRenderer = tessellator.getBuffer();
+
worldRenderer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_COLOR);
- worldRenderer.pos(bb.minX, bb.minY, bb.minZ)
+ worldRenderer.pos(min.getX(), min.getY(), min.getZ())
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
- worldRenderer.pos(bb.maxX, bb.minY, bb.minZ)
+ worldRenderer.pos(max.getX(), min.getY(), min.getZ())
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
- worldRenderer.pos(bb.maxX, bb.minY, bb.maxZ)
+ worldRenderer.pos(max.getX(), min.getY(), max.getZ())
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
- worldRenderer.pos(bb.minX, bb.minY, bb.maxZ)
+ worldRenderer.pos(min.getX(), min.getY(), max.getZ())
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
- if (bb.minY != bb.maxY) {
- worldRenderer.pos(bb.minX, bb.maxY, bb.minZ)
+ if (min.getY() != max.getY()) {
+ worldRenderer.pos(min.getX(), max.getY(), min.getZ())
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
- worldRenderer.pos(bb.maxX, bb.maxY, bb.minZ)
+ worldRenderer.pos(max.getX(), max.getY(), min.getZ())
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
- worldRenderer.pos(bb.maxX, bb.maxY, bb.maxZ)
+ worldRenderer.pos(max.getX(), max.getY(), max.getZ())
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
- worldRenderer.pos(bb.minX, bb.maxY, bb.maxZ)
+ worldRenderer.pos(min.getX(), max.getY(), max.getZ())
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
- worldRenderer.pos(bb.minX, bb.minY, bb.maxZ)
+ worldRenderer.pos(min.getX(), min.getY(), max.getZ())
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
- worldRenderer.pos(bb.minX, bb.maxY, bb.maxZ)
+ worldRenderer.pos(min.getX(), max.getY(), max.getZ())
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
- worldRenderer.pos(bb.maxX, bb.maxY, bb.maxZ)
+ worldRenderer.pos(max.getX(), max.getY(), max.getZ())
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
- worldRenderer.pos(bb.maxX, bb.minY, bb.maxZ)
+ worldRenderer.pos(max.getX(), min.getY(), max.getZ())
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
- worldRenderer.pos(bb.minX, bb.minY, bb.minZ)
+ worldRenderer.pos(min.getX(), min.getY(), min.getZ())
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
- worldRenderer.pos(bb.minX, bb.maxY, bb.minZ)
+ worldRenderer.pos(min.getX(), max.getY(), min.getZ())
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
- worldRenderer.pos(bb.maxX, bb.maxY, bb.minZ)
+ worldRenderer.pos(max.getX(), max.getY(), min.getZ())
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
- worldRenderer.pos(bb.maxX, bb.minY, bb.minZ)
+ worldRenderer.pos(max.getX(), min.getY(), min.getZ())
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
- worldRenderer.pos(bb.minX, bb.minY, bb.minZ)
+ worldRenderer.pos(min.getX(), min.getY(), min.getZ())
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
- worldRenderer.pos(bb.minX, bb.minY, bb.maxZ)
+ worldRenderer.pos(min.getX(), min.getY(), max.getZ())
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
- worldRenderer.pos(bb.minX, bb.maxY, bb.maxZ)
+ worldRenderer.pos(min.getX(), max.getY(), max.getZ())
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
- worldRenderer.pos(bb.minX, bb.maxY, bb.minZ)
+ worldRenderer.pos(min.getX(), max.getY(), min.getZ())
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
- worldRenderer.pos(bb.maxX, bb.minY, bb.minZ)
+ worldRenderer.pos(max.getX(), min.getY(), min.getZ())
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
- worldRenderer.pos(bb.maxX, bb.minY, bb.maxZ)
+ worldRenderer.pos(max.getX(), min.getY(), max.getZ())
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
- worldRenderer.pos(bb.maxX, bb.maxY, bb.maxZ)
+ worldRenderer.pos(max.getX(), max.getY(), max.getZ())
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
- worldRenderer.pos(bb.maxX, bb.maxY, bb.minZ)
+ worldRenderer.pos(max.getX(), max.getY(), min.getZ())
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
}
import com.irtimaled.bbor.client.PlayerCoords;
import com.irtimaled.bbor.common.models.BoundingBoxSlimeChunk;
import com.irtimaled.bbor.config.ConfigManager;
-import net.minecraft.util.math.AxisAlignedBB;
import java.awt.*;
public class SlimeChunkRenderer extends Renderer<BoundingBoxSlimeChunk> {
@Override
public void render(BoundingBoxSlimeChunk boundingBox) {
- AxisAlignedBB aaBB = getAxisAlignedBB(boundingBox);
+ OffsetBox bb = new OffsetBox(boundingBox.getMinCoords(), boundingBox.getMaxCoords());
Color color = boundingBox.getColor();
- renderCuboid(aaBB, color, fill());
+ renderCuboid(bb, color, fill());
double maxY = PlayerCoords.getMaxY(ConfigManager.slimeChunkMaxY.get());
- if (maxY > 39) {
- renderRectangle(aaBB, 39, maxY, color, fill());
+ double dY = maxY - 39;
+ if (dY > 0) {
+ OffsetPoint min = bb.getMin().offset(0, 38, 0);
+ OffsetPoint max = bb.getMax().offset(0, dY, 0);
+ bb = new OffsetBox(min, max);
+ renderCuboid(bb, color, fill());
}
}
}
import net.minecraft.client.renderer.BufferBuilder;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
-import net.minecraft.util.math.AxisAlignedBB;
import org.lwjgl.opengl.GL11;
import java.awt.*;
}
private void renderIronGolemSpawnArea(BoundingBoxVillage boundingBox) {
- Coords center = boundingBox.getCenter();
- AxisAlignedBB abb = getAxisAlignedBB(center, center, false)
- .grow(8, 3, 8)
+ OffsetPoint offsetCenter = new OffsetPoint(boundingBox.getCenter())
.offset(boundingBox.getCenterOffsetX(), 0.0, boundingBox.getCenterOffsetZ());
+ OffsetBox bb = new OffsetBox(offsetCenter, offsetCenter)
+ .grow(8, 3, 8);
- renderCuboid(abb, boundingBox.getColor(), false);
+ renderCuboid(bb, boundingBox.getColor(), false);
}
private void renderVillageDoors(BoundingBoxVillage boundingBox) {
OffsetPoint center = new OffsetPoint(boundingBox.getCenter())
- .add(boundingBox.getCenterOffsetX(), 0.0, boundingBox.getCenterOffsetZ());
+ .offset(boundingBox.getCenterOffsetX(), 0.0, boundingBox.getCenterOffsetZ());
Color color = boundingBox.getColor();
- GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_LINE);
- Tessellator tessellator = Tessellator.getInstance();
- BufferBuilder worldRenderer = tessellator.getBuffer();
-
int colorR = color.getRed();
int colorG = color.getGreen();
int colorB = color.getBlue();
+ GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_LINE);
+ Tessellator tessellator = Tessellator.getInstance();
+ BufferBuilder worldRenderer = tessellator.getBuffer();
+
worldRenderer.begin(GL11.GL_LINES, worldRenderer.getVertexFormat());
for (Coords door : boundingBox.getDoors()) {
- OffsetPoint point = new OffsetPoint(door).add(0.5, 0, 0.5);
+ OffsetPoint point = new OffsetPoint(door).offset(0.5, 0, 0.5);
worldRenderer.pos(point.getX(), point.getY(), point.getZ()).color(colorR, colorG, colorB, 255).endVertex();
worldRenderer.pos(center.getX(), center.getY(), center.getZ()).color(colorR, colorG, colorB, 255).endVertex();
private void renderBoundingBoxVillageAsSphere(BoundingBoxVillage boundingBox) {
OffsetPoint center = new OffsetPoint(boundingBox.getCenter())
- .add(boundingBox.getCenterOffsetX(), 0.0, boundingBox.getCenterOffsetZ());
+ .offset(boundingBox.getCenterOffsetX(), 0.0, boundingBox.getCenterOffsetZ());
int radius = boundingBox.getRadius();
Color color = boundingBox.getColor();
renderSphere(center, radius, color);
private Set<OffsetPoint> buildPoints(OffsetPoint center, double radius) {
int density = ConfigManager.villageSphereDensity.get();
- int segments = 24 + (density*8);
+ int segments = 24 + (density * 8);
- Set<OffsetPoint> points = new HashSet<>(segments*segments);
+ Set<OffsetPoint> points = new HashSet<>(segments * segments);
double tau = 6.283185307179586D;
double pi = tau / 2D;
- double thetaSegment = pi / (double)segments;
- double phiSegment = tau / (double)segments;
+ double thetaSegment = pi / (double) segments;
+ double phiSegment = tau / (double) segments;
for (double phi = 0.0D; phi < tau; phi += phiSegment) {
for (double theta = 0.0D; theta < pi; theta += thetaSegment) {
double dz = radius * Math.sin(phi) * Math.sin(theta);
double dy = radius * Math.cos(phi);
- points.add(center.add(dx, dy, dz));
+ points.add(center.offset(dx, dy, dz));
}
}
return points;
import com.irtimaled.bbor.client.PlayerCoords;
import com.irtimaled.bbor.common.models.BoundingBoxWorldSpawn;
+import com.irtimaled.bbor.common.models.Coords;
import com.irtimaled.bbor.config.ConfigManager;
-import net.minecraft.util.math.AxisAlignedBB;
import java.awt.*;
public class WorldSpawnRenderer extends Renderer<BoundingBoxWorldSpawn> {
@Override
public void render(BoundingBoxWorldSpawn boundingBox) {
- AxisAlignedBB aaBB = getAxisAlignedBB(boundingBox, false);
Color color = boundingBox.getColor();
+ Coords minCoords = boundingBox.getMinCoords();
+ Coords maxCoords = boundingBox.getMaxCoords();
+
double y = PlayerCoords.getMaxY(ConfigManager.worldSpawnMaxY.get()) + 0.001F;
- renderRectangle(aaBB, y, y, color, false);
+
+ OffsetBox bb = new OffsetBox(minCoords.getX(), y, minCoords.getZ(), maxCoords.getX(), y, maxCoords.getZ());
+ renderCuboid(bb, color, false);
}
}
projects / BoundingBoxOutlineReloaded.git / commitdiff