package com.irtimaled.bbor.client;
+import com.irtimaled.bbor.client.config.ConfigManager;
+import com.irtimaled.bbor.client.interop.ClientInterop;
+import com.irtimaled.bbor.client.models.*;
+import com.irtimaled.bbor.client.providers.*;
import com.irtimaled.bbor.client.renderers.*;
-import com.irtimaled.bbor.common.BoundingBoxCache;
-import com.irtimaled.bbor.common.BoundingBoxType;
-import com.irtimaled.bbor.common.models.*;
-import com.irtimaled.bbor.config.ConfigManager;
-import net.minecraft.client.Minecraft;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.ChunkPos;
-import net.minecraft.util.math.MathHelper;
-import net.minecraft.world.dimension.DimensionType;
+import com.irtimaled.bbor.common.MathHelper;
+import com.irtimaled.bbor.common.models.AbstractBoundingBox;
+import com.irtimaled.bbor.common.models.BoundingBoxCuboid;
+import com.irtimaled.bbor.common.models.BoundingBoxVillage;
import org.lwjgl.opengl.GL11;
-import java.util.*;
-
-import static com.irtimaled.bbor.client.Constants.CHUNK_SIZE;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
public class ClientRenderer {
- private final GetCache getCache;
- private static final Map<Class<? extends BoundingBox>, Renderer> boundingBoxRendererMap = new HashMap<>();
- private long seed;
- private Set<BoundingBox> spawnChunkBoundingBoxes = new HashSet<>();
-
- ClientRenderer(GetCache getCache) {
- this.getCache = getCache;
- boundingBoxRendererMap.put(BoundingBoxVillage.class, new VillageRenderer());
- boundingBoxRendererMap.put(BoundingBoxSlimeChunk.class, new SlimeChunkRenderer());
- boundingBoxRendererMap.put(BoundingBoxWorldSpawn.class, new WorldSpawnRenderer());
- boundingBoxRendererMap.put(BoundingBoxStructure.class, new StructureRenderer());
- boundingBoxRendererMap.put(BoundingBoxMobSpawner.class, new MobSpawnerRenderer());
+ private static final int CHUNK_SIZE = 16;
+ private static final Map<Class<? extends AbstractBoundingBox>, AbstractRenderer> boundingBoxRendererMap = new HashMap<>();
+
+ private static boolean active;
+ private static final Set<IBoundingBoxProvider> providers = new HashSet<>();
+
+ public static boolean getActive() {
+ return active;
+ }
+
+ public static void toggleActive() {
+ active = !active;
+ if (!active) return;
+
+ Player.setActiveY();
+ }
+
+ static void deactivate() {
+ active = false;
+ }
+
+ static {
+ registerRenderer(BoundingBoxVillage.class, new VillageRenderer());
+ registerRenderer(BoundingBoxSlimeChunk.class, new SlimeChunkRenderer());
+ registerRenderer(BoundingBoxWorldSpawn.class, new WorldSpawnRenderer());
+ registerRenderer(BoundingBoxCuboid.class, new CuboidRenderer());
+ registerRenderer(BoundingBoxMobSpawner.class, new MobSpawnerRenderer());
+ registerRenderer(BoundingBoxSpawningSphere.class, new SpawningSphereRenderer());
+ registerRenderer(BoundingBoxBeacon.class, new BeaconRenderer());
+ registerRenderer(BoundingBoxBiomeBorder.class, new BiomeBorderRenderer());
+ registerRenderer(BoundingBoxConduit.class, new ConduitRenderer());
+
+ registerProvider(new SlimeChunkProvider());
+ registerProvider(new WorldSpawnProvider());
+ registerProvider(new SpawningSphereProvider());
+ registerProvider(new BeaconProvider());
+ registerProvider(new CustomBoxProvider());
+ registerProvider(new CustomBeaconProvider());
+ registerProvider(new BiomeBorderProvider());
+ registerProvider(new MobSpawnerProvider());
+ registerProvider(new ConduitProvider());
}
- private boolean isWithinRenderDistance(BlockPos minBlockPos, BlockPos maxBlockPos) {
- int renderDistanceBlocks = Minecraft.getInstance().gameSettings.renderDistanceChunks * CHUNK_SIZE;
- int minX = MathHelper.floor(PlayerData.getX() - renderDistanceBlocks);
- int maxX = MathHelper.floor(PlayerData.getX() + renderDistanceBlocks);
- int minZ = MathHelper.floor(PlayerData.getZ() - renderDistanceBlocks);
- int maxZ = MathHelper.floor(PlayerData.getZ() + renderDistanceBlocks);
-
- return maxBlockPos.getX() >= minX &&
- maxBlockPos.getZ() >= minZ &&
- minBlockPos.getX() <= maxX &&
- minBlockPos.getZ() <= maxZ;
+ public static <T extends AbstractBoundingBox> void registerProvider(IBoundingBoxProvider<T> provider) {
+ providers.add(provider);
}
- private boolean isWithinRenderDistance(BoundingBox boundingBox) {
- return isWithinRenderDistance(boundingBox.getMinBlockPos(), boundingBox.getMaxBlockPos());
+ public static <T extends AbstractBoundingBox> void registerRenderer(Class<? extends T> type, AbstractRenderer<T> renderer) {
+ boundingBoxRendererMap.put(type, renderer);
}
- public void render(DimensionType dimensionType, Boolean outerBoxesOnly) {
- Map<BoundingBox, Set<BoundingBox>> boundingBoxes = getBoundingBoxes(dimensionType);
+ private static boolean isWithinRenderDistance(AbstractBoundingBox boundingBox) {
+ int renderDistanceBlocks = ClientInterop.getRenderDistanceChunks() * CHUNK_SIZE;
+ int minX = MathHelper.floor(Player.getX() - renderDistanceBlocks);
+ int maxX = MathHelper.floor(Player.getX() + renderDistanceBlocks);
+ int minZ = MathHelper.floor(Player.getZ() - renderDistanceBlocks);
+ int maxZ = MathHelper.floor(Player.getZ() + renderDistanceBlocks);
+
+ return boundingBox.intersectsBounds(minX, minZ, maxX, maxZ);
+ }
+
+ public static void render(int 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);
if (ConfigManager.alwaysVisible.get()) {
GL11.glClear(GL11.GL_DEPTH_BUFFER_BIT);
}
- for (Map.Entry<BoundingBox, Set<BoundingBox>> entry : boundingBoxes.entrySet()) {
- BoundingBox key = entry.getKey();
- if (!key.shouldRender()) continue;
- Renderer renderer = boundingBoxRendererMap.get(key.getClass());
+ for (AbstractBoundingBox key : boundingBoxes) {
+ AbstractRenderer renderer = boundingBoxRendererMap.get(key.getClass());
if (renderer == null) continue;
- if (!outerBoxesOnly) {
- Set<BoundingBox> children = entry.getValue();
- if (children != null) {
- children.forEach(renderer::render);
- continue;
- }
- }
renderer.render(key);
}
GL11.glEnable(GL11.GL_TEXTURE_2D);
}
- private Map<BoundingBox, Set<BoundingBox>> getBoundingBoxes(DimensionType dimensionType) {
- Map<BoundingBox, Set<BoundingBox>> boundingBoxes = new HashMap<>();
- if (dimensionType == DimensionType.OVERWORLD) {
- if (BoundingBoxType.SlimeChunks.shouldRender()) {
- addSlimeChunks(boundingBoxes);
- }
-
- for (BoundingBox boundingBox : spawnChunkBoundingBoxes) {
- if (boundingBox.shouldRender() && isWithinRenderDistance(boundingBox)) {
- boundingBoxes.put(boundingBox, null);
- }
- }
- }
-
- BoundingBoxCache cache = getCache.apply(dimensionType);
- if (cache != null) {
- for (Map.Entry<BoundingBox, Set<BoundingBox>> entry : cache.getBoundingBoxes().entrySet()) {
- BoundingBox key = entry.getKey();
- if (key.shouldRender() && isWithinRenderDistance(key)) {
- boundingBoxes.put(key, entry.getValue());
- }
- }
- }
- return boundingBoxes;
- }
-
- private void addSlimeChunks(Map<BoundingBox, Set<BoundingBox>> boundingBoxes) {
- Minecraft minecraft = Minecraft.getInstance();
- int renderDistanceChunks = minecraft.gameSettings.renderDistanceChunks;
- int playerChunkX = MathHelper.floor(PlayerData.getX() / 16.0D);
- int playerChunkZ = MathHelper.floor(PlayerData.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);
- BlockPos minBlockPos = new BlockPos(chunk.getXStart(), 1, chunk.getZStart());
- BlockPos maxBlockPos = new BlockPos(chunk.getXEnd(), 38, chunk.getZEnd());
- boundingBoxes.put(BoundingBoxSlimeChunk.from(minBlockPos, maxBlockPos), null);
+ private static Set<AbstractBoundingBox> getBoundingBoxes(int dimensionId) {
+ Set<AbstractBoundingBox> boundingBoxes = new HashSet<>();
+ for (IBoundingBoxProvider<?> provider : providers) {
+ if (provider.canProvide(dimensionId)) {
+ for (AbstractBoundingBox boundingBox : provider.get(dimensionId)) {
+ if (isWithinRenderDistance(boundingBox)) {
+ boundingBoxes.add(boundingBox);
+ }
}
}
}
- }
-
- private boolean isSlimeChunk(int chunkX, int chunkZ) {
- Random r = new Random(seed +
- (long) (chunkX * chunkX * 4987142) +
- (long) (chunkX * 5947611) +
- (long) (chunkZ * chunkZ) * 4392871L +
- (long) (chunkZ * 389711) ^ 987234911L);
- return r.nextInt(10) == 0;
- }
-
- void setWorldData(long seed, int spawnX, int spawnZ) {
- this.seed = seed;
- spawnChunkBoundingBoxes = getSpawnChunkBoundingBoxes(spawnX, spawnZ);
- }
-
- private Set<BoundingBox> getSpawnChunkBoundingBoxes(int spawnX, int spawnZ) {
- Set<BoundingBox> boundingBoxes = new HashSet<>();
- boundingBoxes.add(getWorldSpawnBoundingBox(spawnX, spawnZ));
- boundingBoxes.add(buildSpawnChunksBoundingBox(spawnX, spawnZ, 12, BoundingBoxType.SpawnChunks));
- boundingBoxes.add(buildSpawnChunksBoundingBox(spawnX, spawnZ, 16, BoundingBoxType.LazySpawnChunks));
return boundingBoxes;
}
-
- private BoundingBox getWorldSpawnBoundingBox(int spawnX, int spawnZ) {
- BlockPos minBlockPos = new BlockPos(spawnX - 10, 0, spawnZ - 10);
- BlockPos maxBlockPos = new BlockPos(spawnX + 10, 0, spawnZ + 10);
-
- return BoundingBoxWorldSpawn.from(minBlockPos, maxBlockPos, BoundingBoxType.WorldSpawn);
- }
-
- private BoundingBox buildSpawnChunksBoundingBox(int spawnX, int spawnZ, int size, BoundingBoxType type) {
- double midOffset = CHUNK_SIZE * (size / 2.0);
- double midX = Math.round((float) (spawnX / (double) CHUNK_SIZE)) * (double) CHUNK_SIZE;
- double midZ = Math.round((float) (spawnZ / (double) CHUNK_SIZE)) * (double) CHUNK_SIZE;
- BlockPos minBlockPos = new BlockPos(midX - midOffset, 0, midZ - midOffset);
- if (spawnX / (double) CHUNK_SIZE % 0.5D == 0.0D && spawnZ / (double) CHUNK_SIZE % 0.5D == 0.0D) {
- midX += (double) CHUNK_SIZE;
- midZ += (double) CHUNK_SIZE;
- }
- BlockPos maxBlockPos = new BlockPos(midX + midOffset, 0, midZ + midOffset);
- return BoundingBoxWorldSpawn.from(minBlockPos, maxBlockPos, type);
- }
}