diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaChunkBuildContext.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaChunkBuildContext.java index 98725f8cf..17296e0ce 100644 --- a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaChunkBuildContext.java +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaChunkBuildContext.java @@ -6,13 +6,20 @@ import com.gtnewhorizons.angelica.dynamiclights.IDynamicLightSource; import java.util.List; import com.gtnewhorizons.angelica.rendering.celeritas.iris.BlockRenderContext; import com.gtnewhorizons.angelica.rendering.celeritas.iris.IrisExtendedChunkVertexEncoder; +import org.embeddedt.embeddium.impl.render.chunk.ChunkColorWriter; +import com.gtnewhorizons.angelica.rendering.celeritas.light.LightDataCache; +import com.gtnewhorizons.angelica.rendering.celeritas.light.VanillaDiffuseProvider; +import org.embeddedt.embeddium.impl.model.light.smooth.SmoothLightPipeline; import com.gtnewhorizons.angelica.rendering.celeritas.world.WorldSlice; import lombok.Getter; +import me.jellysquid.mods.sodium.client.SodiumClientMod; +import net.coderbot.iris.block_rendering.BlockRenderingSettings; import net.minecraft.client.Minecraft; import net.minecraft.client.multiplayer.WorldClient; +import net.minecraft.world.IBlockAccess; import net.minecraft.client.renderer.texture.TextureAtlasSprite; -import net.minecraft.client.renderer.texture.TextureMap; import net.minecraft.tileentity.TileEntity; +import org.embeddedt.embeddium.impl.model.light.data.QuadLightData; import org.embeddedt.embeddium.impl.model.quad.properties.ModelQuadFacing; import org.embeddedt.embeddium.impl.render.chunk.RenderPassConfiguration; import org.embeddedt.embeddium.impl.render.chunk.compile.ChunkBuildBuffers; @@ -26,20 +33,43 @@ import org.embeddedt.embeddium.impl.util.QuadUtil; public class AngelicaChunkBuildContext extends ChunkBuildContext { public static final int NUM_PASSES = 2; - private final TextureMap textureMap; + private final TextureMapExtension textureAtlas; private final ChunkVertexEncoder.Vertex[] vertices = ChunkVertexEncoder.Vertex.uninitializedQuad(); @Getter private final WorldSlice worldSlice; + @Getter private final BlockRenderContext blockRenderContext = new BlockRenderContext(); - /** Pre-filtered light sources for the current chunk being built. Null if dynamic lights disabled. */ private List chunkLightSources; private DynamicLights dynamicLightsInstance; + private final LightDataCache lightDataCache = new LightDataCache(); + private final SmoothLightPipeline smoothLightPipeline; + private final QuadLightData quadLightData = new QuadLightData(); + private final VertexArrayQuadView quadView; + private boolean lightPipelineReady = false; + private int originX, originY, originZ; + public AngelicaChunkBuildContext(RenderPassConfiguration renderPassConfiguration, WorldClient world) { super(renderPassConfiguration); - this.textureMap = Minecraft.getMinecraft().getTextureMapBlocks(); + this.textureAtlas = (TextureMapExtension) Minecraft.getMinecraft().getTextureMapBlocks(); this.worldSlice = new WorldSlice(world); + this.smoothLightPipeline = new SmoothLightPipeline(lightDataCache, VanillaDiffuseProvider.INSTANCE, false); + this.quadView = new VertexArrayQuadView(vertices); + } + + public void setupLightPipeline(int minBlockX, int minBlockY, int minBlockZ) { + setupLightPipeline(worldSlice, minBlockX, minBlockY, minBlockZ); + } + + public void setupLightPipeline(IBlockAccess blockAccess, int minBlockX, int minBlockY, int minBlockZ) { + this.originX = minBlockX; + this.originY = minBlockY; + this.originZ = minBlockZ; + lightDataCache.setWorld(blockAccess); + lightDataCache.reset(minBlockX, minBlockY, minBlockZ); + smoothLightPipeline.reset(); + lightPipelineReady = true; } public void setupDynamicLights(int chunkOriginX, int chunkOriginY, int chunkOriginZ) { @@ -52,18 +82,12 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext { } } - public BlockRenderContext getBlockRenderContext() { - return this.blockRenderContext; - } - private Material selectMaterial(Material material, TextureAtlasSprite sprite) { if (sprite != null && sprite.getClass() == TextureAtlasSprite.class && !sprite.hasAnimationMetadata()) { final var transparencyLevel = ((SpriteExtension)sprite).celeritas$getTransparencyLevel(); if (transparencyLevel == SpriteTransparencyLevel.OPAQUE && material == AngelicaRenderPassConfiguration.CUTOUT_MIPPED_MATERIAL) { - // Downgrade to solid return AngelicaRenderPassConfiguration.SOLID_MATERIAL; } else if (material == AngelicaRenderPassConfiguration.TRANSLUCENT_MATERIAL && transparencyLevel != SpriteTransparencyLevel.TRANSLUCENT) { - // Downgrade to cutout return AngelicaRenderPassConfiguration.CUTOUT_MIPPED_MATERIAL; } } @@ -71,8 +95,7 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext { } @SuppressWarnings("unchecked") - public void copyRawBuffer(int[] rawBuffer, int vertexCount, ChunkBuildBuffers buffers, Material material, - int originX, int originY, int originZ) { + public void copyRawBuffer(int[] rawBuffer, int vertexCount, ChunkBuildBuffers buffers, Material material) { if (vertexCount == 0) { return; } @@ -84,11 +107,10 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext { } final boolean hasDynamicLights = chunkLightSources != null && !chunkLightSources.isEmpty(); - - final var encoder = buffers.get(material).getEncoder(); - if (encoder instanceof IrisExtendedChunkVertexEncoder iris) { - iris.setContext(blockRenderContext); - } + final boolean separateAo = BlockRenderingSettings.INSTANCE.shouldUseSeparateAo(); + final boolean sodiumAo = SodiumClientMod.options().quality.useSodiumAO; + final boolean useAoCalculation = lightPipelineReady && (separateAo || sodiumAo); + final ChunkColorWriter colorEncoder = separateAo ? ChunkColorWriter.SEPARATE_AO : ChunkColorWriter.EMBEDDIUM; int ptr = 0; final int numQuads = vertexCount / 4; @@ -112,8 +134,42 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext { vertex.color = rawBuffer[ptr++]; vertex.vanillaNormal = rawBuffer[ptr++]; vertex.light = rawBuffer[ptr++]; + } - if (hasDynamicLights) { + final int trueNormal = QuadUtil.calculateNormal(vertices); + final ModelQuadFacing facing = QuadUtil.findNormalFace(trueNormal); + final TextureAtlasSprite sprite = this.textureAtlas.celeritas$findFromUV(uSum * 0.25f, vSum * 0.25f); + + if (sprite != null && sprite.hasAnimationMetadata()) { + animatedSprites.add(sprite); + } + + if (useAoCalculation) { + final int blockX = blockRenderContext.localPosX; + final int blockY = blockRenderContext.localPosY; + final int blockZ = blockRenderContext.localPosZ; + + quadView.setup(trueNormal, blockX, blockY, blockZ); + final ModelQuadFacing lightFace = quadView.getLightFace(); + + smoothLightPipeline.calculate(quadView, originX + blockX, originY + blockY, originZ + blockZ, quadLightData, lightFace, lightFace, false, true); + + for (int vIdx = 0; vIdx < 4; vIdx++) { + final var vertex = vertices[vIdx]; + vertex.trueNormal = trueNormal; + vertex.color = colorEncoder.writeColor(vertex.color, quadLightData.br[vIdx]); + vertex.light = quadLightData.lm[vIdx]; + } + } else { + for (int vIdx = 0; vIdx < 4; vIdx++) { + vertices[vIdx].trueNormal = trueNormal; + } + } + + // Apply dynamic lights after AO calculation so they're not overwritten + if (hasDynamicLights) { + for (int vIdx = 0; vIdx < 4; vIdx++) { + final var vertex = vertices[vIdx]; final double dynamicLevel = dynamicLightsInstance.getDynamicLightLevelFromSources( originX + vertex.x, originY + vertex.y, originZ + vertex.z, chunkLightSources); if (dynamicLevel > 0) { @@ -122,18 +178,6 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext { } } - final int trueNormal = QuadUtil.calculateNormal(vertices); - for (int vIdx = 0; vIdx < 4; vIdx++) { - vertices[vIdx].trueNormal = trueNormal; - } - - final ModelQuadFacing facing = QuadUtil.findNormalFace(trueNormal); - final TextureAtlasSprite sprite = ((TextureMapExtension) textureMap).celeritas$findFromUV(uSum * 0.25f, vSum * 0.25f); - - if (sprite != null && sprite.hasAnimationMetadata()) { - animatedSprites.add(sprite); - } - final Material correctMaterial = selectMaterial(material, sprite); final var builder = buffers.get(correctMaterial); diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaChunkBuilderMeshingTask.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaChunkBuilderMeshingTask.java index 6ae17708a..b058581bf 100644 --- a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaChunkBuilderMeshingTask.java +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaChunkBuilderMeshingTask.java @@ -218,10 +218,11 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask= absX && absY >= absZ) { + return ny >= 0 ? ModelQuadFacing.POS_Y : ModelQuadFacing.NEG_Y; + } else if (absX >= absZ) { + return nx >= 0 ? ModelQuadFacing.POS_X : ModelQuadFacing.NEG_X; + } else { + return nz >= 0 ? ModelQuadFacing.POS_Z : ModelQuadFacing.NEG_Z; + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/light/LightDataCache.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/light/LightDataCache.java new file mode 100644 index 000000000..8d90a95a2 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/light/LightDataCache.java @@ -0,0 +1,43 @@ +package com.gtnewhorizons.angelica.rendering.celeritas.light; + +import lombok.Setter; +import net.minecraft.block.Block; +import net.minecraft.world.IBlockAccess; +import org.embeddedt.embeddium.impl.model.light.data.LightDataAccess; + +@Setter +public class LightDataCache extends LightDataAccess { + private IBlockAccess world; + + @Override + protected int compute(int x, int y, int z) { + final IBlockAccess world = this.world; + final Block block = world.getBlock(x, y, z); + + final boolean fo = block.isOpaqueCube(); + final boolean fc = block.isNormalCube(); + final int lu = block.getLightValue(world, x, y, z); + + // Optimize: skip light calculation for opaque blocks with no luminance + final int bl, sl; + if (fo && lu == 0) { + bl = 0; + sl = 0; + } else { + final int packed = world.getLightBrightnessForSkyBlocks(x, y, z, 0); + bl = (packed >> 4) & 0xF; + sl = (packed >> 20) & 0xF; + } + + // AO value - blocks that emit light don't contribute to AO + final float ao = lu == 0 ? block.getAmbientOcclusionLightValue() : 1.0f; + + // Opacity check - true if block is view-blocking (solid blocks) + final boolean op = block.getMaterial().isOpaque() && block.getLightOpacity() > 0; + + // Emissive check - full bright if lightmap coords would be max (15, 15) + final boolean em = lu == 15; + + return packFC(fc) | packFO(fo) | packOP(op) | packEM(em) | packAO(ao) | packLU(lu) | packSL(sl) | packBL(bl); + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/light/VanillaDiffuseProvider.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/light/VanillaDiffuseProvider.java new file mode 100644 index 000000000..1a9cf4809 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/light/VanillaDiffuseProvider.java @@ -0,0 +1,35 @@ +package com.gtnewhorizons.angelica.rendering.celeritas.light; + +import org.embeddedt.embeddium.impl.model.light.DiffuseProvider; +import org.embeddedt.embeddium.impl.model.quad.properties.ModelQuadFacing; + +public enum VanillaDiffuseProvider implements DiffuseProvider { + INSTANCE; + + private static final float DOWN = 0.5f; // NEG_Y + private static final float UP = 1.0f; // POS_Y + private static final float NORTH_SOUTH = 0.8f; // NEG_Z, POS_Z + private static final float EAST_WEST = 0.6f; // NEG_X, POS_X + + @Override + public float getDiffuse(float normalX, float normalY, float normalZ, boolean shade) { + if (!shade) { + return 1.0f; + } + return Math.min(normalX * normalX * EAST_WEST + normalY * normalY * (normalY >= 0 ? UP : DOWN) + normalZ * normalZ * NORTH_SOUTH, 1.0f); + } + + @Override + public float getDiffuse(ModelQuadFacing lightFace, boolean shade) { + if (!shade) { + return 1.0f; + } + return switch (lightFace) { + case NEG_Y -> DOWN; + case POS_Y -> UP; + case NEG_Z, POS_Z -> NORTH_SOUTH; + case NEG_X, POS_X -> EAST_WEST; + case UNASSIGNED -> 1.0f; + }; + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/threading/ThreadedAngelicaChunkBuilderMeshingTask.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/threading/ThreadedAngelicaChunkBuilderMeshingTask.java index 1d294b34c..ca0879b81 100644 --- a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/threading/ThreadedAngelicaChunkBuilderMeshingTask.java +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/threading/ThreadedAngelicaChunkBuilderMeshingTask.java @@ -39,7 +39,8 @@ public class ThreadedAngelicaChunkBuilderMeshingTask extends AngelicaChunkBuilde @Override public ChunkBuildOutput execute(ChunkBuildContext context, CancellationToken cancellationToken) { - initBlockAccess((AngelicaChunkBuildContext) context); + final AngelicaChunkBuildContext buildContext = (AngelicaChunkBuildContext) context; + initBlockAccess(buildContext); return super.execute(context, cancellationToken); } @@ -54,12 +55,14 @@ public class ThreadedAngelicaChunkBuilderMeshingTask extends AngelicaChunkBuilde this.blockAccess = worldSlice; this.biomeColorCache = new SmoothBiomeColorCache(worldSlice); this.biomeColorCache.update(new SectionPos(this.render.getChunkX(), this.render.getChunkY(), this.render.getChunkZ())); + buildContext.setupLightPipeline(minX, minY, minZ); } else { // Fallback: direct world access (main thread only) final var world = Minecraft.getMinecraft().theWorld; this.biomeColorCache = ((WorldClientExtension) world).celeritas$getSmoothBiomeColorCache(); this.biomeColorCache.update(new SectionPos(this.render.getChunkX(), this.render.getChunkY(), this.render.getChunkZ())); this.blockAccess = new ChunkCache(world, minX - 1, minY - 1, minZ - 1, minX + 17, minY + 17, minZ + 17, 1); + buildContext.setupLightPipeline(this.blockAccess, minX, minY, minZ); } } diff --git a/src/main/java/net/coderbot/iris/shaderpack/PackDirectives.java b/src/main/java/net/coderbot/iris/shaderpack/PackDirectives.java index 65fa595f2..c86f59572 100644 --- a/src/main/java/net/coderbot/iris/shaderpack/PackDirectives.java +++ b/src/main/java/net/coderbot/iris/shaderpack/PackDirectives.java @@ -77,7 +77,7 @@ public class PackDirectives { sun = properties.getSun().orElse(true); moon = properties.getMoon().orElse(true); rainDepth = properties.getRainDepth().orElse(false); - separateAo = false; //properties.getSeparateAo().orElse(false); + separateAo = properties.getSeparateAo().orElse(false); voxelizeLightBlocks = properties.getVoxelizeLightBlocks().orElse(false); separateEntityDraws = properties.getSeparateEntityDraws().orElse(false); frustumCulling = properties.getFrustumCulling().orElse(true);