Port to 1.21.5

Author: PepperCode1

gradle.properties

@@ -4,16 +4,16 @@ org.gradle.parallel = true
 
 # Fabric Properties
 loom_version = 1.12.7
-minecraft_version = 1.21.4
-yarn_mappings = 1.21.4+build.1
+minecraft_version = 1.21.5
+yarn_mappings = 1.21.5+build.1
 loader_version = 0.17.3
 
 # Mod Properties
 mod_version = 3.0.1
-mod_minecraft_version = 1.21.4
+mod_minecraft_version = 1.21.5
 maven_group = me.pepperbell
 archives_base_name = continuity
 
 # Dependencies
-fabric_version = 0.113.0+1.21.4
-modmenu_version = 13.0.3
+fabric_version = 0.120.0+1.21.5
+modmenu_version = 14.0.0-rc.2

src/main/java/me/pepperbell/continuity/api/client/QuadProcessor.java

@@ -1,7 +1,6 @@
 package me.pepperbell.continuity.api.client;
 
 import java.util.function.Function;
-import java.util.function.Supplier;
 
 import net.fabricmc.fabric.api.renderer.v1.mesh.MutableQuadView;
 import net.fabricmc.fabric.api.renderer.v1.mesh.QuadEmitter;
@@ -13,7 +12,7 @@
 import net.minecraft.world.BlockRenderView;
 
 public interface QuadProcessor {
-	ProcessingResult processQuad(MutableQuadView quad, Sprite sprite, BlockRenderView blockView, BlockState appearanceState, BlockState state, BlockPos pos, Supplier<Random> randomSupplier, int pass, ProcessingContext context);
+	ProcessingResult processQuad(MutableQuadView quad, Sprite sprite, BlockRenderView blockView, BlockPos pos, BlockState appearanceState, BlockState state, Random random, int pass, ProcessingContext context);
 
 	interface ProcessingContext extends ProcessingDataProvider {
 		QuadEmitter getExtraQuadEmitter();

src/main/java/me/pepperbell/continuity/client/mixin/BakedModelManagerMixin.java

@@ -2,6 +2,7 @@
 
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
 import java.util.concurrent.Executor;
 import java.util.function.Function;
 
@@ -29,7 +30,6 @@
 import net.minecraft.resource.ResourceManager;
 import net.minecraft.resource.ResourceReloader;
 import net.minecraft.util.Identifier;
-import net.minecraft.util.profiler.Profiler;
 
 @Mixin(BakedModelManager.class)
 abstract class BakedModelManagerMixin {
@@ -60,22 +60,22 @@ abstract class BakedModelManagerMixin {
 		return original.thenRun(() -> continuity$reloadExtension = null);
 	}
 
-	@ModifyArg(method = "reload(Lnet/minecraft/resource/ResourceReloader$Synchronizer;Lnet/minecraft/resource/ResourceManager;Ljava/util/concurrent/Executor;Ljava/util/concurrent/Executor;)Ljava/util/concurrent/CompletableFuture;", slice = @Slice(from = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/model/SpriteAtlasManager;reload(Lnet/minecraft/resource/ResourceManager;ILjava/util/concurrent/Executor;)Ljava/util/Map;")), at = @At(value = "INVOKE", target = "Ljava/util/concurrent/CompletableFuture;thenApplyAsync(Ljava/util/function/Function;Ljava/util/concurrent/Executor;)Ljava/util/concurrent/CompletableFuture;", ordinal = 0), index = 0)
-	private Function<Void, Object> continuity$modifyFunction(Function<Void, Object> function) {
+	@ModifyArg(method = "reload(Lnet/minecraft/resource/ResourceReloader$Synchronizer;Lnet/minecraft/resource/ResourceManager;Ljava/util/concurrent/Executor;Ljava/util/concurrent/Executor;)Ljava/util/concurrent/CompletableFuture;", slice = @Slice(from = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/model/SpriteAtlasManager;reload(Lnet/minecraft/resource/ResourceManager;ILjava/util/concurrent/Executor;)Ljava/util/Map;")), at = @At(value = "INVOKE", target = "Ljava/util/concurrent/CompletableFuture;thenComposeAsync(Ljava/util/function/Function;Ljava/util/concurrent/Executor;)Ljava/util/concurrent/CompletableFuture;", ordinal = 0), index = 0)
+	private Function<Void, CompletionStage<?>> continuity$modifyFunction(Function<Void, CompletionStage<?>> function) {
 		BakedModelManagerReloadExtension reloadExtension = continuity$reloadExtension;
 		if (reloadExtension != null) {
 			return v -> {
 				BakedModelManagerBakeContext.THREAD_LOCAL.set(reloadExtension);
-				Object result = function.apply(v);
+				CompletionStage<?> result = function.apply(v);
 				BakedModelManagerBakeContext.THREAD_LOCAL.remove();
 				return result;
 			};
 		}
 		return function;
 	}
 
-	@Inject(method = "bake(Lnet/minecraft/util/profiler/Profiler;Ljava/util/Map;Lnet/minecraft/client/render/model/ModelBaker;Lit/unimi/dsi/fastutil/objects/Object2IntMap;Lnet/minecraft/client/render/entity/model/LoadedEntityModels;Lnet/minecraft/client/render/block/entity/LoadedBlockEntityModels;)Lnet/minecraft/client/render/model/BakedModelManager$BakingResult;", at = @At("HEAD"))
-	private static void continuity$onHeadBake(Profiler profiler, final Map<Identifier, SpriteAtlasManager.AtlasPreparation> atlases, ModelBaker baker, Object2IntMap<BlockState> groups, LoadedEntityModels entityModels, LoadedBlockEntityModels blockEntityModels, CallbackInfoReturnable<Object> cir) {
+	@Inject(method = "bake(Ljava/util/Map;Lnet/minecraft/client/render/model/ModelBaker;Lit/unimi/dsi/fastutil/objects/Object2IntMap;Lnet/minecraft/client/render/entity/model/LoadedEntityModels;Lnet/minecraft/client/render/block/entity/LoadedBlockEntityModels;Ljava/util/concurrent/Executor;)Ljava/util/concurrent/CompletableFuture;", at = @At("HEAD"))
+	private static void continuity$onHeadBake(final Map<Identifier, SpriteAtlasManager.AtlasPreparation> atlases, ModelBaker baker, Object2IntMap<BlockState> groups, LoadedEntityModels entityModels, LoadedBlockEntityModels blockEntityModels, Executor executor, CallbackInfoReturnable<CompletableFuture<?>> cir) {
 		BakedModelManagerBakeContext context = BakedModelManagerBakeContext.THREAD_LOCAL.get();
 		if (context != null) {
 			context.beforeBake(atlases);

src/main/java/me/pepperbell/continuity/client/mixin/FallingBlockEntityRendererMixin.java

@@ -2,89 +2,99 @@
 
 import java.util.function.Function;
 import java.util.function.Predicate;
-import java.util.function.Supplier;
 
 import org.jetbrains.annotations.Nullable;
 
 import me.pepperbell.continuity.api.client.QuadProcessor;
 import me.pepperbell.continuity.client.config.ContinuityConfig;
 import me.pepperbell.continuity.client.util.RenderUtil;
 import me.pepperbell.continuity.impl.client.ProcessingContextImpl;
+import net.fabricmc.fabric.api.client.model.loading.v1.wrapper.WrapperBlockStateModel;
 import net.fabricmc.fabric.api.renderer.v1.mesh.MutableQuadView;
 import net.fabricmc.fabric.api.renderer.v1.mesh.QuadEmitter;
 import net.fabricmc.fabric.api.renderer.v1.mesh.QuadTransform;
 import net.minecraft.block.BlockState;
-import net.minecraft.client.render.model.BakedModel;
-import net.minecraft.client.render.model.WrapperBakedModel;
+import net.minecraft.client.render.model.BlockStateModel;
 import net.minecraft.client.texture.Sprite;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Direction;
 import net.minecraft.util.math.random.Random;
 import net.minecraft.world.BlockRenderView;
 
-public class CtmBakedModel extends WrapperBakedModel {
+public class CtmBlockStateModel extends WrapperBlockStateModel {
 	public static final int PASSES = 4;
 
 	protected final BlockState defaultState;
 	protected volatile Function<Sprite, QuadProcessors.Slice> defaultSliceFunc;
 
-	public CtmBakedModel(BakedModel wrapped, BlockState defaultState) {
+	public CtmBlockStateModel(BlockStateModel wrapped, BlockState defaultState) {
 		super(wrapped);
 		this.defaultState = defaultState;
 	}
 
 	@Override
-	public void emitBlockQuads(QuadEmitter emitter, BlockRenderView blockView, BlockState state, BlockPos pos, Supplier<Random> randomSupplier, Predicate<@Nullable Direction> cullTest) {
+	public void emitQuads(QuadEmitter emitter, BlockRenderView blockView, BlockPos pos, BlockState state, Random random, Predicate<@Nullable Direction> cullTest) {
 		if (!ContinuityConfig.INSTANCE.connectedTextures.get()) {
-			super.emitBlockQuads(emitter, blockView, state, pos, randomSupplier, cullTest);
+			super.emitQuads(emitter, blockView, pos, state, random, cullTest);
 			return;
 		}
 
 		ModelObjectsContainer container = ModelObjectsContainer.get();
 		if (!container.featureStates.getConnectedTexturesState().isEnabled()) {
-			super.emitBlockQuads(emitter, blockView, state, pos, randomSupplier, cullTest);
+			super.emitQuads(emitter, blockView, pos, state, random, cullTest);
 			return;
 		}
 
 		CtmQuadTransform quadTransform = container.ctmQuadTransform;
 		if (quadTransform.isActive()) {
-			super.emitBlockQuads(emitter, blockView, state, pos, randomSupplier, cullTest);
+			super.emitQuads(emitter, blockView, pos, state, random, cullTest);
 			return;
 		}
 
-		// The correct way to get the appearance of the origin state from within a block model is to (1) call
-		// getAppearance on the result of blockView.getBlockState(pos) instead of the passed state and (2) pass the
-		// pos and world state of the adjacent block as the source pos and source state.
-		// (1) is not followed here because at this point in execution, within this call to
-		// CtmBakedModel#emitBlockQuads, the state parameter must already contain the world state. Even if this
-		// CtmBakedModel is wrapped, then the wrapper must pass the same state as it received because not doing so can
-		// cause crashes when the wrapped model is a vanilla multipart model or delegates to one. Thus, getting the
-		// world state again is inefficient and unnecessary.
-		// (2) is not possible here because the appearance state is necessary to get the slice and only the processors
-		// within the slice actually perform checks on adjacent blocks. Likewise, the processors themselves cannot
-		// retrieve the appearance state since the correct processors can only be chosen with the initially correct
-		// appearance state.
+		// The correct way to get the appearance of the origin state from within a block model is to call getAppearance
+		// on the passed world state and pass the pos and world state of the adjacent block as the source pos and source
+		// state.
+		// The latter of these is not possible here because the appearance state is necessary to get the slice and only
+		// the processors within the slice actually perform checks on adjacent blocks. Likewise, the processors
+		// themselves cannot retrieve the appearance state since the correct processors can only be chosen with the
+		// initially correct appearance state.
 		// Additionally, the side is chosen to always be the first constant of the enum (DOWN) for simplicity. Querying
 		// the appearance for all six sides would be more correct, but less efficient. This may be fixed in the future,
 		// especially if there is an actual use case for it.
 		BlockState appearanceState = state.getAppearance(blockView, pos, Direction.DOWN, state, pos);
 
-		quadTransform.prepare(blockView, appearanceState, state, pos, randomSupplier.get().nextLong(), cullTest, getSliceFunc(appearanceState));
+		// It would be better to use random.nextLong() as the seed, but that changes the state of the random, which
+		// cannot happen.
+		quadTransform.prepare(blockView, pos, appearanceState, state, state.getRenderingSeed(pos), cullTest, getSliceFunc(appearanceState));
 
 		emitter.pushTransform(quadTransform);
-		super.emitBlockQuads(emitter, blockView, state, pos, randomSupplier, cullTest);
+		super.emitQuads(emitter, blockView, pos, state, random, cullTest);
 		emitter.popTransform();
 
 		quadTransform.processingContext.outputTo(emitter);
 		quadTransform.reset();
 	}
 
 	@Override
-	public boolean isVanillaAdapter() {
+	@Nullable
+	public Object createGeometryKey(BlockRenderView blockView, BlockPos pos, BlockState state, Random random) {
 		if (!ContinuityConfig.INSTANCE.connectedTextures.get()) {
-			return super.isVanillaAdapter();
+			return super.createGeometryKey(blockView, pos, state, random);
 		}
-		return false;
+
+		ModelObjectsContainer container = ModelObjectsContainer.get();
+		if (!container.featureStates.getConnectedTexturesState().isEnabled()) {
+			return super.createGeometryKey(blockView, pos, state, random);
+		}
+
+		CtmQuadTransform quadTransform = container.ctmQuadTransform;
+		if (quadTransform.isActive()) {
+			return super.createGeometryKey(blockView, pos, state, random);
+		}
+
+		// This would be nice to implement, but it's not as important as for a typical model since this CTM wrapper is
+		// always supposed to be at the top level, and implementing this is far from trivial.
+		return null;
 	}
 
 	protected Function<Sprite, QuadProcessors.Slice> getSliceFunc(BlockState state) {
@@ -106,20 +116,12 @@ protected Function<Sprite, QuadProcessors.Slice> getSliceFunc(BlockState state)
 
 	protected static class CtmQuadTransform implements QuadTransform {
 		protected final ProcessingContextImpl processingContext = new ProcessingContextImpl();
-		protected final Supplier<Random> randomSupplier = new Supplier<>() {
-			private final Random random = Random.createLocal();
-
-			@Override
-			public Random get() {
-				random.setSeed(randomSeed);
-				return random;
-			}
-		};
+		protected final Random random = Random.createLocal();
 
 		protected BlockRenderView blockView;
+		protected BlockPos pos;
 		protected BlockState appearanceState;
 		protected BlockState state;
-		protected BlockPos pos;
 		protected long randomSeed;
 		protected Predicate<@Nullable Direction> cullTest;
 		protected Function<Sprite, QuadProcessors.Slice> sliceFunc;
@@ -147,7 +149,8 @@ protected Boolean transformOnce(MutableQuadView quad, int pass) {
 			QuadProcessors.Slice slice = sliceFunc.apply(sprite);
 			QuadProcessor[] processors = pass == 0 ? slice.processors() : slice.multipassProcessors();
 			for (QuadProcessor processor : processors) {
-				QuadProcessor.ProcessingResult result = processor.processQuad(quad, sprite, blockView, appearanceState, state, pos, randomSupplier, pass, processingContext);
+				random.setSeed(randomSeed);
+				QuadProcessor.ProcessingResult result = processor.processQuad(quad, sprite, blockView, pos, appearanceState, state, random, pass, processingContext);
 				if (result == QuadProcessor.ProcessingResult.NEXT_PROCESSOR) {
 					continue;
 				}
@@ -168,11 +171,11 @@ public boolean isActive() {
 			return active;
 		}
 
-		public void prepare(BlockRenderView blockView, BlockState appearanceState, BlockState state, BlockPos pos, long randomSeed, Predicate<@Nullable Direction> cullTest, Function<Sprite, QuadProcessors.Slice> sliceFunc) {
+		public void prepare(BlockRenderView blockView, BlockPos pos, BlockState appearanceState, BlockState state, long randomSeed, Predicate<@Nullable Direction> cullTest, Function<Sprite, QuadProcessors.Slice> sliceFunc) {
 			this.blockView = blockView;
+			this.pos = pos;
 			this.appearanceState = appearanceState;
 			this.state = state;
-			this.pos = pos;
 			this.randomSeed = randomSeed;
 			this.cullTest = cullTest;
 			this.sliceFunc = sliceFunc;
@@ -182,9 +185,9 @@ public void prepare(BlockRenderView blockView, BlockState appearanceState, Block
 
 		public void reset() {
 			blockView = null;
+			pos = null;
 			appearanceState = null;
 			state = null;
-			pos = null;
 			cullTest = null;
 			sliceFunc = null;