Indigo and Renderer API fixes related to fallback consumers (#2775)

* Fix #2639: Indigo fallback consumer does not respect BlendMode or emissivity

* Change renderer testmod to test material change

* Remove presumably unneeded `quad.geometryFlags()` call

* Also test emissivity

* Call emitBlockQuads in the testmod

* Allow passing the block state explicitly to the fallback consumer. Fixes #1871

* Expand testmod to also test item models

* Also fix fallback consumer ignoring material for items

* Slight changes

* Introduce new interface for the expanded fallback consumer

* Add javadoc to ModelHelper

Author: Technici4n

fabric-renderer-api-v1/src/client/java/net/fabricmc/fabric/api/renderer/v1/model/FabricBakedModel.java

@@ -36,6 +36,8 @@
  * Can also be used to generate or customize outputs based on world state instead of
  * or in addition to block state when render chunks are rebuilt.
  *
+ * <p>Implementors should have a look at {@link ModelHelper} as it contains many useful functions.
+ *
  * <p>Note for {@link Renderer} implementors: Fabric causes BakedModel to extend this
  * interface with {@link #isVanillaAdapter()} == true and to produce standard vertex data.
  * This means any BakedModel instance can be safely cast to this interface without an instanceof check.
@@ -82,7 +84,7 @@ public interface FabricBakedModel {
 	 * parameter is normally initialized with the same seed prior to each face layer.
 	 * Model authors should note this method is called only once per block, and call the provided
 	 * Random supplier multiple times if re-seeding is necessary. For wrapped vanilla baked models,
-	 * it will probably be easier to use {@link RenderContext#fallbackConsumer} which handles
+	 * it will probably be easier to use {@link RenderContext#bakedModelConsumer()} which handles
 	 * re-seeding per face automatically.
 	 *
 	 * @param blockView Access to world state. Cast to {@code RenderAttachedBlockView} to

fabric-renderer-api-v1/src/client/java/net/fabricmc/fabric/api/renderer/v1/render/RenderContext.java

@@ -18,6 +18,9 @@
 
 import java.util.function.Consumer;
 
+import org.jetbrains.annotations.Nullable;
+
+import net.minecraft.block.BlockState;
 import net.minecraft.client.render.model.BakedModel;
 
 import net.fabricmc.fabric.api.renderer.v1.mesh.Mesh;
@@ -38,12 +41,65 @@ public interface RenderContext {
 	 */
 	Consumer<Mesh> meshConsumer();
 
+	/**
+	 * Fallback consumer that can process a vanilla {@link BakedModel}.
+	 * Fabric causes vanilla baked models to send themselves
+	 * via this interface. Can also be used by compound models that contain a mix
+	 * of vanilla baked models, packaged quads and/or dynamic elements.
+	 */
+	default BakedModelConsumer bakedModelConsumer() {
+		// Default implementation is provided for compat with older renderer implementations,
+		// but they should always override this function.
+		Consumer<BakedModel> fallback = fallbackConsumer();
+		return new BakedModelConsumer() {
+			@Override
+			public void accept(BakedModel model) {
+				fallback.accept(model);
+			}
+
+			@Override
+			public void accept(BakedModel model, @Nullable BlockState state) {
+				fallback.accept(model);
+			}
+		};
+	}
+
+	interface BakedModelConsumer extends Consumer<BakedModel> {
+		/**
+		 * Render a baked model by processing its {@linkplain BakedModel#getQuads} using the rendered block state.
+		 *
+		 * <p>For block contexts, this will pass the block state being rendered to {@link BakedModel#getQuads}.
+		 * For item contexts, this will pass a {@code null} block state to {@link BakedModel#getQuads}.
+		 * {@link #accept(BakedModel, BlockState)} can be used instead to pass the block state explicitly.
+		 */
+		@Override
+		void accept(BakedModel model);
+
+		/**
+		 * Render a baked model by processing its {@linkplain BakedModel#getQuads} with an explicit block state.
+		 *
+		 * <p>This overload allows passing the block state (or {@code null} to query the item quads).
+		 * This is useful when a model is being wrapped, and expects a different
+		 * block state than the one of the block being rendered.
+		 *
+		 * <p>For item render contexts, you can use this function if you want to render the model with a specific block state.
+		 * Otherwise, use {@linkplain #accept(BakedModel)} the other overload} to render the usual item quads.
+		 */
+		void accept(BakedModel model, @Nullable BlockState state);
+	}
+
 	/**
 	 * Fabric causes vanilla baked models to send themselves
 	 * via this interface. Can also be used by compound models that contain a mix
 	 * of vanilla baked models, packaged quads and/or dynamic elements.
+	 *
+	 * @deprecated Prefer using the more flexible {@link #bakedModelConsumer}.
 	 */
-	Consumer<BakedModel> fallbackConsumer();
+	@Deprecated
+	default Consumer<BakedModel> fallbackConsumer() {
+		// This default implementation relies on implementors overriding bakedModelConsumer().
+		return bakedModelConsumer();
+	}
 
 	/**
 	 * Returns a {@link QuadEmitter} instance that emits directly to the render buffer.

fabric-renderer-api-v1/src/client/java/net/fabricmc/fabric/mixin/renderer/client/BakedModelMixin.java

@@ -42,11 +42,12 @@ default boolean isVanillaAdapter() {
 
 	@Override
 	default void emitBlockQuads(BlockRenderView blockView, BlockState state, BlockPos pos, Supplier<Random> randomSupplier, RenderContext context) {
-		context.fallbackConsumer().accept((BakedModel) this);
+		context.bakedModelConsumer().accept((BakedModel) this, state);
 	}
 
 	@Override
 	default void emitItemQuads(ItemStack stack, Supplier<Random> randomSupplier, RenderContext context) {
-		context.fallbackConsumer().accept((BakedModel) this);
+		// Pass null state to enforce item quads in block render contexts
+		context.bakedModelConsumer().accept((BakedModel) this, null);
 	}
 }

fabric-renderer-api-v1/src/testmod/java/net/fabricmc/fabric/test/renderer/simple/client/FrameBakedModel.java

@@ -24,6 +24,7 @@
 
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockState;
+import net.minecraft.block.Blocks;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.render.model.BakedModel;
 import net.minecraft.client.render.model.BakedQuad;
@@ -36,20 +37,29 @@
 import net.minecraft.world.BlockRenderView;
 import net.minecraft.util.math.random.Random;
 
+import net.fabricmc.fabric.api.renderer.v1.Renderer;
+import net.fabricmc.fabric.api.renderer.v1.RendererAccess;
+import net.fabricmc.fabric.api.renderer.v1.material.BlendMode;
+import net.fabricmc.fabric.api.renderer.v1.material.RenderMaterial;
 import net.fabricmc.fabric.api.renderer.v1.mesh.Mesh;
-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.model.FabricBakedModel;
+import net.fabricmc.fabric.api.renderer.v1.model.ModelHelper;
 import net.fabricmc.fabric.api.renderer.v1.render.RenderContext;
 import net.fabricmc.fabric.api.rendering.data.v1.RenderAttachedBlockView;
 
 final class FrameBakedModel implements BakedModel, FabricBakedModel {
 	private final Mesh frameMesh;
 	private final Sprite frameSprite;
+	private final RenderMaterial translucentMaterial;
+	private final RenderMaterial translucentEmissiveMaterial;
 
 	FrameBakedModel(Mesh frameMesh, Sprite frameSprite) {
 		this.frameMesh = frameMesh;
 		this.frameSprite = frameSprite;
+
+		Renderer renderer = RendererAccess.INSTANCE.getRenderer();
+		this.translucentMaterial = renderer.materialFinder().blendMode(0, BlendMode.TRANSLUCENT).find();
+		this.translucentEmissiveMaterial = renderer.materialFinder().blendMode(0, BlendMode.TRANSLUCENT).emissive(0, true).find();
 	}
 
 	@Override
@@ -69,7 +79,7 @@ public boolean hasDepth() {
 
 	@Override
 	public boolean isSideLit() {
-		return false;
+		return true; // we want the block to be lit from the side when rendered as an item
 	}
 
 	@Override
@@ -84,7 +94,7 @@ public Sprite getParticleSprite() {
 
 	@Override
 	public ModelTransformation getTransformation() {
-		return ModelTransformation.NONE;
+		return ModelHelper.MODEL_TRANSFORM_BLOCK;
 	}
 
 	@Override
@@ -112,27 +122,71 @@ public void emitBlockQuads(BlockRenderView blockView, BlockState state, BlockPos
 			return; // No inner block to render
 		}
 
-		Sprite sprite = MinecraftClient.getInstance().getBlockRenderManager().getModels().getModelManager().getBlockModels().getModelParticleSprite(data.getDefaultState());
-		QuadEmitter emitter = context.getEmitter();
-
-		// We can emit our quads outside of the mesh as the block being put in the frame is very much dynamic.
-		// Emit the quads for each face of the block inside the frame
-		for (Direction direction : Direction.values()) {
-			// Add a face, with an inset to give the appearance of the block being in a frame.
-			emitter.square(direction, 0.1F, 0.1F, 0.9F, 0.9F, 0.1F)
-					// Set the sprite of the fact, use whole texture via BAKE_LOCK_UV
-					.spriteBake(0, sprite, MutableQuadView.BAKE_LOCK_UV)
-					// Allow textures
-					// TODO: the magic values here are not documented at all and probably should be
-					.spriteColor(0, -1, -1, -1, -1)
-					// Emit the quad
-					.emit();
-		}
+		BlockState innerState = data.getDefaultState();
+
+		// Now, we emit a transparent scaled-down version of the inner model
+		// Try both emissive and non-emissive versions of the translucent material
+		RenderMaterial material = pos.getX() % 2 == 0 ? translucentMaterial : translucentEmissiveMaterial;
+
+		emitInnerQuads(context, material, () -> {
+			// Use emitBlockQuads to allow for Renderer API features
+			((FabricBakedModel) MinecraftClient.getInstance().getBlockRenderManager().getModel(innerState)).emitBlockQuads(blockView, innerState, pos, randomSupplier, context);
+		});
 	}
 
 	@Override
 	public void emitItemQuads(ItemStack stack, Supplier<Random> randomSupplier, RenderContext context) {
-		// TODO: Implement an item test.
-		// For now we will just leave this as I have not added a block item yet
+		// Emit our frame mesh
+		context.meshConsumer().accept(this.frameMesh);
+
+		// Emit a scaled-down fence for testing, trying both materials again.
+		RenderMaterial material = stack.hasCustomName() ? translucentEmissiveMaterial : translucentMaterial;
+
+		BlockState innerState = Blocks.OAK_FENCE.getDefaultState();
+
+		emitInnerQuads(context, material, () -> {
+			// Need to use the fallback consumer directly:
+			// - we can't use emitBlockQuads because we don't have a blockView
+			// - we can't use emitItemQuads because multipart models don't have item quads
+			context.bakedModelConsumer().accept(MinecraftClient.getInstance().getBlockRenderManager().getModel(innerState), innerState);
+		});
+	}
+
+	/**
+	 * Emit a scaled-down version of the inner model.
+	 */
+	private void emitInnerQuads(RenderContext context, RenderMaterial material, Runnable innerModelEmitter) {
+		// Let's push a transform to scale the model down and make it transparent
+		context.pushTransform(quad -> {
+			// Scale model down
+			for (int vertex = 0; vertex < 4; ++vertex) {
+				float x = quad.x(vertex) * 0.8f + 0.1f;
+				float y = quad.y(vertex) * 0.8f + 0.1f;
+				float z = quad.z(vertex) * 0.8f + 0.1f;
+				quad.pos(vertex, x, y, z);
+			}
+
+			// Make the quad partially transparent
+			// Change material to translucent
+			quad.material(material);
+
+			// Change vertex colors to be partially transparent
+			for (int vertex = 0; vertex < 4; ++vertex) {
+				int color = quad.spriteColor(vertex, 0);
+				int alpha = (color >> 24) & 0xFF;
+				alpha = alpha * 3 / 4;
+				color = (color & 0xFFFFFF) | (alpha << 24);
+				quad.spriteColor(vertex, 0, color);
+			}
+
+			// Return true because we want the quad to be rendered
+			return true;
+		});
+
+		// Emit the inner block model
+		innerModelEmitter.run();
+
+		// Let's not forget to pop the transform!
+		context.popTransform();
 	}
 }

fabric-renderer-api-v1/src/testmod/java/net/fabricmc/fabric/test/renderer/simple/client/FrameModelResourceProvider.java

@@ -16,6 +16,9 @@
 
 package net.fabricmc.fabric.test.renderer.simple.client;
 
+import java.util.HashSet;
+import java.util.Set;
+
 import org.jetbrains.annotations.Nullable;
 
 import net.minecraft.client.render.model.UnbakedModel;
@@ -28,12 +31,12 @@
  * Provides the unbaked model for use with the frame block.
  */
 final class FrameModelResourceProvider implements ModelResourceProvider {
-	private static final Identifier FRAME_MODEL_ID = new Identifier("fabric-renderer-api-v1-testmod", "block/frame");
+	static final Set<Identifier> FRAME_MODELS = new HashSet<>();
 
 	@Nullable
 	@Override
 	public UnbakedModel loadModelResource(Identifier resourceId, ModelProviderContext context) {
-		if (resourceId.equals(FRAME_MODEL_ID)) {
+		if (FRAME_MODELS.contains(resourceId)) {
 			return new FrameUnbakedModel();
 		}
 

fabric-renderer-api-v1/src/testmod/java/net/fabricmc/fabric/test/renderer/simple/client/RendererClientTest.java

@@ -16,7 +16,10 @@
 
 package net.fabricmc.fabric.test.renderer.simple.client;
 
+import static net.fabricmc.fabric.test.renderer.simple.RendererTest.id;
+
 import net.minecraft.client.render.RenderLayer;
+import net.minecraft.registry.Registries;
 
 import net.fabricmc.api.ClientModInitializer;
 import net.fabricmc.fabric.api.blockrenderlayer.v1.BlockRenderLayerMap;
@@ -31,7 +34,14 @@ public void onInitializeClient() {
 		ModelLoadingRegistry.INSTANCE.registerVariantProvider(manager -> new PillarModelVariantProvider());
 
 		for (FrameBlock frameBlock : RendererTest.FRAMES) {
+			// We don't specify a material for the frame mesh,
+			// so it will use the default material, i.e. the one from BlockRenderLayerMap.
 			BlockRenderLayerMap.INSTANCE.putBlock(frameBlock, RenderLayer.getCutoutMipped());
+
+			String itemPath = Registries.ITEM.getId(frameBlock.asItem()).getPath();
+			FrameModelResourceProvider.FRAME_MODELS.add(id("item/" + itemPath));
 		}
+
+		FrameModelResourceProvider.FRAME_MODELS.add(id("block/frame"));
 	}
 }

fabric-renderer-indigo/src/client/java/net/fabricmc/fabric/impl/client/indigo/renderer/render/AbstractMeshConsumer.java

@@ -26,7 +26,6 @@
 import net.fabricmc.fabric.api.renderer.v1.mesh.QuadEmitter;
 import net.fabricmc.fabric.api.renderer.v1.render.RenderContext.QuadTransform;
 import net.fabricmc.fabric.impl.client.indigo.renderer.IndigoRenderer;
-import net.fabricmc.fabric.impl.client.indigo.renderer.RenderMaterialImpl;
 import net.fabricmc.fabric.impl.client.indigo.renderer.aocalc.AoCalculator;
 import net.fabricmc.fabric.impl.client.indigo.renderer.mesh.EncodingFormat;
 import net.fabricmc.fabric.impl.client.indigo.renderer.mesh.MeshImpl;
@@ -55,7 +54,7 @@ private class Maker extends MutableQuadViewImpl {
 		@Override
 		public Maker emit() {
 			computeGeometry();
-			renderQuad(this);
+			renderQuad(this, false);
 			clear();
 			return this;
 		}
@@ -74,51 +73,12 @@ public void accept(Mesh mesh) {
 			System.arraycopy(data, index, editorQuad.data(), 0, EncodingFormat.TOTAL_STRIDE);
 			editorQuad.load();
 			index += EncodingFormat.TOTAL_STRIDE;
-			renderQuad(editorQuad);
+			renderQuad(editorQuad, false);
 		}
 	}
 
 	public QuadEmitter getEmitter() {
 		editorQuad.clear();
 		return editorQuad;
 	}
-
-	private void renderQuad(MutableQuadViewImpl quad) {
-		if (!transform.transform(quad)) {
-			return;
-		}
-
-		if (!blockInfo.shouldDrawFace(quad.cullFace())) {
-			return;
-		}
-
-		tessellateQuad(quad, 0);
-	}
-
-	/**
-	 * Determines color index and render layer, then routes to appropriate
-	 * tessellate routine based on material properties.
-	 */
-	private void tessellateQuad(MutableQuadViewImpl quad, int textureIndex) {
-		final RenderMaterialImpl.Value mat = quad.material();
-		final int colorIndex = mat.disableColorIndex(textureIndex) ? -1 : quad.colorIndex();
-		final RenderLayer renderLayer = blockInfo.effectiveRenderLayer(mat.blendMode(textureIndex));
-
-		if (blockInfo.defaultAo && !mat.disableAo(textureIndex)) {
-			// needs to happen before offsets are applied
-			aoCalc.compute(quad, false);
-
-			if (mat.emissive(textureIndex)) {
-				tessellateSmoothEmissive(quad, renderLayer, colorIndex);
-			} else {
-				tessellateSmooth(quad, renderLayer, colorIndex);
-			}
-		} else {
-			if (mat.emissive(textureIndex)) {
-				tessellateFlatEmissive(quad, renderLayer, colorIndex);
-			} else {
-				tessellateFlat(quad, renderLayer, colorIndex);
-			}
-		}
-	}
 }