fix(compat): render ArchitectureCraft blocks via the vanilla dispatcher

ArchitectureCraft (TridenMC/Spocel, issue #101) replaces
Minecraft.blockRenderDispatcher with CustomBlockDispatcher during
postInit and emits its shape geometry through that entry point; its
baked-model slots stay empty (blockstates only publish a normal
variant, so facing=* states resolve to Forge's FancyMissingModel).
The fast chunk path reads BlockModelShapes.getModelForState directly,
hits the missing model and skipped the block, so every
ArchitectureCraft block was invisible (0.0.6 crashed on the fancy
missing model's lazy font rendering before #90 made it a skip).

Force blocks registered under the architecturecraft namespace down the
existing vanilla dispatcher fallback (the SnowRealMagicCompat route);
the replaced dispatcher then supplies the real geometry. Its
RenderTargetWorld target writes into a BufferBuilder without touching
GL, so it stays safe on mesh worker threads. The routing decision is
extracted into ArchitectureCraftRenderRouting so it can be tested
without an FML bootstrap, and the compat-bridge renderer is untouched,
keeping the third-party mixin binding contract intact.

Author: DHJComical

gradle/scripts/dependencies.gradle

@@ -145,4 +145,8 @@ dependencies {
     // Botania CEU (issue: held items render flat white because its RenderWorldLastEvent handlers leave
     // GL_TEXTURE_2D disabled in the GLSM cache; the conditional botania mixin restores it)
     modImplementation 'curse.maven:botania-ceu-1179448:8706250'
+
+    // ArchitectureCraft 1.12-3.108 TridenMC (issue #101: its blocks are invisible / sawbench hits
+    // FancyMissingModel inside the fast chunk meshing path; dev-verifies the shape rendering compat)
+    modImplementation 'curse.maven:architecturecraft-tridev-277631:4344128'
 }

src/main/java/com/dhj/actinium/compat/architecturecraft/ArchitectureCraftCompat.java

@@ -0,0 +1,44 @@
+package com.dhj.actinium.compat.architecturecraft;
+
+import net.minecraft.block.Block;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.fml.common.Loader;
+
+/**
+ * Compatibility for ArchitectureCraft (mod id {@code architecturecraft}; the TridentMC and Spocel
+ * releases share it).
+ *
+ * <p>ArchitectureCraft never relies on baked models for its world rendering. Its blockstates only
+ * publish a {@code normal} variant (the runtime definition comes from its generated resource pack),
+ * so every {@code facing=*} state resolves to Forge's {@code FancyMissingModel} in the bake
+ * registry, and the real geometry is emitted by a {@code BlockRendererDispatcher} replacement that
+ * {@code CustomBlockDispatcher.inject()} installs into {@code Minecraft.blockRenderDispatcher}
+ * during postInit. The vanilla chunk rebuild calls that entry point and the blocks stay visible;
+ * Actinium's fast chunk path reads {@code BlockModelShapes.getModelForState} directly, hits the
+ * missing model and skips the block (#101). The dispatcher replacement must therefore not be
+ * bypassed: the compat forces ArchitectureCraft blocks down the vanilla dispatcher fallback,
+ * whose {@code RenderTargetWorld} target writes into a {@code BufferBuilder} without touching GL,
+ * which keeps it safe on mesh worker threads.</p>
+ */
+public final class ArchitectureCraftCompat {
+    /**
+     * The mod ID used by both maintained ArchitectureCraft releases.
+     */
+    public static final String MODID = "architecturecraft";
+    public static final boolean IS_LOADED = Loader.isModLoaded(MODID);
+
+    private ArchitectureCraftCompat() {
+    }
+
+    /**
+     * Returns whether {@code block} belongs to ArchitectureCraft and must be rendered through the
+     * vanilla {@code BlockRendererDispatcher}, which ArchitectureCraft replaces with its own
+     * dispatcher providing the real shape geometry.
+     */
+    public static boolean shouldForceVanillaRender(Block block) {
+        if (!IS_LOADED) {
+            return false;
+        }
+        return ArchitectureCraftRenderRouting.isArchitectureCraftNamespace(block.getRegistryName());
+    }
+}

src/main/java/com/dhj/actinium/compat/architecturecraft/ArchitectureCraftRenderRouting.java

@@ -0,0 +1,24 @@
+package com.dhj.actinium.compat.architecturecraft;
+
+import net.minecraft.util.ResourceLocation;
+
+import javax.annotation.Nullable;
+
+/**
+ * Render-path routing decisions for ArchitectureCraft blocks, kept free of live-client
+ * dependencies so they can be exercised without an FML bootstrap.
+ */
+public final class ArchitectureCraftRenderRouting {
+    private ArchitectureCraftRenderRouting() {
+    }
+
+    /**
+     * Returns whether {@code registryName} belongs to the ArchitectureCraft namespace and
+     * therefore must stay on the vanilla dispatcher path. Identified by the registry namespace,
+     * which covers every block of both maintained releases without referencing any
+     * ArchitectureCraft class.
+     */
+    public static boolean isArchitectureCraftNamespace(@Nullable ResourceLocation registryName) {
+        return registryName != null && ArchitectureCraftCompat.MODID.equals(registryName.getNamespace());
+    }
+}

src/main/java/com/dhj/actinium/render/terrain/compile/task/ChunkBuilderMeshingTask.java

@@ -33,6 +33,7 @@
 import org.embeddedt.embeddium.api.shader.BlockRenderLayer;
 import org.embeddedt.embeddium.api.shader.ShaderProvider;
 import org.embeddedt.embeddium.api.shader.ShaderProviderHolder;
+import com.dhj.actinium.compat.architecturecraft.ArchitectureCraftCompat;
 import com.dhj.actinium.compat.fluidlogged.FluidloggedCompat;
 import com.dhj.actinium.compat.snowrealmagic.SnowRealMagicCompat;
 import com.dhj.actinium.runtime.ActiniumRuntime;
@@ -124,7 +125,9 @@ public ChunkBuildOutput execute(ChunkBuildContext context, CancellationToken can
                             net.minecraft.util.BlockRenderLayer layer = shaderLayerOverride.toVanillaLayer();
                             ForgeHooksClient.setRenderLayer(layer);
                             block.canRenderInLayer(blockState, layer);
-                            if (blockState.getRenderType() == EnumBlockRenderType.MODEL && ActiniumRuntime.options().performance.useFastBlockRenderer && !SnowRealMagicCompat.shouldForceVanillaRender(block)) {
+                            if (blockState.getRenderType() == EnumBlockRenderType.MODEL && ActiniumRuntime.options().performance.useFastBlockRenderer
+                                    && !SnowRealMagicCompat.shouldForceVanillaRender(block)
+                                    && !ArchitectureCraftCompat.shouldForceVanillaRender(block)) {
                                 buildContext.getBlockRenderer().renderBlock(blockState, blockPos, slice, layer, false);
                             } else {
                                 var buffer = buildContext.getBufferForLayer(layer);
@@ -139,7 +142,9 @@ public ChunkBuildOutput execute(ChunkBuildContext context, CancellationToken can
                             for (net.minecraft.util.BlockRenderLayer layer : VintageChunkBuildContext.LAYERS) {
                                 if (block.canRenderInLayer(blockState, layer)) {
                                     ForgeHooksClient.setRenderLayer(layer);
-                                    if (blockState.getRenderType() == EnumBlockRenderType.MODEL && ActiniumRuntime.options().performance.useFastBlockRenderer && !SnowRealMagicCompat.shouldForceVanillaRender(block)) {
+                                    if (blockState.getRenderType() == EnumBlockRenderType.MODEL && ActiniumRuntime.options().performance.useFastBlockRenderer
+                                            && !SnowRealMagicCompat.shouldForceVanillaRender(block)
+                                            && !ArchitectureCraftCompat.shouldForceVanillaRender(block)) {
                                         buildContext.getBlockRenderer().renderBlock(blockState, blockPos, slice, layer);
                                     } else {
                                         var buffer = buildContext.getBufferForLayer(layer);

src/test/java/com/dhj/actinium/compat/architecturecraft/ArchitectureCraftRenderRoutingTest.java

@@ -0,0 +1,26 @@
+package com.dhj.actinium.compat.architecturecraft;
+
+import net.minecraft.util.ResourceLocation;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ArchitectureCraftRenderRoutingTest {
+    @Test
+    void architectureCraftBlocksAreForcedOntoTheVanillaDispatcher() {
+        assertTrue(ArchitectureCraftRenderRouting.isArchitectureCraftNamespace(
+                new ResourceLocation("architecturecraft", "sawbench")));
+        assertTrue(ArchitectureCraftRenderRouting.isArchitectureCraftNamespace(
+                new ResourceLocation("architecturecraft", "shape")));
+    }
+
+    @Test
+    void foreignAndMissingRegistryNamesStayOnTheFastPath() {
+        assertFalse(ArchitectureCraftRenderRouting.isArchitectureCraftNamespace(
+                new ResourceLocation("minecraft", "stone")));
+        assertFalse(ArchitectureCraftRenderRouting.isArchitectureCraftNamespace(
+                new ResourceLocation("chisel", "marble")));
+        assertFalse(ArchitectureCraftRenderRouting.isArchitectureCraftNamespace(null));
+    }
+}