Angelica 2.0

* GLStateManagerService & RenderSystemService
* Wire up Celeritas
* Iris working
* Dynamic lights working
* Goodbye Sodium 0.2
* Add Multi-Threading for check meshing again
This commit is contained in:
Jason Mitchell authored and Jason Mitchell committed 2026-01-07 13:22:16 -08:00
1 parent e5e8250d44
commit be90a01725
354 files changed
+5257 -15599

No files matched your search

@@ -3,17 +3,19 @@ package net.coderbot.iris.pipeline;
import com.google.common.collect.ImmutableList;
import com.gtnewhorizons.angelica.compat.mojang.Camera;
import com.gtnewhorizons.angelica.compat.toremove.MatrixStack;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.RenderSystem;
import com.gtnewhorizons.angelica.rendering.RenderingState;
import com.gtnewhorizons.angelica.rendering.celeritas.CeleritasWorldRenderer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import me.jellysquid.mods.sodium.client.render.SodiumWorldRenderer;
import net.coderbot.iris.Iris;
import net.coderbot.iris.layer.GbufferPrograms;
import net.coderbot.iris.gui.option.IrisVideoSettings;
import net.coderbot.iris.shaderpack.OptionalBoolean;
import net.coderbot.iris.shaderpack.PackDirectives;
@@ -41,8 +43,11 @@ import net.minecraft.client.renderer.entity.RenderManager;
import net.minecraft.client.renderer.texture.TextureMap;
import net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher;
import net.minecraft.entity.Entity;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.profiler.Profiler;
import net.minecraft.tileentity.TileEntity;
import com.gtnewhorizons.angelica.compat.mojang.GameModeUtil;
import org.embeddedt.embeddium.impl.render.viewport.ViewportProvider;
import org.joml.Matrix4f;
import org.joml.Vector3dc;
import org.joml.Vector3f;
@@ -58,9 +63,15 @@ public class ShadowRenderer {
public static final Matrix4f MODELVIEW = new Matrix4f();
public static final FloatBuffer MODELVIEW_BUFFER = BufferUtils.createFloatBuffer(16);
public static final Matrix4f PROJECTION = new Matrix4f();
public static List<TileEntity> visibleTileEntities;
public static List<TileEntity> globalTileEntities;
public static final List<TileEntity> visibleTileEntities = new ArrayList<>();
public static final List<TileEntity> globalTileEntities = new ArrayList<>();
public static boolean ACTIVE = false;
private static final Comparator<Entity> ENTITY_CLASS_COMPARATOR = Comparator.comparingInt(a -> System.identityHashCode(a.getClass()));
private static final NonCullingFrustum NON_CULLING_FRUSTUM = new NonCullingFrustum();
private static final CullEverythingFrustum CULL_EVERYTHING_FRUSTUM = new CullEverythingFrustum();
public static ShadowRenderTargets CURRENT_TARGETS = null;
private final float halfPlaneLength;
private final float renderDistanceMultiplier;
private final float entityShadowDistanceMultiplier;
@@ -76,16 +87,27 @@ public class ShadowRenderer {
private final boolean shouldRenderPlayer;
private final boolean shouldRenderBlockEntities;
private final float sunPathRotation;
// private final RenderBuffers buffers;
// private final RenderBuffersExt renderBuffersExt;
private final List<MipmapPass> mipmapPasses = new ArrayList<>();
private final String debugStringOverall;
private FrustumHolder terrainFrustumHolder;
private FrustumHolder entityFrustumHolder;
private String debugStringTerrain = "(unavailable)";
private int renderedShadowEntities = 0;
private int renderedShadowTileEntities = 0;
private Profiler profiler;
private final List<Entity> renderedEntitiesList = new ArrayList<>(64);
private final MatrixStack shadowModelView = new MatrixStack();
private final CelestialUniforms celestialUniforms;
private final AdvancedShadowCullingFrustum cachedAdvancedFrustum = new AdvancedShadowCullingFrustum();
private final Vector3f shadowLightVectorCache = new Vector3f();
private BoxCuller cachedBoxCuller;
private BoxCullingFrustum cachedBoxCullingFrustum;
private BoxCuller cachedAdvancedBoxCuller;
private BoxCuller cachedTileEntityCuller;
private double lastBoxCullerDistance = -1;
private double lastAdvancedBoxCullerDistance = -1;
private double lastTileEntityCullerDistance = -1;
public ShadowRenderer(ProgramSource shadow, PackDirectives directives, ShadowRenderTargets shadowRenderTargets) {
@@ -123,6 +145,7 @@ public class ShadowRenderer {
}
this.sunPathRotation = directives.getSunPathRotation();
this.celestialUniforms = new CelestialUniforms(this.sunPathRotation);
// this.buffers = new RenderBuffers();
//
@@ -154,6 +177,13 @@ public class ShadowRenderer {
return modelView;
}
private MatrixStack getShadowModelView() {
final Vector3dc cameraPos = CameraUniforms.getUnshiftedCameraPosition();
shadowModelView.reset();
ShadowMatrices.createModelViewMatrix(shadowModelView, getShadowAngle(), this.intervalSize, this.sunPathRotation, cameraPos.x(), cameraPos.y(), cameraPos.z());
return shadowModelView;
}
private static WorldClient getLevel() {
return Objects.requireNonNull(Minecraft.getMinecraft().theWorld);
}
@@ -271,15 +301,14 @@ public class ShadowRenderer {
distanceInfo = Minecraft.getMinecraft().gameSettings.renderDistanceChunks * 16
+ " blocks (capped by normal render distance)";
cullingInfo = "disabled " + reason;
return holder.setInfo(new NonCullingFrustum(), distanceInfo, cullingInfo);
return holder.setInfo(NON_CULLING_FRUSTUM, distanceInfo, cullingInfo);
} else {
distanceInfo = distance + " blocks (set by shader pack)";
cullingInfo = "distance only " + reason;
BoxCuller boxCuller = new BoxCuller(distance);
holder.setInfo(new BoxCullingFrustum(boxCuller), distanceInfo, cullingInfo);
holder.setInfo(getOrCreateBoxCullingFrustum(distance), distanceInfo, cullingInfo);
}
} else {
BoxCuller boxCuller;
final BoxCuller boxCuller;
double distance = halfPlaneLength * renderMultiplier;
String setter = "(set by shader pack)";
@@ -300,30 +329,65 @@ public class ShadowRenderer {
if (distance == 0.0) {
cullingInfo = "no shadows rendered";
holder.setInfo(new CullEverythingFrustum(), distanceInfo, cullingInfo);
return holder.setInfo(CULL_EVERYTHING_FRUSTUM, distanceInfo, cullingInfo);
}
boxCuller = new BoxCuller(distance);
boxCuller = getOrCreateAdvancedBoxCuller(distance);
}
cullingInfo = "Advanced Frustum Culling enabled";
Vector4f shadowLightPosition = new CelestialUniforms(sunPathRotation).getShadowLightPositionInWorldSpace();
final Vector4f shadowLightPosition = celestialUniforms.getShadowLightPositionInWorldSpace();
shadowLightVectorCache.set(shadowLightPosition.x(), shadowLightPosition.y(), shadowLightPosition.z());
shadowLightVectorCache.normalize();
Vector3f shadowLightVectorFromOrigin =
new Vector3f(shadowLightPosition.x(), shadowLightPosition.y(), shadowLightPosition.z());
shadowLightVectorFromOrigin.normalize();
return holder.setInfo(new AdvancedShadowCullingFrustum(RenderingState.INSTANCE.getModelViewMatrix(), RenderingState.INSTANCE.getProjectionMatrix(),
shadowLightVectorFromOrigin, boxCuller), distanceInfo, cullingInfo);
cachedAdvancedFrustum.init(RenderingState.INSTANCE.getModelViewMatrix(), RenderingState.INSTANCE.getProjectionMatrix(), shadowLightVectorCache, boxCuller);
return holder.setInfo(cachedAdvancedFrustum, distanceInfo, cullingInfo);
}
return holder;
}
private BoxCullingFrustum getOrCreateBoxCullingFrustum(double distance) {
if (cachedBoxCuller == null) {
cachedBoxCuller = new BoxCuller(distance);
cachedBoxCullingFrustum = new BoxCullingFrustum(cachedBoxCuller);
lastBoxCullerDistance = distance;
} else if (lastBoxCullerDistance != distance) {
cachedBoxCuller.setMaxDistance(distance);
lastBoxCullerDistance = distance;
}
return cachedBoxCullingFrustum;
}
private BoxCuller getOrCreateAdvancedBoxCuller(double distance) {
if (cachedAdvancedBoxCuller == null) {
cachedAdvancedBoxCuller = new BoxCuller(distance);
lastAdvancedBoxCullerDistance = distance;
} else if (lastAdvancedBoxCullerDistance != distance) {
cachedAdvancedBoxCuller.setMaxDistance(distance);
lastAdvancedBoxCullerDistance = distance;
}
return cachedAdvancedBoxCuller;
}
private BoxCuller getOrCreateTileEntityCuller(double distance) {
if (cachedTileEntityCuller == null) {
cachedTileEntityCuller = new BoxCuller(distance);
lastTileEntityCullerDistance = distance;
} else if (lastTileEntityCullerDistance != distance) {
cachedTileEntityCuller.setMaxDistance(distance);
lastTileEntityCullerDistance = distance;
}
return cachedTileEntityCuller;
}
private void setupGlState(Matrix4f projMatrix) {
// Bind shadow framebuffer and set viewport to shadow resolution
targets.getDepthSourceFb().bind();
GL11.glViewport(0, 0, resolution, resolution);
// Set up our projection matrix and load it into the legacy matrix stack
RenderSystem.setupProjectionMatrix(projMatrix);
@@ -343,6 +407,11 @@ public class ShadowRenderer {
// Make sure to unload the projection matrix
RenderSystem.restoreProjectionMatrix();
// Restore main framebuffer and viewport
Minecraft mc = Minecraft.getMinecraft();
mc.getFramebuffer().bindFramebuffer(false);
GL11.glViewport(0, 0, mc.displayWidth, mc.displayHeight);
}
private void copyPreTranslucentDepth() {
@@ -352,80 +421,112 @@ public class ShadowRenderer {
}
private void renderEntities(EntityRenderer levelRenderer, Frustrum frustum, Object bufferSource, MatrixStack modelView, double cameraX, double cameraY, double cameraZ, float tickDelta) {
int shadowEntities = 0;
profiler.startSection("cull");
List<Entity> renderedEntities = new ArrayList<>(32);
renderedEntitiesList.clear();
final boolean playerIsSpectator = GameModeUtil.isSpectator();
final EntityPlayer player = Minecraft.getMinecraft().thePlayer;
// TODO: I'm sure that this can be improved / optimized.
// TODO: Entity culling
for (Entity entity : getLevel().loadedEntityList) {
if (false/*!dispatcher.shouldRender(entity, frustum, cameraX, cameraY, cameraZ) || entity.isSpectator()*/) {
continue;
}
if (playerIsSpectator && entity == player) continue;
renderedEntities.add(entity);
if (!entity.ignoreFrustumCheck && !frustum.isBoundingBoxInFrustum(entity.boundingBox)) continue;
renderedEntitiesList.add(entity);
}
profiler.endStartSection("sort");
// TODO: Render
// Sort the entities by type first in order to allow vanilla's entity batching system to work better.
renderedEntities.sort(Comparator.comparingInt(entity -> entity.getClass().hashCode()));
renderedEntitiesList.sort(ENTITY_CLASS_COMPARATOR);
profiler.endStartSection("build geometry");
// TODO: Render
setupEntityShadowState(modelView, cameraX, cameraY, cameraZ);
try {
for (Entity entity : renderedEntitiesList) {
RenderManager.instance.renderEntitySimple(entity, tickDelta);
}
} finally {
teardownEntityShadowState();
}
renderedShadowEntities = renderedEntitiesList.size();
profiler.endSection();
}
// Saved RenderManager position for shadow pass
private double savedRenderPosX, savedRenderPosY, savedRenderPosZ;
private void setupEntityShadowState(MatrixStack modelView, double cameraX, double cameraY, double cameraZ) {
savedRenderPosX = RenderManager.renderPosX;
savedRenderPosY = RenderManager.renderPosY;
savedRenderPosZ = RenderManager.renderPosZ;
RenderManager.renderPosX = cameraX;
RenderManager.renderPosY = cameraY;
RenderManager.renderPosZ = cameraZ;
GLStateManager.glEnable(GL11.GL_POLYGON_OFFSET_FILL);
GLStateManager.glPolygonOffset(1.0f, 1.0f);
GL11.glPushMatrix();
MODELVIEW_BUFFER.clear().rewind();
modelView.peek().getModel().get(MODELVIEW_BUFFER);
GL11.glLoadMatrix(MODELVIEW_BUFFER);
for (Entity entity : renderedEntities) {
RenderManager.instance.renderEntitySimple(entity, tickDelta);
shadowEntities++;
}
}
private void teardownEntityShadowState() {
GL11.glPopMatrix();
renderedShadowEntities = shadowEntities;
GLStateManager.glDisable(GL11.GL_POLYGON_OFFSET_FILL);
GLStateManager.glPolygonOffset(0.0f, 0.0f);
profiler.endSection();
}
RenderManager.renderPosX = savedRenderPosX;
RenderManager.renderPosY = savedRenderPosY;
RenderManager.renderPosZ = savedRenderPosZ;
}
private void renderPlayerEntity(EntityRenderer levelRenderer, Frustrum frustum, Object bufferSource, MatrixStack modelView, double cameraX, double cameraY, double cameraZ, float tickDelta) {
profiler.startSection("cull");
Entity player = Minecraft.getMinecraft().thePlayer;
// TODO: Entity culling
// if (!dispatcher.shouldRender(player, frustum, cameraX, cameraY, cameraZ) || player.isSpectator()) {
// return;
// }
// Skip if spectating or outside frustum
if (GameModeUtil.isSpectator()) {
profiler.endSection();
renderedShadowEntities = 0;
return;
}
if (!player.ignoreFrustumCheck && !frustum.isBoundingBoxInFrustum(player.boundingBox)) {
profiler.endSection();
renderedShadowEntities = 0;
return;
}
profiler.endStartSection("build geometry");
int shadowEntities = 0;
GL11.glPushMatrix();
MODELVIEW_BUFFER.clear().rewind();
modelView.peek().getModel().get(MODELVIEW_BUFFER);
GL11.glLoadMatrix(MODELVIEW_BUFFER);
setupEntityShadowState(modelView, cameraX, cameraY, cameraZ);
try {
if (player.riddenByEntity != null) {
RenderManager.instance.renderEntitySimple(player.riddenByEntity, tickDelta);
shadowEntities++;
}
if (player.riddenByEntity != null) {
RenderManager.instance.renderEntitySimple(player.riddenByEntity, tickDelta);
shadowEntities++;
}
if (player.ridingEntity != null) {
RenderManager.instance.renderEntitySimple(player.ridingEntity, tickDelta);
shadowEntities++;
}
if (player.ridingEntity != null) {
RenderManager.instance.renderEntitySimple(player.ridingEntity, tickDelta);
shadowEntities++;
}
RenderManager.instance.renderEntitySimple(player, tickDelta);
GL11.glPopMatrix();
shadowEntities++;
RenderManager.instance.renderEntitySimple(player, tickDelta);
shadowEntities++;
} finally {
teardownEntityShadowState();
}
renderedShadowEntities = shadowEntities;
@@ -453,7 +554,8 @@ public class ShadowRenderer {
int shadowTileEntities = 0;
BoxCuller culler = null;
if (hasEntityFrustum) {
culler = new BoxCuller(halfPlaneLength * (renderDistanceMultiplier * entityShadowDistanceMultiplier));
double distance = halfPlaneLength * (renderDistanceMultiplier * entityShadowDistanceMultiplier);
culler = getOrCreateTileEntityCuller(distance);
culler.setPosition(cameraX, cameraY, cameraZ);
}
@@ -462,6 +564,9 @@ public class ShadowRenderer {
modelView.peek().getModel().get(MODELVIEW_BUFFER);
GL11.glLoadMatrix(MODELVIEW_BUFFER);
GbufferPrograms.beginBlockEntities();
GbufferPrograms.setBlockEntityDefaults();
for (TileEntity tileEntity : visibleTileEntities) {
if (hasEntityFrustum && (culler.isCulled(tileEntity.xCoord - 1, tileEntity.yCoord - 1, tileEntity.zCoord - 1, tileEntity.xCoord + 1, tileEntity.yCoord + 1, tileEntity.zCoord + 1))) {
continue;
@@ -479,6 +584,7 @@ public class ShadowRenderer {
shadowTileEntities++;
}
GbufferPrograms.endBlockEntities();
GLStateManager.glPopMatrix();
renderedShadowTileEntities = shadowTileEntities;
@@ -496,17 +602,18 @@ public class ShadowRenderer {
profiler.endStartSection("shadows");
ACTIVE = true;
CURRENT_TARGETS = this.targets;
// 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
// RenderBuffers playerBuffers = levelRenderer.getRenderBuffers();
// levelRenderer.setRenderBuffers(buffers);
visibleTileEntities = new ArrayList<>();
globalTileEntities = new ArrayList<>();
visibleTileEntities.clear();
globalTileEntities.clear();
// Create our camera
final MatrixStack modelView = createShadowModelView(this.sunPathRotation, this.intervalSize);
final MatrixStack modelView = getShadowModelView();
MODELVIEW.set(modelView.peek().getModel());
final Matrix4f shadowProjection;
@@ -549,6 +656,11 @@ public class ShadowRenderer {
// ((LevelRenderer) levelRenderer).needsUpdate();
// levelRenderer.setShouldRegenerateClouds(regenerateClouds);
// Mark the shadow graph as needing update before terrain setup
// Modern Celeritas does this to ensure the shadow render lists get populated
com.gtnewhorizons.angelica.rendering.celeritas.CeleritasWorldRenderer.getInstance()
.getRenderSectionManager().markGraphDirty();
// Execute the vanilla terrain setup / culling routines using our shadow frustum.
mc.renderGlobal.clipRenderersByFrustum(terrainFrustumHolder.getFrustum(), playerCamera.getPartialTicks());
@@ -567,6 +679,9 @@ public class ShadowRenderer {
rg.sortAndRender(mc.thePlayer, 0, playerCamera.getPartialTicks());
}
// Reset viewport in case terrain rendering changed it
GL11.glViewport(0, 0, resolution, resolution);
profiler.endStartSection("entities");
// Get the current tick delta. Normally this is the same as client.getTickDelta(), but when the game is paused,
@@ -587,6 +702,11 @@ public class ShadowRenderer {
Frustrum entityShadowFrustum = entityFrustumHolder.getFrustum();
entityShadowFrustum.setPosition(cameraX, cameraY, cameraZ);
// Set viewport for entity visibility checks during shadow pass (matches modern Celeritas)
if (AngelicaConfig.enableCeleritas) {
CeleritasWorldRenderer.getInstance().setCurrentViewport(((ViewportProvider)entityShadowFrustum).sodium$createViewport());
}
// Render nearby entities
if (shouldRenderEntities) {
@@ -623,8 +743,6 @@ public class ShadowRenderer {
// renderBuffersExt.endLevelRendering();
// }
debugStringTerrain = SodiumWorldRenderer.getInstance().getChunksDebugString();
profiler.endStartSection("generate mipmaps");
generateMipmaps();
@@ -638,17 +756,19 @@ public class ShadowRenderer {
}
ACTIVE = false;
CURRENT_TARGETS = null;
profiler.endSection();
profiler.endStartSection("updatechunks");
}
public void addDebugText(List<String> messages) {
messages.add("[" + Iris.MODNAME + "] Shadow Maps: " + debugStringOverall);
messages.add("[" + Iris.MODNAME + "] Shadow Distance Terrain: " + terrainFrustumHolder.getDistanceInfo() + " Entity: " + entityFrustumHolder.getDistanceInfo());
messages.add("[" + Iris.MODNAME + "] Shadow Culling Terrain: " + terrainFrustumHolder.getCullingInfo() + " Entity: " + entityFrustumHolder.getCullingInfo());
messages.add("[" + Iris.MODNAME + "] Shadow Terrain: " + debugStringTerrain + (shouldRenderTerrain ? "" : " (no terrain) ") + (shouldRenderTranslucent ? "" : "(no translucent)"));
messages.add("[" + Iris.MODNAME + "] Shadow Entities: " + getEntitiesDebugString());
messages.add("[" + Iris.MODNAME + "] Shadow Block Entities: " + getTileEntitiesDebugString());
messages.add("[" + Iris.MODNAME + " - Shadow Pass]");
messages.add(" Shadow Maps: " + debugStringOverall);
messages.add(" Shadow Distance Terrain: " + terrainFrustumHolder.getDistanceInfo() + " Entity: " + entityFrustumHolder.getDistanceInfo());
messages.add(" Shadow Culling Terrain: " + terrainFrustumHolder.getCullingInfo() + " Entity: " + entityFrustumHolder.getCullingInfo());
messages.add(" Shadow Terrain: " + CeleritasWorldRenderer.getInstance().getChunksDebugString() + (shouldRenderTerrain ? "" : " (no terrain) ") + (shouldRenderTranslucent ? "" : "(no translucent)"));
messages.add(" Shadow Entities: " + getEntitiesDebugString());
messages.add(" Shadow Block Entities: " + getTileEntitiesDebugString());
// if (buffers instanceof DrawCallTrackingRenderBuffers drawCallTracker && (shouldRenderEntities || shouldRenderPlayer)) {
// messages.add("[" + Iris.MODNAME + "] Shadow Entity Batching: " + BatchingDebugMessageHelper.getDebugMessage(drawCallTracker));