Off thread safe blocks (#177)

* Whitelist carpentersblocks for off main thread rendering

* Add bounds checking to WorldSlice,

* Add preliminary `IThreadSafeISBRH` support

* Update TODO

* Adjust min y

* remove unnecessary try/catch

* * Keep track of what should be rendered on the main thread
* Update AngelicaBlockSafetyRegistry to handle vanilla blocks, and ISBHR's

* of -> set

Author: mitchej123

src/main/java/com/gtnewhorizons/angelica/compat/mojang/BlockPos.java

@@ -80,6 +80,9 @@ public static long asLong(int x, int y, int z) {
         return l;
     }
 
+    public BlockPos set(long packedPos) {
+        return set(unpackLongX(packedPos), unpackLongY(packedPos), unpackLongZ(packedPos));
+    }
 
     public static int unpackLongX(long packedPos) {
         return (int)(packedPos << 64 - BIT_SHIFT_X - SIZE_BITS_X >> 64 - SIZE_BITS_X);

src/main/java/com/gtnewhorizons/angelica/interfaces/IThreadSafeISBRH.java

@@ -0,0 +1,8 @@
+package com.gtnewhorizons.angelica.interfaces;
+
+import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
+
+public interface IThreadSafeISBRH extends ISimpleBlockRenderingHandler {
+    IThreadSafeISBRH getThreadLocal();
+
+}

src/main/java/com/gtnewhorizons/angelica/mixins/Mixins.java

@@ -87,7 +87,7 @@ public enum Mixins {
 
     SODIUM(new Builder("Sodium").addTargetedMod(TargetedMod.VANILLA).setSide(Side.CLIENT)
         .setPhase(Phase.EARLY).setApplyIf(() -> AngelicaConfig.enableSodium).addMixinClasses(
-            "sodium.MixinChunkProviderClient"
+             "sodium.MixinChunkProviderClient"
             ,"sodium.MixinBlock"
             ,"sodium.AccessorBiomeColorEvent"
             ,"sodium.MixinBiomeGenBase"
@@ -113,6 +113,7 @@ public enum Mixins {
             ,"sodium.MixinTileEntityRendererDispatcher"
             ,"sodium.MixinLongHashMap"
             ,"sodium.MixinRender"
+            ,"sodium.MixinRenderingRegistry"
         )
     ),
 

src/main/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinRenderingRegistry.java

@@ -0,0 +1,32 @@
+package com.gtnewhorizons.angelica.mixins.early.sodium;
+
+import com.gtnewhorizons.angelica.interfaces.IThreadSafeISBRH;
+import com.gtnewhorizons.angelica.mixins.interfaces.IRenderingRegistryExt;
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
+import cpw.mods.fml.client.registry.RenderingRegistry;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+
+import java.util.Map;
+
+@Mixin(value = RenderingRegistry.class, remap = false)
+public class MixinRenderingRegistry implements IRenderingRegistryExt {
+    @Shadow private Map<Integer, ISimpleBlockRenderingHandler> blockRenderers;
+
+    @Override
+    public ISimpleBlockRenderingHandler getISBRH(int modelId) {
+        return this.blockRenderers.get(modelId);
+    }
+
+    @WrapOperation(method = { "renderWorldBlock", "renderInventoryBlock", "renderItemAsFull3DBlock" }, at = @At(value="INVOKE", target="Ljava/util/Map;get(Ljava/lang/Object;)Ljava/lang/Object;"))
+    private Object getWrapped(Map<Integer, ISimpleBlockRenderingHandler> instance, Object modelId, Operation<ISimpleBlockRenderingHandler> original) {
+        final ISimpleBlockRenderingHandler res = original.call(instance, modelId);
+        if(res instanceof IThreadSafeISBRH isbhr) {
+            return isbhr.getThreadLocal();
+        }
+        return res;
+    }
+}

src/main/java/com/gtnewhorizons/angelica/mixins/interfaces/IRenderingRegistryExt.java

@@ -0,0 +1,7 @@
+package com.gtnewhorizons.angelica.mixins.interfaces;
+
+import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
+
+public interface IRenderingRegistryExt {
+    ISimpleBlockRenderingHandler getISBRH(int modelId);
+}

src/main/java/com/gtnewhorizons/angelica/rendering/AngelicaBlockSafetyRegistry.java

@@ -1,47 +1,56 @@
 package com.gtnewhorizons.angelica.rendering;
 
+import com.gtnewhorizons.angelica.interfaces.IThreadSafeISBRH;
+import com.gtnewhorizons.angelica.mixins.interfaces.IRenderingRegistryExt;
+import cpw.mods.fml.client.registry.RenderingRegistry;
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.versioning.ComparableVersion;
 import it.unimi.dsi.fastutil.objects.Reference2BooleanMap;
 import it.unimi.dsi.fastutil.objects.Reference2BooleanOpenHashMap;
 import net.minecraft.block.Block;
 
 import java.util.concurrent.locks.StampedLock;
 
 public class AngelicaBlockSafetyRegistry {
-    private static final Reference2BooleanMap<Block> SAFETY_MAP = new Reference2BooleanOpenHashMap<>();
+    private static final Reference2BooleanMap<Block> BLOCK_SAFETY_MAP = new Reference2BooleanOpenHashMap<>();
+    private static final Reference2BooleanMap<Block> ISBRH_SAFETY_MAP = new Reference2BooleanOpenHashMap<>();
     private static final StampedLock LOCK = new StampedLock();
 
-    public static boolean canBlockRenderOffThread(Block block) {
+    public static boolean canBlockRenderOffThread(Block block, boolean checkISBRH) {
         final long stamp = LOCK.readLock();
+        final Reference2BooleanMap<Block> map = checkISBRH ? ISBRH_SAFETY_MAP : BLOCK_SAFETY_MAP;
         boolean isOffThread, shouldPopulate;
         try {
-            isOffThread = SAFETY_MAP.getBoolean(block);
+            isOffThread = map.getBoolean(block);
             if (isOffThread) {
                 return true; // no need to check if 'false' was due to not being populated
             }
 
-            shouldPopulate = !SAFETY_MAP.containsKey(block);
+            shouldPopulate = !map.containsKey(block);
         } finally {
             LOCK.unlock(stamp);
         }
 
         if(shouldPopulate) {
-            isOffThread = populateCanRenderOffThread(block);
+            isOffThread = populateCanRenderOffThread(block, map);
         }
 
         return isOffThread;
     }
 
-    private static boolean populateCanRenderOffThread(Block block) {
-        final boolean canBeOffThread = !(block.getClass().getName().startsWith("gregtech."));
+    private static boolean populateCanRenderOffThread(Block block, Reference2BooleanMap<Block> map) {
+        @SuppressWarnings("deprecation")
+        final boolean canBeOffThread = map == ISBRH_SAFETY_MAP ? ((IRenderingRegistryExt)RenderingRegistry.instance()).getISBRH(block.getRenderType()) instanceof IThreadSafeISBRH : !(block.getClass().getName().startsWith("gregtech."));
 
         final long stamp = LOCK.writeLock();
 
         try {
-            SAFETY_MAP.put(block, canBeOffThread);
+            map.put(block, canBeOffThread);
         } finally {
             LOCK.unlock(stamp);
         }
 
         return canBeOffThread;
     }
+
 }

src/main/java/me/jellysquid/mods/sodium/client/render/chunk/tasks/ChunkRenderRebuildTask.java

@@ -6,6 +6,7 @@
 import com.gtnewhorizons.angelica.mixins.interfaces.ITexturesCache;
 import com.gtnewhorizons.angelica.rendering.AngelicaBlockSafetyRegistry;
 import com.gtnewhorizons.angelica.rendering.AngelicaRenderQueue;
+import it.unimi.dsi.fastutil.longs.LongArrayFIFOQueue;
 import me.jellysquid.mods.sodium.client.SodiumClientMod;
 import me.jellysquid.mods.sodium.client.render.chunk.ChunkGraphicsState;
 import me.jellysquid.mods.sodium.client.render.chunk.ChunkRenderContainer;
@@ -89,7 +90,7 @@ private boolean rendersOutsideBoundingBox(TileEntity entity, int baseX, int base
 
     private boolean rendersOffThread(Block block) {
         final int type = block.getRenderType();
-        return type < 42 && type != 22 && AngelicaBlockSafetyRegistry.canBlockRenderOffThread(block);
+        return (type < 42 && type != 22 && AngelicaBlockSafetyRegistry.canBlockRenderOffThread(block, false)) || AngelicaBlockSafetyRegistry.canBlockRenderOffThread(block, true);
     }
 
     private void handleRenderBlocksTextures(RenderBlocks rb, ChunkRenderData.Builder builder) {
@@ -104,7 +105,6 @@ private void handleRenderBlocksTextures(RenderBlocks rb, ChunkRenderData.Builder
 
     @Override
     public ChunkBuildResult<T> performBuild(ChunkRenderCacheLocal cache, ChunkBuildBuffers buffers, CancellationSource cancellationSource) {
-        // COMPATIBLITY NOTE: Oculus relies on the LVT of this method being unchanged, at least in 16.5
         final ChunkRenderData.Builder renderData = new ChunkRenderData.Builder();
         final ChunkOcclusionDataBuilder occluder = new ChunkOcclusionDataBuilder();
         final ChunkRenderBounds.Builder bounds = new ChunkRenderBounds.Builder();
@@ -120,9 +120,10 @@ public ChunkBuildResult<T> performBuild(ChunkRenderCacheLocal cache, ChunkBuildB
         final int baseY = this.render.getOriginY();
         final int baseZ = this.render.getOriginZ();
 
-        final BlockPos.Mutable pos = new BlockPos.Mutable();
+        final BlockPos pos = new BlockPos();
         final BlockPos renderOffset = this.offset;
 
+        final LongArrayFIFOQueue mainThreadBlocks = new LongArrayFIFOQueue();
         boolean hasMainThreadBlocks = false;
 
         for (int relY = 0; relY < 16; relY++) {
@@ -160,6 +161,7 @@ public ChunkBuildResult<T> performBuild(ChunkRenderCacheLocal cache, ChunkBuildB
                             }
                         }
                     } else {
+                        mainThreadBlocks.enqueue(pos.asLong());
                         hasMainThreadBlocks = true;
                     }
 
@@ -200,7 +202,7 @@ public ChunkBuildResult<T> performBuild(ChunkRenderCacheLocal cache, ChunkBuildB
         if(hasMainThreadBlocks) {
             // Render the other blocks on the main thread
             try {
-                CompletableFuture.runAsync(() -> this.performMainBuild(cache, buffers, cancellationSource, bounds, renderData), AngelicaRenderQueue.executor()).get();
+                CompletableFuture.runAsync(() -> this.performMainBuild(cache, buffers, cancellationSource, bounds, renderData, mainThreadBlocks), AngelicaRenderQueue.executor()).get();
             } catch(InterruptedException e) {
                 Thread.currentThread().interrupt();
                 return null;
@@ -230,54 +232,51 @@ public ChunkBuildResult<T> performBuild(ChunkRenderCacheLocal cache, ChunkBuildB
 
     /**
      * Render the blocks that should be rendered on the main thread.
-     *
-     * TODO: Deduplicate this with the main method above.
      */
-    private void performMainBuild(ChunkRenderCacheLocal cache, ChunkBuildBuffers buffers, CancellationSource cancellationSource, ChunkRenderBounds.Builder bounds, ChunkRenderData.Builder renderData) {
+    private void performMainBuild(ChunkRenderCacheLocal cache, ChunkBuildBuffers buffers, CancellationSource cancellationSource, ChunkRenderBounds.Builder bounds, ChunkRenderData.Builder renderData, LongArrayFIFOQueue mainThreadBlocks) {
         final WorldSlice slice = cache.getWorldSlice();
-        final BlockPos.Mutable pos = new BlockPos.Mutable();
+        final BlockPos pos = new BlockPos();
         final int baseX = this.render.getOriginX();
         final int baseY = this.render.getOriginY();
         final int baseZ = this.render.getOriginZ();
         final BlockPos renderOffset = this.offset;
         final RenderBlocks rb = new RenderBlocks(slice.getWorld());
-        for (int relY = 0; relY < 16; relY++) {
+        while(!mainThreadBlocks.isEmpty()) {
+            final long longPos = mainThreadBlocks.dequeueLong();
             if (cancellationSource.isCancelled()) {
                 return;
             }
-            for (int relZ = 0; relZ < 16; relZ++) {
-                for (int relX = 0; relX < 16; relX++) {
-                    final Block block = slice.getBlockRelative(relX + 16, relY + 16, relZ + 16);
+            pos.set(longPos);
+            final int relX = pos.getX() - baseX;
+            final int relY = pos.getY() - baseY;
+            final int relZ = pos.getZ() - baseZ;
+            final Block block = slice.getBlockRelative(relX + 16, relY + 16, relZ + 16);
+
+            // Only render blocks that need main thread assistance
+            if (block.getMaterial() == Material.air || rendersOffThread(block)) {
+                continue;
+            }
 
-                    // Only render blocks that need main thread assistance
-                    if (block.getMaterial() == Material.air || rendersOffThread(block)) {
-                        continue;
-                    }
+            // TODO: Collect data on which render types are hitting this code path most often so mods can be updated slowly
 
-                    // TODO: Collect data on which render types are hitting this code path most often
-                    // so mods can be updated slowly
+            final int meta = slice.getBlockMetadataRelative(relX + 16, relY + 16, relZ + 16);
 
-                    final int meta = slice.getBlockMetadataRelative(relX + 16, relY + 16, relZ + 16);
+            buffers.setRenderOffset(pos.x - renderOffset.getX(), pos.y - renderOffset.getY(), pos.z - renderOffset.getZ());
+            if(AngelicaConfig.enableIris) buffers.iris$setLocalPos(relX, relY, relZ);
 
-                    pos.set(baseX + relX, baseY + relY, baseZ + relZ);
-                    buffers.setRenderOffset(pos.x - renderOffset.getX(), pos.y - renderOffset.getY(), pos.z - renderOffset.getZ());
-                    if(AngelicaConfig.enableIris) buffers.iris$setLocalPos(relX, relY, relZ);
+            // Do regular block rendering
+            for (BlockRenderPass pass : BlockRenderPass.VALUES) {
+                if (block.canRenderInPass(pass.ordinal()) && (!AngelicaConfig.enableSodiumFluidRendering || !(block instanceof IFluidBlock))) {
+                    final long seed = MathUtil.hashPos(pos.x, pos.y, pos.z);
+                    if(AngelicaConfig.enableIris) buffers.iris$setMaterialId(block, ExtendedDataHelper.BLOCK_RENDER_TYPE);
 
-                    // Do regular block rendering
-                    for (BlockRenderPass pass : BlockRenderPass.VALUES) {
-                        if (block.canRenderInPass(pass.ordinal()) && (!AngelicaConfig.enableSodiumFluidRendering || !(block instanceof IFluidBlock))) {
-                            final long seed = MathUtil.hashPos(pos.x, pos.y, pos.z);
-                            if(AngelicaConfig.enableIris) buffers.iris$setMaterialId(block, ExtendedDataHelper.BLOCK_RENDER_TYPE);
-
-                            if (cache.getBlockRenderer().renderModel(slice.getWorld(), rb, block, meta, pos, buffers.get(pass), true, seed)) {
-                                bounds.addBlock(relX, relY, relZ);
-                            }
-                        }
+                    if (cache.getBlockRenderer().renderModel(slice.getWorld(), rb, block, meta, pos, buffers.get(pass), true, seed)) {
+                        bounds.addBlock(relX, relY, relZ);
                     }
-
-                    if(AngelicaConfig.enableIris) buffers.iris$resetBlockContext();
                 }
             }
+
+            if(AngelicaConfig.enableIris) buffers.iris$resetBlockContext();
         }
 
         handleRenderBlocksTextures(rb, renderData);

src/main/java/me/jellysquid/mods/sodium/client/render/pipeline/FluidRenderer.java

@@ -95,6 +95,7 @@ public boolean render(IBlockAccess world, WorldSlice slice, Block block, BlockPo
         int posZ = pos.z;
 
         Fluid fluid = ((IFluidBlock) block).getFluid();
+        if(fluid == null) return false;
 
         // Check for occluded sides; if everything is occluded, don't render
         boolean sfUp = this.isFluidOccluded(world, posX, posY, posZ, ForgeDirection.UP, fluid);