Use emitBlockQuads in SpriteCalculator

Author: PepperCode1

src/main/java/me/pepperbell/continuity/client/model/CtmBakedModel.java

@@ -106,15 +106,15 @@ 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 Supplier<Random> randomSupplier = new Supplier<>() {
+			private final Random random = Random.createLocal();
+
+			@Override
+			public Random get() {
+				random.setSeed(randomSeed);
+				return random;
+			}
+		};
 
 		protected BlockRenderView blockView;
 		protected BlockState appearanceState;

src/main/java/me/pepperbell/continuity/client/util/SpriteCalculator.java

@@ -6,24 +6,28 @@
 import java.util.concurrent.locks.StampedLock;
 import java.util.function.Supplier;
 
-import org.apache.commons.lang3.ArrayUtils;
 import org.jetbrains.annotations.Unmodifiable;
 
+import it.unimi.dsi.fastutil.objects.ObjectArrayList;
 import it.unimi.dsi.fastutil.objects.Reference2ObjectOpenHashMap;
-import it.unimi.dsi.fastutil.objects.ReferenceArrayList;
 import net.fabricmc.fabric.api.client.rendering.v1.InvalidateRenderStateCallback;
+import net.fabricmc.fabric.api.renderer.v1.Renderer;
+import net.fabricmc.fabric.api.renderer.v1.mesh.MutableMesh;
+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.MinecraftClient;
 import net.minecraft.client.render.block.BlockModels;
 import net.minecraft.client.render.model.BakedModel;
-import net.minecraft.client.render.model.BakedQuad;
 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.EmptyBlockRenderView;
 
 public final class SpriteCalculator {
 	private static final BlockModels MODELS = MinecraftClient.getInstance().getBakedModelManager().getBlockModels();
-	private static final Direction[] CULL_FACES = ArrayUtils.add(Direction.values(), null);
 
 	private static final EnumMap<Direction, SpriteCache> SPRITE_CACHES = new EnumMap<>(Direction.class);
 
@@ -40,24 +44,6 @@ public static Set<Sprite> getSprites(BlockState state, Direction face) {
 		return SPRITE_CACHES.get(face).getSprites(state);
 	}
 
-	@Unmodifiable
-	public static Set<Sprite> calculateSprites(BlockState state, Direction face, Supplier<Random> randomSupplier) {
-		List<Sprite> sprites = new ReferenceArrayList<>();
-		BakedModel model = MODELS.getModel(state);
-		try {
-			for (Direction cullFace : CULL_FACES) {
-				for (BakedQuad quad : model.getQuads(state, cullFace, randomSupplier.get())) {
-					if (quad.getFace() == face) {
-						sprites.add(quad.getSprite());
-					}
-				}
-			}
-		} catch (Exception e) {
-			//
-		}
-		return !sprites.isEmpty() ? Set.copyOf(sprites) : Set.of(model.getParticleSprite());
-	}
-
 	public static void clearCache() {
 		for (SpriteCache cache : SPRITE_CACHES.values()) {
 			cache.clear();
@@ -67,6 +53,8 @@ public static void clearCache() {
 	private static class SpriteCache {
 		private final Direction face;
 		private final Reference2ObjectOpenHashMap<BlockState, Set<Sprite>> spritesMap = new Reference2ObjectOpenHashMap<>();
+		private final MutableMesh mutableMesh = Renderer.get().mutableMesh();
+		private final CollectingQuadTransform quadTransform;
 		private final Supplier<Random> randomSupplier = new Supplier<>() {
 			private final Random random = Random.create();
 
@@ -81,6 +69,7 @@ public Random get() {
 
 		public SpriteCache(Direction face) {
 			this.face = face;
+			quadTransform = new CollectingQuadTransform(face);
 		}
 
 		@Unmodifiable
@@ -114,7 +103,7 @@ public Set<Sprite> getSprites(BlockState state) {
 				try {
 					sprites = spritesMap.get(state);
 					if (sprites == null) {
-						sprites = calculateSprites(state, face, randomSupplier);
+						sprites = calculateSprites(state);
 						spritesMap.put(state, sprites);
 					}
 				} finally {
@@ -125,13 +114,56 @@ public Set<Sprite> getSprites(BlockState state) {
 			return sprites;
 		}
 
+		@Unmodifiable
+		private Set<Sprite> calculateSprites(BlockState state) {
+			BakedModel model = MODELS.getModel(state);
+			QuadEmitter emitter = mutableMesh.emitter();
+			quadTransform.clear();
+			emitter.pushTransform(quadTransform);
+			try {
+				model.emitBlockQuads(emitter, EmptyBlockRenderView.INSTANCE, state, BlockPos.ORIGIN, randomSupplier, cullFace -> false);
+			} catch (Exception e) {
+				//
+			}
+			emitter.popTransform();
+			Set<Sprite> sprites = quadTransform.result();
+			return !sprites.isEmpty() ? sprites : Set.of(model.getParticleSprite());
+		}
+
 		public void clear() {
 			long writeStamp = lock.writeLock();
 			try {
 				spritesMap.clear();
+				quadTransform.clear();
 			} finally {
 				lock.unlockWrite(writeStamp);
 			}
 		}
+
+		private static class CollectingQuadTransform implements QuadTransform {
+			private final Direction face;
+			private final List<Sprite> sprites = new ObjectArrayList<>();
+
+			private CollectingQuadTransform(Direction face) {
+				this.face = face;
+			}
+
+			@Override
+			public boolean transform(MutableQuadView quad) {
+				if (quad.lightFace() == face) {
+					sprites.add(RenderUtil.getSpriteFinder().find(quad));
+				}
+				return false;
+			}
+
+			public void clear() {
+				sprites.clear();
+			}
+
+			@Unmodifiable
+			public Set<Sprite> result() {
+				return Set.copyOf(sprites);
+			}
+		}
 	}
 }