Update to Celeritas 2.5.12 with translucency sorting v3 (#2151)

This commit is contained in:
Jason Mitchell authored and GitHub committed 2026-09-27 09:37:40 -07:00
1 parent a8c29fa3f9
commit c9d46e70e0
50 files changed
+870 -556

No files matched your search

@@ -5,6 +5,8 @@ import org.embeddedt.embeddium.impl.render.chunk.fog.FogService;
import org.embeddedt.embeddium.impl.render.chunk.shader.ChunkFogMode;
public class AngelicaFogService implements FogService {
public static final AngelicaFogService INSTANCE = new AngelicaFogService();
private final float[] fogColorArray = new float[4];
@Override
@@ -419,6 +419,10 @@ public class AngelicaConfig {
@Config.DefaultBoolean(false)
public static boolean disableF3Additions;
@Config.Comment("Shows developer counters (FFP, streaming, TESR, transfer) on the F3 screen. Toggle in game with F3+V.")
@Config.DefaultBoolean(false)
public static boolean verboseF3;
@Config.Comment("Replaces various FFP uploads with statically allocated VBO's.")
@Config.DefaultBoolean(true)
public static boolean replaceFFPUploads;
@@ -0,0 +1,28 @@
package com.gtnewhorizons.angelica.debug;
import com.gtnewhorizon.gtnhlib.GTNHLib;
import com.gtnewhorizon.gtnhlib.config.ConfigurationManager;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import com.gtnewhorizons.angelica.rendering.celeritas.CeleritasDebugScreenHandler;
import cpw.mods.fml.common.eventhandler.SubscribeEvent;
import cpw.mods.fml.common.gameevent.InputEvent;
import net.minecraft.client.Minecraft;
import net.minecraft.util.StatCollector;
import org.lwjgl.input.Keyboard;
/** F3+V toggles {@link AngelicaConfig#verboseF3} */
public class DebugKeyHandler {
@SubscribeEvent
public void onKey(InputEvent.KeyInputEvent event) {
if (!Keyboard.getEventKeyState() || Keyboard.getEventKey() != Keyboard.KEY_V || !Keyboard.isKeyDown(Keyboard.KEY_F3)
|| Minecraft.getMinecraft().currentScreen != null) {
return;
}
AngelicaConfig.verboseF3 = !AngelicaConfig.verboseF3;
ConfigurationManager.save(AngelicaConfig.class);
CeleritasDebugScreenHandler.invalidate();
GTNHLib.proxy.addDebugToChat(StatCollector.translateToLocal(AngelicaConfig.verboseF3 ? "angelica.debug.verbose.on" : "angelica.debug.verbose.off"));
}
}
@@ -419,7 +419,9 @@ public enum Mixins implements IMixins {
, "celeritas.terrain.MixinWorld_AwaitingDescriptor"
, "celeritas.terrain.MixinRenderRegion"
, "celeritas.terrain.MixinSectionRenderDataStorage"
, "celeritas.terrain.MixinDefaultChunkShaderInterface"
, "celeritas.terrain.MixinSharedQuadIndexBuffer"
, "celeritas.terrain.MixinRenderRegionManager"
, "celeritas.terrain.MixinShaderLoader"
)
),
@@ -1,14 +1,11 @@
package com.gtnewhorizons.angelica.mixins.interfaces;
import it.unimi.dsi.fastutil.longs.Long2ReferenceMap;
import org.embeddedt.embeddium.impl.render.chunk.RenderSection;
import org.embeddedt.embeddium.impl.render.chunk.compile.ChunkTaskOutput;
import org.embeddedt.embeddium.impl.render.chunk.compile.executor.ChunkJobResult;
import java.util.concurrent.ConcurrentLinkedDeque;
public interface RenderSectionManagerAccessor {
Long2ReferenceMap<RenderSection> angelica$getSectionByPosition();
ConcurrentLinkedDeque<Runnable> angelica$getAsyncSubmittedTasks();
ConcurrentLinkedDeque<ChunkJobResult<? extends ChunkTaskOutput>> angelica$getBuildResults();
}
@@ -22,8 +22,6 @@ import com.gtnewhorizons.angelica.rendering.tesr.TesrBatchRenderer;
import net.coderbot.iris.pipeline.ShadowRenderer;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.WorldRenderer;
import org.embeddedt.embeddium.impl.render.chunk.SharedQuadIndexBuffer;
import org.embeddedt.embeddium.impl.render.chunk.region.RenderRegionManager;
public final class TracyFramePlots {
private static final long P_ALLOC_RATE = Tracy.plotHandle("allocRate", TracyBackend.PLOT_FORMAT_MEMORY);
@@ -267,9 +265,9 @@ public final class TracyFramePlots {
TESR_BAILS[reason.ordinal()].plot(batcher.statBail(reason));
}
P_MESH_UPLOADED_SECTIONS.plot(RenderRegionManager.getSectionsUploaded());
P_MESH_UPLOADED_BYTES.plot(RenderRegionManager.getBytesUploaded());
P_DRAW_INDEX_BUFFER_GROWTHS.plot(SharedQuadIndexBuffer.getGrowths());
P_MESH_UPLOADED_SECTIONS.plot(TerrainDrawStats.getSectionsUploaded());
P_MESH_UPLOADED_BYTES.plot(TerrainDrawStats.getBytesUploaded());
P_DRAW_INDEX_BUFFER_GROWTHS.plot(TerrainDrawStats.getIndexBufferGrowths());
Tracy.plotInt(P_MESH_META_SLOTS, GpuCulling.sectionMeta().getHighWaterMark());
Tracy.plotInt(P_MT_QUEUE_DEPTH, AngelicaRenderQueue.getQueueDepth());
Tracy.plotInt(P_MT_QUEUE_TASKS, AngelicaRenderQueue.getLastFrameTasksRan());
@@ -1,5 +1,6 @@
package com.gtnewhorizons.angelica.proxy;
import com.gtnewhorizons.angelica.debug.DebugKeyHandler;
import com.gtnewhorizons.angelica.rendering.culling.GpuCulling;
import static com.gtnewhorizons.angelica.AngelicaMod.MOD_ID;
@@ -185,6 +186,7 @@ public final class ClientProxy extends CommonProxy {
Zoom.init();
}
FpsReducer.init();
FMLCommonHandler.instance().bus().register(new DebugKeyHandler());
AngelicaConfig.applyGpuCullingMode();
if (AngelicaConfig.enableDynamicLights) {
EntityLightConfig.init(new java.io.File(mc.mcDataDir, "config"));
@@ -299,7 +299,7 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
final Reference2ReferenceMap<TerrainRenderPass, BuiltSectionMeshParts> meshes;
try {
meshes = BuiltSectionMeshParts.groupFromBuildBuffers(buffers,
(float) camera.x - minX, (float) camera.y - minY, (float) camera.z - minZ);
(float) (camera.x - minX), (float) (camera.y - minY), (float) (camera.z - minZ));
} finally {
if (Tracy.ENABLED) Tracy.endZone();
}
@@ -399,7 +399,7 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
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);
meshes = BuiltSectionMeshParts.groupFromBuildBuffers(m.buffers, (float) (camera.x - minX), (float) (camera.y - minY), (float) (camera.z - minZ));
} finally {
if (Tracy.ENABLED) Tracy.endZone();
}
@@ -1,6 +1,7 @@
package com.gtnewhorizons.angelica.rendering.celeritas;
import com.gtnewhorizons.angelica.AngelicaMod;
import com.gtnewhorizons.angelica.client.rendering.AngelicaFogService;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.RenderSystem;
import com.gtnewhorizons.angelica.glsm.backend.BackendManager;
@@ -27,7 +28,6 @@ import org.embeddedt.embeddium.impl.gl.device.RenderDevice;
import org.embeddedt.embeddium.impl.gl.shader.GlProgram;
import org.embeddedt.embeddium.impl.gl.shader.GlShader;
import org.embeddedt.embeddium.impl.gl.shader.ShaderConstants;
import org.embeddedt.embeddium.impl.gl.shader.ShaderParser;
import org.embeddedt.embeddium.impl.gl.shader.ShaderType;
import org.embeddedt.embeddium.impl.gl.tessellation.GlPrimitiveType;
import org.embeddedt.embeddium.impl.gl.tessellation.GlTessellation;
@@ -81,7 +81,7 @@ class AngelicaChunkRenderer extends DefaultChunkRenderer {
private static MultiDrawMode installedBatchMode;
public AngelicaChunkRenderer(RenderDevice device, RenderPassConfiguration<?> renderPassConfiguration) {
super(device, renderPassConfiguration);
super(device, renderPassConfiguration, AngelicaFogService.INSTANCE);
installBatchFactory();
this.culler = createCuller();
@@ -148,11 +148,6 @@ class AngelicaChunkRenderer extends DefaultChunkRenderer {
return null;
}
private static GlShader loadShader(ShaderType type, String path, ShaderConstants constants) {
final String source = ShaderParser.parseShader(ShaderLoader.getShaderSource(path), ShaderLoader::getShaderSource, constants);
return new GlShader(type, path, source);
}
@Override
protected void begin(TerrainRenderPass pass) {
if (Tracy.ENABLED) Tracy.beginZone(Z_CHUNK_BEGIN);
@@ -301,8 +296,8 @@ class AngelicaChunkRenderer extends DefaultChunkRenderer {
final List<GlShader> loadedShaders = new ArrayList<>();
try {
loadedShaders.add(loadShader(ShaderType.VERTEX, "sodium:" + path + ".vsh", constants));
loadedShaders.add(loadShader(ShaderType.FRAGMENT, "angelica:" + path + ".fsh", constants));
loadedShaders.add(ShaderLoader.loadShader(ShaderType.VERTEX, "sodium:" + path + ".vsh", constants));
loadedShaders.add(ShaderLoader.loadShader(ShaderType.FRAGMENT, "angelica:" + path + ".fsh", constants));
final var builder = GlProgram.builder("sodium:chunk_shader");
loadedShaders.forEach(builder::attachShader);
@@ -310,8 +305,10 @@ class AngelicaChunkRenderer extends DefaultChunkRenderer {
for (var attr : options.pass().vertexType().getVertexFormat().getAttributes()) {
builder.bindAttribute(attr.getName(), i++);
}
builder.bindFragmentData("fragColor", ChunkShaderBindingPoints.FRAG_COLOR);
return builder.link((shader) -> new DefaultChunkShaderInterface(shader, options));
if (!this.enableLegacyGLPatches) {
builder.bindFragmentData("fragColor", ChunkShaderBindingPoints.FRAG_COLOR);
}
return builder.link((shader) -> new DefaultChunkShaderInterface(shader, options, this.environment));
} finally {
loadedShaders.forEach(GlShader::delete);
}
@@ -351,12 +348,12 @@ class AngelicaChunkRenderer extends DefaultChunkRenderer {
useBlockFaceCulling, cacheParams);
}
final long batchesCreatedBefore = BatchAssembler.getCachedBatchesCreated();
final CachedBatch before = storage.getCachedMultiDrawBatch(cacheParams);
Tracy.beginZone(Z_CHUNK_ASSEMBLE_REGION);
try {
final CachedBatch cached = super.getRegionBatch(commandList, region, storage, renderList, occlusionCamera,
renderPass, useBlockFaceCulling, cacheParams);
if (BatchAssembler.getCachedBatchesCreated() != batchesCreatedBefore) TerrainDrawStats.recordRebuild();
if (cached != before) TerrainDrawStats.recordRebuild();
final MultiDrawBatch batch = cached != null ? cached.getBatch() : null;
if (batch != null && !batch.isEmpty()) TerrainDrawStats.recordBatch(batch.size());
return cached;
@@ -1,62 +0,0 @@
/*
* Adapated from: Beddium for usage in Angelica
*
* Copyright (C) 2025 Ven, FalsePattern
* All Rights Reserved
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, only version 3 of the License.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.gtnewhorizons.angelica.rendering.celeritas;
import org.embeddedt.embeddium.impl.render.chunk.RenderSectionManager;
import org.embeddedt.embeddium.impl.render.chunk.map.ChunkStatus;
import org.embeddedt.embeddium.impl.render.chunk.map.ChunkTrackerImpl;
import org.embeddedt.embeddium.impl.util.PositionUtil;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
/**
* Configurable chunk tracker supporting "fast" and "aggressive" loading modes.
* Based on Beddium's SafeChunkTracker by Ven and FalsePattern.
*
* Modes (controlled by {@link AngelicaConfig#useVanillaChunkTracking}):
* - Fast (default): Only renders chunks when all 8 neighbors are loaded (better lighting/AO)
* - Aggressive: Renders chunks immediately when loaded (faster perceived loading)
*
* Mode can be switched at runtime via options menu - triggers renderer reload.
*/
public class AngelicaChunkTracker extends ChunkTrackerImpl {
@Override
public void forEachReady(RenderSectionManager sectionManager) {
if (this.isFastModeEnabled() != AngelicaConfig.useVanillaChunkTracking) {
setFastMode(AngelicaConfig.useVanillaChunkTracking);
}
super.forEachReady(sectionManager);
}
@Override
public void forEachEvent(RenderSectionManager sectionManager) {
if (this.isFastModeEnabled() != AngelicaConfig.useVanillaChunkTracking) {
setFastMode(AngelicaConfig.useVanillaChunkTracking);
}
super.forEachEvent(sectionManager);
}
}
@@ -3,6 +3,7 @@ package com.gtnewhorizons.angelica.rendering.celeritas;
import com.google.common.collect.ImmutableListMultimap;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.StateSet;
import com.gtnewhorizons.angelica.proxy.ClientProxy;
import com.gtnewhorizons.angelica.utils.SpritePadding;
import it.unimi.dsi.fastutil.objects.Reference2ReferenceOpenHashMap;
import lombok.Getter;
@@ -15,6 +16,7 @@ import org.embeddedt.embeddium.impl.render.chunk.terrain.material.parameters.Alp
import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkVertexType;
import org.lwjgl.opengl.GL11;
import java.util.LinkedHashMap;
import java.util.Map;
public class AngelicaRenderPassConfiguration {
@@ -31,25 +33,32 @@ public class AngelicaRenderPassConfiguration {
.vertexType(vertexType)
.primitiveType(QuadPrimitiveType.TRIANGULATED);
final int mipmapLevels = SodiumGameOptions.terrainMipmapLevels();
if (rgssEnabled) {
builder.extraDefine("USE_RGSS", "");
}
if (SodiumGameOptions.usesTerrainTexelSnap()) {
builder.extraDefine("USE_TEXEL_SNAP", "");
}
if (SodiumGameOptions.effectiveTextureFilterMode().usesAnisotropy()) {
builder.extraDefine("USE_ANISOTROPIC", "");
builder.extraDefine("TERRAIN_GUTTER", SpritePadding.gutterFor(mipmapLevels, true) + ".0");
}
if (mipmapLevels <= 0) {
builder.extraDefine("TERRAIN_NO_MIPS", "");
}
samplerDefines(rgssEnabled, SodiumGameOptions.usesTerrainTexelSnap(),
SodiumGameOptions.effectiveTextureFilterMode().usesAnisotropy(), SodiumGameOptions.terrainMipmapLevels())
.forEach(builder::extraDefine);
return builder;
}
/** Defines selecting the terrain fragment shader's sampling path. */
public static Map<String, String> samplerDefines(boolean rgss, boolean texelSnap, boolean anisotropic, int mipmapLevels) {
final Map<String, String> defines = new LinkedHashMap<>();
if (rgss) {
defines.put("USE_RGSS", "");
}
if (texelSnap) {
defines.put("USE_TEXEL_SNAP", "");
}
if (anisotropic) {
defines.put("USE_ANISOTROPIC", "");
defines.put("TERRAIN_GUTTER", SpritePadding.gutterFor(mipmapLevels, true) + ".0");
}
if (mipmapLevels <= 0) {
defines.put("TERRAIN_NO_MIPS", "");
}
return defines;
}
public static RenderPassConfiguration<BlockRenderLayer> build(ChunkVertexType vertexType) {
rgssEnabled = SodiumGameOptions.effectiveTextureFilterMode().usesRgss();
@@ -69,7 +78,7 @@ public class AngelicaRenderPassConfiguration {
.name("translucent")
.fragmentDiscard(false)
.useReverseOrder(true)
.useTranslucencySorting(true)
.useTranslucencySorting(ClientProxy.options().performance.translucencySorting)
.build();
TRANSLUCENT_MATERIAL = new Material(TRANSLUCENT_PASS, AlphaCutoffParameter.ZERO, true);
@@ -1,6 +1,7 @@
package com.gtnewhorizons.angelica.rendering.celeritas;
import com.cardinalstar.cubicchunks.world.ICubicWorld;
import com.gtnewhorizons.angelica.client.rendering.AngelicaFogService;
import com.gtnewhorizons.angelica.compat.ModStatus;
import com.gtnewhorizons.angelica.compat.cubicchunks.CubicChunksAPI;
import com.gtnewhorizons.angelica.glsm.profiling.Tracy;
@@ -20,22 +21,21 @@ import net.minecraft.client.multiplayer.WorldClient;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.world.chunk.Chunk;
import org.embeddedt.embeddium.impl.gl.device.CommandList;
import org.embeddedt.embeddium.impl.render.chunk.ChunkRenderMatrices;
import org.embeddedt.embeddium.impl.render.chunk.ChunkUpdateType;
import org.embeddedt.embeddium.impl.render.chunk.RenderPassConfiguration;
import org.embeddedt.embeddium.impl.render.chunk.RenderSection;
import org.embeddedt.embeddium.impl.render.chunk.RenderSectionManager;
import org.embeddedt.embeddium.impl.render.chunk.compile.ChunkBuildOutput;
import org.embeddedt.embeddium.impl.render.chunk.compile.tasks.ChunkBuilderTask;
import org.embeddedt.embeddium.impl.render.chunk.fog.FogService;
import org.embeddedt.embeddium.impl.render.chunk.lists.SectionTicker;
import org.embeddedt.embeddium.impl.render.chunk.occlusion.AsyncOcclusionMode;
import org.embeddedt.embeddium.impl.render.chunk.sprite.GenericSectionSpriteTicker;
import org.embeddedt.embeddium.impl.render.chunk.terrain.TerrainRenderPass;
import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkVertexType;
import org.embeddedt.embeddium.impl.render.viewport.CameraTransform;
import org.embeddedt.embeddium.impl.render.viewport.Viewport;
import org.embeddedt.embeddium.impl.util.PositionUtil;
import org.jetbrains.annotations.Nullable;
import org.joml.Vector3d;
import java.util.ArrayList;
import java.util.Collection;
@@ -58,15 +58,13 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {
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);
private static final Tracy.ZoneId Z_SECTION_UPLOAD = Tracy.zoneId("sectionUpload", Tracy.COLOR_TERRAIN);
private static final Tracy.ZoneId Z_SHADOW_GRAPH_WAIT = Tracy.zoneId("shadowGraphWait", Tracy.COLOR_TERRAIN);
private boolean initialCameraSectionReady = false;
private final WorldClient world;
private final ClonedChunkSectionCache sectionCache;
private final ChunkTaskProvider taskProvider;
private final LongOpenHashSet biomeRebuildColumns = new LongOpenHashSet();
private final DeferredMeshScheduler deferredScheduler;
private int shadowSearchSubmissions;
public AngelicaRenderSectionManager(RenderPassConfiguration<?> configuration, WorldClient world, int renderDistance, CommandList commandList, int minSection, int maxSection, int requestedThreads, ChunkTaskProvider taskProvider) {
super(configuration, () -> new AngelicaChunkBuildContext(configuration, world), AngelicaChunkRenderer::new, renderDistance, commandList, minSection, maxSection, requestedThreads, true /* hasShadowPass = true for Iris */);
@@ -92,24 +90,9 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {
return new AngelicaRenderSectionManager(AngelicaRenderPassConfiguration.build(vertexType), world, renderDistance, commandList, minSection, maxSection, provider.threadCount(), provider);
}
public void setCameraPosition(double x, double y, double z) {
this.cameraPosition.set(x, y, z);
}
@Override
public void update(Viewport positionedViewport, int frame, boolean spectator) {
if (isInShadowPass()) {
return;
}
if (!initialCameraSectionReady) {
var origin = positionedViewport.getChunkCoord();
long key = PositionUtil.packSection(origin.x(), origin.y(), origin.z());
if (!((RenderSectionManagerAccessor) this).angelica$getSectionByPosition().containsKey(key)) {
return;
}
initialCameraSectionReady = true;
}
super.update(positionedViewport, frame, spectator);
public FogService getFogService() {
return AngelicaFogService.INSTANCE;
}
@Override
@@ -173,7 +156,7 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {
return null;
}
final ChunkBuilderTask<ChunkBuildOutput> task = this.taskProvider.createRebuildTask(render, frame, this.cameraPosition, this.sectionCache);
final ChunkBuilderTask<ChunkBuildOutput> task = this.taskProvider.createRebuildTask(render, frame, new Vector3d(this.cameraPosition), this.sectionCache);
if (task instanceof AngelicaChunkBuilderMeshingTask t) {
final ChunkUpdateType pending = render.getPendingUpdate();
t.bindScheduler(this.deferredScheduler, pending != null && pending.isImportant());
@@ -219,9 +202,6 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {
@Override
public void updateChunks(boolean updateImmediately) {
if (isInShadowPass()) {
return;
}
this.sectionCache.cleanup();
this.flushBiomeRebuilds();
if (Tracy.ENABLED) Tracy.beginZone(Z_GRAPH_SEARCH);
@@ -276,14 +256,19 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {
}
@Override
public boolean canSubmitShadowGraphSearch() {
return super.canSubmitShadowGraphSearch() && this.shadowRenderListManager.isNeedsUpdate()
&& !this.shadowRenderListManager.hasOcclusionFutureInFlight();
protected boolean canSubmitShadowGraphSearch() {
return super.canSubmitShadowGraphSearch() && this.shadowRenderListManager.isNeedsUpdate();
}
@Override
public boolean submitShadowGraphSearch(Viewport viewport, int frame) {
return super.submitShadowGraphSearch(viewport, frame);
protected void submitShadowGraphSearch(Viewport viewport, int frame) {
super.submitShadowGraphSearch(viewport, frame);
this.shadowSearchSubmissions++;
}
/** Running count of submitted shadow searches; a change across a shadow pass means new lists are pending. */
public int getShadowSearchSubmissions() {
return this.shadowSearchSubmissions;
}
public boolean isShadowGraphDirty() {
@@ -314,20 +299,6 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {
return list;
}
@Override
public void renderLayer(ChunkRenderMatrices matrices, TerrainRenderPass pass, CameraTransform occlusionCamera, CameraTransform camera) {
// Shadow pass graph update is async - must wait for it to complete before rendering
if (IrisShaderProviderHolder.isShadowPass()) {
if (Tracy.ENABLED) Tracy.beginZone(Z_SHADOW_GRAPH_WAIT);
try {
finishAllGraphUpdates();
} finally {
if (Tracy.ENABLED) Tracy.endZone();
}
}
super.renderLayer(matrices, pass, occlusionCamera, camera);
}
/**
* Process both asyncSubmittedTasks and AngelicaRenderQueue.TASKS.
*/
@@ -35,6 +35,15 @@ public class CeleritasDebugScreenHandler {
private List<String> cachedRight;
private long lastBuildNanos;
static boolean isVerbose() {
return AngelicaConfig.verboseF3 || SystemProperties.DEBUG_F3_DETAIL;
}
/** Drops the cached right-hand lines so a verbose toggle shows on the next frame. */
public static void invalidate() {
INSTANCE.cachedRight = null;
}
@SubscribeEvent(priority = EventPriority.LOW)
public void onRenderGameOverlayTextEvent(RenderGameOverlayEvent.Text event) {
final Minecraft mc = Minecraft.getMinecraft();
@@ -69,17 +78,17 @@ public class CeleritasDebugScreenHandler {
lines.add("");
lines.add(EnumChatFormatting.GREEN + "Angelica " + Tags.VERSION + " [Celeritas Renderer] [" + RENDER_BACKEND.getName() + "]");
lines.addAll(renderer.getDebugStrings());
final ShaderManager sm = ShaderManager.getInstance();
if (sm != null) {
lines.add(sm.getDebugInfo());
}
lines.add(TessellatorStreamingDrawer.getDebugInfo());
lines.add(TesrBatchRenderer.INSTANCE.getDebugSummaryLine());
final String transferInfo = RENDER_BACKEND.getTransferDebugInfo();
if (transferInfo != null) {
lines.add(transferInfo);
}
if (SystemProperties.DEBUG_F3_DETAIL) {
if (isVerbose()) {
final ShaderManager sm = ShaderManager.getInstance();
if (sm != null) {
lines.add(sm.getDebugInfo());
}
lines.add(TessellatorStreamingDrawer.getDebugInfo());
lines.add(TesrBatchRenderer.INSTANCE.getDebugSummaryLine());
final String transferInfo = RENDER_BACKEND.getTransferDebugInfo();
if (transferInfo != null) {
lines.add(transferInfo);
}
lines.addAll(TesrBatchRenderer.INSTANCE.getDebugDetailStrings());
lines.add(ModelPartBatcher.INSTANCE.getDebugString());
if (Tracy.ENABLED) {
@@ -2,17 +2,13 @@ package com.gtnewhorizons.angelica.rendering.celeritas;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import com.gtnewhorizons.angelica.event.ChunkBiomeDataChangedEvent;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.loading.AngelicaClientTweaker;
import org.embeddedt.embeddium.impl.gl.device.GLRenderDevice;
import org.lwjgl.opengl.GL15;
public class CeleritasSetup {
private static boolean initialized = false;
public static void ensureInitialized() {
if (!initialized) {
GLRenderDevice.VANILLA_STATE_RESETTER = () -> GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
ChunkBiomeDataChangedEvent.BUS.addListener(CeleritasSetup::onChunkBiomeDataChanged);
AngelicaClientTweaker.LOGGER.debug("Celeritas init");
initialized = true;
@@ -3,7 +3,6 @@ package com.gtnewhorizons.angelica.rendering.celeritas;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import com.gtnewhorizons.angelica.compat.bop.FogBiomeCache;
@@ -25,9 +24,8 @@ import org.embeddedt.embeddium.impl.gl.device.CommandList;
import org.embeddedt.embeddium.impl.gl.device.RenderDevice;
import org.embeddedt.embeddium.impl.render.chunk.ChunkRenderMatrices;
import org.embeddedt.embeddium.impl.render.chunk.RenderSection;
import org.embeddedt.embeddium.impl.render.chunk.data.MinecraftBuiltRenderSectionData;
import org.embeddedt.embeddium.impl.render.chunk.lists.ChunkRenderList;
import org.embeddedt.embeddium.impl.render.chunk.lists.SortedRenderLists;
import org.embeddedt.embeddium.impl.render.chunk.map.ChunkTracker;
import org.embeddedt.embeddium.impl.render.chunk.map.ChunkTrackerHolder;
import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkMeshFormats;
import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkVertexType;
import org.embeddedt.embeddium.impl.render.terrain.SimpleWorldRenderer;
@@ -41,6 +39,7 @@ import org.lwjgl.opengl.GL11;
import com.gtnewhorizons.angelica.compat.ModStatus;
import com.gtnewhorizons.angelica.compat.cubicchunks.CubicChunksAPI;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import com.gtnewhorizons.angelica.dynamiclights.DynamicLights;
import com.gtnewhorizons.angelica.dynamiclights.IDynamicLightWorldRenderer;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
@@ -78,7 +77,9 @@ public class CeleritasWorldRenderer extends SimpleWorldRenderer<WorldClient, Ang
/** Debug flag for wireframe rendering mode. Toggle via /angelica wireframe */
public static boolean DEBUG_WIREFRAME_MODE = false;
private final TileEntityRenderContext teRenderContext = new TileEntityRenderContext();
private final TileEntityRenderContext teRenderContext = new TileEntityRenderContext(false);
private final TileEntityRenderContext shadowCollectContext = new TileEntityRenderContext(true);
private Viewport shadowPassPlayerViewport;
private boolean useEntityCulling = true;
private FrustumIntersection teFrustum;
@@ -86,9 +87,6 @@ public class CeleritasWorldRenderer extends SimpleWorldRenderer<WorldClient, Ang
private int teCullEpoch;
private double teCamX, teCamY, teCamZ;
// the volume of a section multiplied by the number of sections to be checked at most
private static final double MAX_ENTITY_CHECK_VOLUME = 16 * 16 * 16 * 15;
private final ObjectArrayList<TileEntity> frameTEs = new ObjectArrayList<>();
private final ObjectArrayList<TileEntity> frameOverride = new ObjectArrayList<>();
@@ -130,7 +128,7 @@ public class CeleritasWorldRenderer extends SimpleWorldRenderer<WorldClient, Ang
public void runFrameIdleWork(long deadlineNanos) {
final AngelicaRenderSectionManager rsm = this.renderSectionManager;
if (rsm == null || this.world == null) return;
if (rsm == null || this.world == null || rsm.isInShadowPass()) return;
RenderDevice.enterManagedCode();
try {
long start = System.nanoTime();
@@ -264,104 +262,105 @@ public class CeleritasWorldRenderer extends SimpleWorldRenderer<WorldClient, Ang
return count;
}
private CameraState lastMainCameraState;
@Override
public void setupTerrain(Viewport viewport, CameraState cameraState, int frame, boolean spectator, boolean updateChunksImmediately) {
var transform = viewport.getTransform();
this.shadowPassPlayerViewport = null;
final CameraTransform transform = viewport.getTransform();
if (transform.x == 0 && transform.y == 0 && transform.z == 0) {
return;
}
renderSectionManager.setCameraPosition(transform.x, transform.y, transform.z);
this.useEntityCulling = ClientProxy.options().performance.useEntityCulling;
if (renderSectionManager.isInShadowPass()) {
if (lastMainCameraState != null) {
cameraState = lastMainCameraState;
}
} else {
lastMainCameraState = cameraState;
// Same inputs as the shadow pass's state; reusing it keeps a fog-end change made while rendering shadows from
// dirtying the graph a second time this frame.
if (renderSectionManager.didShadowPassRunThisFrame() && this.lastCameraState != null) {
cameraState = this.lastCameraState;
}
super.setupTerrain(viewport, cameraState, frame, spectator, updateChunksImmediately);
if (!renderSectionManager.isInShadowPass()) {
final GpuTerrainCuller terrainCuller = GpuTerrainCuller.activeInstance();
if (terrainCuller != null) {
terrainCuller.prepareAllPasses(createChunkRenderMatrices(), renderSectionManager.getRenderLists(),
viewport.getTransform(), cameraTransform(cameraState.x(), cameraState.y(), cameraState.z()),
IrisShaderProviderHolder.shouldUseFaceCulling());
}
final GpuTerrainCuller terrainCuller = GpuTerrainCuller.activeInstance();
if (terrainCuller != null) {
terrainCuller.prepareAllPasses(createChunkRenderMatrices(), renderSectionManager.getRenderLists(),
viewport.getTransform(), cameraTransform(cameraState.x(), cameraState.y(), cameraState.z()),
IrisShaderProviderHolder.shouldUseFaceCulling());
}
// Process deferred dynamic light chunk rebuilds with frustum culling
if (DynamicLights.isEnabled() && DynamicLights.FrustumCullingEnabled) {
DynamicLights.get().processChunkRebuilds(viewport);
}
}
if (renderSectionManager.isInShadowPass()) {
if (IrisShaderProviderHolder.isActive()) {
collectTileEntitiesForShadow();
}
} else if (IrisShaderProviderHolder.isActive()) {
IrisShaderProviderHolder.getProvider().preSubmitShadowGraph(frame);
/** Captured before the shadow pass; the shadow pass's clipRenderersByFrustum only sees the shadow frustum. */
public void setShadowPassPlayerViewport(Viewport viewport) {
this.shadowPassPlayerViewport = viewport;
}
/** Shadow-pass entry from clipRenderersByFrustum; falls back to the last terrain viewport if none was captured. */
public void setupShadowTerrain(Viewport shadowViewport, CameraState cameraState, int frame, boolean spectator) {
Viewport playerViewport = this.shadowPassPlayerViewport;
this.shadowPassPlayerViewport = null;
if (playerViewport == null) {
playerViewport = this.getLastViewport();
}
if (playerViewport != null) {
this.setupShadowTerrain(playerViewport, shadowViewport, cameraState, frame, spectator);
}
}
@Override
public void setupShadowTerrain(Viewport playerViewport, Viewport shadowViewport, CameraState cameraState, int frame, boolean spectator) {
final CameraTransform transform = playerViewport.getTransform();
if (transform.x == 0 && transform.y == 0 && transform.z == 0) {
return;
}
this.useEntityCulling = ClientProxy.options().performance.useEntityCulling;
super.setupShadowTerrain(playerViewport, shadowViewport, cameraState, frame, spectator);
if (DynamicLights.isEnabled() && DynamicLights.FrustumCullingEnabled) {
DynamicLights.get().processChunkRebuilds(shadowViewport);
}
if (IrisShaderProviderHolder.isActive()) {
super.renderBlockEntities(this.shadowCollectContext);
}
}
@Override
protected void processChunkEvents() {
final ChunkTracker tracker = ChunkTrackerHolder.get(this.world);
if (tracker instanceof CubeStatusTracker cubic) {
cubic.forEachEvent(this.renderSectionManager);
return;
}
syncChunkTrackingMode(tracker);
super.processChunkEvents();
}
@Override
protected void initRenderer(CommandList commandList) {
final ChunkTracker tracker = ChunkTrackerHolder.get(this.world);
if (!(tracker instanceof CubeStatusTracker)) {
syncChunkTrackingMode(tracker);
}
super.initRenderer(commandList);
if (tracker instanceof CubeStatusTracker cubic) {
cubic.forEachReady(this.renderSectionManager);
}
}
private static void syncChunkTrackingMode(ChunkTracker tracker) {
tracker.setRequiredNeighborRadius(AngelicaConfig.useVanillaChunkTracking ? 0 : 1);
}
public void setCurrentViewport(Viewport viewport) {
this.currentViewport = viewport;
}
public Viewport getCurrentViewport() {
return this.currentViewport;
}
@SuppressWarnings("unchecked")
private void collectTileEntitiesForShadow() {
final SortedRenderLists renderLists = renderSectionManager.getRenderLists();
final Iterator<ChunkRenderList> renderListIterator = renderLists.iterator();
while (renderListIterator.hasNext()) {
final var renderList = renderListIterator.next();
final var renderRegion = renderList.getRegion();
final var renderSectionIterator = renderList.sectionsWithEntitiesIterator();
if (renderSectionIterator == null) {
continue;
}
while (renderSectionIterator.hasNext()) {
final var renderSectionId = renderSectionIterator.nextByteAsInt();
final var renderSection = renderRegion.getSection(renderSectionId);
if (renderSection == null) {
continue;
}
final var context = renderSection.getBuiltContext();
if (context instanceof MinecraftBuiltRenderSectionData<?, ?> mcData) {
final var culledEntities = (List<TileEntity>) mcData.culledBlockEntities;
if (!culledEntities.isEmpty()) {
ShadowRenderer.visibleTileEntities.add(culledEntities);
}
}
}
}
for (var renderSection : renderSectionManager.getSectionsWithGlobalEntities()) {
final var context = renderSection.getBuiltContext();
if (context instanceof MinecraftBuiltRenderSectionData<?, ?> mcData) {
final var globalEntities = (List<TileEntity>) mcData.globalBlockEntities;
if (!globalEntities.isEmpty()) {
ShadowRenderer.globalTileEntities.add(globalEntities);
}
}
}
}
private CameraTransform cachedCameraTransform;
private double cachedCamX, cachedCamY, cachedCamZ;
@@ -481,6 +480,11 @@ public class CeleritasWorldRenderer extends SimpleWorldRenderer<WorldClient, Ang
@Override
protected int renderSectionBlockEntities(RenderSection section, List<TileEntity> blockEntities, boolean culled, TileEntityRenderContext renderContext) {
if (renderContext.shadowCollect) {
(culled ? ShadowRenderer.visibleTileEntities : ShadowRenderer.globalTileEntities).add(blockEntities);
return blockEntities.size();
}
if (culled) {
if (section.getBuiltContext() instanceof AngelicaBuiltRenderSectionData angelicaData) {
if (TeDistanceMath.distSqToSection(teCamX, teCamY, teCamZ,
@@ -625,20 +629,19 @@ public class CeleritasWorldRenderer extends SimpleWorldRenderer<WorldClient, Ang
return true;
}
// bail on very large entities to avoid checking many sections
final double entityVolume = (box.maxX - box.minX) * (box.maxY - box.minY) * (box.maxZ - box.minZ);
if (entityVolume > MAX_ENTITY_CHECK_VOLUME) {
// TODO: do a frustum check instead, even large entities aren't visible if they're outside the frustum
return true;
}
return this.isBoxVisible(box.minX, box.minY, box.minZ, box.maxX, box.maxY, box.maxZ);
}
public static class TileEntityRenderContext {
/** Collects shadow-pass block entity lists for ShadowRenderer instead of rendering. */
final boolean shadowCollect;
public float partialTicks;
public int pass;
TileEntityRenderContext(boolean shadowCollect) {
this.shadowCollect = shadowCollect;
}
public TileEntityRenderContext set(float partialTicks, int pass) {
this.partialTicks = partialTicks;
this.pass = pass;
@@ -7,7 +7,8 @@ import com.cardinalstar.cubicchunks.util.HashMap3D;
import com.cardinalstar.cubicchunks.util.HashSet3D;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
public class CubeStatusTracker implements ChunkTracker {
/** Tracks 3D cubes instead of columns; the inherited 2D state stays empty. */
public class CubeStatusTracker extends ChunkTracker {
/// Cubes that have been synced to the client and are currently loaded.
private final HashSet3D loadedCubes = new HashSet3D();
@@ -28,14 +29,12 @@ public class CubeStatusTracker implements ChunkTracker {
}
@Override
public void setFastMode(boolean fastMode) {
this.fastMode = fastMode;
this.loadedCubes.forEach(this::pollCube);
}
@Override
public boolean isFastModeEnabled() {
return fastMode;
}
@@ -107,7 +106,6 @@ public class CubeStatusTracker implements ChunkTracker {
// do nothing
}
@Override
public void forEachReady(RenderSectionManager renderSectionManager) {
if (this.isFastModeEnabled() != AngelicaConfig.useVanillaChunkTracking) {
setFastMode(AngelicaConfig.useVanillaChunkTracking);
@@ -134,7 +132,6 @@ public class CubeStatusTracker implements ChunkTracker {
}
}
@Override
public void forEachEvent(RenderSectionManager renderSectionManager) {
if (this.isFastModeEnabled() != AngelicaConfig.useVanillaChunkTracking) {
setFastMode(AngelicaConfig.useVanillaChunkTracking);
@@ -1,27 +0,0 @@
package com.gtnewhorizons.angelica.rendering.celeritas;
/** Decides when the section-age uniform upload can be skipped */
public final class SectionAgeMath {
public static final long STEP_NANOS = 100_000_000L;
private SectionAgeMath() {}
public static long quantize(long timestampNanos) {
return timestampNanos - Math.floorMod(timestampNanos, STEP_NANOS);
}
public static long[] newState() {
return new long[] { Long.MIN_VALUE, Long.MIN_VALUE, 0L };
}
public static boolean canSkip(long[] state, long newestLoadTime, long quantizedTimestamp) {
return state[0] == newestLoadTime && (state[2] == 1L || state[1] == quantizedTimestamp);
}
public static void record(long[] state, long newestLoadTime, long quantizedTimestamp, boolean allSaturated) {
state[0] = newestLoadTime;
state[1] = quantizedTimestamp;
state[2] = allSaturated ? 1L : 0L;
}
}
@@ -14,6 +14,11 @@ public final class TerrainDrawStats {
private static int cullMaxRegionCommands;
private static long sectionMetaBytes;
// Running totals
private static long indexBufferGrowths;
private static long sectionsUploaded;
private static long bytesUploaded;
private TerrainDrawStats() {
}
@@ -44,6 +49,27 @@ public final class TerrainDrawStats {
sectionMetaBytes += bytes;
}
public static void recordIndexBufferGrowth() {
indexBufferGrowths++;
}
public static void recordSectionUpload(long bytes) {
sectionsUploaded++;
bytesUploaded += bytes;
}
public static long getIndexBufferGrowths() {
return indexBufferGrowths;
}
public static long getSectionsUploaded() {
return sectionsUploaded;
}
public static long getBytesUploaded() {
return bytesUploaded;
}
public static int takeBatchRebuilds() {
final int n = batchRebuilds;
batchRebuilds = 0;
@@ -27,6 +27,4 @@ public interface IrisShaderProvider {
/** Block render layer overrides from shader pack */
@Nullable Map<Block, BlockRenderLayer> getBlockTypeIds();
default void preSubmitShadowGraph(int frame) {}
}
@@ -442,8 +442,9 @@ public final class GpuTerrainCuller {
}
private void walkSortedGroup(ChunkRenderMatrices matrices, ChunkRenderListIterable renderLists, CameraTransform occlusionCamera, CameraTransform camera, boolean useBlockFaceCulling, boolean chained) {
final int indexPointerMask = AngelicaRenderPassConfiguration.TRANSLUCENT_PASS.isSorted() ? 0xFFFFFFFF : 0;
if (chained) {
startSortedPass(0xFFFFFFFF);
startSortedPass(indexPointerMask);
} else {
invalidatePreparedPasses();
computeActiveThisPass = GpuCulling.mode().computeEnabled();
@@ -452,7 +453,7 @@ public final class GpuTerrainCuller {
passOutputBase = 0;
walkPrimitiveType = null;
primaryPass.reset(0, 0);
sortedPass.reset(0xFFFFFFFF, 0);
sortedPass.reset(indexPointerMask, 0);
buildPass = sortedPass;
current = sortedPass;
}
@@ -766,6 +766,12 @@ public class SodiumGameOptionPages {
.setControl(TickBoxControl::new)
.setBinding((opts, value) -> AngelicaConfig.disableF3Additions = value, opts -> AngelicaConfig.disableF3Additions)
.build())
.add(OptionImpl.createBuilder(boolean.class, angelicaOpts)
.setName(I18n.format("options.angelica.verbosef3"))
.setTooltip(I18n.format("options.angelica.verbosef3.tooltip"))
.setControl(TickBoxControl::new)
.setBinding((opts, value) -> AngelicaConfig.verboseF3 = value, opts -> AngelicaConfig.verboseF3)
.build())
.build());
if (AngelicaConfig.enableZoom) {
@@ -66,12 +66,6 @@ public class IrisCeleritasShaderProvider implements IrisShaderProvider {
return BlockRenderingSettings.INSTANCE.getBlockTypeIds();
}
@Override
public void preSubmitShadowGraph(int frame) {
final WorldRenderingPipeline pipeline = Iris.getPipelineManager().getPipelineNullable();
if (pipeline != null) pipeline.preSubmitShadowGraph(frame);
}
public void deleteShaders() {
overrides.deleteShaders();
}
@@ -1958,11 +1958,6 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R
isRenderingFullScreenPass = false;
}
@Override
public void preSubmitShadowGraph(int frame) {
if (shadowRenderer != null) shadowRenderer.preSubmitGraphUpdate(frame);
}
@Override
public void renderShadows(EntityRenderer levelRenderer, Camera playerCamera) {
if (shouldRenderPrepareBeforeShadow) {
@@ -81,6 +81,7 @@ public class ShadowRenderer {
private static final Tracy.ZoneId Z_SHADOW_FRUSTUM = Tracy.zoneId("shadowFrustum", Tracy.COLOR_IRIS);
private static final Tracy.ZoneId Z_SHADOW_VIEWPORT = Tracy.zoneId("shadowViewport", Tracy.COLOR_IRIS);
private static final Tracy.ZoneId Z_SHADOW_MODEL_PARTS = Tracy.zoneId("shadowModelParts", Tracy.COLOR_IRIS);
private static final Tracy.ZoneId Z_SHADOW_GRAPH_JOIN = Tracy.zoneId("shadowGraphJoin", Tracy.COLOR_IRIS);
public static final Matrix4f MODELVIEW = new Matrix4f();
public static final FloatBuffer MODELVIEW_BUFFER = BufferUtils.createFloatBuffer(16);
@@ -114,6 +115,7 @@ public class ShadowRenderer {
private final boolean shouldRenderEntities;
private final boolean shouldRenderPlayer;
private final boolean shouldRenderBlockEntities;
private final boolean shouldRenderLightBlockEntities;
private final float sunPathRotation;
private final List<MipmapPass> mipmapPasses = new ArrayList<>();
private final String debugStringOverall;
@@ -171,10 +173,9 @@ public class ShadowRenderer {
private final FrustumCaches entityFrustumCaches = new FrustumCaches();
private float lastGraphShadowAngle = Float.NaN;
private float relayShadowAngle = Float.NaN;
private FrustumHolder preSubmitFrustumHolder = new FrustumHolder("preSubmit");
private final FrustumCaches preSubmitFrustumCaches = new FrustumCaches();
private boolean preSubmitActive;
private float preSubmittedShadowAngle = Float.NaN;
/** A shadow search was submitted by the last shadow pass; with async occlusion its lists are published by this pass's join. */
private boolean shadowSearchPending;
private float searchedShadowAngle = Float.NaN;
private float shadowAngleDelta() {
final Vector4f light = celestialUniforms.getShadowLightPositionInWorldSpace();
@@ -185,25 +186,6 @@ public class ShadowRenderer {
AngelicaConfig.shadowGraphHorizonScale);
}
public void preSubmitGraphUpdate(int frame) {
final AngelicaRenderSectionManager rsm = CeleritasWorldRenderer.getInstance().getRenderSectionManager();
final float currentShadowAngle = getShadowAngle();
if (ShadowGraphGate.shouldMarkDirty(lastGraphShadowAngle, currentShadowAngle, shadowAngleDelta())) {
rsm.markShadowGraphDirty();
lastGraphShadowAngle = currentShadowAngle;
}
if (!rsm.canSubmitShadowGraphSearch()) return;
preSubmitFrustumHolder = createShadowFrustum(renderDistanceMultiplier, preSubmitFrustumHolder, preSubmitFrustumCaches);
if (!(preSubmitFrustumHolder.getFrustum() instanceof ViewportProvider provider)) return;
final Vector3d entityPos = Camera.INSTANCE.getEntityPos();
preSubmitFrustumHolder.getFrustum().setPosition(entityPos.x, entityPos.y, entityPos.z);
if (rsm.submitShadowGraphSearch(provider.sodium$createViewport(), frame)) {
preSubmittedShadowAngle = lastGraphShadowAngle;
preSubmitActive = true;
}
}
private long lastRelayNanos;
private final Vector3f shadowLightVectorCache = new Vector3f();
private final MemoizedBoxCuller tileEntityCuller = new MemoizedBoxCuller();
@@ -232,6 +214,7 @@ public class ShadowRenderer {
this.shouldRenderEntities = shadowDirectives.shouldRenderEntities();
this.shouldRenderPlayer = shadowDirectives.shouldRenderPlayer();
this.shouldRenderBlockEntities = shadowDirectives.shouldRenderBlockEntities();
this.shouldRenderLightBlockEntities = shadowDirectives.shouldRenderLightBlockEntities();
this.shouldRenderDH = shadowDirectives.isDhShadowEnabled().orElse(false);
this.packUsesShadowtex1 = packUsesShadowtex1;
@@ -797,7 +780,11 @@ public class ShadowRenderer {
);
}
private void renderTileEntities(Object bufferSource, MatrixStack modelView, double cameraX, double cameraY, double cameraZ, float partialTicks, boolean hasEntityFrustum) {
private static boolean emitsLight(TileEntity tile) {
return tile.getBlockType().getLightValue(tile.getWorldObj(), tile.xCoord, tile.yCoord, tile.zCoord) > 0;
}
private void renderTileEntities(Object bufferSource, MatrixStack modelView, double cameraX, double cameraY, double cameraZ, float partialTicks, boolean hasEntityFrustum, boolean lightsOnly) {
profiler.startSection("iris_shadow_build_blockentities");
int shadowTileEntities = 0;
@@ -826,6 +813,9 @@ public class ShadowRenderer {
if (hasEntityFrustum && (culler.isCulled(tileEntity.xCoord - 1, tileEntity.yCoord - 1, tileEntity.zCoord - 1, tileEntity.xCoord + 1, tileEntity.yCoord + 1, tileEntity.zCoord + 1))) {
continue;
}
if (lightsOnly && !emitsLight(tileEntity)) {
continue;
}
renderTileEntity(tileEntity, cameraX, cameraY, cameraZ, partialTicks);
shadowTileEntities++;
@@ -838,6 +828,9 @@ public class ShadowRenderer {
if (hasEntityFrustum && (culler.isCulled(tileEntity.xCoord - 1, tileEntity.yCoord - 1, tileEntity.zCoord - 1, tileEntity.xCoord + 1, tileEntity.yCoord + 1, tileEntity.zCoord + 1))) {
continue;
}
if (lightsOnly && !emitsLight(tileEntity)) {
continue;
}
renderTileEntity(tileEntity, cameraX, cameraY, cameraZ, partialTicks);
shadowTileEntities++;
@@ -864,8 +857,20 @@ public class ShadowRenderer {
this.profiler = Minecraft.getMinecraft().mcProfiler;
profiler.endStartSection("iris_shadows");
final AngelicaRenderSectionManager rsm = CeleritasWorldRenderer.getInstance().getRenderSectionManager();
// The in-flight shadow search reads terrainFrustumHolder's frustum, which createShadowFrustum re-inits below.
if (Tracy.ENABLED) Tracy.beginZone(Z_SHADOW_GRAPH_JOIN);
try {
rsm.finishAllGraphUpdates();
} finally {
if (Tracy.ENABLED) Tracy.endZone();
}
ACTIVE = true;
CURRENT_TARGETS = this.targets;
// ACTIVE routes clipRenderersByFrustum into the shadow path; a leak would send every main pass there.
try {
// NB: We store the previous player buffers in order to be able to allow mods rendering entities in the shadow pass (Flywheel) to use the shadow buffers instead.
// TODO: Render
@@ -875,25 +880,27 @@ public class ShadowRenderer {
visibleTileEntities.clear();
globalTileEntities.clear();
final boolean newShadowLists = shadowSearchPending;
shadowSearchPending = false;
final float currentShadowAngle = getShadowAngle();
if (ShadowGraphGate.shouldMarkDirty(lastGraphShadowAngle, currentShadowAngle, shadowAngleDelta())) {
CeleritasWorldRenderer.getInstance().getRenderSectionManager().markShadowGraphDirty();
rsm.markShadowGraphDirty();
lastGraphShadowAngle = currentShadowAngle;
}
final boolean deferActive = shouldRenderTerrain;
final long frameNanos = System.nanoTime();
final boolean consumePreSubmit = preSubmitActive;
preSubmitActive = false;
final boolean shadowGraphDirty = rsm.isShadowGraphDirty();
final boolean relayTerrain = shadowTerrainAlwaysRelays()
|| !targets.isTerrainSnapshotValid()
|| consumePreSubmit
|| CeleritasWorldRenderer.getInstance().getRenderSectionManager().isShadowGraphDirty()
|| newShadowLists
|| shadowGraphDirty
|| frameNanos - lastRelayNanos >= SHADOW_RELAY_MAX_AGE_NANOS;
if (relayTerrain) {
relayShadowAngle = consumePreSubmit && !CeleritasWorldRenderer.getInstance().getRenderSectionManager().isShadowGraphDirty() ? preSubmittedShadowAngle : currentShadowAngle;
// New lists draw at the angle they were searched at, unless the gate already wants a newer search.
relayShadowAngle = newShadowLists && !shadowGraphDirty ? searchedShadowAngle : currentShadowAngle;
}
activeShadowAngle = relayShadowAngle;
SHADOW_TERRAIN_RELAID = relayTerrain;
@@ -934,11 +941,9 @@ public class ShadowRenderer {
profiler.endSection();
// Save the main camera viewport before shadow pass overwrites it.
// clipRenderersByFrustum -> setupTerrain sets currentViewport to the shadow frustum.
// If the shadow pass throws or the main setupTerrain doesn't run after us, the shadow
// viewport would persist and corrupt entity culling in the main pass.
final Viewport savedViewport = CeleritasWorldRenderer.getInstance().getCurrentViewport();
// clipRenderersByFrustum -> setupShadowTerrain sets currentViewport to the shadow frustum; restore the last
// terrain viewport so entity culling never sees the shadow one if the main setupTerrain doesn't run.
final Viewport savedViewport = CeleritasWorldRenderer.getInstance().getLastViewport();
// Pair setupGlState / restoreGlState with try-finally so any throw between them
// (translucent terrain, entity rendering, mipmaps, etc.) still unwinds the
@@ -947,7 +952,13 @@ public class ShadowRenderer {
boolean setupGlStateRan = false;
try {
// Execute the vanilla terrain setup / culling routines using our shadow frustum.
final int shadowSearchesBefore = rsm.getShadowSearchSubmissions();
mc.renderGlobal.clipRenderersByFrustum(terrainFrustumHolder.getFrustum(), playerCamera.getPartialTicks());
if (rsm.getShadowSearchSubmissions() != shadowSearchesBefore) {
shadowSearchPending = true;
// createShadowFrustum built the search's light vector from the current light
searchedShadowAngle = currentShadowAngle;
}
// Don't forget to increment the frame counter! This variable is arbitrary and only used in terrain setup,
// and if it's not incremented, the vanilla culling code will get confused and think that it's already seen
@@ -983,9 +994,9 @@ public class ShadowRenderer {
renderShadowEntitiesAndPlayer(levelRenderer, entityShadowFrustum, modelView, entityX, entityY, entityZ, tickDelta);
}
if (shouldRenderBlockEntities) {
if (shouldRenderBlockEntities || shouldRenderLightBlockEntities) {
try (GLDebug.Scope s = GLDebug.scope("shadow:block_entities")) {
renderTileEntities(null, modelView, entityX, entityY, entityZ, tickDelta, entityFrustumConstrained);
renderTileEntities(null, modelView, entityX, entityY, entityZ, tickDelta, entityFrustumConstrained, !shouldRenderBlockEntities);
}
}
@@ -1036,9 +1047,10 @@ public class ShadowRenderer {
profiler.endStartSection("iris_shadowcomp");
if (compositeRenderer != null) compositeRenderer.renderAll();
ACTIVE = false;
CURRENT_TARGETS = null;
} finally {
ACTIVE = false;
CURRENT_TARGETS = null;
}
profiler.endSection();
profiler.endStartSection("culling");
}
@@ -1062,7 +1074,7 @@ public class ShadowRenderer {
}
private String getTileEntitiesDebugString() {
return shouldRenderBlockEntities ? (renderedShadowTileEntities + "/" + Minecraft.getMinecraft().theWorld.loadedTileEntityList.size()) : "disabled by pack";
return (shouldRenderBlockEntities || shouldRenderLightBlockEntities) ? (renderedShadowTileEntities + "/" + Minecraft.getMinecraft().theWorld.loadedTileEntityList.size()) : "disabled by pack";
}
private static class MipmapPass {
@@ -22,7 +22,6 @@ import java.util.OptionalInt;
public interface WorldRenderingPipeline {
void beginLevelRendering();
void renderShadows(EntityRenderer levelRenderer, Camera camera);
default void preSubmitShadowGraph(int frame) {}
void addDebugText(List<String> messages);
OptionalInt getForcedShadowRenderDistanceChunksForDisplay();
@@ -611,16 +611,6 @@ public final class RwImageStoreExtractor {
final Set<String> present = new HashSet<>();
for (AttributeSlot slot : attrs) present.add(slot.name());
out.append("#ifdef USE_VERTEX_COMPRESSION\n");
if (present.contains("a_PosId")) {
out.append(" _vert_position = vec3(a_PosId.xyz) * VERT_POS_SCALE + VERT_POS_OFFSET;\n");
out.append(" _draw_id = (a_PosId.w >> 8u) & 0xFFu;\n");
out.append(" _material_params = (a_PosId.w >> 0u) & 0xFFu;\n");
}
if (present.contains("a_TexCoord")) out.append(" _vert_tex_diffuse_coord = a_TexCoord * VERT_TEX_SCALE;\n");
if (present.contains("a_LightCoord")) out.append(" _vert_tex_light_coord = a_LightCoord;\n");
if (present.contains("a_Color")) out.append(" _vert_color = a_Color;\n");
out.append("#else\n");
if (present.contains("a_PosId")) out.append(" _vert_position = a_PosId;\n");
if (present.contains("a_TexCoord")) out.append(" _vert_tex_diffuse_coord = a_TexCoord;\n");
if (present.contains("a_Color")) out.append(" _vert_color = a_Color;\n");
@@ -630,7 +620,6 @@ public final class RwImageStoreExtractor {
out.append(" _draw_id = (_vg_draw_params >> 8) & 0xFFu;\n");
out.append(" _vert_tex_light_coord = ivec2((uvec2((a_LightCoord >> 16) & 0xFFFFu) >> uvec2(0, 8)) & uvec2(0xFFu));\n");
}
out.append("#endif\n");
}
private static void emitDispatchMain(StringBuilder out, RwExtractMode mode, List<AttributeSlot> attrs) {
@@ -788,11 +777,6 @@ public final class RwImageStoreExtractor {
addAttr(m, new AttributeSlot("a_LightCoord", "uint", 24,
"_vg_vbuf.data[base + 6u]"));
addAttr(m, new AttributeSlot("a_PosId", "uvec4", 0,
"uvec4(0u, 0u, 0u, 0u)", false));
addAttr(m, new AttributeSlot("a_LightCoord", "ivec2", 24,
"ivec2(0, 0)", false));
final LinkedHashMap<String, Map<String, AttributeSlot>> immutable = new LinkedHashMap<>();
for (var e : m.entrySet()) immutable.put(e.getKey(), Map.copyOf(e.getValue()));
return Map.copyOf(immutable);
@@ -29,6 +29,7 @@ public class PackShadowDirectives {
private final boolean shouldRenderEntities;
private final boolean shouldRenderPlayer;
private final boolean shouldRenderBlockEntities;
private final boolean shouldRenderLightBlockEntities;
@Getter private final ShadowCullState cullingState;
private final OptionalBoolean dhShadowEnabled;
private float nearPlane, farPlane;
@@ -83,6 +84,7 @@ public class PackShadowDirectives {
this.shouldRenderEntities = properties.getShadowEntities().orElse(true);
this.shouldRenderPlayer = properties.getShadowPlayer().orElse(false);
this.shouldRenderBlockEntities = properties.getShadowBlockEntities().orElse(true);
this.shouldRenderLightBlockEntities = properties.getShadowLightBlockEntities().orElse(false);
this.cullingState = properties.getShadowCulling();
this.shadowEnabled = properties.getShadowEnabled();
this.dhShadowEnabled = properties.getDhShadowEnabled();
@@ -114,6 +116,7 @@ public class PackShadowDirectives {
this.shouldRenderEntities = shadowDirectives.shouldRenderEntities;
this.shouldRenderPlayer = shadowDirectives.shouldRenderPlayer;
this.shouldRenderBlockEntities = shadowDirectives.shouldRenderBlockEntities;
this.shouldRenderLightBlockEntities = shadowDirectives.shouldRenderLightBlockEntities;
this.cullingState = shadowDirectives.cullingState;
this.depthSamplingSettings = shadowDirectives.depthSamplingSettings;
this.colorSamplingSettings = shadowDirectives.colorSamplingSettings;
@@ -185,6 +188,10 @@ public class PackShadowDirectives {
return shouldRenderBlockEntities;
}
public boolean shouldRenderLightBlockEntities() {
return shouldRenderLightBlockEntities;
}
public OptionalBoolean isShadowEnabled() {
return shadowEnabled;
}