Merge branch '1.20.1/dev' into 1.21.1/dev

# Conflicts:
#	common/src/api/java/dev/engine_room/flywheel/api/Flywheel.java
#	common/src/main/java/dev/engine_room/flywheel/impl/event/RenderContextImpl.java
#	common/src/main/java/dev/engine_room/flywheel/impl/mixin/LevelRendererMixin.java
#	fabric/src/lib/java/dev/engine_room/flywheel/lib/model/baked/MeshEmitter.java
#	fabric/src/main/java/dev/engine_room/flywheel/impl/FabricFlwConfig.java
#	forge/src/main/java/dev/engine_room/flywheel/impl/FlywheelForge.java
#	neoforge/src/main/java/dev/engine_room/flywheel/impl/NeoForgeFlwConfig.java

Author: Jozufozu

common/src/api/java/dev/engine_room/flywheel/api/Flywheel.java

@@ -1,14 +1,11 @@
 package dev.engine_room.flywheel.api;
 
-import net.minecraft.resources.ResourceLocation;
-
 public final class Flywheel {
+	/**
+	 * The mod ID and resource namespace of Flywheel.
+	 */
 	public static final String ID = "flywheel";
 
 	private Flywheel() {
 	}
-
-	public static ResourceLocation rl(String path) {
-		return ResourceLocation.fromNamespaceAndPath(ID, path);
-	}
 }

common/src/api/java/dev/engine_room/flywheel/api/backend/Engine.java

@@ -5,10 +5,8 @@
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.Range;
 
-import dev.engine_room.flywheel.api.RenderContext;
 import dev.engine_room.flywheel.api.instance.Instance;
 import dev.engine_room.flywheel.api.task.Plan;
-import dev.engine_room.flywheel.api.visualization.VisualType;
 import dev.engine_room.flywheel.api.visualization.VisualizationContext;
 import it.unimi.dsi.fastutil.longs.LongSet;
 import net.minecraft.client.Camera;
@@ -22,14 +20,13 @@ public interface Engine {
 	/**
 	 * Create a visualization context that will be used to create visuals of the given type.
 	 *
-	 * @param visualType The type of visual.
 	 * @return A new visualization context.
 	 */
-	VisualizationContext createVisualizationContext(VisualType visualType);
+	VisualizationContext createVisualizationContext();
 
 	/**
 	 * Create a plan that will start execution after the start of the level render and
-	 * finish execution before {@link #setupRender} is called.
+	 * finish execution before {@link #render} is called.
 	 *
 	 * @return A new plan.
 	 */
@@ -60,32 +57,20 @@ public interface Engine {
 	void onLightUpdate(SectionPos sectionPos, LightLayer layer);
 
 	/**
-	 * Set up rendering for the current level render.
+	 * Render all instances necessary for the given visual type.
 	 *
 	 * <p>This method is guaranteed to be called after
 	 * {@linkplain #createFramePlan() the frame plan} has finished execution and before
-	 * {@link #render} and {@link #renderCrumbling} are called. This method is guaranteed to
-	 * be called on the render thread.
-	 *
-	 * @param context The context for the current level render.
-	 */
-	void setupRender(RenderContext context);
-
-	/**
-	 * Render all instances necessary for the given visual type.
-	 *
-	 * <p>This method is guaranteed to be called after {@link #setupRender} for the current
-	 * level render. This method is guaranteed to be called on the render thread.
+	 * {@link #renderCrumbling} are called. This method is guaranteed to be called on the render thread.
 	 *
 	 * @param context The context for the current level render.
-	 * @param visualType The type of visual.
 	 */
-	void render(RenderContext context, VisualType visualType);
+	void render(RenderContext context);
 
 	/**
 	 * Render the given instances as a crumbling overlay.
 	 *
-	 * <p>This method is guaranteed to be called after {@link #setupRender} for the current
+	 * <p>This method is guaranteed to be called after {@link #render} for the current
 	 * level render. This method is guaranteed to be called on the render thread.
 	 *
 	 * @param context The context for the current level render.

…ine_room/flywheel/api/RenderContext.java …/flywheel/api/backend/RenderContext.javacommon/src/api/java/dev/engine_room/flywheel/api/RenderContext.java renamed to common/src/api/java/dev/engine_room/flywheel/api/backend/RenderContext.java common/src/api/java/dev/engine_room/flywheel/api/RenderContext.java renamed to common/src/api/java/dev/engine_room/flywheel/api/backend/RenderContext.java

@@ -1,4 +1,4 @@
-package dev.engine_room.flywheel.api;
+package dev.engine_room.flywheel.api.backend;
 
 import org.joml.Matrix4fc;
 

common/src/api/java/dev/engine_room/flywheel/api/material/Transparency.java

@@ -1,10 +1,81 @@
 package dev.engine_room.flywheel.api.material;
 
 public enum Transparency {
+	/**
+	 * No blending. Used for solid and cutout geometry.
+	 */
 	OPAQUE,
+
+	/**
+	 * Additive blending.
+	 *
+	 * <p>Each fragment blends color and alpha with the following equation:
+	 * <pre>
+	 * {@code
+	 * out = src + dst
+	 * }
+	 * </pre>
+	 */
 	ADDITIVE,
+
+	/**
+	 * Lightning transparency.
+	 *
+	 * <p>Each fragment blends color and alpha with the following equation:
+	 * <pre>
+	 * {@code
+	 * out = src * alpha_src + dst
+	 * }
+	 * </pre>
+	 */
 	LIGHTNING,
+
+	/**
+	 * Glint transparency. Used for the enchantment effect.
+	 *
+	 * <p>Each fragment blends with the following equations:
+	 * <pre>
+	 * {@code
+	 * color_out = color_src^2 + color_dst
+	 * alpha_out = alpha_dst
+	 * }
+	 * </pre>
+	 */
 	GLINT,
+
+	/**
+	 * Crumbling transparency. Used for the block breaking overlay.
+	 *
+	 * <p>Each fragment blends with the following equations:
+	 * <pre>
+	 * {@code
+	 * color_out = 2 * color_src * color_dst
+	 * alpha_out = alpha_src
+	 * }
+	 * </pre>
+	 */
 	CRUMBLING,
+
+	/**
+	 * Translucent transparency.
+	 *
+	 * <p>Each fragment blends with the following equations:
+	 * <pre>
+	 * {@code
+	 * color_out = color_src * alpha_src + color_dst * (1 - alpha_src)
+	 * alpha_out = alpha_src + alpha_dst * (1 - alpha_src)
+	 * }
+	 * </pre>
+	 */
 	TRANSLUCENT,
+
+	/**
+	 * If supported by the backend, this mode will use OIT that approximates {@code TRANSLUCENT} transparency.
+	 *
+	 * <p>If a backend does not support OIT, it must treat this the same as {@code TRANSLUCENT}.
+	 *
+	 * <p>It is recommended to use this option when possible, though for cases where blend modes are used as an
+	 * overlay against solid geometry the order dependent modes are preferred.
+	 */
+	ORDER_INDEPENDENT,
 }

common/src/api/java/dev/engine_room/flywheel/api/visualization/VisualType.java

@@ -5,7 +5,7 @@
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.Nullable;
 
-import dev.engine_room.flywheel.api.RenderContext;
+import dev.engine_room.flywheel.api.backend.RenderContext;
 import dev.engine_room.flywheel.api.internal.FlwApiLink;
 import dev.engine_room.flywheel.api.visual.Effect;
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
@@ -47,14 +47,31 @@ static VisualizationManager getOrThrow(@Nullable LevelAccessor level) {
 
 	@ApiStatus.NonExtendable
 	interface RenderDispatcher {
+		/**
+		 * Prepare visuals for render.
+		 *
+		 * <p>Guaranteed to be called before {@link #afterEntities} and {@link #beforeCrumbling}.
+		 * <br>Guaranteed to be called after the render thread has processed all light updates.
+		 * <br>The caller is otherwise free to choose an invocation site, but it is recommended to call
+		 * this as early as possible to give the VisualizationManager time to process things off-thread.
+		 */
 		void onStartLevelRender(RenderContext ctx);
 
-		void afterBlockEntities(RenderContext ctx);
-
+		/**
+		 * Render instances.
+		 *
+		 * <p>Guaranteed to be called after {@link #onStartLevelRender} and before {@link #beforeCrumbling}.
+		 * <br>The caller is otherwise free to choose an invocation site, but it is recommended to call
+		 * this between rendering entities and block entities.
+		 */
 		void afterEntities(RenderContext ctx);
 
+		/**
+		 * Render crumbling block entities.
+		 *
+		 * <p>Guaranteed to be called after {@link #onStartLevelRender} and {@link #afterEntities}
+		 * @param destructionProgress The destruction progress map from {@link net.minecraft.client.renderer.LevelRenderer LevelRenderer}.
+		 */
 		void beforeCrumbling(RenderContext ctx, Long2ObjectMap<SortedSet<BlockDestructionProgress>> destructionProgress);
-
-		void afterParticles(RenderContext ctx);
 	}
 }

common/src/api/java/dev/engine_room/flywheel/api/visualization/VisualizationManager.java

@@ -1,14 +1,15 @@
 package dev.engine_room.flywheel.backend;
 
-import dev.engine_room.flywheel.api.Flywheel;
 import dev.engine_room.flywheel.api.backend.Backend;
 import dev.engine_room.flywheel.backend.compile.IndirectPrograms;
 import dev.engine_room.flywheel.backend.compile.InstancingPrograms;
 import dev.engine_room.flywheel.backend.engine.EngineImpl;
 import dev.engine_room.flywheel.backend.engine.indirect.IndirectDrawManager;
 import dev.engine_room.flywheel.backend.engine.instancing.InstancedDrawManager;
+import dev.engine_room.flywheel.backend.gl.Driver;
 import dev.engine_room.flywheel.backend.gl.GlCompat;
 import dev.engine_room.flywheel.lib.backend.SimpleBackend;
+import dev.engine_room.flywheel.lib.util.ResourceUtil;
 import dev.engine_room.flywheel.lib.util.ShadersModHelper;
 
 public final class Backends {
@@ -19,16 +20,25 @@ public final class Backends {
 			.engineFactory(level -> new EngineImpl(level, new InstancedDrawManager(InstancingPrograms.get()), 256))
 			.priority(500)
 			.supported(() -> GlCompat.SUPPORTS_INSTANCING && InstancingPrograms.allLoaded() && !ShadersModHelper.isShaderPackInUse())
-			.register(Flywheel.rl("instancing"));
+			.register(ResourceUtil.rl("instancing"));
 
 	/**
 	 * Use Compute shaders to cull instances.
 	 */
 	public static final Backend INDIRECT = SimpleBackend.builder()
 			.engineFactory(level -> new EngineImpl(level, new IndirectDrawManager(IndirectPrograms.get()), 256))
-			.priority(1000)
+			.priority(() -> {
+				// Read from GlCompat in these provider because loading GlCompat
+				// at the same time the backends are registered causes GlCapabilities to be null.
+				if (GlCompat.DRIVER == Driver.INTEL) {
+					// Intel has very poor performance with indirect rendering, and on top of that has graphics bugs
+					return 1;
+				} else {
+					return 1000;
+				}
+			})
 			.supported(() -> GlCompat.SUPPORTS_INDIRECT && IndirectPrograms.allLoaded() && !ShadersModHelper.isShaderPackInUse())
-			.register(Flywheel.rl("indirect"));
+			.register(ResourceUtil.rl("indirect"));
 
 	private Backends() {
 	}

common/src/backend/java/dev/engine_room/flywheel/backend/Backends.java

@@ -2,11 +2,11 @@
 
 import java.util.List;
 
-import dev.engine_room.flywheel.api.Flywheel;
 import dev.engine_room.flywheel.api.layout.FloatRepr;
 import dev.engine_room.flywheel.api.layout.Layout;
 import dev.engine_room.flywheel.api.layout.LayoutBuilder;
 import dev.engine_room.flywheel.backend.gl.array.VertexAttribute;
+import dev.engine_room.flywheel.lib.util.ResourceUtil;
 import dev.engine_room.flywheel.lib.vertex.FullVertexView;
 import dev.engine_room.flywheel.lib.vertex.VertexView;
 import net.minecraft.resources.ResourceLocation;
@@ -24,7 +24,7 @@ public final class InternalVertex {
 	public static final List<VertexAttribute> ATTRIBUTES = LayoutAttributes.attributes(LAYOUT);
 	public static final int STRIDE = LAYOUT.byteSize();
 
-	public static final ResourceLocation LAYOUT_SHADER = Flywheel.rl("internal/vertex_input.vert");
+	public static final ResourceLocation LAYOUT_SHADER = ResourceUtil.rl("internal/vertex_input.vert");
 
 	private InternalVertex() {
 	}

common/src/backend/java/dev/engine_room/flywheel/backend/InternalVertex.java

@@ -0,0 +1,52 @@
+package dev.engine_room.flywheel.backend;
+
+import java.io.IOException;
+
+import org.jetbrains.annotations.UnknownNullability;
+import org.lwjgl.opengl.GL32;
+
+import com.mojang.blaze3d.platform.NativeImage;
+import com.mojang.blaze3d.systems.RenderSystem;
+
+import dev.engine_room.flywheel.backend.gl.GlTextureUnit;
+import dev.engine_room.flywheel.lib.util.ResourceUtil;
+import net.minecraft.client.renderer.texture.DynamicTexture;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.packs.resources.ResourceManager;
+
+public class NoiseTextures {
+	public static final ResourceLocation NOISE_TEXTURE = ResourceUtil.rl("textures/flywheel/noise/blue.png");
+
+	@UnknownNullability
+	public static DynamicTexture BLUE_NOISE;
+
+	public static void reload(ResourceManager manager) {
+		if (BLUE_NOISE != null) {
+			BLUE_NOISE.close();
+			BLUE_NOISE = null;
+		}
+		var optional = manager.getResource(NOISE_TEXTURE);
+
+		if (optional.isEmpty()) {
+			return;
+		}
+
+		try (var is = optional.get()
+				.open()) {
+			var image = NativeImage.read(NativeImage.Format.LUMINANCE, is);
+
+			BLUE_NOISE = new DynamicTexture(image);
+
+			GlTextureUnit.T0.makeActive();
+			BLUE_NOISE.bind();
+
+			NoiseTextures.BLUE_NOISE.setFilter(true, false);
+			RenderSystem.texParameter(GL32.GL_TEXTURE_2D, GL32.GL_TEXTURE_WRAP_S, GL32.GL_REPEAT);
+			RenderSystem.texParameter(GL32.GL_TEXTURE_2D, GL32.GL_TEXTURE_WRAP_T, GL32.GL_REPEAT);
+
+			RenderSystem.bindTexture(0);
+		} catch (IOException e) {
+
+		}
+	}
+}

common/src/backend/java/dev/engine_room/flywheel/backend/NoiseTextures.java

@@ -10,4 +10,8 @@ public class Samplers {
 	public static final GlTextureUnit INSTANCE_BUFFER = GlTextureUnit.T4;
 	public static final GlTextureUnit LIGHT_LUT = GlTextureUnit.T5;
 	public static final GlTextureUnit LIGHT_SECTIONS = GlTextureUnit.T6;
+
+	public static final GlTextureUnit DEPTH_RANGE = GlTextureUnit.T7;
+	public static final GlTextureUnit COEFFICIENTS = GlTextureUnit.T8;
+	public static final GlTextureUnit NOISE = GlTextureUnit.T9;
 }