.DS_Store
.gradle
build
-run
+run*/
.idea
classes
*.iml
*.ipr
out
logs/
+*.hprof
buildscript {
repositories {
- jcenter()
+ mavenCentral()
maven {
name = 'Fabric'
url = 'https://maven.fabricmc.net/'
}
+ maven {
+ name = 'Cotton'
+ url = 'https://server.bbkr.space/artifactory/libs-release/'
+ }
}
dependencies {
- classpath "net.fabricmc:fabric-loom:0.8-SNAPSHOT"
+ classpath "net.fabricmc:fabric-loom:0.11-SNAPSHOT"
+ classpath "io.github.juuxel:loom-quiltflower:1.6.0"
}
}
apply plugin: 'fabric-loom'
+apply plugin: 'io.github.juuxel.loom-quiltflower'
apply plugin: 'java'
apply plugin: 'idea'
version project.buildVersion + '-' + project.mcVersion
archivesBaseName = 'BBOutlineReloaded'
-sourceCompatibility = JavaVersion.VERSION_16
-targetCompatibility = JavaVersion.VERSION_16
+sourceCompatibility = JavaVersion.VERSION_17
+targetCompatibility = JavaVersion.VERSION_17
tasks.withType(JavaCompile).configureEach {
// ensure that the encoding is set to UTF-8, no matter what the system default is
// If Javadoc is generated, this must be specified in that task too.
it.options.encoding = "UTF-8"
- // Minecraft 1.17 (21w19a) upwards uses Java 16.
- it.options.release = 16
+ it.options.release = 17
}
dependencies {
minecraft 'com.mojang:minecraft:' + project.mcVersion
- mappings 'net.fabricmc:yarn:' + project.mcVersion + '+build.29:v2'
- modImplementation 'net.fabricmc:fabric-loader:0.11.6'
+ mappings 'net.fabricmc:yarn:' + project.mcVersion + '+build.22:v2'
+ modImplementation 'net.fabricmc:fabric-loader:0.12.12'
}
loom {
- accessWidener "src/main/resources/bbor.accesswidener"
-}
-
-minecraft {
- refmapName = 'mixins.bbor.refmap.json'
+ accessWidenerPath = file("src/main/resources/bbor.accesswidener")
}
processResources {
java {
toolchain {
- languageVersion = JavaLanguageVersion.of(16)
+ languageVersion = JavaLanguageVersion.of(17)
}
withSourcesJar()
}
afterEvaluate {
remapJar.classifier = 'fabric'
}
+
+afterEvaluate {
+ migrateMappings.configure {
+ outputDir = project.file("src/main/java")
+ }
+}
+# Done to increase the memory available to gradle and improve build times.
+org.gradle.jvmargs=-Xmx4G
name=bbor
buildVersion=2.4
# leave a space to reduce merge conflicts on version change
-mcVersion=1.17.1
+mcVersion=1.18.1
#Tue May 26 09:16:06 PDT 2020
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.1.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.3.2-all.zip
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
zipStorePath=wrapper/dists
import com.irtimaled.bbor.client.events.UpdateWorldSpawnReceived;
import com.irtimaled.bbor.client.gui.LoadSavesScreen;
import com.irtimaled.bbor.client.gui.SettingsScreen;
-import com.irtimaled.bbor.client.interop.FlowerForestHelper;
import com.irtimaled.bbor.client.keyboard.Key;
import com.irtimaled.bbor.client.keyboard.KeyListener;
import com.irtimaled.bbor.client.providers.CacheProvider;
protected void setSeed(long seed) {
super.setSeed(seed);
SlimeChunkProvider.setSeed(seed);
- FlowerForestHelper.setSeed(seed);
+// FlowerForestHelper.setSeed(seed);
}
@Override
import com.irtimaled.bbor.client.interop.TileEntitiesHelper;
import com.irtimaled.bbor.client.models.Point;
import com.irtimaled.bbor.client.providers.BeaconProvider;
-import com.irtimaled.bbor.client.providers.BedrockCeilingProvider;
import com.irtimaled.bbor.client.providers.BiomeBorderProvider;
import com.irtimaled.bbor.client.providers.ConduitProvider;
import com.irtimaled.bbor.client.providers.CustomBeaconProvider;
import com.irtimaled.bbor.client.providers.CustomBoxProvider;
import com.irtimaled.bbor.client.providers.CustomLineProvider;
import com.irtimaled.bbor.client.providers.CustomSphereProvider;
-import com.irtimaled.bbor.client.providers.FlowerForestProvider;
import com.irtimaled.bbor.client.providers.IBoundingBoxProvider;
import com.irtimaled.bbor.client.providers.ICachingProvider;
import com.irtimaled.bbor.client.providers.MobSpawnerProvider;
registerProvider(new SpawnableBlocksProvider());
registerProvider(new CustomLineProvider());
registerProvider(new CustomSphereProvider());
- registerProvider(new FlowerForestProvider());
- registerProvider(new BedrockCeilingProvider());
+// registerProvider(new FlowerForestProvider());
+// registerProvider(new BedrockCeilingProvider());
}
public static <T extends AbstractBoundingBox> void registerProvider(IBoundingBoxProvider<T> provider) {
registerType(BoundingBoxType.Custom, ConfigManager.drawConduits, ConfigManager.colorCustom);
registerType(BoundingBoxType.Conduit, ConfigManager.drawConduits, ConfigManager.colorConduits);
registerType(BoundingBoxType.SpawnableBlocks, ConfigManager.drawSpawnableBlocks, ConfigManager.colorSpawnableBlocks);
- registerType(BoundingBoxType.FlowerForest, ConfigManager.drawFlowerForests, null);
- registerType(BoundingBoxType.BedrockCeiling, ConfigManager.drawBedrockCeilingBlocks, ConfigManager.colorBedrockCeilingBlocks);
+// registerType(BoundingBoxType.FlowerForest, ConfigManager.drawFlowerForests, null);
+// registerType(BoundingBoxType.BedrockCeiling, ConfigManager.drawBedrockCeilingBlocks, ConfigManager.colorBedrockCeilingBlocks);
registerType(BoundingBoxType.JungleTemple, ConfigManager.drawJungleTemples, ConfigManager.colorJungleTemples);
registerType(BoundingBoxType.DesertTemple, ConfigManager.drawDesertTemples, ConfigManager.colorDesertTemples);
public static Setting<Integer> spawnableBlocksRenderHeight;
public static Setting<Boolean> invertBoxColorPlayerInside;
public static Setting<Boolean> renderSphereAsDots;
- public static Setting<Boolean> drawFlowerForests;
- public static Setting<Integer> flowerForestsRenderDistance;
- public static Setting<Boolean> drawBedrockCeilingBlocks;
+// public static Setting<Boolean> drawFlowerForests;
+// public static Setting<Integer> flowerForestsRenderDistance;
+// public static Setting<Boolean> drawBedrockCeilingBlocks;
public static Setting<HexColor> colorWorldSpawn;
public static Setting<HexColor> colorLazySpawnChunks;
biomeBordersRenderDistance = setup(config, "biomeBorders", "biomeBordersRenderDistance", 3, "The distance from the player where biome borders will be drawn.");
biomeBordersMaxY = setup(config, "biomeBorders", "biomeBordersMaxY", -1, "The maximum top of the biome borders. If set to -1 it will use the value when activated, if set to 0 it will always track the players feet.");
- drawFlowerForests = setup(config, "flowerForests", "drawFlowerForests", true, "If set to true flower forest flower overlays will be drawn.");
- flowerForestsRenderDistance = setup(config, "flowerForests", "flowerForestsRenderDistance", 3, "The distance from the player where flower forests will be drawn.");
+// drawFlowerForests = setup(config, "flowerForests", "drawFlowerForests", true, "If set to true flower forest flower overlays will be drawn.");
+// flowerForestsRenderDistance = setup(config, "flowerForests", "flowerForestsRenderDistance", 3, "The distance from the player where flower forests will be drawn.");
- drawBedrockCeilingBlocks = setup(config, "bedrockCeiling", "drawBedrockCeilingBlocks", true, "If set to true position with only one layer of bedrock will be drawn.");
+// drawBedrockCeilingBlocks = setup(config, "bedrockCeiling", "drawBedrockCeilingBlocks", true, "If set to true position with only one layer of bedrock will be drawn.");
drawVillages = setup(config, "structures", "drawVillages", false, "If set to true village bounding boxes will be drawn.");
drawDesertTemples = setup(config, "structures", "drawDesertTemples", true, "If set to true desert temple bounding boxes are drawn.");
}
protected void render(MatrixStack matrixStack, int mouseX, int mouseY) {
- RenderSystem.assertThread(RenderSystem::isOnRenderThread);
+ RenderSystem.assertOnRenderThread();
this.renderBackground(matrixStack);
this.controlList.render(matrixStack, mouseX, mouseY);
.addDisplayValue(1, I18n.translate("bbor.options.distance.nearest"))
.addDisplayValue(2, I18n.translate("bbor.options.distance.nearer"))
.addDisplayValue(3, I18n.translate("bbor.options.distance.normal")))
- .section(I18n.translate("bbor.features.flowerForests"),
- width -> new BoundingBoxTypeButton(width, I18n.translate("bbor.features.flowerForests"), BoundingBoxType.FlowerForest),
- width -> new IntSettingSlider(width, 1, 3, "bbor.options.distance", ConfigManager.flowerForestsRenderDistance)
- .addDisplayValue(1, I18n.translate("bbor.options.distance.nearest"))
- .addDisplayValue(2, I18n.translate("bbor.options.distance.nearer"))
- .addDisplayValue(3, I18n.translate("bbor.options.distance.normal")))
- .section(I18n.translate("bbor.features.bedrockCeilingBlocks"),
- width -> new BoundingBoxTypeButton(width, I18n.translate("bbor.features.bedrockCeilingBlocks"), BoundingBoxType.BedrockCeiling))
+// .section(I18n.translate("bbor.features.flowerForests"),
+// width -> new BoundingBoxTypeButton(width, I18n.translate("bbor.features.flowerForests"), BoundingBoxType.FlowerForest),
+// width -> new IntSettingSlider(width, 1, 3, "bbor.options.distance", ConfigManager.flowerForestsRenderDistance)
+// .addDisplayValue(1, I18n.translate("bbor.options.distance.nearest"))
+// .addDisplayValue(2, I18n.translate("bbor.options.distance.nearer"))
+// .addDisplayValue(3, I18n.translate("bbor.options.distance.normal")))
+// .section(I18n.translate("bbor.features.bedrockCeilingBlocks"),
+// width -> new BoundingBoxTypeButton(width, I18n.translate("bbor.features.bedrockCeilingBlocks"), BoundingBoxType.BedrockCeiling))
.section(I18n.translate("bbor.features.mobSpawners"),
width -> new BoundingBoxTypeButton(width, I18n.translate("bbor.features.mobSpawners"), BoundingBoxType.MobSpawner),
width -> new BoolSettingButton(width, I18n.translate("bbor.features.mobSpawners.spawnArea"), ConfigManager.renderMobSpawnerSpawnArea),
+/*
package com.irtimaled.bbor.client.interop;
import net.minecraft.block.BlockState;
import net.minecraft.block.Blocks;
import net.minecraft.client.MinecraftClient;
import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.gen.ChunkRandom;
+import net.minecraft.world.gen.random.ChunkRandom;
+import net.minecraft.world.gen.random.SimpleRandom;
import java.util.Random;
}
public static Random getRandomForChunk(int chunkX, int chunkZ) {
- ChunkRandom random = new ChunkRandom();
+ ChunkRandom random = new ChunkRandom(new SimpleRandom());
random.setTerrainSeed(chunkX, chunkZ);
return random;
}
}
+
+ */
+/*
package com.irtimaled.bbor.client.interop;
import com.irtimaled.bbor.client.config.ConfigManager;
return MinecraftClient.getInstance().world.getBlockState(new BlockPos(x, y, z)).getBlock() == Blocks.GRASS_BLOCK;
}
}
+
+ */
\ No newline at end of file
import net.minecraft.client.MinecraftClient;
import net.minecraft.nbt.NbtCompound;
import net.minecraft.nbt.NbtList;
-import net.minecraft.server.world.ServerWorld;
-import net.minecraft.structure.StructureManager;
+import net.minecraft.structure.StructureContext;
import net.minecraft.structure.StructurePiece;
+import net.minecraft.structure.StructurePiecesList;
import net.minecraft.structure.StructureStart;
import net.minecraft.util.math.BlockBox;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.ChunkPos;
-import net.minecraft.util.registry.DynamicRegistryManager;
import net.minecraft.world.FeatureUpdater;
-import net.minecraft.world.HeightLimitView;
import net.minecraft.world.PersistentStateManager;
import net.minecraft.world.StructureWorldAccess;
import net.minecraft.world.World;
-import net.minecraft.world.biome.Biome;
import net.minecraft.world.dimension.DimensionType;
import net.minecraft.world.gen.StructureAccessor;
import net.minecraft.world.gen.chunk.ChunkGenerator;
import net.minecraft.world.level.storage.LevelStorage;
import net.minecraft.world.storage.RegionBasedStorage;
-import java.io.File;
import java.io.IOException;
+import java.nio.file.Path;
+import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
+import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
private FeatureUpdater legacyStructureDataUtil = null;
private LevelStorage.Session saveHandler = null;
- private File chunkSaveLocation = null;
+ private Path chunkSaveLocation = null;
private ChunkLoader chunkLoader;
- NBTStructureLoader(DimensionId dimensionId, LevelStorage.Session saveHandler, File worldDirectory) {
+ NBTStructureLoader(DimensionId dimensionId, LevelStorage.Session saveHandler, Path worldDirectory) {
this.dimensionId = dimensionId;
this.configure(saveHandler, worldDirectory);
}
}
}
- void configure(LevelStorage.Session saveHandler, File worldDirectory) {
+ void configure(LevelStorage.Session saveHandler, Path worldDirectory) {
this.saveHandler = saveHandler;
if (worldDirectory != null) {
- this.chunkSaveLocation = new File(DimensionType.getSaveDirectory(this.dimensionId.getDimensionType(), worldDirectory), "region");
+ this.chunkSaveLocation = DimensionType.getSaveDirectory(this.dimensionId.getDimensionType(), worldDirectory).resolve("region");
this.chunkLoader = new ChunkLoader(this.chunkSaveLocation);
}
}
private FeatureUpdater getLegacyStructureDataUtil() {
if (this.legacyStructureDataUtil == null) {
- File dataFolder = new File(this.saveHandler.getWorldDirectory(World.OVERWORLD), "data");
+ Path dataFolder = this.saveHandler.getWorldDirectory(World.OVERWORLD).resolve("data");
this.legacyStructureDataUtil = FeatureUpdater.create(dimensionId.getDimensionType(),
- new PersistentStateManager(dataFolder, MinecraftClient.getInstance().getDataFixer()));
+ new PersistentStateManager(dataFolder.toFile(), MinecraftClient.getInstance().getDataFixer()));
}
return this.legacyStructureDataUtil;
}
super(null,
new ChunkPos(0, 0),
0,
- 0);
+ new StructurePiecesList(createList(compound)));
this.parsedBoundingBox = create(compound.getIntArray("BB"));
+ }
+ private static List<StructurePiece> createList(NbtCompound compound) {
+ final ArrayList<StructurePiece> pieces = new ArrayList<>();
NbtList children = compound.getList("Children", 10);
for (int index = 0; index < children.size(); ++index) {
NbtCompound child = children.getCompound(index);
- if (child.contains("BB")) this.children.add(new SimpleStructurePiece(child));
+ if (child.contains("BB")) pieces.add(new SimpleStructurePiece(child));
}
+ return pieces;
}
private static BlockBox create(int[] compound) {
}
@Override
- public void init(DynamicRegistryManager dynamicRegistryManager, ChunkGenerator chunkGenerator, StructureManager structureManager, ChunkPos chunkPos, Biome biome, FeatureConfig featureConfig, HeightLimitView heightLimitView) {
+ public void place(StructureWorldAccess world, StructureAccessor structureAccessor, ChunkGenerator chunkGenerator, Random random, BlockBox chunkBox, ChunkPos chunkPos) {
}
@Override
- protected BlockBox calculateBoundingBox() {
+ public BlockBox getBoundingBox() {
return this.parsedBoundingBox;
}
}
}
@Override
- protected void writeNbt(ServerWorld serverWorld, NbtCompound nbtCompound) {
+ protected void writeNbt(StructureContext context, NbtCompound nbt) {
}
@Override
- public boolean generate(StructureWorldAccess structureWorldAccess, StructureAccessor structureAccessor, ChunkGenerator chunkGenerator, Random random, BlockBox blockBox, ChunkPos chunkPos, BlockPos blockPos) {
- return false;
+ public void generate(StructureWorldAccess structureWorldAccess, StructureAccessor structureAccessor, ChunkGenerator chunkGenerator, Random random, BlockBox blockBox, ChunkPos chunkPos, BlockPos blockPos) {
}
}
private static class ChunkLoader implements AutoCloseable {
- private static final BiFunction<File, Boolean, RegionBasedStorage> creator =
- ReflectionHelper.getPrivateInstanceBuilder(RegionBasedStorage.class, File.class, boolean.class);
+ private static final BiFunction<Path, Boolean, RegionBasedStorage> creator =
+ ReflectionHelper.getPrivateInstanceBuilder(RegionBasedStorage.class, Path.class, boolean.class);
private final RegionBasedStorage regionFileCache;
- public ChunkLoader(File file) {
+ public ChunkLoader(Path file) {
this.regionFileCache = creator.apply(file, false);
}
import net.minecraft.client.MinecraftClient;
import net.minecraft.world.level.storage.LevelStorage;
-import java.io.File;
import java.io.IOException;
+import java.nio.file.Path;
import java.util.HashMap;
import java.util.Map;
public class SaveGameStructureLoader {
private static final Map<DimensionId, NBTStructureLoader> nbtStructureLoaders = new HashMap<>();
private static LevelStorage.Session saveHandler = null;
- private static File worldDirectory = null;
+ private static Path worldDirectory = null;
static void loadSaveGame(String fileName) {
MinecraftClient minecraft = MinecraftClient.getInstance();
} catch (IOException e) {
e.printStackTrace();
}
- worldDirectory = saveLoader.getSavesDirectory().resolve(fileName).toFile();
+ worldDirectory = saveLoader.getSavesDirectory().resolve(fileName);
for (DimensionId dimensionId : nbtStructureLoaders.keySet()) {
NBTStructureLoader dimensionProcessor = getNBTStructureLoader(dimensionId);
+/*
package com.irtimaled.bbor.client.models;
import com.irtimaled.bbor.client.renderers.AbstractRenderer;
return RENDERER;
}
}
+ */
+/*
package com.irtimaled.bbor.client.models;
import com.irtimaled.bbor.client.RenderCulling;
return RenderCulling.isVisibleCulling(coords.getX(), coords.getY() + 0.01d, coords.getZ(), coords.getX() + 1, coords.getY(), coords.getZ() + 1);
}
}
+ */
+/*
package com.irtimaled.bbor.client.providers;
import com.irtimaled.bbor.client.Player;
return dimensionId == DimensionId.NETHER && BoundingBoxTypeHelper.shouldRender(BoundingBoxType.BedrockCeiling) && Player.getY() > 110;
}
}
+ */
+/*
package com.irtimaled.bbor.client.providers;
import com.irtimaled.bbor.client.Player;
return 0;
}
}
+
+ */
\ No newline at end of file
import com.irtimaled.bbor.common.MathHelper;
import com.irtimaled.bbor.common.models.Coords;
import com.irtimaled.bbor.common.models.DimensionId;
-import net.minecraft.world.gen.ChunkRandom;
+import net.minecraft.world.gen.random.ChunkRandom;
import java.util.HashSet;
import java.util.Set;
}
if (!fillOnly) {
stack.push();
- stack.peek().getModel().load(lastStack.getModel());
- stack.peek().getNormal().load(lastStack.getNormal());
+ stack.peek().getPositionMatrix().load(lastStack.getPositionMatrix());
+ stack.peek().getNormalMatrix().load(lastStack.getNormalMatrix());
renderLine(stack, new OffsetPoint(minX, minY, minZ), new OffsetPoint(maxX, minY, minZ), color, true);
renderLine(stack, new OffsetPoint(maxX, minY, minZ), new OffsetPoint(maxX, minY, maxZ), color, true);
renderLine(stack, new OffsetPoint(maxX, minY, maxZ), new OffsetPoint(minX, minY, maxZ), color, true);
+/*
package com.irtimaled.bbor.client.renderers;
import com.irtimaled.bbor.client.models.BoundingBoxFlowerForest;
boundingBox.getColor(), true, 127);
}
}
+ */
if (!sameX && !sameZ) {
if (mask) quadMaskedCount.getAndIncrement();
else quadNonMaskedCount.getAndIncrement();
- bufferBuilder.vertex(matrixEntry.getModel(), minX, minY, minZ).color(red, green, blue, alpha).next();
- bufferBuilder.vertex(matrixEntry.getModel(), maxX, minY, minZ).color(red, green, blue, alpha).next();
- bufferBuilder.vertex(matrixEntry.getModel(), maxX, minY, maxZ).color(red, green, blue, alpha).next();
- bufferBuilder.vertex(matrixEntry.getModel(), minX, minY, maxZ).color(red, green, blue, alpha).next();
+ bufferBuilder.vertex(matrixEntry.getPositionMatrix(), minX, minY, minZ).color(red, green, blue, alpha).next();
+ bufferBuilder.vertex(matrixEntry.getPositionMatrix(), maxX, minY, minZ).color(red, green, blue, alpha).next();
+ bufferBuilder.vertex(matrixEntry.getPositionMatrix(), maxX, minY, maxZ).color(red, green, blue, alpha).next();
+ bufferBuilder.vertex(matrixEntry.getPositionMatrix(), minX, minY, maxZ).color(red, green, blue, alpha).next();
if (!sameY) {
if (mask) quadMaskedCount.getAndIncrement();
else quadNonMaskedCount.getAndIncrement();
- bufferBuilder.vertex(matrixEntry.getModel(), minX, maxY, minZ).color(red, green, blue, alpha).next();
- bufferBuilder.vertex(matrixEntry.getModel(), minX, maxY, maxZ).color(red, green, blue, alpha).next();
- bufferBuilder.vertex(matrixEntry.getModel(), maxX, maxY, maxZ).color(red, green, blue, alpha).next();
- bufferBuilder.vertex(matrixEntry.getModel(), maxX, maxY, minZ).color(red, green, blue, alpha).next();
+ bufferBuilder.vertex(matrixEntry.getPositionMatrix(), minX, maxY, minZ).color(red, green, blue, alpha).next();
+ bufferBuilder.vertex(matrixEntry.getPositionMatrix(), minX, maxY, maxZ).color(red, green, blue, alpha).next();
+ bufferBuilder.vertex(matrixEntry.getPositionMatrix(), maxX, maxY, maxZ).color(red, green, blue, alpha).next();
+ bufferBuilder.vertex(matrixEntry.getPositionMatrix(), maxX, maxY, minZ).color(red, green, blue, alpha).next();
}
}
if (!sameX && !sameY) {
if (mask) quadMaskedCount.getAndIncrement();
else quadNonMaskedCount.getAndIncrement();
- bufferBuilder.vertex(matrixEntry.getModel(), minX, minY, minZ).color(red, green, blue, alpha).next();
- bufferBuilder.vertex(matrixEntry.getModel(), minX, maxY, minZ).color(red, green, blue, alpha).next();
- bufferBuilder.vertex(matrixEntry.getModel(), maxX, maxY, minZ).color(red, green, blue, alpha).next();
- bufferBuilder.vertex(matrixEntry.getModel(), maxX, minY, minZ).color(red, green, blue, alpha).next();
+ bufferBuilder.vertex(matrixEntry.getPositionMatrix(), minX, minY, minZ).color(red, green, blue, alpha).next();
+ bufferBuilder.vertex(matrixEntry.getPositionMatrix(), minX, maxY, minZ).color(red, green, blue, alpha).next();
+ bufferBuilder.vertex(matrixEntry.getPositionMatrix(), maxX, maxY, minZ).color(red, green, blue, alpha).next();
+ bufferBuilder.vertex(matrixEntry.getPositionMatrix(), maxX, minY, minZ).color(red, green, blue, alpha).next();
if (!sameZ) {
if (mask) quadMaskedCount.getAndIncrement();
else quadNonMaskedCount.getAndIncrement();
- bufferBuilder.vertex(matrixEntry.getModel(), minX, minY, maxZ).color(red, green, blue, alpha).next();
- bufferBuilder.vertex(matrixEntry.getModel(), maxX, minY, maxZ).color(red, green, blue, alpha).next();
- bufferBuilder.vertex(matrixEntry.getModel(), maxX, maxY, maxZ).color(red, green, blue, alpha).next();
- bufferBuilder.vertex(matrixEntry.getModel(), minX, maxY, maxZ).color(red, green, blue, alpha).next();
+ bufferBuilder.vertex(matrixEntry.getPositionMatrix(), minX, minY, maxZ).color(red, green, blue, alpha).next();
+ bufferBuilder.vertex(matrixEntry.getPositionMatrix(), maxX, minY, maxZ).color(red, green, blue, alpha).next();
+ bufferBuilder.vertex(matrixEntry.getPositionMatrix(), maxX, maxY, maxZ).color(red, green, blue, alpha).next();
+ bufferBuilder.vertex(matrixEntry.getPositionMatrix(), minX, maxY, maxZ).color(red, green, blue, alpha).next();
}
}
if (!sameY && !sameZ) {
if (mask) quadMaskedCount.getAndIncrement();
else quadNonMaskedCount.getAndIncrement();
- bufferBuilder.vertex(matrixEntry.getModel(), minX, minY, minZ).color(red, green, blue, alpha).next();
- bufferBuilder.vertex(matrixEntry.getModel(), minX, minY, maxZ).color(red, green, blue, alpha).next();
- bufferBuilder.vertex(matrixEntry.getModel(), minX, maxY, maxZ).color(red, green, blue, alpha).next();
- bufferBuilder.vertex(matrixEntry.getModel(), minX, maxY, minZ).color(red, green, blue, alpha).next();
+ bufferBuilder.vertex(matrixEntry.getPositionMatrix(), minX, minY, minZ).color(red, green, blue, alpha).next();
+ bufferBuilder.vertex(matrixEntry.getPositionMatrix(), minX, minY, maxZ).color(red, green, blue, alpha).next();
+ bufferBuilder.vertex(matrixEntry.getPositionMatrix(), minX, maxY, maxZ).color(red, green, blue, alpha).next();
+ bufferBuilder.vertex(matrixEntry.getPositionMatrix(), minX, maxY, minZ).color(red, green, blue, alpha).next();
if (!sameX) {
if (mask) quadMaskedCount.getAndIncrement();
else quadNonMaskedCount.getAndIncrement();
- bufferBuilder.vertex(matrixEntry.getModel(), maxX, minY, minZ).color(red, green, blue, alpha).next();
- bufferBuilder.vertex(matrixEntry.getModel(), maxX, maxY, minZ).color(red, green, blue, alpha).next();
- bufferBuilder.vertex(matrixEntry.getModel(), maxX, maxY, maxZ).color(red, green, blue, alpha).next();
- bufferBuilder.vertex(matrixEntry.getModel(), maxX, minY, maxZ).color(red, green, blue, alpha).next();
+ bufferBuilder.vertex(matrixEntry.getPositionMatrix(), maxX, minY, minZ).color(red, green, blue, alpha).next();
+ bufferBuilder.vertex(matrixEntry.getPositionMatrix(), maxX, maxY, minZ).color(red, green, blue, alpha).next();
+ bufferBuilder.vertex(matrixEntry.getPositionMatrix(), maxX, maxY, maxZ).color(red, green, blue, alpha).next();
+ bufferBuilder.vertex(matrixEntry.getPositionMatrix(), maxX, minY, maxZ).color(red, green, blue, alpha).next();
}
}
}
lineCount.getAndIncrement();
lineBufferBuilder
- .vertex(matrixEntry.getModel(),
+ .vertex(matrixEntry.getPositionMatrix(),
(float) startPoint.getX() - regionX,
(float) startPoint.getY(),
(float) startPoint.getZ() - regionZ)
.color(color.getRed(), color.getGreen(), color.getBlue(), alpha)
.next();
lineBufferBuilder
- .vertex(matrixEntry.getModel(),
+ .vertex(matrixEntry.getPositionMatrix(),
(float) endPoint.getX() - regionX,
(float) endPoint.getY(),
(float) endPoint.getZ() - regionZ)
}
public static void beforeRenderFont(MatrixStack matrixStack, OffsetPoint offsetPoint) {
- RenderSystem.assertThread(RenderSystem::isOnRenderThread);
+ RenderSystem.assertOnRenderThread();
matrixStack.push();
polygonModeFill();
matrixStack.translate(offsetPoint.getX(), offsetPoint.getY() + 0.002D, offsetPoint.getZ());
public static void afterRenderFont(MatrixStack matrixStack) {
disableTexture();
disableBlend();
- RenderSystem.assertThread(RenderSystem::isOnRenderThread);
+ RenderSystem.assertOnRenderThread();
matrixStack.pop();
enableDepthTest();
}
// }
public static void lineWidth2() {
- RenderSystem.assertThread(RenderSystem::isOnRenderThread);
+ RenderSystem.assertOnRenderThread();
RenderSystem.lineWidth(2f);
}
}
public static void enablePolygonOffsetLine() {
- RenderSystem.assertThread(RenderSystem::isOnRenderThread);
+ RenderSystem.assertOnRenderThread();
GL11.glEnable(GL11.GL_POLYGON_OFFSET_LINE);
}
}
private void pos(double x, double y, double z) {
- bufferBuilder.vertex(matrixStack.peek().getModel(), (float) x, (float) y, (float) z);
+ bufferBuilder.vertex(matrixStack.peek().getPositionMatrix(), (float) x, (float) y, (float) z);
}
private void tex(double u, double v) {
public static final BoundingBoxType Beacon = register("Beacon");
public static final BoundingBoxType Conduit = register("Conduit");
public static final BoundingBoxType SpawnableBlocks = register("Spawnable Blocks");
- public static final BoundingBoxType FlowerForest = register("Flower Forest");
- public static final BoundingBoxType BedrockCeiling = register("Bedrock Ceiling");
+// public static final BoundingBoxType FlowerForest = register("Flower Forest");
+// public static final BoundingBoxType BedrockCeiling = register("Bedrock Ceiling");
public static final BoundingBoxType JungleTemple = register("jungle_pyramid");
public static final BoundingBoxType DesertTemple = register("desert_pyramid");
if (structureStart == null) return;
try {
- structureStart.setBoundingBoxFromChildren();
+ structureStart.getBoundingBox();
} catch (Throwable ignored) {
}
- BlockBox bb = ((IStructureStart) structureStart).getBoundingBox();
+ BlockBox bb = ((IStructureStart) structureStart).getBoundingBox1();
if (bb == null) return;
AbstractBoundingBox boundingBox = buildStructure(bb, type);
@Mixin(StructureStart.class)
public interface IStructureStart {
- @Accessor
- BlockBox getBoundingBox();
+ @Accessor("boundingBox")
+ BlockBox getBoundingBox1();
}
@Mixin(ChatScreen.class)
public class MixinChatScreen {
- @Inject(method = "keyPressed", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/MinecraftClient;openScreen(Lnet/minecraft/client/gui/screen/Screen;)V", shift = At.Shift.BEFORE), cancellable = true)
+ @Inject(method = "keyPressed", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/MinecraftClient;setScreen(Lnet/minecraft/client/gui/screen/Screen;)V", shift = At.Shift.BEFORE), cancellable = true)
private void keyPressed(CallbackInfoReturnable<Boolean> cir) {
if (MinecraftClient.getInstance().currentScreen instanceof ListScreen) {
cir.setReturnValue(true);
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
-import java.util.Map;
+import java.util.Set;
@Mixin(KeyBinding.class)
public class MixinKeyBinding {
- @Final
- @Shadow
- private static Map<String, Integer> categoryOrderMap;
+
+ @Shadow @Final private static Set<String> KEY_CATEGORIES;
static {
- categoryOrderMap.put(KeyListener.Category, 0);
+ KEY_CATEGORIES.add(KeyListener.Category);
}
}
@Mixin(WorldChunk.class)
public class MixinChunk {
- @Inject(method = "loadToWorld", at = @At("RETURN"))
- private void onLoad(CallbackInfo ci) {
- CommonInterop.chunkLoaded((WorldChunk) (Object) this);
+ @Inject(method = "setLoadedToWorld", at = @At("RETURN"))
+ private void onLoad(boolean loaded, CallbackInfo ci) {
+ if (loaded) CommonInterop.chunkLoaded((WorldChunk) (Object) this);
}
}
accessWidener v1 named
accessible class net/minecraft/client/world/ClientChunkManager$ClientChunkMap
+
+extendable class net/minecraft/structure/StructureStart
"mixins.bbor.json"
],
"depends": {
- "minecraft": ">=1.17.1"
+ "minecraft": ">=1.18.1"
}
}
projects / BoundingBoxOutlineReloaded.git / commitdiff