X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmain%2Fjava%2Fcom%2Firtimaled%2Fbbor%2Fclient%2FClientRenderer.java;h=6672c6955d15f1e29752441734df31c53e49bdd4;hb=5fb79bdb4a572647b00d0a0fc10215642d6b417d;hp=40d4386f64fd93cb4d6061db8e399b4788aae9b2;hpb=a3dbe27a969d20c738a1aa720053ceffb38d243d;p=BoundingBoxOutlineReloaded.git diff --git a/src/main/java/com/irtimaled/bbor/client/ClientRenderer.java b/src/main/java/com/irtimaled/bbor/client/ClientRenderer.java index 40d4386..6672c69 100644 --- a/src/main/java/com/irtimaled/bbor/client/ClientRenderer.java +++ b/src/main/java/com/irtimaled/bbor/client/ClientRenderer.java @@ -1,51 +1,87 @@ 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.Dimensions; import com.irtimaled.bbor.common.MathHelper; -import com.irtimaled.bbor.common.models.*; -import com.irtimaled.bbor.config.ConfigManager; -import net.minecraft.client.Minecraft; +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 java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.Set; public class ClientRenderer { private static final int CHUNK_SIZE = 16; private static final Map, AbstractRenderer> boundingBoxRendererMap = new HashMap<>(); - private final GetCache getCache; - private long seed; - private Set 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 boolean active; + private static final Set providers = new HashSet<>(); + + public static boolean getActive() { + return active; + } + + public static void toggleActive() { + active = !active; + if (!active) return; + + Player.setActiveY(); } - private boolean isWithinRenderDistance(AbstractBoundingBox 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); - int maxZ = MathHelper.floor(PlayerCoords.getZ() + renderDistanceBlocks); - - return maxCoords.getX() >= minX && - maxCoords.getZ() >= minZ && - minCoords.getX() <= maxX && - minCoords.getZ() <= maxZ; + 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()); + } + + public static void registerProvider(IBoundingBoxProvider provider) { + providers.add(provider); + } + + public static void registerRenderer(Class type, AbstractRenderer renderer) { + boundingBoxRendererMap.put(type, renderer); + } + + 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 void render(int dimensionId, Boolean outerBoxesOnly) { - Map> boundingBoxes = getBoundingBoxes(dimensionId); + public static void render(int dimensionId) { + if (!active) return; + + Set boundingBoxes = getBoundingBoxes(dimensionId); GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); GL11.glLineWidth(2.0f); @@ -55,20 +91,11 @@ public class ClientRenderer { if (ConfigManager.alwaysVisible.get()) { GL11.glClear(GL11.GL_DEPTH_BUFFER_BIT); } - for (Map.Entry> entry : boundingBoxes.entrySet()) { - AbstractBoundingBox key = entry.getKey(); - if (!key.shouldRender()) continue; + for (AbstractBoundingBox key : boundingBoxes) { AbstractRenderer renderer = boundingBoxRendererMap.get(key.getClass()); if (renderer == null) continue; - if (!outerBoxesOnly) { - Set children = entry.getValue(); - if (children != null) { - children.forEach(renderer::render); - continue; - } - } renderer.render(key); } @@ -77,101 +104,17 @@ public class ClientRenderer { GL11.glEnable(GL11.GL_TEXTURE_2D); } - private Map> getBoundingBoxes(int dimensionId) { - Map> boundingBoxes = new HashMap<>(); - if (dimensionId == Dimensions.OVERWORLD) { - if (BoundingBoxType.SlimeChunks.shouldRender()) { - addSlimeChunks(boundingBoxes); - } - - for (AbstractBoundingBox boundingBox : spawnChunkBoundingBoxes) { - if (boundingBox.shouldRender() && isWithinRenderDistance(boundingBox)) { - boundingBoxes.put(boundingBox, null); - } - } - } - - BoundingBoxCache cache = getCache.apply(dimensionId); - if (cache != null) { - for (Map.Entry> entry : cache.getBoundingBoxes().entrySet()) { - AbstractBoundingBox key = entry.getKey(); - if (key.shouldRender() && isWithinRenderDistance(key)) { - boundingBoxes.put(key, entry.getValue()); - } - } - } - return boundingBoxes; - } - - private void addSlimeChunks(Map> boundingBoxes) { - 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)) { - 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 static Set getBoundingBoxes(int dimensionId) { + Set boundingBoxes = new HashSet<>(); + for (IBoundingBoxProvider provider : providers) { + if (provider.canProvide(dimensionId)) { + for (AbstractBoundingBox boundingBox : provider.get(dimensionId)) { + if (isWithinRenderDistance(boundingBox)) { + boundingBoxes.add(boundingBox); + } } } } - } - - private int getRenderDistanceChunks() { - return Minecraft.getInstance().gameSettings.renderDistanceChunks; - } - - 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 setSeed(long seed) { - this.seed = seed; - } - - void setWorldSpawn(int spawnX, int spawnZ) { - spawnChunkBoundingBoxes = getSpawnChunkBoundingBoxes(spawnX, spawnZ); - } - - private Set getSpawnChunkBoundingBoxes(int spawnX, int spawnZ) { - Set 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 AbstractBoundingBox getWorldSpawnBoundingBox(int spawnX, int spawnZ) { - Coords minCoords = new Coords(spawnX - 10, 0, spawnZ - 10); - Coords maxCoords = new Coords(spawnX + 10, 0, spawnZ + 10); - - return BoundingBoxWorldSpawn.from(minCoords, maxCoords, BoundingBoxType.WorldSpawn); - } - - private AbstractBoundingBox 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; - Coords maxCoords = new Coords(midX + midOffset, 0, midZ + midOffset); - if ((spawnX / (double) CHUNK_SIZE) % 1.0D == 0.5D) { - midX -= (double) CHUNK_SIZE; - } - if ((spawnZ / (double) CHUNK_SIZE) % 1.0D == 0.5D) { - midZ -= (double) CHUNK_SIZE; - } - Coords minCoords = new Coords(midX - midOffset, 0, midZ - midOffset); - return BoundingBoxWorldSpawn.from(minCoords, maxCoords, type); - } - - void clear() { - spawnChunkBoundingBoxes = new HashSet<>(); - } }