Hand Rendering

src/main/java/net/coderbot/iris/layer/GbufferProgram.java

@@ -18,5 +18,6 @@ public enum GbufferProgram {
 	ARMOR_GLINT,
 	EYES,
 	HAND,
+	HAND_TRANSLUCENT,
 	WEATHER
 }

src/main/java/net/coderbot/iris/layer/GbufferPrograms.java

@@ -1,6 +1,7 @@
 package net.coderbot.iris.layer;
 
 import net.coderbot.iris.Iris;
+import net.coderbot.iris.pipeline.HandRenderer;
 import net.coderbot.iris.pipeline.WorldRenderingPipeline;
 
 public class GbufferPrograms {
@@ -12,7 +13,9 @@ public class GbufferPrograms {
 	 */
 	private static GbufferProgram refine(GbufferProgram program) {
 		if (program == GbufferProgram.ENTITIES || program == GbufferProgram.TERRAIN || program == GbufferProgram.TRANSLUCENT_TERRAIN) {
-			if (entities) {
+			if (HandRenderer.INSTANCE.isActive()) {
+				return HandRenderer.INSTANCE.isRenderingSolid() ? GbufferProgram.HAND : GbufferProgram.HAND_TRANSLUCENT;
+			} else if (entities) {
 				return GbufferProgram.ENTITIES;
 			} else if (blockEntities) {
 				return GbufferProgram.BLOCK_ENTITIES;

src/main/java/net/coderbot/iris/mixin/GameRendererAccessor.java

@@ -0,0 +1,25 @@
+package net.coderbot.iris.mixin;
+
+import com.mojang.blaze3d.vertex.PoseStack;
+
+import net.minecraft.client.Camera;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import org.spongepowered.asm.mixin.gen.Invoker;
+
+import net.minecraft.client.renderer.GameRenderer;
+
+@Mixin(GameRenderer.class)
+public interface GameRendererAccessor {
+	@Accessor
+	boolean getPanoramicMode();
+
+	@Invoker
+	void invokeBobView(PoseStack poseStack, float tickDelta);
+
+	@Invoker
+	void invokeBobHurt(PoseStack poseStack, float tickDelta);
+
+	@Invoker
+	double invokeGetFov(Camera camera, float tickDelta, boolean bobView);
+}

src/main/java/net/coderbot/iris/mixin/MixinGameRenderer.java

@@ -1,11 +1,16 @@
 package net.coderbot.iris.mixin;
 
 import com.mojang.blaze3d.platform.GlUtil;
+
 import net.coderbot.iris.Iris;
+import net.coderbot.iris.pipeline.FixedFunctionWorldRenderingPipeline;
+
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
 import net.fabricmc.api.EnvType;
 import net.fabricmc.api.Environment;
 import net.minecraft.client.Minecraft;
@@ -24,4 +29,9 @@ public class MixinGameRenderer {
 		Iris.logger.info("GPU: " + GlUtil.getRenderer() + " (Supports OpenGL " + GlUtil.getOpenGLVersion() + ")");
 		Iris.logger.info("OS: " + System.getProperty("os.name"));
 	}
+
+	@Redirect(method = "renderLevel", at = @At(value = "FIELD", target = "Lnet/minecraft/client/renderer/GameRenderer;renderHand:Z"))
+	private boolean disableVanillaHandRendering(GameRenderer gameRenderer) {
+		return Iris.getPipelineManager().getPipeline() instanceof FixedFunctionWorldRenderingPipeline;
+	}
 }

src/main/java/net/coderbot/iris/mixin/MixinItemInHandRenderer.java

@@ -0,0 +1,25 @@
+package net.coderbot.iris.mixin;
+
+import com.mojang.blaze3d.vertex.PoseStack;
+import net.coderbot.iris.pipeline.HandRenderer;
+import net.minecraft.client.player.AbstractClientPlayer;
+import net.minecraft.client.renderer.ItemInHandRenderer;
+import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.item.ItemStack;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(ItemInHandRenderer.class)
+public class MixinItemInHandRenderer {
+	@Inject(method = "renderArmWithItem", at = @At("HEAD"), cancellable = true)
+	private void skipTranslucentHands(AbstractClientPlayer abstractClientPlayer, float f, float g, InteractionHand interactionHand, float h, ItemStack itemStack, float i, PoseStack poseStack, MultiBufferSource multiBufferSource, int j, CallbackInfo ci) {
+		if (HandRenderer.INSTANCE.isRenderingSolid() && HandRenderer.INSTANCE.isHandTranslucent(interactionHand)) {
+			ci.cancel();
+		} else if (!HandRenderer.INSTANCE.isRenderingSolid() && !HandRenderer.INSTANCE.isHandTranslucent(interactionHand)) {
+			ci.cancel();
+		}
+	}
+}

src/main/java/net/coderbot/iris/mixin/MixinLevelRenderer.java

@@ -8,6 +8,7 @@
 import net.coderbot.iris.Iris;
 import net.coderbot.iris.gl.program.Program;
 import net.coderbot.iris.layer.GbufferProgram;
+import net.coderbot.iris.pipeline.HandRenderer;
 import net.coderbot.iris.pipeline.WorldRenderingPipeline;
 import net.coderbot.iris.uniforms.CapturedRenderingState;
 import net.coderbot.iris.uniforms.SystemTimeUniforms;
@@ -16,7 +17,10 @@
 import net.minecraft.client.Options;
 import net.minecraft.client.renderer.*;
 import net.minecraft.world.phys.Vec3;
+
+import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
@@ -75,6 +79,7 @@ public class MixinLevelRenderer {
 	// render their waypoint beams.
 	@Inject(method = RENDER_LEVEL, at = @At(value = "RETURN", shift = At.Shift.BEFORE))
 	private void iris$endLevelRender(PoseStack poseStack, float tickDelta, long limitTime, boolean renderBlockOutline, Camera camera, GameRenderer gameRenderer, LightTexture lightTexture, Matrix4f projection, CallbackInfo callback) {
+		HandRenderer.INSTANCE.renderTranslucent(poseStack, tickDelta, camera, gameRenderer, pipeline);
 		Minecraft.getInstance().getProfiler().popPush("iris_final");
 		pipeline.finalizeLevelRendering();
 		pipeline = null;
@@ -209,6 +214,8 @@ public class MixinLevelRenderer {
 										boolean renderBlockOutline, Camera camera, GameRenderer gameRenderer,
 										LightTexture lightTexture, Matrix4f projection,
 										CallbackInfo ci) {
+		pipeline.beginHand();
+		HandRenderer.INSTANCE.renderSolid(poseStack, tickDelta, camera, gameRenderer, pipeline);
 		Minecraft.getInstance().getProfiler().popPush("iris_pre_translucent");
 		pipeline.beginTranslucents();
 	}

src/main/java/net/coderbot/iris/mixin/rendertype/MixinRenderType.java

@@ -1,8 +1,10 @@
 package net.coderbot.iris.mixin.rendertype;
 
 import net.coderbot.iris.layer.GbufferProgram;
+import net.coderbot.iris.layer.GbufferPrograms;
 import net.coderbot.iris.layer.IrisRenderTypeWrapper;
 import net.coderbot.iris.layer.UseProgramRenderStateShard;
+
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Mutable;
@@ -138,12 +140,12 @@ private static RenderType wrap(RenderType wrapped, GbufferProgram program) {
 		"armorCutoutNoCull",
 		"entitySolid",
 		"entityCutout",
-		"itemEntityTranslucentCull",
-		"entityTranslucentCull",
 		"entitySmoothCutout",
 		"entityDecal",
 		"entityNoOutline",
 		"entityShadow",
+		"entityTranslucentCull",
+		"itemEntityTranslucentCull",
 		"text",
 		"textSeeThrough",
 	}, cancellable = true)

src/main/java/net/coderbot/iris/pipeline/DeferredWorldRenderingPipeline.java

@@ -84,6 +84,10 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline {
 	@Nullable
 	private final Pass blockEntities;
 	@Nullable
+	private final Pass hand;
+	@Nullable
+	private final Pass handTranslucent;
+	@Nullable
 	private final Pass glowingEntities;
 	@Nullable
 	private final Pass glint;
@@ -259,6 +263,8 @@ public DeferredWorldRenderingPipeline(ProgramSet programs) {
 		this.beaconBeam = programs.getGbuffersBeaconBeam().map(this::createPass).orElse(textured);
 		this.entities = programs.getGbuffersEntities().map(this::createPass).orElse(texturedLit);
 		this.blockEntities = programs.getGbuffersBlock().map(this::createPass).orElse(terrain);
+		this.hand = programs.getGbuffersHand().map(this::createPass).orElse(texturedLit);
+		this.handTranslucent = programs.getGbuffersHandWater().map(this::createPass).orElse(hand);
 		this.glowingEntities = programs.getGbuffersEntitiesGlowing().map(this::createPass).orElse(entities);
 		this.glint = programs.getGbuffersGlint().map(this::createPass).orElse(textured);
 		this.eyes = programs.getGbuffersEntityEyes().map(this::createPass).orElse(textured);
@@ -385,6 +391,9 @@ private Pass getPass(GbufferProgram program) {
 			case WEATHER:
 				return weather;
 			case HAND:
+				return hand;
+			case HAND_TRANSLUCENT:
+				return handTranslucent;
 			default:
 				// TODO
 				throw new UnsupportedOperationException("TODO: Unsupported gbuffer program: " + program);
@@ -654,11 +663,21 @@ private void prepareRenderTargets() {
 		}
 	}
 
+	@Override
+	public void beginHand() {
+		// We need to copy the current depth texture so that depthtex2 can contain the depth values for
+		// all non-translucent content without the hand, as required.
+		baseline.bindAsReadBuffer();
+		GlStateManager._bindTexture(renderTargets.getDepthTextureNoHand().getTextureId());
+		GL20C.glCopyTexImage2D(GL20C.GL_TEXTURE_2D, 0, GL20C.GL_DEPTH_COMPONENT, 0, 0, renderTargets.getCurrentWidth(), renderTargets.getCurrentHeight(), 0);
+		GlStateManager._bindTexture(0);
+	}
+
 	@Override
 	public void beginTranslucents() {
 		isBeforeTranslucent = false;
 
-		// We need to copy the current depth texture so that depthtex1 and depthtex2 can contain the depth values for
+		// We need to copy the current depth texture so that depthtex1 can contain the depth values for
 		// all non-translucent content, as required.
 		baseline.bindAsReadBuffer();
 		GlStateManager._bindTexture(renderTargets.getDepthTextureNoTranslucents().getTextureId());
@@ -709,6 +728,7 @@ public OptionalInt getForcedShadowRenderDistanceChunksForDisplay() {
 	public void beginLevelRendering() {
 		isRenderingWorld = true;
 		isBeforeTranslucent = true;
+		HandRenderer.INSTANCE.getBufferSource().resetDrawCalls();
 
 		checkWorld();
 

src/main/java/net/coderbot/iris/pipeline/FixedFunctionWorldRenderingPipeline.java

@@ -48,6 +48,11 @@ public void endShadowRender() {
 		// stub: nothing to do here
 	}
 
+	@Override
+	public void beginHand() {
+	    // stub: nothing to do here
+	}
+
 	@Override
 	public void beginTranslucents() {
 		// stub: nothing to do here

src/main/java/net/coderbot/iris/pipeline/HandRenderer.java

@@ -0,0 +1,137 @@
+package net.coderbot.iris.pipeline;
+
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.PoseStack;
+
+import com.mojang.math.Matrix4f;
+import net.coderbot.batchedentityrendering.impl.FullyBufferedMultiBufferSource;
+import net.coderbot.iris.layer.GbufferProgram;
+import net.coderbot.iris.mixin.GameRendererAccessor;
+import net.coderbot.iris.uniforms.CapturedRenderingState;
+import net.minecraft.client.Camera;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.*;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.entity.EquipmentSlot;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.BlockItem;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.level.GameType;
+
+public class HandRenderer {
+	public static final HandRenderer INSTANCE = new HandRenderer();
+
+	private boolean ACTIVE;
+	private boolean renderingSolid;
+	private FullyBufferedMultiBufferSource bufferSource = new FullyBufferedMultiBufferSource();
+
+	private void setupGlState(GameRenderer gameRenderer, Camera camera, PoseStack poseStack, float tickDelta) {
+        final PoseStack.Pose pose = poseStack.last();
+
+		// We need to scale the matrix by 0.125 so the hand doesn't clip through blocks.
+		Matrix4f scaleMatrix = Matrix4f.createScaleMatrix(1F, 1F, 0.125F);
+		scaleMatrix.multiply(gameRenderer.getProjectionMatrix(camera, tickDelta, false));
+		gameRenderer.resetProjectionMatrix(scaleMatrix);
+
+		pose.pose().setIdentity();
+        pose.normal().setIdentity();
+
+		((GameRendererAccessor) gameRenderer).invokeBobHurt(poseStack, tickDelta);
+
+		if(Minecraft.getInstance().options.bobView) {
+			((GameRendererAccessor) gameRenderer).invokeBobView(poseStack, tickDelta);
+		}
+	}
+
+	private boolean canRender(Camera camera, GameRenderer gameRenderer) {
+		return !(camera.isDetached() 
+			|| !(camera.getEntity() instanceof Player) 
+				|| ((GameRendererAccessor)gameRenderer).getPanoramicMode() 
+					|| Minecraft.getInstance().options.hideGui 
+						|| (camera.getEntity() instanceof LivingEntity && ((LivingEntity)camera.getEntity()).isSleeping()) 
+							|| Minecraft.getInstance().gameMode.getPlayerMode() == GameType.SPECTATOR);
+	}
+
+	public boolean isHandTranslucent(InteractionHand hand) {
+		Item item = Minecraft.getInstance().player.getItemBySlot(hand == InteractionHand.OFF_HAND ? EquipmentSlot.OFFHAND : EquipmentSlot.MAINHAND).getItem();
+
+		if (item instanceof BlockItem) {
+			return ItemBlockRenderTypes.getChunkRenderType(((BlockItem) item).getBlock().defaultBlockState()) == RenderType.translucent();
+		}
+
+		return false;
+	}
+
+	public boolean isAnyHandTranslucent() {
+		return isHandTranslucent(InteractionHand.MAIN_HAND) || isHandTranslucent(InteractionHand.OFF_HAND);
+	}
+
+	public void renderSolid(PoseStack poseStack, float tickDelta, Camera camera, GameRenderer gameRenderer, WorldRenderingPipeline pipeline) {
+		if(!canRender(camera, gameRenderer) || pipeline instanceof FixedFunctionWorldRenderingPipeline) {
+			return;
+		}
+
+		ACTIVE = true;
+
+		poseStack.pushPose();
+
+		Minecraft.getInstance().getProfiler().push("iris_hand");
+
+		setupGlState(gameRenderer, camera, poseStack, tickDelta);
+
+		renderingSolid = true;
+
+		Minecraft.getInstance().getItemInHandRenderer().renderHandsWithItems(tickDelta, poseStack, bufferSource, Minecraft.getInstance().player, Minecraft.getInstance().getEntityRenderDispatcher().getPackedLightCoords(camera.getEntity(), tickDelta));
+
+		Minecraft.getInstance().getProfiler().pop();
+
+		gameRenderer.resetProjectionMatrix(CapturedRenderingState.INSTANCE.getGbufferProjection());
+
+		poseStack.popPose();
+
+		bufferSource.endBatch();
+
+		renderingSolid = false;
+
+		ACTIVE = false;
+	}
+
+	public void renderTranslucent(PoseStack poseStack, float tickDelta, Camera camera, GameRenderer gameRenderer, WorldRenderingPipeline pipeline) {
+		if(!canRender(camera, gameRenderer) || !isAnyHandTranslucent() || pipeline instanceof FixedFunctionWorldRenderingPipeline) {
+			return;
+		}
+
+		ACTIVE = true;
+
+		poseStack.pushPose();
+
+		Minecraft.getInstance().getProfiler().push("iris_hand_translucent");
+
+		setupGlState(gameRenderer, camera, poseStack, tickDelta);
+
+		Minecraft.getInstance().getItemInHandRenderer().renderHandsWithItems(tickDelta, poseStack, bufferSource, Minecraft.getInstance().player, Minecraft.getInstance().getEntityRenderDispatcher().getPackedLightCoords(camera.getEntity(), tickDelta));
+
+		poseStack.popPose();
+
+		Minecraft.getInstance().getProfiler().pop();
+
+		gameRenderer.resetProjectionMatrix(CapturedRenderingState.INSTANCE.getGbufferProjection());
+
+		bufferSource.endBatch();
+
+		ACTIVE = false;
+	}
+
+	public boolean isActive() {
+		return ACTIVE;
+	}
+
+	public boolean isRenderingSolid() {
+		return renderingSolid;
+	}
+
+	public FullyBufferedMultiBufferSource getBufferSource() {
+		return bufferSource;
+	}
+}

src/main/java/net/coderbot/iris/pipeline/WorldRenderingPipeline.java

@@ -13,6 +13,9 @@ public interface WorldRenderingPipeline {
 	OptionalInt getForcedShadowRenderDistanceChunksForDisplay();
 	void beginShadowRender();
 	void endShadowRender();
+
+	void beginHand();
+
 	void beginTranslucents();
 	void pushProgram(GbufferProgram program);
 	void popProgram(GbufferProgram program);