Move deferred chunk meshing back off the main thread (#2306)

This commit is contained in:
Jason Mitchell authored and GitHub committed 2026-10-26 22:16:14 -07:00
1 parent 91e67f8d5d
commit ed6dd12db7
11 files changed
+638 -247

No files matched your search

@@ -44,6 +44,7 @@ import java.util.List;
public class AngelicaChunkBuildContext extends ChunkBuildContext {
public static final int NUM_PASSES = 2;
public static final int INTS_PER_VERTEX = 8;
// Yoinked from Celeritas
private static final int[] REVERSED_QUAD_ORDER = { 0, 3, 2, 1 };
@@ -121,7 +122,7 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext {
}
@SuppressWarnings("unchecked")
public void copyRawBuffer(int[] rawBuffer, int vertexCount, int[] vertexStates,
public void copyRawBuffer(int[] rawBuffer, int vertexOffset, int vertexCount, int[] vertexStates,
int[] shaderOverrideBlockIds,
ChunkBuildBuffers buffers, Material material, boolean isShaderPackOverride,
boolean blockAllowsSmoothLighting) {
@@ -144,7 +145,7 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext {
final boolean shouldApplyDiffuse = !BlockRenderingSettings.INSTANCE.shouldDisableDirectionalShading();
final ChunkColorWriter colorEncoder = separateAo ? ChunkColorWriter.SEPARATE_AO : ChunkColorWriter.EMBEDDIUM;
int ptr = 0;
int ptr = vertexOffset * INTS_PER_VERTEX;
final int numQuads = vertexCount / 4;
final int blockX = blockRenderContext.localPosX;
@@ -156,7 +157,7 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext {
final short originalBlockId = blockRenderContext.blockId;
int stateIdx = 0;
int stateIdx = vertexOffset;
materialSelector.reset(material, isShaderPackOverride, useRenderPassOptimization);
this.fluidQuadLightFace = null;
@@ -250,7 +251,7 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext {
final Material correctMaterial = materialSelector.select(facing, sprite, hasVertexTransparency);
final var builder = buffers.get(correctMaterial);
final int shaderOverrideBlockId = shaderOverrideBlockIds[quadIdx * 4];
final int shaderOverrideBlockId = shaderOverrideBlockIds[vertexOffset + quadIdx * 4];
blockRenderContext.blockId = shaderOverrideBlockId == StateAwareTessellator.UNMAPPED_SHADER_BLOCK_ID
? -1 : shaderOverrideBlockId != -1 ? (short) shaderOverrideBlockId : originalBlockId;
@@ -1,7 +1,9 @@
package com.gtnewhorizons.angelica.rendering.celeritas;
import com.gtnewhorizon.gtnhlib.blockpos.BlockPos;
import com.gtnewhorizon.gtnhlib.client.renderer.TessellatorManager;
import com.gtnewhorizons.angelica.glsm.profiling.Tracy;
import com.gtnewhorizons.angelica.rendering.RenderThreadContext;
import com.gtnewhorizons.angelica.rendering.StateAwareTessellator;
import com.gtnewhorizons.angelica.mixins.interfaces.OverridesGetDistanceFrom;
import com.gtnewhorizons.angelica.rendering.TileEntityRenderBoundsRegistry;
@@ -254,6 +256,8 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
// Check for shader pack override
final BlockRenderLayer override = blockTypeIds != null ? blockTypeIds.get(block) : null;
int deferredPasses = 0;
Material deferredOverride = null;
for (int pass = 0; pass < AngelicaChunkBuildContext.NUM_PASSES; pass++) {
final boolean canRender;
@@ -273,13 +277,17 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
if (canRender) {
final boolean isShaderPackOverride = materialOverride != null;
if (!canRenderOffThread) {
deferredBlocks.add(new DeferredBlock(x, y, z, block, meta, pass, materialOverride, isShaderPackOverride));
deferredPasses |= 1 << pass;
deferredOverride = materialOverride;
continue;
}
renderBlock(block, meta, x, y, z, pass, tessellator, renderBlocks, buffers, buildContext, blockRenderContext, minX, minY, minZ, materialOverride, isShaderPackOverride, teMap, currentTick);
}
}
if (deferredPasses != 0) {
deferredBlocks.add(new DeferredBlock(x, y, z, block, meta, deferredPasses, deferredOverride));
}
if (block.isOpaqueCube()) {
occluder.markOpaque(x, y, z);
@@ -301,7 +309,8 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
throw new IllegalStateException("Deferred handoff requires the context WorldSlice for " + this.render);
}
final WorldSlice slice = buildContext.swapWorldSlice(scheduler.acquireSlice());
final DeferredSectionMesh mesh = new DeferredSectionMesh(this, cancellationToken, buffers, slice, renderData, deferredBlocks, teMap, currentTick, this.important, System.nanoTime() - start);
final long priority = (long) this.render.getSquaredDistanceFromBlockCenter((int) Math.floor(camera.x), (int) Math.floor(camera.y), (int) Math.floor(camera.z));
final DeferredSectionMesh mesh = new DeferredSectionMesh(this, cancellationToken, buffers, slice, renderData, deferredBlocks, teMap, currentTick, this.important, priority, System.nanoTime() - start);
scheduler.submit(mesh);
handoffBuffers = null;
@@ -311,32 +320,10 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
return null;
}
if (Tracy.ENABLED) Tracy.beginZone(Z_MESH_FINALIZE);
final Reference2ReferenceMap<TerrainRenderPass, BuiltSectionMeshParts> meshes;
try {
meshes = BuiltSectionMeshParts.groupFromBuildBuffers(buffers,
(float) (camera.x - minX), (float) (camera.y - minY), (float) (camera.z - minZ));
} finally {
if (Tracy.ENABLED) Tracy.endZone();
}
if (!meshes.isEmpty()) {
renderData.hasBlockGeometry = true;
if (Tracy.ENABLED) {
long meshBytes = 0;
for (BuiltSectionMeshParts parts : meshes.values()) {
if (parts.vertexBuffer() != null) meshBytes += parts.vertexBuffer().getLength();
}
Tracy.zoneValue(meshBytes);
}
}
SmoothBiomeColorCache.clearActiveCache();
tessellator.setTranslation(0, 0, 0);
CeleritasDebug.incrementChunkUpdateCounter();
return new ChunkBuildOutput(this.render, renderData, meshes, this.buildTime);
return finalizeSection(buffers, renderData, minX, minY, minZ);
} catch (ReportedException ex) {
throw fillCrashInfo(ex.getCrashReport(), region, blockPos);
@@ -374,7 +361,7 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
return (mask[bit >>> 6] & (1L << bit)) != 0;
}
ChunkJobResult<ChunkBuildOutput> completeDeferred(DeferredSectionMesh m, AngelicaChunkBuildContext ctx) {
ChunkJobResult<ChunkBuildOutput> captureDeferred(DeferredSectionMesh m) {
final long start = System.nanoTime();
final int minX = this.render.getOriginX();
@@ -384,7 +371,10 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
final WorldSlice slice = m.slice;
final BlockPos blockPos = new BlockPos(minX, minY, minZ);
final Tessellator tessellator = Tessellator.instance;
final StateAwareTessellator stateTessellator = (StateAwareTessellator) tessellator;
final List<DeferredBlock> blocks = m.blocks;
final DeferredSectionMesh.DeferredCapture capture = m.capture;
final NbtConditionalIdMap<Block> teMap = m.teMap;
if (Tracy.ENABLED) {
Tracy.beginZone(Z_MESH_DEFERRED_MAIN);
@@ -392,51 +382,44 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
}
try {
ctx.setupLightPipeline(slice, minX, minY, minZ);
ctx.setupDynamicLights(minX, minY, minZ);
slice.setRenderingBlock(null);
SmoothBiomeColorCache.setActiveCache(slice.getBiomeColorCache());
((StateAwareTessellator)tessellator).angelica$setCeleritasMeshing(true);
stateTessellator.angelica$setCeleritasMeshing(true);
tessellator.setTranslation(-minX, -minY, -minZ);
final RenderBlocks renderBlocks = new RenderBlocks(slice);
final BlockRenderContext blockRenderContext = ctx.getBlockRenderContext();
for (int i = 0, n = blocks.size(); i < n; i++) {
final DeferredBlock deferred = blocks.get(i);
blockPos.set(deferred.x(), deferred.y(), deferred.z());
slice.setRenderingBlock(deferred.block());
if (!deferred.isShaderPackOverride()) {
setRenderPass(deferred.pass());
if (!deferred.block().canRenderInPass(deferred.pass())) continue;
final Block block = deferred.block();
final int x = deferred.x(), y = deferred.y(), z = deferred.z();
blockPos.set(x, y, z);
slice.setRenderingBlock(block);
for (int pass = 0; pass < AngelicaChunkBuildContext.NUM_PASSES; pass++) {
if ((deferred.passMask() & (1 << pass)) == 0) continue;
if (!deferred.isShaderPackOverride()) {
setRenderPass(pass);
if (!block.canRenderInPass(pass)) continue;
}
final int teBlockId = resolveTeBlockId(teMap, slice, block, deferred.meta(), x, y, z, m.buffers, pass, deferred.materialOverride(), m.currentTick);
drawBlock(block, x, y, z, pass, tessellator, renderBlocks);
if (tessellator.vertexCount > 0) {
capture.add(i * AngelicaChunkBuildContext.NUM_PASSES + pass, tessellator.rawBuffer, tessellator.vertexCount, stateTessellator.angelica$getVertexStates(), stateTessellator.angelica$getShaderOverrideBlockIds(), teBlockId);
}
tessellator.reset();
tessellator.isDrawing = false;
}
renderBlock(deferred.block(), deferred.meta(), deferred.x(), deferred.y(), deferred.z(), deferred.pass(),
tessellator, renderBlocks, m.buffers, ctx, blockRenderContext, minX, minY, minZ,
deferred.materialOverride(), deferred.isShaderPackOverride(), m.teMap, m.currentTick);
}
if (Tracy.ENABLED) Tracy.beginZone(Z_MESH_FINALIZE);
final Reference2ReferenceMap<TerrainRenderPass, BuiltSectionMeshParts> meshes;
try {
meshes = BuiltSectionMeshParts.groupFromBuildBuffers(m.buffers, (float) (camera.x - minX), (float) (camera.y - minY), (float) (camera.z - minZ));
} finally {
if (Tracy.ENABLED) Tracy.endZone();
}
if (!meshes.isEmpty()) {
m.renderData.hasBlockGeometry = true;
}
CeleritasDebug.incrementChunkUpdateCounter();
return new ChunkJobResult.Success<>(new ChunkBuildOutput(this.render, m.renderData, meshes, this.buildTime), m.workerNanos + (System.nanoTime() - start));
m.mainNanos = System.nanoTime() - start;
return null;
} catch (ReportedException ex) {
return new ChunkJobResult.Failure<>(fillCrashInfo(ex.getCrashReport(), slice, blockPos));
} catch (Throwable ex) {
return new ChunkJobResult.Failure<>(fillCrashInfo(CrashReport.makeCrashReport(ex, "Encountered exception while building deferred chunk meshes"), slice, blockPos));
} finally {
((StateAwareTessellator)tessellator).angelica$setCeleritasMeshing(false);
stateTessellator.angelica$setCeleritasMeshing(false);
tessellator.setTranslation(0, 0, 0);
SmoothBiomeColorCache.clearActiveCache();
RenderPassHelper.resetWorldRenderPass();
@@ -444,22 +427,105 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
}
}
protected void renderBlock(Block block, int metadata, int x, int y, int z, int pass, Tessellator tessellator, RenderBlocks renderBlocks, ChunkBuildBuffers buffers, AngelicaChunkBuildContext buildContext, BlockRenderContext blockRenderContext, int originX, int originY, int originZ, Material materialOverride, boolean isShaderPackOverride, NbtConditionalIdMap<Block> teMap, long currentTick) {
ChunkBuildOutput finishDeferred(DeferredSectionMesh m, AngelicaChunkBuildContext ctx) {
final int minX = this.render.getOriginX();
final int minY = this.render.getOriginY();
final int minZ = this.render.getOriginZ();
final var blockMaterial = block.getMaterial();
final boolean isFluid = blockMaterial == net.minecraft.block.material.Material.water || blockMaterial == net.minecraft.block.material.Material.lava;
final WorldSlice slice = m.slice;
final BlockPos blockPos = new BlockPos(minX, minY, minZ);
final ChunkBuildBuffers buffers = m.buffers;
final List<DeferredBlock> blocks = m.blocks;
final DeferredSectionMesh.DeferredCapture capture = m.capture;
final boolean bindSlice = !TessellatorManager.isOnMainThread();
// Use material override if provided, otherwise derive from pass
// Lava is opaque - use solid to skip unnecessary alpha testing
final Material passMaterial;
if (materialOverride != null) {
passMaterial = materialOverride;
} else if (blockMaterial == net.minecraft.block.material.Material.lava) {
passMaterial = AngelicaRenderPassConfiguration.SOLID_MATERIAL;
} else {
passMaterial = buffers.getRenderPassConfiguration().getMaterialForRenderType(BlockRenderLayer.fromVanillaPass(pass));
try {
ctx.setupLightPipeline(slice, minX, minY, minZ);
ctx.setupDynamicLights(minX, minY, minZ);
if (bindSlice) RenderThreadContext.set(slice);
slice.setRenderingBlock(null);
final BlockRenderContext blockRenderContext = ctx.getBlockRenderContext();
final int[] raw = capture.raw.elements();
final int[] vertexStates = capture.vertexStates.elements();
final int[] shaderBlockIds = capture.shaderBlockIds.elements();
for (int i = 0, n = capture.blockCount(); i < n; i++) {
final int entry = capture.blockIndex.getInt(i);
final DeferredBlock deferred = blocks.get(entry / AngelicaChunkBuildContext.NUM_PASSES);
final Block block = deferred.block();
final int x = deferred.x(), y = deferred.y(), z = deferred.z();
blockPos.set(x, y, z);
slice.setRenderingBlock(block);
final Material passMaterial = resolvePassMaterial(block, entry % AngelicaChunkBuildContext.NUM_PASSES, buffers, deferred.materialOverride());
final ContextAwareChunkVertexEncoder contextEncoder = prepareEncode(block, deferred.meta(), x, y, z, slice, buffers, blockRenderContext, passMaterial, capture.teBlockIds.getInt(i));
encodeTessellated(raw, capture.blockStart.getInt(i), capture.blockVertexCount.getInt(i), vertexStates, shaderBlockIds, block, buffers, ctx, passMaterial, deferred.isShaderPackOverride(), contextEncoder);
}
return finalizeSection(buffers, m.renderData, minX, minY, minZ);
} catch (ReportedException ex) {
throw fillCrashInfo(ex.getCrashReport(), slice, blockPos);
} catch (Throwable ex) {
throw fillCrashInfo(CrashReport.makeCrashReport(ex, "Encountered exception while building deferred chunk meshes"), slice, blockPos);
} finally {
if (bindSlice) RenderThreadContext.clear();
}
}
private ChunkBuildOutput finalizeSection(ChunkBuildBuffers buffers, AngelicaBuiltRenderSectionData renderData, int minX, int minY, int minZ) {
if (Tracy.ENABLED) Tracy.beginZone(Z_MESH_FINALIZE);
final Reference2ReferenceMap<TerrainRenderPass, BuiltSectionMeshParts> meshes;
try {
meshes = BuiltSectionMeshParts.groupFromBuildBuffers(buffers, (float) (camera.x - minX), (float) (camera.y - minY), (float) (camera.z - minZ));
} finally {
if (Tracy.ENABLED) Tracy.endZone();
}
if (!meshes.isEmpty()) {
renderData.hasBlockGeometry = true;
if (Tracy.ENABLED) {
long meshBytes = 0;
for (BuiltSectionMeshParts parts : meshes.values()) {
if (parts.vertexBuffer() != null) meshBytes += parts.vertexBuffer().getLength();
}
Tracy.zoneValue(meshBytes);
}
}
CeleritasDebug.incrementChunkUpdateCounter();
return new ChunkBuildOutput(this.render, renderData, meshes, this.buildTime);
}
protected void renderBlock(Block block, int metadata, int x, int y, int z, int pass, Tessellator tessellator, RenderBlocks renderBlocks, ChunkBuildBuffers buffers, AngelicaChunkBuildContext buildContext, BlockRenderContext blockRenderContext, int originX, int originY, int originZ, Material materialOverride, boolean isShaderPackOverride, NbtConditionalIdMap<Block> teMap, long currentTick) {
final Material passMaterial = resolvePassMaterial(block, pass, buffers, materialOverride);
final int teBlockId = resolveTeBlockId(teMap, renderBlocks.blockAccess, block, metadata, x, y, z, buffers, pass, materialOverride, currentTick);
final ContextAwareChunkVertexEncoder contextEncoder = prepareEncode(block, metadata, x, y, z, renderBlocks.blockAccess, buffers, blockRenderContext, passMaterial, teBlockId);
drawBlock(block, x, y, z, pass, tessellator, renderBlocks);
encodeTessellated(tessellator.rawBuffer, 0, tessellator.vertexCount, ((StateAwareTessellator) tessellator).angelica$getVertexStates(),
((StateAwareTessellator) tessellator).angelica$getShaderOverrideBlockIds(), block, buffers, buildContext, passMaterial, isShaderPackOverride, contextEncoder);
tessellator.reset();
tessellator.isDrawing = false;
}
private static Material resolvePassMaterial(Block block, int pass, ChunkBuildBuffers buffers, Material materialOverride) {
// Use material override if provided, otherwise derive from pass
// Lava is opaque - use solid to skip unnecessary alpha testing
if (materialOverride != null) {
return materialOverride;
} else if (block.getMaterial() == net.minecraft.block.material.Material.lava) {
return AngelicaRenderPassConfiguration.SOLID_MATERIAL;
} else {
return buffers.getRenderPassConfiguration().getMaterialForRenderType(BlockRenderLayer.fromVanillaPass(pass));
}
}
private static boolean isFluid(Block block) {
final var blockMaterial = block.getMaterial();
return blockMaterial == net.minecraft.block.material.Material.water || blockMaterial == net.minecraft.block.material.Material.lava;
}
private static ContextAwareChunkVertexEncoder prepareEncode(Block block, int metadata, int x, int y, int z, IBlockAccess blockAccess, ChunkBuildBuffers buffers, BlockRenderContext blockRenderContext, Material passMaterial, int teBlockId) {
final var encoder = buffers.get(passMaterial).getEncoder();
final ContextAwareChunkVertexEncoder contextEncoder = (encoder instanceof ContextAwareChunkVertexEncoder) ? (ContextAwareChunkVertexEncoder) encoder : null;
@@ -469,43 +535,49 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
if (contextEncoder != null) {
final byte lightValue = (byte) block.getLightValue();
if (isFluid) {
if (isFluid(block)) {
contextEncoder.prepareToRenderFluid(blockRenderContext, block, metadata, lightValue);
} else {
int effectiveMeta = metadata;
if (BlockRenderingSettings.INSTANCE.hasSnowyEntries()
&& BlockRenderingSettings.INSTANCE.getSnowyBlocks().contains(block)
&& RenderBlocksUtils.isSnowCovered(renderBlocks.blockAccess, x, y, z)) {
&& RenderBlocksUtils.isSnowCovered(blockAccess, x, y, z)) {
effectiveMeta |= BlockMaterialMapping.SNOWY_META_BIT;
} else if (block instanceof BlockDoublePlant doublePlant && BlockDoublePlant.func_149887_c(metadata)) {
effectiveMeta = 0x8 | (doublePlant.func_149885_e(renderBlocks.blockAccess, x, y, z) & 7);
effectiveMeta = 0x8 | (doublePlant.func_149885_e(blockAccess, x, y, z) & 7);
}
contextEncoder.prepareToRenderBlock(blockRenderContext, block, effectiveMeta,
ExtendedDataHelper.BLOCK_RENDER_TYPE, lightValue);
// Check for TileEntity NBT-conditional shader block ID override
if (teMap != null && teMap.hasConditions(block)) {
final long packedPos = BlockRenderingSettings.packBlockPos(x, y, z);
int teBlockId = BlockRenderingSettings.getCachedTeNbtId(packedPos, currentTick);
if (teBlockId == BlockRenderingSettings.CACHE_MISS) {
final TileEntity te = renderBlocks.blockAccess.getTileEntity(x, y, z);
if (te != null) {
final NBTTagCompound teNbt = new NBTTagCompound();
te.writeToNBT(teNbt);
teBlockId = teMap.resolve(block, teNbt, metadata);
} else {
teBlockId = -1;
}
BlockRenderingSettings.cacheTeNbtId(packedPos, teBlockId, currentTick);
}
if (teBlockId != -1) {
blockRenderContext.blockId = (short) teBlockId;
}
if (teBlockId != -1) {
blockRenderContext.blockId = (short) teBlockId;
}
}
}
return contextEncoder;
}
private static int resolveTeBlockId(NbtConditionalIdMap<Block> teMap, IBlockAccess blockAccess, Block block, int metadata, int x, int y, int z, ChunkBuildBuffers buffers, int pass, Material materialOverride, long currentTick) {
// Check for TileEntity NBT-conditional shader block ID override
if (teMap == null || !teMap.hasConditions(block) || isFluid(block)) return -1;
if (!(buffers.get(resolvePassMaterial(block, pass, buffers, materialOverride)).getEncoder() instanceof ContextAwareChunkVertexEncoder)) return -1;
final long packedPos = BlockRenderingSettings.packBlockPos(x, y, z);
int teBlockId = BlockRenderingSettings.getCachedTeNbtId(packedPos, currentTick);
if (teBlockId == BlockRenderingSettings.CACHE_MISS) {
final TileEntity te = blockAccess.getTileEntity(x, y, z);
if (te != null) {
final NBTTagCompound teNbt = new NBTTagCompound();
te.writeToNBT(teNbt);
teBlockId = teMap.resolve(block, teNbt, metadata);
} else {
teBlockId = -1;
}
BlockRenderingSettings.cacheTeNbtId(packedPos, teBlockId, currentTick);
}
return teBlockId;
}
private void drawBlock(Block block, int x, int y, int z, int pass, Tessellator tessellator, RenderBlocks renderBlocks) {
setRenderPass(pass);
// Trigger side effects from canRenderInPass (some ISBRHs like BuildCraft set global state in this method that gets read elsewhere renderWorldBlock)
block.canRenderInPass(pass);
@@ -518,15 +590,13 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
renderBlocks.renderBlockByRenderType(block, x, y, z);
if (applyNaturalTex) { renderBlocks.uvRotateTop = 0; } // Reset
}
private static void encodeTessellated(int[] rawBuffer, int vertexOffset, int vertexCount, int[] vertexStates, int[] shaderOverrideBlockIds, Block block, ChunkBuildBuffers buffers, AngelicaChunkBuildContext buildContext, Material passMaterial, boolean isShaderPackOverride, ContextAwareChunkVertexEncoder contextEncoder) {
boolean blockAllowsSmoothLighting = Minecraft.isAmbientOcclusionEnabled() // smooth lighting on
&& block.getLightValue() == 0; // does not emit real block light
buildContext.copyRawBuffer(tessellator.rawBuffer, tessellator.vertexCount,
((StateAwareTessellator)tessellator).angelica$getVertexStates(),
((StateAwareTessellator)tessellator).angelica$getShaderOverrideBlockIds(),
buildContext.copyRawBuffer(rawBuffer, vertexOffset, vertexCount, vertexStates, shaderOverrideBlockIds,
buffers, passMaterial, isShaderPackOverride, blockAllowsSmoothLighting);
tessellator.reset();
tessellator.isDrawing = false;
if (contextEncoder != null) {
contextEncoder.finishRenderingBlock();
@@ -55,6 +55,7 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {
private static final long P_DRAW_REGION_BUFFERS = Tracy.plotHandle("draw.regionBuffers");
private static final long P_MESH_DEVICE_ALLOCATED = Tracy.plotHandle("mesh.deviceAllocated", TracyBackend.PLOT_FORMAT_MEMORY);
private static final long P_MESH_DEFERRED_PENDING = Tracy.plotHandle("mesh.deferredPending");
private static final long P_MESH_DEFERRED_FINISHING = Tracy.plotHandle("mesh.deferredFinishing");
private static final Tracy.ZoneId Z_BIOME_REBUILDS = Tracy.zoneId("biomeRebuilds", Tracy.COLOR_TERRAIN);
private static final Tracy.ZoneId Z_GRAPH_SEARCH = Tracy.zoneId("graphSearch", Tracy.COLOR_TERRAIN);
@@ -72,7 +73,7 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {
this.world = world;
this.sectionCache = new ClonedChunkSectionCache(world);
this.taskProvider = taskProvider;
this.deferredScheduler = new DeferredMeshScheduler(configuration, () -> new AngelicaChunkBuildContext(configuration, world), () -> new WorldSlice(world), AngelicaRenderQueue::submit, ((RenderSectionManagerAccessor) this).angelica$getBuildResults());
this.deferredScheduler = new DeferredMeshScheduler(configuration, getBuilder(), () -> new WorldSlice(world), AngelicaRenderQueue::submit, ((RenderSectionManagerAccessor) this).angelica$getBuildResults());
}
public static AngelicaRenderSectionManager create(ChunkVertexType vertexType, WorldClient world, int renderDistance, CommandList commandList) {
@@ -225,6 +226,7 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {
this.deferredScheduler.markDestroyed();
super.destroy();
this.deferredScheduler.runImportant();
this.deferredScheduler.releaseOrphans();
}
@Override
@@ -350,5 +352,6 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {
Tracy.plotInt(P_MESH_DEVICE_ALLOCATED, mem.deviceAllocated + mem.indexAllocated);
Tracy.plotInt(P_DRAW_REGION_BUFFERS, mem.bufferCount);
Tracy.plotInt(P_MESH_DEFERRED_PENDING, this.deferredScheduler.pendingCount());
Tracy.plotInt(P_MESH_DEFERRED_FINISHING, this.deferredScheduler.finishingCount());
}
}
@@ -3,4 +3,8 @@ package com.gtnewhorizons.angelica.rendering.celeritas;
import net.minecraft.block.Block;
import org.embeddedt.embeddium.impl.render.chunk.terrain.material.Material;
public record DeferredBlock(int x, int y, int z, Block block, int meta, int pass, Material materialOverride, boolean isShaderPackOverride) {}
public record DeferredBlock(int x, int y, int z, Block block, int meta, int passMask, Material materialOverride) {
public boolean isShaderPackOverride() {
return materialOverride != null;
}
}
@@ -0,0 +1,42 @@
package com.gtnewhorizons.angelica.rendering.celeritas;
import com.gtnewhorizons.angelica.glsm.profiling.Tracy;
import org.embeddedt.embeddium.impl.render.chunk.compile.ChunkBuildContext;
import org.embeddedt.embeddium.impl.render.chunk.compile.ChunkBuildOutput;
import org.embeddedt.embeddium.impl.render.chunk.compile.executor.ChunkJobCollector;
import org.embeddedt.embeddium.impl.render.chunk.compile.executor.ChunkJobResult;
import org.embeddedt.embeddium.impl.render.chunk.compile.tasks.ChunkBuilderTask;
import org.embeddedt.embeddium.impl.util.task.CancellationToken;
import org.jetbrains.annotations.Nullable;
import java.util.function.Consumer;
public final class DeferredFinishTask extends ChunkBuilderTask<ChunkBuildOutput> implements Consumer<ChunkJobResult<ChunkBuildOutput>> {
private static final Tracy.ZoneId Z_MESH_DEFERRED_FINISH = Tracy.zoneId("meshDeferredFinish");
private final DeferredSectionMesh mesh;
private final DeferredMeshScheduler scheduler;
private final @Nullable ChunkJobCollector collector;
public DeferredFinishTask(DeferredSectionMesh mesh, DeferredMeshScheduler scheduler, @Nullable ChunkJobCollector collector) {
this.mesh = mesh;
this.scheduler = scheduler;
this.collector = collector;
}
@Override
public ChunkBuildOutput execute(ChunkBuildContext context, CancellationToken cancellationToken) {
if (mesh.isObsolete()) return null;
if (Tracy.ENABLED) Tracy.beginZone(Z_MESH_DEFERRED_FINISH);
try {
return mesh.finish(context);
} finally {
if (Tracy.ENABLED) Tracy.endZone();
}
}
@Override
public void accept(@Nullable ChunkJobResult<ChunkBuildOutput> result) {
scheduler.finished(mesh, result, collector);
}
}
@@ -2,37 +2,56 @@ package com.gtnewhorizons.angelica.rendering.celeritas;
import org.embeddedt.embeddium.impl.render.chunk.RenderPassConfiguration;
import org.embeddedt.embeddium.impl.render.chunk.compile.ChunkBuildBuffers;
import org.embeddedt.embeddium.impl.render.chunk.compile.ChunkBuildOutput;
import org.embeddedt.embeddium.impl.render.chunk.compile.ChunkTaskOutput;
import org.embeddedt.embeddium.impl.render.chunk.compile.executor.ChunkBuilder;
import org.embeddedt.embeddium.impl.render.chunk.compile.executor.ChunkJobCollector;
import org.embeddedt.embeddium.impl.render.chunk.compile.executor.ChunkJobResult;
import org.embeddedt.embeddium.impl.render.chunk.compile.executor.ChunkJobTyped;
import com.gtnewhorizons.angelica.rendering.celeritas.DeferredSectionMesh.DeferredCapture;
import com.gtnewhorizons.angelica.rendering.celeritas.world.WorldSlice;
import org.jetbrains.annotations.Nullable;
import java.util.Comparator;
import java.util.Queue;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Consumer;
import java.util.function.Supplier;
public class DeferredMeshScheduler {
private final Supplier<AngelicaChunkBuildContext> mainContextFactory;
/** Must stay below every distance priority: queued finishes hold pooled buffers and slices. */
private static final long FINISH_PRIORITY = -1L;
private static final Comparator<DeferredSectionMesh> NEAREST_FIRST = Comparator.comparingLong(m -> m.priority);
private final ChunkBuilder builder;
private final Consumer<Runnable> mainThreadQueue;
private final Queue<ChunkJobResult<? extends ChunkTaskOutput>> results;
private final Consumer<ChunkJobResult<? extends ChunkTaskOutput>> resultSink;
private final ObjectPool<ChunkBuildBuffers> buffers;
private final ObjectPool<WorldSlice> slices;
private final ObjectPool<DeferredCapture> captures;
private final ConcurrentLinkedQueue<DeferredSectionMesh> important = new ConcurrentLinkedQueue<>();
private final ConcurrentLinkedQueue<DeferredSectionMesh> normal = new ConcurrentLinkedQueue<>();
private final PriorityBlockingQueue<DeferredSectionMesh> normal = new PriorityBlockingQueue<>(11, NEAREST_FIRST);
private final Set<DeferredSectionMesh> inFlight = ConcurrentHashMap.newKeySet();
private final Runnable runNext = this::runNext;
private final AtomicInteger pending = new AtomicInteger();
private AngelicaChunkBuildContext mainContext;
private boolean destroyed;
public DeferredMeshScheduler(RenderPassConfiguration<?> config, Supplier<AngelicaChunkBuildContext> mainContextFactory, Supplier<WorldSlice> sliceFactory, Consumer<Runnable> mainThreadQueue, Queue<ChunkJobResult<? extends ChunkTaskOutput>> results) {
this.mainContextFactory = mainContextFactory;
public DeferredMeshScheduler(RenderPassConfiguration<?> config, ChunkBuilder builder, Supplier<WorldSlice> sliceFactory, Consumer<Runnable> mainThreadQueue, Queue<ChunkJobResult<? extends ChunkTaskOutput>> results) {
this.builder = builder;
this.mainThreadQueue = mainThreadQueue;
this.results = results;
this.buffers = new ObjectPool<>(() -> new ChunkBuildBuffers(config));
this.slices = new ObjectPool<>(sliceFactory);
this.resultSink = results::add;
this.buffers = new ObjectPool<>(() -> new ChunkBuildBuffers(config), Integer.MAX_VALUE);
this.slices = new ObjectPool<>(sliceFactory, Integer.MAX_VALUE);
this.captures = new ObjectPool<>(DeferredCapture::new, Math.max(1, builder.getTotalThreadCount()) * 2);
}
public ChunkBuildBuffers acquireBuffers() {
@@ -59,17 +78,30 @@ public class DeferredMeshScheduler {
}
public void runImportant() {
if (important.isEmpty()) return;
final ChunkJobCollector collector = new ChunkJobCollector(Integer.MAX_VALUE, resultSink);
DeferredSectionMesh m;
while ((m = important.poll()) != null) {
run(m);
run(m, collector);
}
collector.awaitCompletion(builder);
}
public void markDestroyed() {
destroyed = true;
if (mainContext != null) {
mainContext.cleanup();
mainContext = null;
}
/** Call after the builder shut down: its queued jobs were dropped without reaching their consumers. */
public void releaseOrphans() {
DeferredSectionMesh m;
while ((m = important.poll()) != null) {
release(m);
}
while ((m = normal.poll()) != null) {
release(m);
}
for (final DeferredSectionMesh orphan : inFlight) {
if (inFlight.remove(orphan)) release(orphan);
}
}
@@ -77,29 +109,67 @@ public class DeferredMeshScheduler {
return pending.get();
}
private AngelicaChunkBuildContext mainContext() {
if (mainContext == null) {
mainContext = mainContextFactory.get();
public int finishingCount() {
return inFlight.size();
}
void finished(DeferredSectionMesh m, @Nullable ChunkJobResult<ChunkBuildOutput> result, @Nullable ChunkJobCollector collector) {
final long nanos = m.workerNanos + m.mainNanos;
ChunkJobResult<ChunkBuildOutput> out = result instanceof ChunkJobResult.Success<ChunkBuildOutput> success ? new ChunkJobResult.Success<>(success.output(), nanos + success.executionTimeNanos()) : result;
if (inFlight.remove(m)) {
// Runs as a celeritas job consumer on a worker, where an escaping throwable kills the worker thread.
try {
release(m);
} catch (Throwable t) {
out = new ChunkJobResult.Failure<>(t);
}
}
if (collector != null) {
collector.onJobFinished(out);
} else if (out != null) {
results.add(out);
}
return mainContext;
}
private void runNext() {
final DeferredSectionMesh m = normal.poll();
if (m != null) {
run(m);
run(m, null);
}
}
private void run(DeferredSectionMesh m) {
private void run(DeferredSectionMesh m, @Nullable ChunkJobCollector collector) {
boolean scheduled = false;
try {
if (destroyed || m.isObsolete()) return;
results.add(m.complete(mainContext()));
m.capture = captures.acquire();
final ChunkJobResult<ChunkBuildOutput> failure = m.capture();
if (failure != null) {
results.add(failure);
return;
}
final DeferredFinishTask task = new DeferredFinishTask(m, this, collector);
inFlight.add(m);
final ChunkJobTyped<DeferredFinishTask, ChunkBuildOutput> job = builder.scheduleTask(task, m.important, FINISH_PRIORITY, task);
scheduled = true;
if (collector != null) collector.addSubmittedJob(job);
} finally {
releaseBuffers(m.buffers);
m.slice.releaseContext();
slices.release(m.slice);
pending.decrementAndGet();
if (!scheduled) {
inFlight.remove(m);
release(m);
}
}
}
private void release(DeferredSectionMesh m) {
releaseBuffers(m.buffers);
m.slice.releaseContext();
slices.release(m.slice);
if (m.capture != null) {
m.capture.clear();
captures.release(m.capture);
m.capture = null;
}
pending.decrementAndGet();
}
}
@@ -1,9 +1,11 @@
package com.gtnewhorizons.angelica.rendering.celeritas;
import com.gtnewhorizons.angelica.rendering.celeritas.world.WorldSlice;
import it.unimi.dsi.fastutil.ints.IntArrayList;
import net.coderbot.iris.block_rendering.NbtConditionalIdMap;
import net.minecraft.block.Block;
import org.embeddedt.embeddium.impl.render.chunk.compile.ChunkBuildBuffers;
import org.embeddedt.embeddium.impl.render.chunk.compile.ChunkBuildContext;
import org.embeddedt.embeddium.impl.render.chunk.compile.ChunkBuildOutput;
import org.embeddedt.embeddium.impl.render.chunk.compile.executor.ChunkJobResult;
import org.embeddedt.embeddium.impl.util.task.CancellationToken;
@@ -20,9 +22,12 @@ public class DeferredSectionMesh {
public final NbtConditionalIdMap<Block> teMap;
public final long currentTick;
public final boolean important;
public final long priority;
public final long workerNanos;
public DeferredCapture capture;
public long mainNanos;
public DeferredSectionMesh(AngelicaChunkBuilderMeshingTask task, CancellationToken token, ChunkBuildBuffers buffers, WorldSlice slice, AngelicaBuiltRenderSectionData renderData, List<DeferredBlock> blocks, NbtConditionalIdMap<Block> teMap, long currentTick, boolean important, long workerNanos) {
public DeferredSectionMesh(AngelicaChunkBuilderMeshingTask task, CancellationToken token, ChunkBuildBuffers buffers, WorldSlice slice, AngelicaBuiltRenderSectionData renderData, List<DeferredBlock> blocks, NbtConditionalIdMap<Block> teMap, long currentTick, boolean important, long priority, long workerNanos) {
this.task = task;
this.token = token;
this.buffers = buffers;
@@ -32,6 +37,7 @@ public class DeferredSectionMesh {
this.teMap = teMap;
this.currentTick = currentTick;
this.important = important;
this.priority = priority;
this.workerNanos = workerNanos;
}
@@ -39,7 +45,57 @@ public class DeferredSectionMesh {
return token.isCancelled() || task.render.isDisposed() || task.render.getLastBuiltFrame() > task.buildTime;
}
public ChunkJobResult<ChunkBuildOutput> complete(AngelicaChunkBuildContext ctx) {
return task.completeDeferred(this, ctx);
/** Main thread only; returns a failure or null. */
public ChunkJobResult<ChunkBuildOutput> capture() {
return task.captureDeferred(this);
}
public ChunkBuildOutput finish(ChunkBuildContext context) {
return task.finishDeferred(this, (AngelicaChunkBuildContext) context);
}
public static final class DeferredCapture {
public static final int VERTEX_TRIM = 1 << 17;
public final IntArrayList raw = new IntArrayList();
public final IntArrayList vertexStates = new IntArrayList();
public final IntArrayList shaderBlockIds = new IntArrayList();
public final IntArrayList blockIndex = new IntArrayList();
public final IntArrayList blockStart = new IntArrayList();
public final IntArrayList blockVertexCount = new IntArrayList();
public final IntArrayList teBlockIds = new IntArrayList();
public void add(int blockIdx, int[] rawBuffer, int vertexCount, int[] states, int[] shaderIds, int teBlockId) {
blockIndex.add(blockIdx);
blockStart.add(vertexStates.size());
blockVertexCount.add(vertexCount);
teBlockIds.add(teBlockId);
raw.addElements(raw.size(), rawBuffer, 0, vertexCount * AngelicaChunkBuildContext.INTS_PER_VERTEX);
vertexStates.addElements(vertexStates.size(), states, 0, vertexCount);
shaderBlockIds.addElements(shaderBlockIds.size(), shaderIds, 0, vertexCount);
}
public int blockCount() {
return blockIndex.size();
}
public int vertexCount() {
return vertexStates.size();
}
public void clear() {
reset(raw, VERTEX_TRIM * AngelicaChunkBuildContext.INTS_PER_VERTEX);
reset(vertexStates, VERTEX_TRIM);
reset(shaderBlockIds, VERTEX_TRIM);
reset(blockIndex, VERTEX_TRIM);
reset(blockStart, VERTEX_TRIM);
reset(blockVertexCount, VERTEX_TRIM);
reset(teBlockIds, VERTEX_TRIM);
}
private static void reset(IntArrayList list, int cap) {
list.clear();
if (list.elements().length > cap) list.trim(cap);
}
}
}
@@ -1,22 +1,32 @@
package com.gtnewhorizons.angelica.rendering.celeritas;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Supplier;
final class ObjectPool<T> {
private final ConcurrentLinkedQueue<T> free = new ConcurrentLinkedQueue<>();
private final ConcurrentLinkedDeque<T> free = new ConcurrentLinkedDeque<>();
private final AtomicInteger freeCount = new AtomicInteger();
private final Supplier<T> factory;
private final int maxFree;
ObjectPool(Supplier<T> factory) {
ObjectPool(Supplier<T> factory, int maxFree) {
this.factory = factory;
this.maxFree = maxFree;
}
T acquire() {
final T t = free.poll();
return t != null ? t : factory.get();
final T t = free.pollFirst();
if (t == null) return factory.get();
freeCount.decrementAndGet();
return t;
}
void release(T t) {
free.add(t);
if (freeCount.incrementAndGet() > maxFree) {
freeCount.decrementAndGet();
return;
}
free.offerFirst(t);
}
}