diff --git a/README.MD b/README.MD index 48cf9feb2..39028e32d 100644 --- a/README.MD +++ b/README.MD @@ -9,8 +9,8 @@ ## **Beta Quality - Here there be Dragons** * Shaders - Beta - * Complementary & BSL mostly function, but have some bugs - * Sildurs, Seus, and any other shader probably doesn't work + * Complementary + Euphoria Patches is the primary compatibility target + * Sildurs, Seus, and any other shaders might work # Required Dependencies @@ -38,7 +38,7 @@ * [Amazing Trophies 1.2.1 and below](https://github.com/GTNewHorizons/Amazing-Trophies/releases) - Use 1.2.2+ * [LWJGL3ify 1.5.4 and below](https://github.com/GTNewHorizons/lwjgl3ify/releases/) - Use the latest version available, 1.5.7+ * [ArchaicFix 0.6.2 and below](https://www.curseforge.com/minecraft/mc-mods/archaicfix/files/all?page=1&pageSize=20) - Use 0.7.0 or above -* [Hodgepodge 2.4.3 and below](https://github.com/GTNewHorizons/Hodgepodge/releases) - Use 0.4.5 or above +* [Hodgepodge 2.4.3 and below](https://github.com/GTNewHorizons/Hodgepodge/releases) - Use 2.4.5 or above * CodeChicken[Core](https://github.com/GTNewHorizons/CodeChickenCore/releases)/[Lib](https://github.com/GTNewHorizons/CodeChickenLib/releases) <1.2.0 - Threading issues, use 1.3.0+ * Neodymium - Untested, but unlikely to be compatible. (Chunk Meshing is definitely incompatible, other features might work depending on config) * SmoothFont - Equivalent functionality added diff --git a/build.gradle.kts b/build.gradle.kts index 86409790e..4971ff9c9 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -42,3 +42,12 @@ tasks.register("copyDependencies") { from(configurations.default) into("testDependencies") } + +val embedOnly: Configuration by configurations + +tasks.shadowJar { + from(embedOnly.map(::zipTree)) + relocate("com.mitchej123", "com.mitchej123") + relocate("org.embeddedt", "org.embeddedt") +} + diff --git a/dependencies.gradle b/dependencies.gradle index 42d885a6c..db7736bc9 100644 --- a/dependencies.gradle +++ b/dependencies.gradle @@ -46,6 +46,13 @@ configurations { // Can be enabled for testing if desired // runtimeClasspath.extendsFrom(transformedMod) // testRuntimeClasspath.extendsFrom(transformedMod) + + // Embed in JAR without relocation (compile only, shadowed into JAR) + embedOnly + embedOnly.canBeConsumed = false + embedOnly.canBeResolved = true + compileClasspath.extendsFrom(embedOnly) + testCompileClasspath.extendsFrom(embedOnly) } dependencies { @@ -67,8 +74,8 @@ dependencies { compileOnly "org.apache.ant:ant:1.8.2" // Celeritas (transitive=false: deps provided by GTNHLib/runtime) - shadowImplementation("org.embeddedt.celeritas:celeritas-common:2.4.0-dev") { transitive = false } - shadowImplementation("org.embeddedt.celeritas:celeritas-lwjgl2-service:2.4.0-dev") { transitive = false } + embedOnly("org.embeddedt.celeritas:celeritas-common:2.5.0-GTNH") { transitive = false } + embedOnly("org.embeddedt.celeritas:celeritas-lwjgl2-service:2.5.0-GTNH") { transitive = false } // Because who doesn't want NEI devOnlyNonPublishable('com.github.GTNewHorizons:NotEnoughItems:2.8.35-GTNH:dev') diff --git a/settings.gradle.kts b/settings.gradle.kts index 78dd7fdbc..3557e0d6e 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -16,5 +16,5 @@ pluginManagement { } plugins { - id("com.gtnewhorizons.gtnhsettingsconvention") version("2.0.99") + id("com.gtnewhorizons.gtnhsettingsconvention") version("2.0.11") } diff --git a/src/main/java/com/gtnewhorizons/angelica/AngelicaMod.java b/src/main/java/com/gtnewhorizons/angelica/AngelicaMod.java index 02d802e6b..2d6db742a 100644 --- a/src/main/java/com/gtnewhorizons/angelica/AngelicaMod.java +++ b/src/main/java/com/gtnewhorizons/angelica/AngelicaMod.java @@ -9,6 +9,8 @@ import com.gtnewhorizons.angelica.utils.AnimationMode; import com.gtnewhorizons.angelica.utils.ManagedEnum; import cpw.mods.fml.common.Mod; import cpw.mods.fml.common.SidedProxy; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; import cpw.mods.fml.common.event.FMLInitializationEvent; import cpw.mods.fml.common.event.FMLPostInitializationEvent; import cpw.mods.fml.common.event.FMLPreInitializationEvent; @@ -29,6 +31,7 @@ import cpw.mods.fml.common.event.FMLPreInitializationEvent; guiFactory = "com.gtnewhorizons.angelica.config.AngelicaGuiConfigFactory") public class AngelicaMod { public static final String MOD_ID = "angelica"; + public static final Logger LOGGER = LogManager.getLogger("Angelica"); @SidedProxy(clientSide = "com.gtnewhorizons.angelica.proxy.ClientProxy", serverSide = "com.gtnewhorizons.angelica.proxy.CommonProxy") public static CommonProxy proxy; diff --git a/src/main/java/com/gtnewhorizons/angelica/api/TextureServices.java b/src/main/java/com/gtnewhorizons/angelica/api/TextureServices.java index 97a35bb7f..daa66c6c6 100644 --- a/src/main/java/com/gtnewhorizons/angelica/api/TextureServices.java +++ b/src/main/java/com/gtnewhorizons/angelica/api/TextureServices.java @@ -1,7 +1,7 @@ package com.gtnewhorizons.angelica.api; -import com.gtnewhorizons.angelica.mixins.interfaces.IPatchedTextureAtlasSprite; import com.gtnewhorizons.angelica.mixins.interfaces.ITexturesCache; +import com.gtnewhorizons.angelica.rendering.celeritas.SpriteExtension; import net.minecraft.client.renderer.RenderBlocks; import net.minecraft.util.IIcon; @@ -20,8 +20,8 @@ public class TextureServices { @SuppressWarnings("unused") public static void updateTextureAnimation(IIcon icon) { - if(icon instanceof IPatchedTextureAtlasSprite patchedSprite) { - patchedSprite.markNeedsAnimationUpdate(); + if (icon instanceof SpriteExtension ext) { + ext.celeritas$markActive(); } } } diff --git a/src/main/java/com/gtnewhorizons/angelica/compat/bettercrashes/BetterCrashesCompat.java b/src/main/java/com/gtnewhorizons/angelica/compat/bettercrashes/BetterCrashesCompat.java index cfa4b3464..a5e5cec00 100644 --- a/src/main/java/com/gtnewhorizons/angelica/compat/bettercrashes/BetterCrashesCompat.java +++ b/src/main/java/com/gtnewhorizons/angelica/compat/bettercrashes/BetterCrashesCompat.java @@ -27,7 +27,7 @@ public class BetterCrashesCompat implements StateManager.IResettable { @Override public void resetState() { LOGGER.info("Reloading SodiumRenderer"); - ((IRenderGlobalExt) Minecraft.getMinecraft().renderGlobal).reload(); + ((IRenderGlobalExt) Minecraft.getMinecraft().renderGlobal).angelica$reload(); LOGGER.info("Resetting GLStateManager"); GLStateManager.reset(); } diff --git a/src/main/java/com/gtnewhorizons/angelica/compat/toremove/MatrixStack.java b/src/main/java/com/gtnewhorizons/angelica/compat/toremove/MatrixStack.java index f3babdbde..04f1d0527 100644 --- a/src/main/java/com/gtnewhorizons/angelica/compat/toremove/MatrixStack.java +++ b/src/main/java/com/gtnewhorizons/angelica/compat/toremove/MatrixStack.java @@ -34,10 +34,17 @@ public class MatrixStack { public void pop() { this.matrixStack.removeLast(); } - public boolean clear() { + public boolean isEmpty() { return this.matrixStack.size() == 1; } + public void reset() { + while (this.matrixStack.size() > 1) { + this.matrixStack.removeLast(); + } + loadIdentity(); + } + public void translate(double d, double e, double f) { final Entry lv = (Entry)this.matrixStack.getLast(); lv.model.translate((float)d, (float)e, (float)f); diff --git a/src/main/java/com/gtnewhorizons/angelica/config/AngelicaConfig.java b/src/main/java/com/gtnewhorizons/angelica/config/AngelicaConfig.java index 52507650b..91a958b25 100644 --- a/src/main/java/com/gtnewhorizons/angelica/config/AngelicaConfig.java +++ b/src/main/java/com/gtnewhorizons/angelica/config/AngelicaConfig.java @@ -4,10 +4,21 @@ import com.gtnewhorizon.gtnhlib.config.Config; @Config(modid = "angelica", filename = "angelica-modules") public class AngelicaConfig { - @Config.Comment("Enable Sodium rendering") + @Config.Comment("Enable Celeritas terrain rendering") @Config.DefaultBoolean(true) @Config.RequiresMcRestart - public static boolean enableSodium; + public static boolean enableCeleritas; + + @Config.Comment("Enable multi-threaded chunk building for improved performance [Requires Celeritas]") + @Config.DefaultBoolean(true) + @Config.RequiresWorldRestart + public static boolean enableThreadedChunkBuilding; + + @Config.Comment("Number of chunk builder threads. 0 = auto-detect, -1 = use single-threaded fallback") + @Config.DefaultInt(0) + @Config.RangeInt(min = -1, max = 16) + @Config.RequiresWorldRestart + public static int chunkBuilderThreadCount; @Config.Comment("Enable NotFine Options") @Config.DefaultBoolean(false) @@ -17,11 +28,6 @@ public class AngelicaConfig { @Config.DefaultBoolean(true) public static boolean enableReesesSodiumOptions; - @Config.Comment("Enable Sodium fluid rendering [Experimental]") - @Config.DefaultBoolean(false) - @Config.RequiresMcRestart - public static boolean enableSodiumFluidRendering; - @Config.Comment("Inject BakedModel rendering into some vanilla blocks") @Config.DefaultBoolean(false) @Config.RequiresMcRestart @@ -32,7 +38,7 @@ public class AngelicaConfig { @Config.Ignore() public static boolean enableTestBlocks; - @Config.Comment("Enable Iris Shaders [Requires Sodium]") + @Config.Comment("Enable Iris Shaders [Requires Celeritas]") @Config.DefaultBoolean(true) @Config.RequiresMcRestart public static boolean enableIris; diff --git a/src/main/java/com/gtnewhorizons/angelica/dynamiclights/DynamicLights.java b/src/main/java/com/gtnewhorizons/angelica/dynamiclights/DynamicLights.java index 27a33dab8..93becc906 100644 --- a/src/main/java/com/gtnewhorizons/angelica/dynamiclights/DynamicLights.java +++ b/src/main/java/com/gtnewhorizons/angelica/dynamiclights/DynamicLights.java @@ -10,7 +10,6 @@ import com.gtnewhorizons.angelica.compat.battlegear2.Battlegear2Compat; import com.gtnewhorizons.angelica.config.AngelicaConfig; import it.unimi.dsi.fastutil.longs.LongOpenHashSet; import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet; -import me.jellysquid.mods.sodium.client.render.SodiumWorldRenderer; import mods.battlegear2.api.core.IBattlePlayer; import net.irisshaders.iris.api.v0.IrisApi; import net.minecraft.block.Block; @@ -34,6 +33,7 @@ import java.util.function.Predicate; public class DynamicLights { private static DynamicLights instance; + private static IDynamicLightWorldRenderer activeRenderer; public static DynamicLightsMode Mode = DynamicLightsMode.OFF; public static boolean ShaderForce = false; @@ -60,12 +60,20 @@ public class DynamicLights { (ShaderForce || !IrisApi.getInstance().isShaderPackInUse()); } + public static IDynamicLightWorldRenderer getActiveRenderer() { + return activeRenderer; + } + + public static void setActiveRenderer(IDynamicLightWorldRenderer renderer) { + activeRenderer = renderer; + } + /** * Updates all light sources. * * @param renderer the renderer */ - public void updateAll(@NotNull SodiumWorldRenderer renderer) { + public void updateAll(@NotNull IDynamicLightWorldRenderer renderer) { if (!isEnabled()) return; @@ -107,8 +115,8 @@ public class DynamicLights { it = dynamicLightSources.next(); if (it.equals(lightSource)) { dynamicLightSources.remove(); - if (SodiumWorldRenderer.getInstance() != null) - lightSource.angelica$scheduleTrackedChunksRebuild(SodiumWorldRenderer.getInstance()); + if (activeRenderer != null) + lightSource.angelica$scheduleTrackedChunksRebuild(activeRenderer); break; } } @@ -130,10 +138,10 @@ public class DynamicLights { it = dynamicLightSources.next(); if (filter.test(it)) { dynamicLightSources.remove(); - if (SodiumWorldRenderer.getInstance() != null) { + if (activeRenderer != null) { if (it.angelica$getLuminance() > 0) it.angelica$resetDynamicLight(); - it.angelica$scheduleTrackedChunksRebuild(SodiumWorldRenderer.getInstance()); + it.angelica$scheduleTrackedChunksRebuild(activeRenderer); } break; } @@ -153,10 +161,10 @@ public class DynamicLights { while (dynamicLightSources.hasNext()) { it = dynamicLightSources.next(); dynamicLightSources.remove(); - if (SodiumWorldRenderer.getInstance() != null) { + if (activeRenderer != null) { if (it.angelica$getLuminance() > 0) it.angelica$resetDynamicLight(); - it.angelica$scheduleTrackedChunksRebuild(SodiumWorldRenderer.getInstance()); + it.angelica$scheduleTrackedChunksRebuild(activeRenderer); } } @@ -203,6 +211,20 @@ public class DynamicLights { return MathHelper.clamp_double(result, 0, 15); } + /** + * Gets dynamic light level at an exact world position (for smooth per-vertex lighting). + */ + public double getDynamicLightLevel(double x, double y, double z) { + double result = 0; + this.lightSourcesLock.readLock().lock(); + for (var lightSource : this.dynamicLightSources) { + result = maxDynamicLightLevelExact(x, y, z, lightSource, result); + } + this.lightSourcesLock.readLock().unlock(); + + return MathHelper.clamp_double(result, 0, 15); + } + public double getDynamicLightLevel(@NotNull BlockPos pos) { return this.getDynamicLightLevel(pos.getX(), pos.getY(), pos.getZ()); } @@ -229,6 +251,29 @@ public class DynamicLights { return currentLightLevel; } + /** + * Calculates dynamic light level at an exact position (no block center offset). + * Used for smooth per-vertex lighting. + */ + public static double maxDynamicLightLevelExact(double x, double y, double z, @NotNull IDynamicLightSource lightSource, double currentLightLevel) { + int luminance = lightSource.angelica$getLuminance(); + if (luminance > 0) { + double dx = x - lightSource.angelica$getDynamicLightX(); + double dy = y - lightSource.angelica$getDynamicLightY(); + double dz = z - lightSource.angelica$getDynamicLightZ(); + + double distanceSquared = dx * dx + dy * dy + dz * dz; + if (distanceSquared <= MAX_RADIUS_SQUARED) { + double multiplier = 1.0 - Math.sqrt(distanceSquared) / MAX_RADIUS; + double lightLevel = multiplier * (double) luminance; + if (lightLevel > currentLightLevel) { + return lightLevel; + } + } + } + return currentLightLevel; + } + /** * Returns the dynamic light level generated by the light source at the specified position. * @@ -275,7 +320,7 @@ public class DynamicLights { * @param renderer the renderer * @param chunkPos the chunk position */ - public static void scheduleChunkRebuild(@NotNull SodiumWorldRenderer renderer, @NotNull IBlockPos chunkPos) { + public static void scheduleChunkRebuild(@NotNull IDynamicLightWorldRenderer renderer, @NotNull IBlockPos chunkPos) { scheduleChunkRebuild(renderer, chunkPos.getX(), chunkPos.getY(), chunkPos.getZ()); } @@ -285,11 +330,11 @@ public class DynamicLights { * @param renderer the renderer * @param chunkPos the packed chunk position */ - public static void scheduleChunkRebuild(@NotNull SodiumWorldRenderer renderer, long chunkPos) { + public static void scheduleChunkRebuild(@NotNull IDynamicLightWorldRenderer renderer, long chunkPos) { scheduleChunkRebuild(renderer, CoordinatePacker.unpackX(chunkPos), CoordinatePacker.unpackY(chunkPos), CoordinatePacker.unpackZ(chunkPos)); } - public static void scheduleChunkRebuild(@NotNull SodiumWorldRenderer renderer, int x, int y, int z) { + public static void scheduleChunkRebuild(@NotNull IDynamicLightWorldRenderer renderer, int x, int y, int z) { renderer.scheduleRebuildForChunk(x, y, z, false); } diff --git a/src/main/java/com/gtnewhorizons/angelica/dynamiclights/IDynamicLightSource.java b/src/main/java/com/gtnewhorizons/angelica/dynamiclights/IDynamicLightSource.java index 9ebc841fe..fd6791ca3 100644 --- a/src/main/java/com/gtnewhorizons/angelica/dynamiclights/IDynamicLightSource.java +++ b/src/main/java/com/gtnewhorizons/angelica/dynamiclights/IDynamicLightSource.java @@ -1,6 +1,5 @@ package com.gtnewhorizons.angelica.dynamiclights; -import me.jellysquid.mods.sodium.client.render.SodiumWorldRenderer; import org.jetbrains.annotations.ApiStatus; import org.jetbrains.annotations.NotNull; @@ -27,11 +26,13 @@ public interface IDynamicLightSource { double angelica$getDynamicLightZ(); /** - * Returns the dynamic light source world. + * Returns the dynamic light source world renderer. * - * @return the world instance + * @return the world renderer instance */ - SodiumWorldRenderer angelica$getDynamicLightWorld(); + default IDynamicLightWorldRenderer angelica$getDynamicLightWorld() { + return DynamicLights.getActiveRenderer(); + } /** * Returns whether the dynamic light is enabled or not. @@ -73,7 +74,7 @@ public interface IDynamicLightSource { */ void angelica$dynamicLightTick(); - boolean angelica$updateDynamicLight(@NotNull SodiumWorldRenderer renderer); + boolean angelica$updateDynamicLight(@NotNull IDynamicLightWorldRenderer renderer); - void angelica$scheduleTrackedChunksRebuild(@NotNull SodiumWorldRenderer renderer); + void angelica$scheduleTrackedChunksRebuild(@NotNull IDynamicLightWorldRenderer renderer); } diff --git a/src/main/java/com/gtnewhorizons/angelica/dynamiclights/IDynamicLightWorldRenderer.java b/src/main/java/com/gtnewhorizons/angelica/dynamiclights/IDynamicLightWorldRenderer.java new file mode 100644 index 000000000..9bcc9ed7c --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/dynamiclights/IDynamicLightWorldRenderer.java @@ -0,0 +1,17 @@ +package com.gtnewhorizons.angelica.dynamiclights; + +/** + * Common interface for world renderers that support dynamic lights chunk rebuilds. + * Implemented by CeleritasWorldRenderer. + */ +public interface IDynamicLightWorldRenderer { + /** + * Schedules a chunk rebuild for the render section at the given chunk coordinates. + */ + void scheduleRebuildForChunk(int x, int y, int z, boolean important); + + /** + * Returns whether this renderer is currently active (has a world loaded). + */ + boolean isActive(); +} diff --git a/src/main/java/com/gtnewhorizons/angelica/glsm/AngelicaFogService.java b/src/main/java/com/gtnewhorizons/angelica/glsm/AngelicaFogService.java new file mode 100644 index 000000000..06cfabf13 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/glsm/AngelicaFogService.java @@ -0,0 +1,52 @@ +package com.gtnewhorizons.angelica.glsm; + +import org.embeddedt.embeddium.impl.render.chunk.fog.FogService; +import org.embeddedt.embeddium.impl.render.chunk.shader.ChunkFogMode; + +public class AngelicaFogService implements FogService { + private final float[] fogColorArray = new float[4]; + + @Override + public float getFogEnd() { + return GLStateManager.getFogState().getEnd(); + } + + @Override + public float getFogStart() { + return GLStateManager.getFogState().getStart(); + } + + @Override + public float getFogDensity() { + return GLStateManager.getFogState().getDensity(); + } + + @Override + public int getFogShapeIndex() { + return 0; // 1.7.10 only has one fog shape + } + + @Override + public float getFogCutoff() { + return getFogEnd(); + } + + @Override + public float[] getFogColor() { + final var fogState = GLStateManager.getFogState(); + final var color = fogState.getFogColor(); + fogColorArray[0] = (float) color.x; + fogColorArray[1] = (float) color.y; + fogColorArray[2] = (float) color.z; + fogColorArray[3] = fogState.getFogAlpha(); + return fogColorArray; + } + + @Override + public ChunkFogMode getFogMode() { + if (!GLStateManager.getFogMode().isEnabled()) { + return ChunkFogMode.NONE; + } + return ChunkFogMode.fromGLMode(GLStateManager.getFogState().getFogMode()); + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/glsm/AngelicaGLStateManagerService.java b/src/main/java/com/gtnewhorizons/angelica/glsm/AngelicaGLStateManagerService.java new file mode 100644 index 000000000..770f6029d --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/glsm/AngelicaGLStateManagerService.java @@ -0,0 +1,369 @@ +package com.gtnewhorizons.angelica.glsm; + +import com.mitchej123.glsm.GLStateManagerService; +import org.lwjgl.BufferUtils; +import org.lwjgl.opengl.GL11; +import org.lwjgl.opengl.GL13; +import org.lwjgl.opengl.GL15; +import org.lwjgl.opengl.GL20; +import org.lwjgl.opengl.GL30; + +import java.nio.IntBuffer; + +public class AngelicaGLStateManagerService implements GLStateManagerService { + + private IntBuffer intArrayBuffer = BufferUtils.createIntBuffer(16); + + private IntBuffer getIntArrayBuffer(int size) { + if (intArrayBuffer.capacity() < size) { + intArrayBuffer = BufferUtils.createIntBuffer(size); + } + intArrayBuffer.clear(); + return intArrayBuffer; + } + + @Override + public int getPriority() { + return 100; + } + + // ===================== QUERY OPERATIONS ===================== + + @Override + public int glGetInteger(int pname) { + return GLStateManager.glGetInteger(pname); + } + + @Override + public String glGetString(int pname) { + return GL11.glGetString(pname); + } + + // ===================== FRAMEBUFFER OPERATIONS ===================== + + @Override + public int glGenFramebuffers() { + return GL30.glGenFramebuffers(); + } + + @Override + public void glDeleteFramebuffers(int framebuffer) { + GL30.glDeleteFramebuffers(framebuffer); + } + + @Override + public void glBindFramebuffer(int target, int framebuffer) { + GL30.glBindFramebuffer(target, framebuffer); + } + + @Override + public int glCheckFramebufferStatus(int target) { + return GL30.glCheckFramebufferStatus(target); + } + + @Override + public void glFramebufferTexture2D(int target, int attachment, int textarget, int texture, int level) { + GL30.glFramebufferTexture2D(target, attachment, textarget, texture, level); + } + + // ===================== SHADER OPERATIONS ===================== + + @Override + public int glCreateShader(int type) { + return GL20.glCreateShader(type); + } + + @Override + public void glCompileShader(int shader) { + GL20.glCompileShader(shader); + } + + @Override + public int glGetShaderi(int shader, int pname) { + return GL20.glGetShaderi(shader, pname); + } + + @Override + public String glGetShaderInfoLog(int shader, int maxLength) { + return GL20.glGetShaderInfoLog(shader, maxLength); + } + + @Override + public void glDeleteShader(int shader) { + GL20.glDeleteShader(shader); + } + + @Override + public int glCreateProgram() { + return GL20.glCreateProgram(); + } + + @Override + public void glAttachShader(int program, int shader) { + GL20.glAttachShader(program, shader); + } + + @Override + public void glLinkProgram(int program) { + GL20.glLinkProgram(program); + } + + @Override + public int glGetProgrami(int program, int pname) { + return GL20.glGetProgrami(program, pname); + } + + @Override + public void glUseProgram(int program) { + GLStateManager.glUseProgram(program); + } + + @Override + public void glDeleteProgram(int program) { + GL20.glDeleteProgram(program); + } + + // ===================== UNIFORM/ATTRIBUTE OPERATIONS ===================== + + @Override + public int glGetUniformLocation(int program, CharSequence name) { + return GL20.glGetUniformLocation(program, name); + } + + @Override + public void glUniform1i(int location, int value) { + GL20.glUniform1i(location, value); + } + + @Override + public int glGetAttribLocation(int program, CharSequence name) { + return GL20.glGetAttribLocation(program, name); + } + + @Override + public void glBindAttribLocation(int program, int index, CharSequence name) { + GL20.glBindAttribLocation(program, index, name); + } + + // ===================== VAO OPERATIONS ===================== + + @Override + public int glGenVertexArrays() { + return GL30.glGenVertexArrays(); + } + + @Override + public void glBindVertexArray(int array) { + GL30.glBindVertexArray(array); + } + + @Override + public void glDeleteVertexArrays(int array) { + GL30.glDeleteVertexArrays(array); + } + + // ===================== BUFFER OPERATIONS ===================== + + @Override + public int glGenBuffers() { + return GL15.glGenBuffers(); + } + + @Override + public void glBindBuffer(int target, int buffer) { + GL15.glBindBuffer(target, buffer); + } + + @Override + public void glDeleteBuffers(int buffer) { + GL15.glDeleteBuffers(buffer); + } + + // ===================== TEXTURE OPERATIONS ===================== + + @Override + public int glGenTextures() { + return GL11.glGenTextures(); + } + + @Override + public void glGenTextures(int[] textures) { + IntBuffer buffer = getIntArrayBuffer(textures.length); + GL11.glGenTextures(buffer); + buffer.get(textures); + } + + @Override + public void glDeleteTextures(int texture) { + GLStateManager.glDeleteTextures(texture); + } + + @Override + public void glDeleteTextures(int[] textures) { + IntBuffer buffer = getIntArrayBuffer(textures.length); + buffer.put(textures); + buffer.flip(); + GLStateManager.glDeleteTextures(buffer); + } + + @Override + public void glActiveTexture(int texture) { + GLStateManager.glActiveTexture(texture); + } + + @Override + public int glGetTexLevelParameteri(int target, int level, int pname) { + return GLStateManager.glGetTexLevelParameteri(target, level, pname); + } + + @Override + public int glGetTexLevelParameter(int target, int level, int pname) { + return GLStateManager.glGetTexLevelParameteri(target, level, pname); + } + + @Override + public void glCopyTexSubImage2D(int target, int level, int xoffset, int yoffset, int x, int y, int width, int height) { + GL11.glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); + } + + @Override + public void glPixelStorei(int pname, int param) { + GLStateManager.glPixelStorei(pname, param); + } + + // ===================== STATE OPERATIONS ===================== + + @Override + public void enableCullFace() { + GLStateManager.enableCull(); + } + + @Override + public void disableCullFace() { + GLStateManager.disableCull(); + } + + @Override + public void enableBlend() { + GLStateManager.enableBlend(); + } + + @Override + public void disableBlend() { + GLStateManager.disableBlend(); + } + + @Override + public void glBlendFuncSeparate(int srcRGB, int dstRGB, int srcAlpha, int dstAlpha) { + GLStateManager.tryBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); + } + + @Override + public void enableDepthTest() { + GLStateManager.enableDepthTest(); + } + + @Override + public void disableDepthTest() { + GLStateManager.disableDepthTest(); + } + + @Override + public void glDepthFunc(int func) { + GLStateManager.glDepthFunc(func); + } + + @Override + public void glDepthMask(boolean flag) { + GLStateManager.glDepthMask(flag); + } + + @Override + public void glViewport(int x, int y, int width, int height) { + GLStateManager.glViewport(x, y, width, height); + } + + @Override + public void glColorMask(boolean red, boolean green, boolean blue, boolean alpha) { + GLStateManager.glColorMask(red, green, blue, alpha); + } + + @Override + public void glClearColor(float red, float green, float blue, float alpha) { + GLStateManager.glClearColor(red, green, blue, alpha); + } + + @Override + public void glClear(int mask) { + GLStateManager.glClear(mask); + } + + // ===================== MOJANG ADDITIONS ===================== + + @Override + public void clear(int mask, boolean checkError) { + GLStateManager.glClear(mask); + } + + @Override + public void bindTexture(int texture) { + GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texture); + } + + @Override + public int getActiveTexture() { + return GLStateManager.getActiveTextureUnit() + GL13.GL_TEXTURE0; + } + + @Override + public int getActiveTextureAccessor() { + return GLStateManager.getActiveTextureUnit(); + } + + @Override + public int getBoundTexture(int internalUnit) { + return GLStateManager.getBoundTextureForServerState(internalUnit); + } + + @Override + public int getActiveBoundTexture() { + return GLStateManager.getBoundTextureForServerState(); + } + + @Override + public int getViewportWidth() { + return GLStateManager.getViewportState().width; + } + + @Override + public int getViewportHeight() { + return GLStateManager.getViewportState().height; + } + + @Override + public boolean getDepthStateMask() { + return GLStateManager.getDepthState().isEnabled(); + } + + @Override + public boolean isBlendEnabled() { + return GLStateManager.getBlendMode().isEnabled(); + } + + @Override + public void setBoundTexture(int unit, int texture) { + int currentUnit = GLStateManager.getActiveTextureUnit(); + if (currentUnit != unit) { + GLStateManager.glActiveTexture(GL13.GL_TEXTURE0 + unit); + } + GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texture); + if (currentUnit != unit) { + GLStateManager.glActiveTexture(GL13.GL_TEXTURE0 + currentUnit); + } + } + + @Override + public int getTextureBinding(int unit) { + return GLStateManager.getBoundTextureForServerState(unit); + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/glsm/AngelicaRenderSystemService.java b/src/main/java/com/gtnewhorizons/angelica/glsm/AngelicaRenderSystemService.java new file mode 100644 index 000000000..a8d8c2040 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/glsm/AngelicaRenderSystemService.java @@ -0,0 +1,244 @@ +package com.gtnewhorizons.angelica.glsm; + +import com.mitchej123.glsm.RenderSystemService; +import org.joml.Matrix4f; +import org.lwjgl.BufferUtils; +import org.lwjgl.opengl.GL11; +import org.lwjgl.opengl.GL20; + +import java.nio.FloatBuffer; + +public class AngelicaRenderSystemService implements RenderSystemService { + + // Shader state (Mojang-specific, tracked here) + private final int[] shaderTextures = new int[16]; + private final float[] shaderColor = {1f, 1f, 1f, 1f}; + private final float[] shaderFogColor = {0f, 0f, 0f, 1f}; + private float shaderFogStart = 0f; + private float shaderFogEnd = 0f; + private int fogShape = 0; + private float shaderLineWidth = 1f; + private final Matrix4f projectionMatrix = new Matrix4f(); + private final FloatBuffer projectionMatrixBuffer = BufferUtils.createFloatBuffer(16); + + @Override + public int getPriority() { + return 100; + } + + // ===================== TEXTURE OPERATIONS ===================== + + @Override + public void glActiveTexture(int texture) { + GLStateManager.glActiveTexture(texture); + } + + @Override + public void bindTexture(int texture) { + GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texture); + } + + // ===================== STATE OPERATIONS ===================== + + @Override + public void enableCullFace() { + GLStateManager.enableCull(); + } + + @Override + public void disableCullFace() { + GLStateManager.disableCull(); + } + + @Override + public void enableBlend() { + GLStateManager.enableBlend(); + } + + @Override + public void disableBlend() { + GLStateManager.disableBlend(); + } + + @Override + public void defaultBlendFunc() { + GLStateManager.defaultBlendFunc(); + } + + @Override + public void blendFuncSeparate(int srcRGB, int dstRGB, int srcAlpha, int dstAlpha) { + GLStateManager.tryBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); + } + + @Override + public void setUnknownBlendState() { + // No-op: Angelica tracks blend state accurately + } + + @Override + public void enableDepthTest() { + GLStateManager.enableDepthTest(); + } + + @Override + public void disableDepthTest() { + GLStateManager.disableDepthTest(); + } + + @Override + public void depthFunc(int depthFunc) { + GLStateManager.glDepthFunc(depthFunc); + } + + @Override + public void depthMask(boolean flag) { + GLStateManager.glDepthMask(flag); + } + + @Override + public void glViewport(int x, int y, int width, int height) { + GLStateManager.glViewport(x, y, width, height); + } + + @Override + public void glClearColor(float red, float green, float blue, float alpha) { + GLStateManager.glClearColor(red, green, blue, alpha); + } + + @Override + public void clear(int mask, boolean checkError) { + GLStateManager.glClear(mask); + } + + // ===================== UNIFORM OPERATIONS ===================== + + @Override + public void glUniform1i(int location, int value) { + GL20.glUniform1i(location, value); + } + + @Override + public void glUniformMatrix3(int location, boolean transpose, FloatBuffer value) { + GL20.glUniformMatrix3(location, transpose, value); + } + + @Override + public void glUniformMatrix4(int location, boolean transpose, FloatBuffer value) { + GL20.glUniformMatrix4(location, transpose, value); + } + + // ===================== THREAD ASSERTIONS ===================== + + @Override + public void assertOnRenderThread() { + // No-op: 1.7.10 is single-threaded for rendering + } + + @Override + public void assertOnRenderThreadOrInit() { + // No-op: 1.7.10 is single-threaded for rendering + } + + // ===================== SHADER STATE ===================== + + @Override + public void setShaderTexture(int shaderTexture, int textureId) { + if (shaderTexture >= 0 && shaderTexture < 16) { + shaderTextures[shaderTexture] = textureId; + } + } + + @Override + public int getShaderTexture(int shaderTexture) { + return (shaderTexture >= 0 && shaderTexture < 16) ? shaderTextures[shaderTexture] : 0; + } + + @Override + public void setShaderColor(float red, float green, float blue, float alpha) { + shaderColor[0] = red; + shaderColor[1] = green; + shaderColor[2] = blue; + shaderColor[3] = alpha; + } + + @Override + public float[] getShaderColor() { + return shaderColor.clone(); + } + + @Override + public void setShaderLineWidth(float lineWidth) { + shaderLineWidth = lineWidth; + } + + @Override + public float getShaderLineWidth() { + return shaderLineWidth; + } + + // ===================== FOG STATE ===================== + + @Override + public void setShaderFogColor(float red, float green, float blue, float alpha) { + shaderFogColor[0] = red; + shaderFogColor[1] = green; + shaderFogColor[2] = blue; + shaderFogColor[3] = alpha; + } + + @Override + public float[] getShaderFogColor() { + return shaderFogColor.clone(); + } + + @Override + public void setShaderFogStart(float start) { + shaderFogStart = start; + } + + @Override + public float getShaderFogStart() { + return shaderFogStart; + } + + @Override + public void setShaderFogEnd(float end) { + shaderFogEnd = end; + } + + @Override + public float getShaderFogEnd() { + return shaderFogEnd; + } + + @Override + public void setFogShape(int shape) { + fogShape = shape; + } + + @Override + public int getFogShape() { + return fogShape; + } + + // ===================== PROJECTION MATRIX ===================== + + @Override + public Matrix4f getProjectionMatrix() { + return new Matrix4f(projectionMatrix); + } + + @Override + public void setProjectionMatrixOrth(Matrix4f m) { + projectionMatrix.set(m); + GLStateManager.glMatrixMode(GL11.GL_PROJECTION); + projectionMatrix.get(projectionMatrixBuffer); + projectionMatrixBuffer.rewind(); + GLStateManager.glLoadMatrix(projectionMatrixBuffer); + } + + @Override + public void setProjectionMatrixOrigin(Matrix4f m) { + setProjectionMatrixOrth(m); + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/glsm/DisplayListManager.java b/src/main/java/com/gtnewhorizons/angelica/glsm/DisplayListManager.java index 20ba6d3cf..caf411130 100644 --- a/src/main/java/com/gtnewhorizons/angelica/glsm/DisplayListManager.java +++ b/src/main/java/com/gtnewhorizons/angelica/glsm/DisplayListManager.java @@ -1024,7 +1024,6 @@ public class DisplayListManager { final CompiledDisplayList compiled = displayListCache.get(list); if (compiled != null) { - GLStateManager.trySyncProgram(); final int prevList = currentRenderingList; currentRenderingList = list; compiled.render(); @@ -1043,7 +1042,6 @@ public class DisplayListManager { } else { // Positive IDs - fall back to native GL display lists // This happens for lists allocated but never compiled via glNewList - GLStateManager.trySyncProgram(); GL11.glCallList(list); } } diff --git a/src/main/java/com/gtnewhorizons/angelica/glsm/GLDebug.java b/src/main/java/com/gtnewhorizons/angelica/glsm/GLDebug.java index 1f6ad44f0..f7be55eb2 100644 --- a/src/main/java/com/gtnewhorizons/angelica/glsm/GLDebug.java +++ b/src/main/java/com/gtnewhorizons/angelica/glsm/GLDebug.java @@ -103,6 +103,9 @@ public final class GLDebug { GL43.glDebugMessageControl(GL11.GL_DONT_CARE, GL11.GL_DONT_CARE, GL43.GL_DEBUG_SEVERITY_NOTIFICATION, null, false); GL43.glDebugMessageCallback(proc); + // Enable synchronous debug output so errors are reported immediately with accurate stack traces + GL11.glEnable(GL43.GL_DEBUG_OUTPUT_SYNCHRONOUS); + if ((GL11.glGetInteger(GL30.GL_CONTEXT_FLAGS) & GL43.GL_CONTEXT_FLAG_DEBUG_BIT) == 0) { LOGGER.warn("[GL] Warning: A non-debug context may not produce any debug output."); GL11.glEnable(GL43.GL_DEBUG_OUTPUT); @@ -125,6 +128,9 @@ public final class GLDebug { ARBDebugOutput.glDebugMessageControlARB(GL11.GL_DONT_CARE, GL11.GL_DONT_CARE, GL43.GL_DEBUG_SEVERITY_LOW, null, false); ARBDebugOutput.glDebugMessageControlARB(GL11.GL_DONT_CARE, GL11.GL_DONT_CARE, GL43.GL_DEBUG_SEVERITY_NOTIFICATION, null, false); ARBDebugOutput.glDebugMessageCallbackARB(proc); + + // Enable synchronous debug output so errors are reported immediately with accurate stack traces + GL11.glEnable(ARBDebugOutput.GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB); return 1; } else if (GLStateManager.capabilities.GL_AMD_debug_output) { LOGGER.info("[GL] Using AMD_debug_output for error logging."); diff --git a/src/main/java/com/gtnewhorizons/angelica/glsm/GLStateManager.java b/src/main/java/com/gtnewhorizons/angelica/glsm/GLStateManager.java index fc9bf2ad8..dea2a27af 100644 --- a/src/main/java/com/gtnewhorizons/angelica/glsm/GLStateManager.java +++ b/src/main/java/com/gtnewhorizons/angelica/glsm/GLStateManager.java @@ -46,8 +46,6 @@ import net.coderbot.iris.gbuffer_overrides.state.StateTracker; import net.coderbot.iris.gl.blending.AlphaTestStorage; import net.coderbot.iris.gl.blending.BlendModeStorage; import net.coderbot.iris.gl.blending.DepthColorStorage; -import net.coderbot.iris.gl.state.StateUpdateNotifiers; -import net.coderbot.iris.pipeline.WorldRenderingPipeline; import net.coderbot.iris.samplers.IrisSamplers; import net.coderbot.iris.texture.pbr.PBRTextureManager; import net.minecraft.client.Minecraft; @@ -352,14 +350,6 @@ public class GLStateManager { projectionMatrix.clear(); } - // Iris Listeners - private static Runnable blendFuncListener = null; - private static Runnable fogToggleListener = null; - private static Runnable fogModeListener = null; - private static Runnable fogStartListener = null; - private static Runnable fogEndListener = null; - private static Runnable fogDensityListener = null; - /** * Check if a display list exists (has been compiled and stored). * Delegates to DisplayListManager. @@ -431,14 +421,6 @@ public class GLStateManager { public static void init() { RenderSystem.initRenderer(); - if (Iris.enabled) { - StateUpdateNotifiers.blendFuncNotifier = listener -> blendFuncListener = listener; - StateUpdateNotifiers.fogToggleNotifier = listener -> fogToggleListener = listener; - StateUpdateNotifiers.fogModeNotifier = listener -> fogModeListener = listener; - StateUpdateNotifiers.fogStartNotifier = listener -> fogStartListener = listener; - StateUpdateNotifiers.fogEndNotifier = listener -> fogEndListener = listener; - StateUpdateNotifiers.fogDensityNotifier = listener -> fogDensityListener = listener; - } if(BYPASS_CACHE) { LOGGER.info("GLStateManager cache bypassed"); } @@ -1027,9 +1009,6 @@ public class GLStateManager { if (caching) blendState.setSrcDstRgb(srcFactor, dstFactor); GL11.glBlendFunc(srcFactor, dstFactor); } - - // Iris - if (blendFuncListener != null) blendFuncListener.run(); } public static void glBlendEquation(int mode) { @@ -1071,9 +1050,6 @@ public class GLStateManager { if (caching) blendState.setAll(srcRgb, dstRgb, srcAlpha, dstAlpha); OpenGlHelper.glBlendFunc(srcRgb, dstRgb, srcAlpha, dstAlpha); } - - // Iris - if (blendFuncListener != null) blendFuncListener.run(); } public static void checkCompiling() { @@ -1765,12 +1741,6 @@ public class GLStateManager { glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, j); } - public static void trySyncProgram() { - if (Iris.enabled) { - Iris.getPipelineManager().getPipeline().ifPresent(WorldRenderingPipeline::syncProgram); - } - } - public static void glBegin(int mode) { if (DisplayListManager.isRecording()) { // Record to immediate mode recorder @@ -1780,7 +1750,6 @@ public class GLStateManager { } return; // Don't call actual GL during recording } - trySyncProgram(); GL11.glBegin(mode); } @@ -1851,7 +1820,6 @@ public class GLStateManager { if (DisplayListManager.isRecording()) { throw new UnsupportedOperationException("glDrawElements in display lists not yet implemented - if you see this, please report!"); } - trySyncProgram(); GL11.glDrawElements(mode, indices); } @@ -1859,7 +1827,6 @@ public class GLStateManager { if (DisplayListManager.isRecording()) { throw new UnsupportedOperationException("glDrawElements in display lists not yet implemented - if you see this, please report!"); } - trySyncProgram(); GL11.glDrawElements(mode, indices); } @@ -1867,7 +1834,6 @@ public class GLStateManager { if (DisplayListManager.isRecording()) { throw new UnsupportedOperationException("glDrawElements in display lists not yet implemented - if you see this, please report!"); } - trySyncProgram(); GL11.glDrawElements(mode, indices); } @@ -1875,7 +1841,6 @@ public class GLStateManager { if (DisplayListManager.isRecording()) { throw new UnsupportedOperationException("glDrawElements in display lists not yet implemented - if you see this, please report!"); } - trySyncProgram(); GL11.glDrawElements(mode, indices_count, type, indices_buffer_offset); } @@ -1883,7 +1848,6 @@ public class GLStateManager { if (DisplayListManager.isRecording()) { throw new UnsupportedOperationException("glDrawElements in display lists not yet implemented - if you see this, please report!"); } - trySyncProgram(); GL11.glDrawElements(mode, count, type, indices); } @@ -1895,7 +1859,6 @@ public class GLStateManager { return; } } - trySyncProgram(); GL11.glDrawBuffer(mode); } @@ -1910,7 +1873,6 @@ public class GLStateManager { } return; } - trySyncProgram(); GL11.glDrawArrays(mode, first, count); } @@ -2151,9 +2113,6 @@ public class GLStateManager { } } fogMode.enable(); - if (fogToggleListener != null) { - fogToggleListener.run(); - } } public static void disableFog() { @@ -2165,9 +2124,6 @@ public class GLStateManager { } } fogMode.disable(); - if (fogToggleListener != null) { - fogToggleListener.run(); - } } public static void glFog(int pname, FloatBuffer param) { @@ -2233,24 +2189,9 @@ public class GLStateManager { // Only update cached state when caching is enabled if (isCachingEnabled()) { switch (pname) { - case GL11.GL_FOG_DENSITY -> { - fogState.setDensity(param); - if (fogDensityListener != null) { - fogDensityListener.run(); - } - } - case GL11.GL_FOG_START -> { - fogState.setStart(param); - if (fogStartListener != null) { - fogStartListener.run(); - } - } - case GL11.GL_FOG_END -> { - fogState.setEnd(param); - if (fogEndListener != null) { - fogEndListener.run(); - } - } + case GL11.GL_FOG_DENSITY -> fogState.setDensity(param); + case GL11.GL_FOG_START -> fogState.setStart(param); + case GL11.GL_FOG_END -> fogState.setEnd(param); } } } @@ -2267,9 +2208,6 @@ public class GLStateManager { // Only update cached state when caching is enabled if (isCachingEnabled() && pname == GL11.GL_FOG_MODE) { fogState.setFogMode(param); - if (fogModeListener != null) { - fogModeListener.run(); - } } } diff --git a/src/main/java/com/gtnewhorizons/angelica/glsm/compat/FogHelper.java b/src/main/java/com/gtnewhorizons/angelica/glsm/compat/FogHelper.java new file mode 100644 index 000000000..b8bb70156 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/glsm/compat/FogHelper.java @@ -0,0 +1,11 @@ +package com.gtnewhorizons.angelica.glsm.compat; + +/** + * Simple holder for fog color values captured from vanilla rendering. + * Used by terrain renderers to access fog state. + */ +public class FogHelper { + public static float red; + public static float green; + public static float blue; +} diff --git a/src/main/java/com/gtnewhorizons/angelica/glsm/recording/RecordedGeometry.java b/src/main/java/com/gtnewhorizons/angelica/glsm/recording/RecordedGeometry.java deleted file mode 100644 index 69364689c..000000000 --- a/src/main/java/com/gtnewhorizons/angelica/glsm/recording/RecordedGeometry.java +++ /dev/null @@ -1,19 +0,0 @@ -package com.gtnewhorizons.angelica.glsm.recording; - -import com.github.bsideup.jabel.Desugar; -import com.gtnewhorizons.angelica.glsm.recording.commands.DrawCommand; -import me.jellysquid.mods.sodium.client.gl.attribute.BufferVertexFormat; - -import java.nio.ByteBuffer; -import java.util.List; - -/** - * Represents recorded geometry from a display list compilation. - * Contains the vertex data buffer and metadata about draw commands. - */ -@Desugar -public record RecordedGeometry(ByteBuffer buffer, BufferVertexFormat format, List drawCommands, int totalVertexCount) { - public int getByteSize() { - return buffer.remaining(); - } -} diff --git a/src/main/java/com/gtnewhorizons/angelica/glsm/texture/TextureTracker.java b/src/main/java/com/gtnewhorizons/angelica/glsm/texture/TextureTracker.java index 40fe20f98..60bdaac0d 100644 --- a/src/main/java/com/gtnewhorizons/angelica/glsm/texture/TextureTracker.java +++ b/src/main/java/com/gtnewhorizons/angelica/glsm/texture/TextureTracker.java @@ -5,7 +5,6 @@ import com.gtnewhorizons.angelica.glsm.RenderSystem; import it.unimi.dsi.fastutil.ints.Int2ObjectMap; import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap; import net.coderbot.iris.Iris; -import net.coderbot.iris.gl.state.StateUpdateNotifiers; import net.coderbot.iris.pipeline.WorldRenderingPipeline; import net.minecraft.client.renderer.texture.AbstractTexture; import org.jetbrains.annotations.Nullable; @@ -17,12 +16,6 @@ public class TextureTracker { public static final TextureTracker INSTANCE = new TextureTracker(); - private static Runnable bindTextureListener; - - static { - StateUpdateNotifiers.bindTextureNotifier = listener -> bindTextureListener = listener; - } - private final Int2ObjectMap textures = new Int2ObjectOpenHashMap<>(); private boolean lockBindCallback; @@ -45,9 +38,6 @@ public class TextureTracker { } if (GLStateManager.getActiveTextureUnit() == 0) { lockBindCallback = true; - if (bindTextureListener != null) { - bindTextureListener.run(); - } if(Iris.enabled) { final WorldRenderingPipeline pipeline = Iris.getPipelineManager().getPipelineNullable(); if (pipeline != null) { diff --git a/src/main/java/com/gtnewhorizons/angelica/loading/AngelicaTweaker.java b/src/main/java/com/gtnewhorizons/angelica/loading/AngelicaTweaker.java index 3d6e65d1c..f72bf3df1 100644 --- a/src/main/java/com/gtnewhorizons/angelica/loading/AngelicaTweaker.java +++ b/src/main/java/com/gtnewhorizons/angelica/loading/AngelicaTweaker.java @@ -16,6 +16,7 @@ import jss.notfine.asm.AsmTransformers; import jss.notfine.asm.mappings.Namer; import jss.notfine.config.MCPatcherForgeConfig; import jss.notfine.config.NotFineConfig; +import com.gtnewhorizons.retrofuturabootstrap.SharedConfig; import net.minecraft.launchwrapper.Launch; import org.apache.logging.log4j.Level; import org.apache.logging.log4j.LogManager; @@ -55,6 +56,10 @@ public class AngelicaTweaker implements IFMLLoadingPlugin, IEarlyMixinLoader { private String[] transformerClasses; public AngelicaTweaker() { + if (Launch.blackboard.getOrDefault("angelica.rfbPluginLoaded", Boolean.FALSE) == Boolean.TRUE) { + addLwjgl3ifyExclusions(); + } + try { // Angelica Config ConfigurationManager.registerConfig(AngelicaConfig.class); @@ -137,9 +142,6 @@ public class AngelicaTweaker implements IFMLLoadingPlugin, IEarlyMixinLoader { boolean rfbLoaded = Launch.blackboard.getOrDefault("angelica.rfbPluginLoaded", Boolean.FALSE) == Boolean.TRUE; if (!rfbLoaded) { tweaks.add("com.gtnewhorizons.angelica.loading.fml.tweakers.AngelicaLateTweaker"); - if (AngelicaConfig.enableSodium) { - tweaks.add("com.gtnewhorizons.angelica.loading.fml.tweakers.SodiumLateTweaker"); - } } } } @@ -168,6 +170,19 @@ public class AngelicaTweaker implements IFMLLoadingPlugin, IEarlyMixinLoader { return IMixins.getEarlyMixins(Mixins.class, loadedCoreMods); } + private static void addLwjgl3ifyExclusions() { + var handle = SharedConfig.getRfbTransformers().stream() + .filter(transformer -> transformer.id().equals("lwjgl3ify:redirect")) + .findFirst() + .orElse(null); + if (handle != null) { + handle.exclusions().add("org.embeddedt.embeddium"); + handle.exclusions().add("org.taumc.celeritas"); + handle.exclusions().add("com.mitchej123.lwjgl.lwjgl3"); + handle.exclusions().add("com.mitchej123.glsm"); + } + } + /** * Returns true if we are in an obfuscated environment, returns false in dev environment. */ diff --git a/src/main/java/com/gtnewhorizons/angelica/loading/fml/transformers/SodiumBlockTransformer.java b/src/main/java/com/gtnewhorizons/angelica/loading/fml/transformers/SodiumBlockTransformer.java index 491916bff..a9e3404ca 100644 --- a/src/main/java/com/gtnewhorizons/angelica/loading/fml/transformers/SodiumBlockTransformer.java +++ b/src/main/java/com/gtnewhorizons/angelica/loading/fml/transformers/SodiumBlockTransformer.java @@ -17,7 +17,7 @@ public class SodiumBlockTransformer implements IClassTransformer { public SodiumBlockTransformer() { this.inner = new SodiumBlockTransform(AngelicaTweaker.isObfEnv()); this.exclusions = inner.getTransformerExclusions(); - this.inner.setSodiumSetting(); + this.inner.setCeleritasSetting(); } /** diff --git a/src/main/java/com/gtnewhorizons/angelica/loading/fml/tweakers/SodiumLateTweaker.java b/src/main/java/com/gtnewhorizons/angelica/loading/fml/tweakers/SodiumLateTweaker.java deleted file mode 100644 index 655cacaa9..000000000 --- a/src/main/java/com/gtnewhorizons/angelica/loading/fml/tweakers/SodiumLateTweaker.java +++ /dev/null @@ -1,35 +0,0 @@ -package com.gtnewhorizons.angelica.loading.fml.tweakers; - -import cpw.mods.fml.relauncher.FMLRelaunchLog; -import net.minecraft.launchwrapper.ITweaker; -import net.minecraft.launchwrapper.Launch; -import net.minecraft.launchwrapper.LaunchClassLoader; - -import java.io.File; -import java.util.List; - -public class SodiumLateTweaker implements ITweaker { - - @Override - public void acceptOptions(List args, File gameDir, File assetsDir, String profile) { - // no-op - } - - @Override - public void injectIntoClassLoader(LaunchClassLoader classLoader) { - // no-op - } - - @Override - public String getLaunchTarget() { - return null; - } - - @Override - public String[] getLaunchArguments() { - String transformer = "com.gtnewhorizons.angelica.loading.fml.transformers.SodiumBlockTransformer"; - FMLRelaunchLog.finer("Registering transformer %s", transformer); - Launch.classLoader.registerTransformer(transformer); - return new String[0]; - } -} diff --git a/src/main/java/com/gtnewhorizons/angelica/loading/shared/transformers/SodiumBlockTransform.java b/src/main/java/com/gtnewhorizons/angelica/loading/shared/transformers/SodiumBlockTransform.java index f436fe131..1504813e2 100644 --- a/src/main/java/com/gtnewhorizons/angelica/loading/shared/transformers/SodiumBlockTransform.java +++ b/src/main/java/com/gtnewhorizons/angelica/loading/shared/transformers/SodiumBlockTransform.java @@ -58,22 +58,22 @@ public class SodiumBlockTransform { // Block owners we *shouldn't* redirect because they shadow one of our fields private static final Set blockOwnerExclusions = Collections.newSetFromMap(new ConcurrentHashMap<>()); // Needed because the config is loaded in LaunchClassLoader, but we need to access it in the parent system loader. - private static final MethodHandle angelicaConfigSodiumEnabledGetter; - private static boolean isSodiumEnabled; + private static final MethodHandle angelicaConfigCeleritasEnabledGetter; + private static boolean isCeleritasEnabled; static { try { final Class angelicaConfig = Class.forName("com.gtnewhorizons.angelica.config.AngelicaConfig", true, Launch.classLoader); - angelicaConfigSodiumEnabledGetter = MethodHandles.lookup().findStaticGetter(angelicaConfig, "enableSodium", boolean.class); + angelicaConfigCeleritasEnabledGetter = MethodHandles.lookup().findStaticGetter(angelicaConfig, "enableCeleritas", boolean.class); } catch (ReflectiveOperationException e) { throw new RuntimeException(e); } } - private static boolean isSodiumEnabled() { - if (isSodiumEnabled) return true; + private static boolean isCeleritasEnabled() { + if (isCeleritasEnabled) return true; try { - return (boolean) angelicaConfigSodiumEnabledGetter.invokeExact(); + return (boolean) angelicaConfigCeleritasEnabledGetter.invokeExact(); } catch (Throwable e) { throw new RuntimeException(e); } @@ -119,7 +119,7 @@ public class SodiumBlockTransform { return false; } - if ("net.minecraft.block.Block".equals(transformedName) && isSodiumEnabled()) { + if ("net.minecraft.block.Block".equals(transformedName) && isCeleritasEnabled()) { cn.fields.removeIf(field -> BlockBoundsFields.stream().anyMatch(pair -> field.name.equals(pair.getLeft()) || field.name.equals(pair.getRight()))); } @@ -164,7 +164,7 @@ public class SodiumBlockTransform { for (MethodNode mn : cn.methods) { for (AbstractInsnNode node : mn.instructions.toArray()) { if ((node.getOpcode() == Opcodes.GETFIELD || node.getOpcode() == Opcodes.PUTFIELD) && node instanceof FieldInsnNode fNode) { - if (!blockOwnerExclusions.contains(fNode.owner) && isBlockSubclass(fNode.owner) && isSodiumEnabled()) { + if (!blockOwnerExclusions.contains(fNode.owner) && isBlockSubclass(fNode.owner) && isCeleritasEnabled()) { Pair fieldToRedirect = BlockBoundsFields.stream() .filter(pair -> fNode.name.equals(getFieldName(pair))) .findFirst() @@ -206,7 +206,7 @@ public class SodiumBlockTransform { return changed; } - public void setSodiumSetting() { - isSodiumEnabled = true; + public void setCeleritasSetting() { + isCeleritasEnabled = true; } } diff --git a/src/main/java/com/gtnewhorizons/angelica/mixins/Mixins.java b/src/main/java/com/gtnewhorizons/angelica/mixins/Mixins.java index 112fa6db9..707fd28f5 100644 --- a/src/main/java/com/gtnewhorizons/angelica/mixins/Mixins.java +++ b/src/main/java/com/gtnewhorizons/angelica/mixins/Mixins.java @@ -138,36 +138,52 @@ public enum Mixins implements IMixins { ) ), - SODIUM(new MixinBuilder() + RENDERING_INFRASTRUCTURE(new MixinBuilder() .setPhase(Phase.EARLY) - .setApplyIf(() -> AngelicaConfig.enableSodium) + .setApplyIf(() -> AngelicaConfig.enableCeleritas) .addClientMixins( - "sodium.MixinBlock" - , "sodium.MixinBlockFluidBase" - , "sodium.AccessorBiomeColorEvent" - , "sodium.MixinBiomeGenBase" - , "sodium.MixinChunk" - , "sodium.MixinChunkProviderServer" - , "sodium.MixinClientRegistry" - , "sodium.MixinEntity_RenderDist" - , "sodium.MixinEntityItem_RenderDist" - , "sodium.MixinRenderManager" - , "sodium.MixinEntityRenderer" - , "sodium.MixinFMLClientHandler" - , "sodium.MixinForgeHooksClient" - , "sodium.MixinGameSettings" - , "sodium.MixinFrustrum" - , "sodium.MixinMinecraft" - , "sodium.MixinRenderBlocks" - , "sodium.MixinRenderGlobal" - , "sodium.MixinWorldClient" - , "sodium.MixinTileEntity" - , "sodium.MixinTileEntityMobSpawner" - , "sodium.MixinEffectRenderer" - , "sodium.MixinTileEntityRendererDispatcher" - , "sodium.MixinLongHashMap" - , "sodium.MixinRenderingRegistry" - , "sodium.MixinPlayerManager" + "rendering.MixinBlock" + , "rendering.MixinBlockFluidBase" + , "rendering.AccessorBiomeColorEvent" + , "rendering.MixinBiomeGenBase" + , "rendering.MixinChunk" + , "rendering.MixinChunkProviderServer" + , "rendering.MixinClientRegistry" + , "rendering.MixinEntity_RenderDist" + , "rendering.MixinEntityItem_RenderDist" + , "rendering.MixinEntityRenderer" + , "rendering.MixinFMLClientHandler" + , "rendering.MixinGameSettings" + , "rendering.MixinLongHashMap" + , "rendering.MixinMinecraft" + , "rendering.MixinPlayerManager" + , "rendering.MixinRenderBlocks" + , "rendering.MixinRenderingRegistry" + , "rendering.MixinTileEntity" + , "rendering.MixinTileEntityMobSpawner" + , "rendering.MixinTileEntityRendererDispatcher" + ) + ), + + CELERITAS(new MixinBuilder() + .setPhase(Phase.EARLY) + .setApplyIf(() -> AngelicaConfig.enableCeleritas) + .addClientMixins( + "celeritas.terrain.MixinChunkProviderClient" + , "celeritas.terrain.MixinMinecraft_ChunkUpdates" + , "celeritas.terrain.MixinRenderGlobal" + , "celeritas.terrain.MixinRenderSectionManager" + , "celeritas.terrain.MixinWorldClient" + , "celeritas.frustum.MixinFrustrum" + , "celeritas.features.culling.MixinEffectRenderer" + , "celeritas.features.mipmaps.MixinTextureAtlasSprite" + , "celeritas.features.mipmaps.MixinTextureUtil" + , "celeritas.features.textures.MixinTextureMap" + , "celeritas.features.textures.MixinTextureAtlasSprite" + , "celeritas.biome_blending.MixinBlockGrass" + , "celeritas.biome_blending.MixinBlockLeaves" + , "celeritas.biome_blending.MixinBlockLiquid" + , "celeritas.threading.MixinForgeHooksClient" ) ), @@ -209,7 +225,7 @@ public enum Mixins implements IMixins { ANGELICA_TEXTURE(new MixinBuilder() .setPhase(Phase.EARLY) - .setApplyIf(() -> AngelicaConfig.enableIris || AngelicaConfig.enableSodium) + .setApplyIf(() -> AngelicaConfig.enableIris || AngelicaConfig.enableCeleritas) .addClientMixins( "angelica.textures.MixinTextureAtlasSprite" , "angelica.textures.MixinTextureUtil" @@ -250,13 +266,8 @@ public enum Mixins implements IMixins { .addClientMixins( "angelica.animation.MixinTextureAtlasSprite", "angelica.animation.MixinTextureMap", - "angelica.animation.MixinBlockFire", - "angelica.animation.MixinMinecraftForgeClient", "angelica.animation.MixinChunkCache", - "angelica.animation.MixinRenderBlocks", - "angelica.animation.MixinRenderBlockFluid", - "angelica.animation.MixinWorldRenderer", - "angelica.animation.MixinRenderItem")), + "angelica.animation.MixinRenderBlocks")), SCALED_RESOUTION_UNICODE_FIX(new MixinBuilder("Removes unicode languages gui scaling being forced to even values") .setPhase(Phase.EARLY) @@ -452,12 +463,12 @@ public enum Mixins implements IMixins { ), MCPATCHER_FORGE_RENDERPASS_DISPLAYLIST(new MixinBuilder("RenderPass display list allocation increase") .setPhase(Phase.EARLY) - .setApplyIf(() -> NotFineConfig.renderPass && !AngelicaConfig.enableSodium) + .setApplyIf(() -> NotFineConfig.renderPass && !AngelicaConfig.enableCeleritas) .addClientMixins("mcpatcherforge.renderpass.MixinRenderGlobal_DisplayLists") ), MCPATCHER_FORGE_RENDERPASS_FEATURES(new MixinBuilder("RenderPass rendering features") .setPhase(Phase.EARLY) - .setApplyIf(() -> NotFineConfig.renderPass && !AngelicaConfig.enableSodium) + .setApplyIf(() -> NotFineConfig.renderPass && !AngelicaConfig.enableCeleritas) .addClientMixins("mcpatcherforge.renderpass.MixinRenderGlobal_Features") ), MCPATCHER_FORGE_CUSTOM_COLORS(new MixinBuilder() diff --git a/src/main/java/com/gtnewhorizons/angelica/mixins/interfaces/EntityRendererAccessor.java b/src/main/java/com/gtnewhorizons/angelica/mixins/interfaces/EntityRendererAccessor.java index f5b8cac3e..ab44d5c18 100644 --- a/src/main/java/com/gtnewhorizons/angelica/mixins/interfaces/EntityRendererAccessor.java +++ b/src/main/java/com/gtnewhorizons/angelica/mixins/interfaces/EntityRendererAccessor.java @@ -1,7 +1,13 @@ package com.gtnewhorizons.angelica.mixins.interfaces; +import net.minecraft.client.renderer.texture.DynamicTexture; import net.minecraft.entity.player.EntityPlayer; public interface EntityRendererAccessor { float invokeGetNightVisionBrightness(EntityPlayer entityPlayer, float partialTicks); + + /** + * Get the lightmap texture for shader binding. + */ + DynamicTexture getLightmapTexture(); } diff --git a/src/main/java/com/gtnewhorizons/angelica/mixins/interfaces/IPatchedTextureAtlasSprite.java b/src/main/java/com/gtnewhorizons/angelica/mixins/interfaces/IPatchedTextureAtlasSprite.java index 43dc253eb..a09da3f92 100644 --- a/src/main/java/com/gtnewhorizons/angelica/mixins/interfaces/IPatchedTextureAtlasSprite.java +++ b/src/main/java/com/gtnewhorizons/angelica/mixins/interfaces/IPatchedTextureAtlasSprite.java @@ -1,12 +1,9 @@ package com.gtnewhorizons.angelica.mixins.interfaces; +@SuppressWarnings("unused") public interface IPatchedTextureAtlasSprite { - void markNeedsAnimationUpdate(); - boolean needsAnimationUpdate(); - void unmarkNeedsAnimationUpdate(); - void updateAnimationsDryRun(); } diff --git a/src/main/java/com/gtnewhorizons/angelica/mixins/interfaces/IRenderGlobalExt.java b/src/main/java/com/gtnewhorizons/angelica/mixins/interfaces/IRenderGlobalExt.java index 749ae5e40..afa2237b0 100644 --- a/src/main/java/com/gtnewhorizons/angelica/mixins/interfaces/IRenderGlobalExt.java +++ b/src/main/java/com/gtnewhorizons/angelica/mixins/interfaces/IRenderGlobalExt.java @@ -1,7 +1,6 @@ package com.gtnewhorizons.angelica.mixins.interfaces; public interface IRenderGlobalExt { - void scheduleTerrainUpdate(); - void reload(); - + void angelica$scheduleTerrainUpdate(); + void angelica$reload(); } diff --git a/src/main/java/com/gtnewhorizons/angelica/mixins/interfaces/RenderSectionManagerAccessor.java b/src/main/java/com/gtnewhorizons/angelica/mixins/interfaces/RenderSectionManagerAccessor.java new file mode 100644 index 000000000..c75050cec --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/mixins/interfaces/RenderSectionManagerAccessor.java @@ -0,0 +1,8 @@ +package com.gtnewhorizons.angelica.mixins.interfaces; + +import it.unimi.dsi.fastutil.longs.Long2ReferenceMap; +import org.embeddedt.embeddium.impl.render.chunk.RenderSection; + +public interface RenderSectionManagerAccessor { + Long2ReferenceMap angelica$getSectionByPosition(); +} diff --git a/src/main/java/com/gtnewhorizons/angelica/proxy/ClientProxy.java b/src/main/java/com/gtnewhorizons/angelica/proxy/ClientProxy.java index cc113f1d6..3ef0bc772 100644 --- a/src/main/java/com/gtnewhorizons/angelica/proxy/ClientProxy.java +++ b/src/main/java/com/gtnewhorizons/angelica/proxy/ClientProxy.java @@ -20,6 +20,10 @@ import com.gtnewhorizons.angelica.hudcaching.HUDCaching; import com.gtnewhorizons.angelica.mixins.interfaces.IGameSettingsExt; import com.gtnewhorizons.angelica.render.CloudRenderer; import com.gtnewhorizons.angelica.rendering.AngelicaBlockSafetyRegistry; +import com.gtnewhorizons.angelica.rendering.celeritas.CeleritasDebugScreenHandler; +import com.gtnewhorizons.angelica.rendering.celeritas.threading.ChunkTaskRegistry; +import com.gtnewhorizons.angelica.rendering.celeritas.threading.DefaultChunkTaskProvider; +import com.gtnewhorizons.angelica.rendering.celeritas.threading.ThreadedChunkTaskProvider; import com.gtnewhorizons.angelica.zoom.Zoom; import cpw.mods.fml.client.registry.ClientRegistry; import cpw.mods.fml.common.FMLCommonHandler; @@ -35,7 +39,6 @@ import java.lang.management.ManagementFactory; import java.util.Locale; import java.util.concurrent.ConcurrentHashMap; import jss.notfine.core.Settings; -import me.jellysquid.mods.sodium.client.SodiumDebugScreenHandler; import net.coderbot.iris.Iris; import net.coderbot.iris.client.IrisDebugScreenHandler; import net.minecraft.block.Block; @@ -59,7 +62,9 @@ import net.minecraftforge.client.event.GuiOpenEvent; import net.minecraftforge.client.event.RenderGameOverlayEvent; import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.event.world.WorldEvent; +import org.embeddedt.embeddium.impl.gl.device.GLRenderDevice; import org.lwjgl.input.Keyboard; +import org.lwjgl.opengl.GL15; public class ClientProxy extends CommonProxy { @@ -84,7 +89,11 @@ public class ClientProxy extends CommonProxy { LOGGER.info("World loaded - Enabling GLSM Cache"); } - if (AngelicaConfig.enableSodium) { + if (AngelicaConfig.enableCeleritas) { + ChunkTaskRegistry.reset(); + ChunkTaskRegistry.registerProvider(DefaultChunkTaskProvider.INSTANCE); + ChunkTaskRegistry.registerProvider(ThreadedChunkTaskProvider.INSTANCE); + // Register all blocks. Because blockids are unique to a world, this must be done each load GameData.getBlockRegistry().typeSafeIterable().forEach(o -> { AngelicaBlockSafetyRegistry.canBlockRenderOffThread(o, true, true); @@ -102,8 +111,9 @@ public class ClientProxy extends CommonProxy { if (AngelicaConfig.enableHudCaching) { HUDCaching.init(); } - if (AngelicaConfig.enableSodium) { - MinecraftForge.EVENT_BUS.register(SodiumDebugScreenHandler.INSTANCE); + if (AngelicaConfig.enableCeleritas) { + GLRenderDevice.VANILLA_STATE_RESETTER = () -> GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0); + MinecraftForge.EVENT_BUS.register(CeleritasDebugScreenHandler.INSTANCE); } if (AngelicaConfig.enableIris) { MinecraftForge.EVENT_BUS.register(IrisDebugScreenHandler.INSTANCE); @@ -145,7 +155,7 @@ public class ClientProxy extends CommonProxy { public void postInit(FMLPostInitializationEvent event) { super.postInit(event); - if (ModStatus.isLotrLoaded && AngelicaConfig.enableSodium && CompatConfig.fixLotr) { + if (ModStatus.isLotrLoaded && AngelicaConfig.enableCeleritas && CompatConfig.fixLotr) { try { Class lotrRendering = Class.forName("lotr.common.coremod.LOTRReplacedMethods$BlockRendering"); ReflectionHelper.setPrivateValue(lotrRendering, null, new ConcurrentHashMap<>(), "naturalBlockClassTable"); diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/AngelicaRenderQueue.java b/src/main/java/com/gtnewhorizons/angelica/rendering/AngelicaRenderQueue.java index fb2058784..3ab2bd4ef 100644 --- a/src/main/java/com/gtnewhorizons/angelica/rendering/AngelicaRenderQueue.java +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/AngelicaRenderQueue.java @@ -11,6 +11,27 @@ public class AngelicaRenderQueue { private static final Thread MAIN_THREAD = Thread.currentThread(); private static final Queue TASKS = new ConcurrentLinkedQueue<>(); + // Metrics + private static volatile int lastFrameTasksRan = 0; + private static volatile long lastFrameTimeNs = 0; + + public static int getQueueDepth() { + return TASKS.size(); + } + + public static int getLastFrameTasksRan() { + return lastFrameTasksRan; + } + + public static long getLastFrameTimeNs() { + return lastFrameTimeNs; + } + + public static void recordFrameStats(int tasksRan, long timeNs) { + lastFrameTasksRan = tasksRan; + lastFrameTimeNs = timeNs; + } + private static final Executor EXECUTOR = (runnable) -> { if(Thread.currentThread() == MAIN_THREAD) { runnable.run(); @@ -27,7 +48,7 @@ public class AngelicaRenderQueue { public static int processTasks(int max) { int tasksRun = 0; while(tasksRun < max) { - Runnable r = TASKS.poll(); + final Runnable r = TASKS.poll(); if(r == null) break; r.run(); @@ -36,11 +57,7 @@ public class AngelicaRenderQueue { return tasksRun; } - public static int processTasks() { - return processTasks(Integer.MAX_VALUE); - } - - private static final long WAIT_TIME = TimeUnit.MILLISECONDS.toNanos(50); + private static final long WAIT_TIME = TimeUnit.MILLISECONDS.toNanos(20); public static void managedBlock(BooleanSupplier isDone) { while(!isDone.getAsBoolean()) { diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaChunkBuildContext.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaChunkBuildContext.java new file mode 100644 index 000000000..e735e2f19 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaChunkBuildContext.java @@ -0,0 +1,129 @@ +package com.gtnewhorizons.angelica.rendering.celeritas; + +import com.gtnewhorizons.angelica.dynamiclights.DynamicLights; +import com.gtnewhorizons.angelica.rendering.celeritas.iris.BlockRenderContext; +import com.gtnewhorizons.angelica.rendering.celeritas.iris.IrisExtendedChunkVertexEncoder; +import com.gtnewhorizons.angelica.rendering.celeritas.world.WorldSlice; +import lombok.Getter; +import net.minecraft.client.Minecraft; +import net.minecraft.client.multiplayer.WorldClient; +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.quad.properties.ModelQuadFacing; +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.ChunkBuildContext; +import org.embeddedt.embeddium.impl.render.chunk.data.MinecraftBuiltRenderSectionData; +import org.embeddedt.embeddium.impl.render.chunk.sprite.SpriteTransparencyLevel; +import org.embeddedt.embeddium.impl.render.chunk.terrain.material.Material; +import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkVertexEncoder; +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 ChunkVertexEncoder.Vertex[] vertices = ChunkVertexEncoder.Vertex.uninitializedQuad(); + @Getter + private final WorldSlice worldSlice; + private final BlockRenderContext blockRenderContext = new BlockRenderContext(); + + public AngelicaChunkBuildContext(RenderPassConfiguration renderPassConfiguration, WorldClient world) { + super(renderPassConfiguration); + this.textureMap = Minecraft.getMinecraft().getTextureMapBlocks(); + this.worldSlice = new WorldSlice(world); + } + + 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; + } + } + return material; + } + + @SuppressWarnings("unchecked") + public void copyRawBuffer(int[] rawBuffer, int vertexCount, ChunkBuildBuffers buffers, Material material, + int originX, int originY, int originZ) { + if (vertexCount == 0) { + return; + } + + final var animatedSprites = ((MinecraftBuiltRenderSectionData)buffers.getSectionContextBundle()).animatedSprites; + + if ((vertexCount & 0x3) != 0) { + throw new IllegalStateException("Only quads are supported, got: " + vertexCount); + } + + final DynamicLights dynamicLights = DynamicLights.isEnabled() ? DynamicLights.get() : null; + + final var encoder = buffers.get(material).getEncoder(); + if (encoder instanceof IrisExtendedChunkVertexEncoder iris) { + iris.setContext(blockRenderContext); + } + + int ptr = 0; + final int numQuads = vertexCount / 4; + + for (int quadIdx = 0; quadIdx < numQuads; quadIdx++) { + float uSum = 0, vSum = 0; + + for (int vIdx = 0; vIdx < 4; vIdx++) { + final var vertex = vertices[vIdx]; + vertex.x = Float.intBitsToFloat(rawBuffer[ptr++]); + vertex.y = Float.intBitsToFloat(rawBuffer[ptr++]); + vertex.z = Float.intBitsToFloat(rawBuffer[ptr++]); + + final float u = Float.intBitsToFloat(rawBuffer[ptr++]); + final float v = Float.intBitsToFloat(rawBuffer[ptr++]); + vertex.u = u; + uSum += u; + vertex.v = v; + vSum += v; + + vertex.color = rawBuffer[ptr++]; + vertex.vanillaNormal = rawBuffer[ptr++]; + vertex.light = rawBuffer[ptr++]; + + if (dynamicLights != null) { + final double dynamicLevel = dynamicLights.getDynamicLightLevel(originX + vertex.x, originY + vertex.y, originZ + vertex.z); + if (dynamicLevel > 0) { + vertex.light = dynamicLights.getLightmapWithDynamicLight(dynamicLevel, vertex.light); + } + } + } + + 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); + + if (correctMaterial != material && builder.getEncoder() instanceof IrisExtendedChunkVertexEncoder iris) { + iris.setContext(blockRenderContext); + } + + builder.getVertexBuffer(facing).push(vertices, 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 new file mode 100644 index 000000000..d1cd37599 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaChunkBuilderMeshingTask.java @@ -0,0 +1,287 @@ +package com.gtnewhorizons.angelica.rendering.celeritas; + +import com.gtnewhorizon.gtnhlib.blockpos.BlockPos; +import com.gtnewhorizons.angelica.compat.toremove.RenderLayer; +import com.gtnewhorizons.angelica.rendering.AngelicaRenderQueue; +import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProvider; +import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProviderHolder; +import com.gtnewhorizons.angelica.rendering.celeritas.iris.BlockRenderContext; +import com.gtnewhorizons.angelica.rendering.celeritas.iris.ContextAwareChunkVertexEncoder; +import it.unimi.dsi.fastutil.objects.Reference2ReferenceMap; +import net.coderbot.iris.vertices.ExtendedDataHelper; +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher; +import net.minecraft.crash.CrashReport; +import net.minecraft.crash.CrashReportCategory; +import net.minecraft.init.Blocks; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.ReportedException; +import net.minecraft.world.IBlockAccess; +import org.embeddedt.embeddium.impl.render.chunk.RenderSection; +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.tasks.ChunkBuilderTask; +import org.embeddedt.embeddium.impl.render.chunk.data.BuiltSectionMeshParts; +import org.embeddedt.embeddium.impl.render.chunk.data.MinecraftBuiltRenderSectionData; +import org.embeddedt.embeddium.impl.render.chunk.occlusion.SectionVisibilityBuilder; +import org.embeddedt.embeddium.impl.render.chunk.terrain.TerrainRenderPass; +import org.embeddedt.embeddium.impl.util.task.CancellationToken; +import org.joml.Vector3d; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; + +public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask { + protected final RenderSection render; + protected final int buildTime; + protected final Vector3d camera; + + protected record DeferredBlock(int x, int y, int z, Block block, int meta, int pass) {} + + public AngelicaChunkBuilderMeshingTask(RenderSection render, int time, Vector3d camera) { + this.render = render; + this.buildTime = time; + this.camera = camera; + } + + protected abstract Tessellator getTessellator(); + protected abstract void setRenderPass(int pass); + protected abstract IBlockAccess getBlockAccess(); + protected abstract SmoothBiomeColorCache getBiomeColorCache(); + + protected boolean isThreaded() { + return false; + } + + protected boolean canRenderOffThread(Block block) { + return false; + } + + protected void onEnterExecute() {} + + protected void onExitExecute() {} + + protected void addExtraCrashInfo(CrashReportCategory category) {} + + @Override + public ChunkBuildOutput execute(ChunkBuildContext context, CancellationToken cancellationToken) { + final AngelicaChunkBuildContext buildContext = (AngelicaChunkBuildContext) context; + final MinecraftBuiltRenderSectionData renderData = new MinecraftBuiltRenderSectionData<>(); + final SectionVisibilityBuilder occluder = new SectionVisibilityBuilder(); + + final ChunkBuildBuffers buffers = buildContext.buffers; + buffers.init(renderData, this.render.getSectionIndex()); + + final int minX = this.render.getOriginX(); + final int minY = this.render.getOriginY(); + final int minZ = this.render.getOriginZ(); + + final int maxX = minX + 16; + final int maxY = minY + 16; + final int maxZ = minZ + 16; + + final BlockPos blockPos = new BlockPos(minX, minY, minZ); + final IBlockAccess region = getBlockAccess(); + final SmoothBiomeColorCache biomeColorCache = getBiomeColorCache(); + + onEnterExecute(); + + final Tessellator tessellator = getTessellator(); + + try { + tessellator.setTranslation(-minX, -minY, -minZ); + SmoothBiomeColorCache.setActiveCache(biomeColorCache); + + final IrisShaderProvider provider = IrisShaderProviderHolder.getProvider(); + final Map blockTypeIds = provider != null ? provider.getBlockTypeIds() : null; + final BlockRenderContext blockRenderContext = buildContext.getBlockRenderContext(); + + final boolean threaded = isThreaded(); + final List deferredBlocks = threaded ? new ArrayList<>() : null; + + final RenderBlocks renderBlocks = new RenderBlocks(region); + + for (int y = minY; y < maxY; y++) { + if (cancellationToken.isCancelled()) { + return null; + } + + for (int z = minZ; z < maxZ; z++) { + for (int x = minX; x < maxX; x++) { + blockPos.set(x, y, z); + + final Block block = region.getBlock(x, y, z); + + if (block == Blocks.air) { + continue; + } + + final int meta = region.getBlockMetadata(x, y, z); + + if (block.hasTileEntity(meta)) { + final TileEntity tileEntity = region.getTileEntity(x, y, z); + if (TileEntityRendererDispatcher.instance.hasSpecialRenderer(tileEntity)) { + renderData.globalBlockEntities.add(tileEntity); + } + } + + final boolean canRenderOffThread = !threaded || canRenderOffThread(block); + + for (int pass = 0; pass < AngelicaChunkBuildContext.NUM_PASSES; pass++) { + boolean canRender = block.canRenderInPass(pass); + + // Shader pack can override render layer via block.properties + if (blockTypeIds != null) { + final RenderLayer overrideLayer = blockTypeIds.get(block); + if (overrideLayer != null) { + canRender = switch (pass) { + case 0 -> overrideLayer == RenderLayer.cutout(); + case 1 -> overrideLayer == RenderLayer.translucent(); + default -> canRender; + }; + } + } + + if (canRender) { + if (!canRenderOffThread) { + deferredBlocks.add(new DeferredBlock(x, y, z, block, meta, pass)); + continue; + } + + renderBlock(block, x, y, z, pass, tessellator, renderBlocks, + buffers, buildContext, blockRenderContext, minX, minY, minZ); + } + } + + if (block.isOpaqueCube()) { + occluder.markOpaque(x, y, z); + } + } + } + } + + // Process deferred blocks on main thread if any + if (deferredBlocks != null && !deferredBlocks.isEmpty()) { + processDeferredBlocks(deferredBlocks, buildContext, buffers, region, minX, minY, minZ); + } + + final Reference2ReferenceMap meshes = + BuiltSectionMeshParts.groupFromBuildBuffers(buffers, + (float) camera.x - minX, (float) camera.y - minY, (float) camera.z - minZ); + + if (!meshes.isEmpty()) { + renderData.hasBlockGeometry = true; + } + + renderData.visibilityData = occluder.computeVisibilityEncoding(); + + SmoothBiomeColorCache.clearActiveCache(); + tessellator.setTranslation(0, 0, 0); + + CeleritasDebug.incrementChunkUpdateCounter(); + + return new ChunkBuildOutput(this.render, renderData, meshes, this.buildTime); + + } catch (ReportedException ex) { + throw fillCrashInfo(ex.getCrashReport(), region, blockPos); + } catch (Throwable ex) { + throw fillCrashInfo(CrashReport.makeCrashReport(ex, "Encountered exception while building chunk meshes"), region, blockPos); + } finally { + SmoothBiomeColorCache.clearActiveCache(); + onExitExecute(); + } + } + + protected void renderBlock(Block block, int x, int y, int z, int pass, Tessellator tessellator, RenderBlocks renderBlocks, ChunkBuildBuffers buffers, AngelicaChunkBuildContext buildContext, BlockRenderContext blockRenderContext, int originX, int originY, int originZ) { + + final Material blockMaterial = block.getMaterial(); + final boolean isFluid = blockMaterial == Material.water || blockMaterial == Material.lava; + + // Lava is opaque - use solid to skip unnecessary alpha testing + final var passMaterial = blockMaterial == Material.lava ? AngelicaRenderPassConfiguration.SOLID_MATERIAL : buffers.getRenderPassConfiguration().getMaterialForRenderType(BlockRenderLayer.fromVanillaPass(pass)); + + final var encoder = buffers.get(passMaterial).getEncoder(); + final ContextAwareChunkVertexEncoder contextEncoder = (encoder instanceof ContextAwareChunkVertexEncoder) ? (ContextAwareChunkVertexEncoder) encoder : null; + + if (contextEncoder != null) { + blockRenderContext.localPosX = x & 15; + blockRenderContext.localPosY = y & 15; + blockRenderContext.localPosZ = z & 15; + final byte lightValue = (byte) block.getLightValue(); + if (isFluid) { + contextEncoder.prepareToRenderFluid(blockRenderContext, block, lightValue); + } else { + contextEncoder.prepareToRenderBlock(blockRenderContext, block, + ExtendedDataHelper.BLOCK_RENDER_TYPE, lightValue); + } + } + + setRenderPass(pass); + tessellator.startDrawingQuads(); + renderBlocks.renderBlockByRenderType(block, x, y, z); + buildContext.copyRawBuffer(tessellator.rawBuffer, tessellator.vertexCount, buffers, + passMaterial, originX, originY, originZ); + tessellator.reset(); + tessellator.isDrawing = false; + + if (contextEncoder != null) { + contextEncoder.finishRenderingBlock(); + } + } + + private void processDeferredBlocks(List deferredBlocks, AngelicaChunkBuildContext buildContext, ChunkBuildBuffers buffers, IBlockAccess region, int minX, int minY, int minZ) { + + final BlockRenderContext blockRenderContext = buildContext.getBlockRenderContext(); + + final CompletableFuture future = CompletableFuture.runAsync(() -> { + final RenderBlocks mainThreadRenderBlocks = new RenderBlocks(region); + final Tessellator mainTessellator = Tessellator.instance; + mainTessellator.setTranslation(-minX, -minY, -minZ); + + for (DeferredBlock deferred : deferredBlocks) { + renderBlock(deferred.block(), deferred.x(), deferred.y(), deferred.z(), deferred.pass(), + mainTessellator, mainThreadRenderBlocks, buffers, buildContext, + blockRenderContext, minX, minY, minZ); + } + + mainTessellator.setTranslation(0, 0, 0); + }, AngelicaRenderQueue.executor()); + + try { + future.get(); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + throw new RuntimeException("Interrupted during deferred block rendering", e); + } catch (ExecutionException e) { + throw new RuntimeException("Error during main thread deferred block rendering", e); + } + } + + private ReportedException fillCrashInfo(CrashReport report, IBlockAccess slice, BlockPos pos) { + final CrashReportCategory crashReportSection = report.makeCategory("Block being rendered"); + + Block block = Blocks.air; + int meta = 0; + try { + block = slice.getBlock(pos.x, pos.y, pos.z); + meta = slice.getBlockMetadata(pos.x, pos.y, pos.z); + } catch (Exception ignored) {} + + crashReportSection.addCrashSection("Block", block); + crashReportSection.addCrashSection("Block location", String.format("World: (%d,%d,%d)", pos.x, pos.y, pos.z)); + crashReportSection.addCrashSection("Block meta", meta); + crashReportSection.addCrashSection("Chunk section", this.render); + + addExtraCrashInfo(crashReportSection); + + return new ReportedException(report); + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaChunkRenderer.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaChunkRenderer.java new file mode 100644 index 000000000..7ecf11dc1 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaChunkRenderer.java @@ -0,0 +1,77 @@ +package com.gtnewhorizons.angelica.rendering.celeritas; + +import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProvider; +import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProviderHolder; +import org.embeddedt.embeddium.impl.gl.device.RenderDevice; +import org.embeddedt.embeddium.impl.gl.shader.GlProgram; +import org.embeddedt.embeddium.impl.render.chunk.DefaultChunkRenderer; +import org.embeddedt.embeddium.impl.render.chunk.RenderPassConfiguration; +import org.embeddedt.embeddium.impl.render.chunk.shader.ChunkShaderInterface; +import org.embeddedt.embeddium.impl.render.chunk.shader.ChunkShaderTextureSlot; +import org.embeddedt.embeddium.impl.render.chunk.terrain.TerrainRenderPass; + +class AngelicaChunkRenderer extends DefaultChunkRenderer { + private GlProgram irisProgram; + private boolean usingIrisProgram; + + public AngelicaChunkRenderer(RenderDevice device, RenderPassConfiguration renderPassConfiguration) { + super(device, renderPassConfiguration); + + final IrisShaderProvider provider = IrisShaderProviderHolder.getProvider(); + if (provider != null) { + provider.setRenderPassConfiguration(renderPassConfiguration); + } + } + + @Override + protected void begin(TerrainRenderPass pass) { + final IrisShaderProvider provider = IrisShaderProviderHolder.getProvider(); + + // Check if Iris shaders are active and we have an override + if (provider != null && provider.isShadersEnabled()) { + final GlProgram override = provider.getShaderOverride(pass); + if (override != null) { + pass.startDrawing(); + override.bind(); + override.getInterface().setupState(pass); + this.activeProgram = (GlProgram) override; + this.irisProgram = override; + this.usingIrisProgram = true; + return; + } + } + + // Fall back to default shader + this.usingIrisProgram = false; + this.irisProgram = null; + super.begin(pass); + } + + @Override + protected void end(TerrainRenderPass pass) { + if (usingIrisProgram && irisProgram != null) { + irisProgram.getInterface().restoreState(); + irisProgram.unbind(); + irisProgram = null; + usingIrisProgram = false; + this.activeProgram = null; + pass.endDrawing(); + return; + } + + super.end(pass); + } + + @Override + protected boolean useBlockFaceCulling() { + return IrisShaderProviderHolder.shouldUseFaceCulling(); + } + + @Override + protected void configureShaderInterface(ChunkShaderInterface shader) { + if (!usingIrisProgram) { + shader.setTextureSlot(ChunkShaderTextureSlot.BLOCK, 0); + shader.setTextureSlot(ChunkShaderTextureSlot.LIGHT, 1); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaMainThreadMeshingTask.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaMainThreadMeshingTask.java new file mode 100644 index 000000000..402de3128 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaMainThreadMeshingTask.java @@ -0,0 +1,52 @@ +package com.gtnewhorizons.angelica.rendering.celeritas; + +import com.gtnewhorizons.angelica.rendering.celeritas.threading.RenderPassHelper; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.world.ChunkCache; +import net.minecraft.world.IBlockAccess; +import org.embeddedt.embeddium.impl.render.chunk.RenderSection; +import org.embeddedt.embeddium.impl.util.position.SectionPos; +import org.joml.Vector3d; + +public class AngelicaMainThreadMeshingTask extends AngelicaChunkBuilderMeshingTask { + + private IBlockAccess blockAccess; + private SmoothBiomeColorCache biomeColorCache; + + public AngelicaMainThreadMeshingTask(RenderSection render, int time, Vector3d camera) { + super(render, time, camera); + initBlockAccess(); + } + + private void initBlockAccess() { + final int minX = this.render.getOriginX(); + final int minY = this.render.getOriginY(); + final int minZ = this.render.getOriginZ(); + + 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); + } + + @Override + protected Tessellator getTessellator() { + return Tessellator.instance; + } + + @Override + protected void setRenderPass(int pass) { + RenderPassHelper.setWorldRenderPass(pass); + } + + @Override + protected IBlockAccess getBlockAccess() { + return blockAccess; + } + + @Override + protected SmoothBiomeColorCache getBiomeColorCache() { + return biomeColorCache; + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaRenderPassConfiguration.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaRenderPassConfiguration.java new file mode 100644 index 000000000..ba8ce0eb1 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaRenderPassConfiguration.java @@ -0,0 +1,82 @@ +package com.gtnewhorizons.angelica.rendering.celeritas; + +import com.google.common.collect.ImmutableListMultimap; +import it.unimi.dsi.fastutil.objects.Reference2ReferenceOpenHashMap; +import org.embeddedt.embeddium.impl.render.chunk.RenderPassConfiguration; +import org.embeddedt.embeddium.impl.render.chunk.compile.sorting.QuadPrimitiveType; +import org.embeddedt.embeddium.impl.render.chunk.terrain.TerrainRenderPass; +import org.embeddedt.embeddium.impl.render.chunk.terrain.material.Material; +import org.embeddedt.embeddium.impl.render.chunk.terrain.material.parameters.AlphaCutoffParameter; +import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkVertexType; +import org.lwjgl.opengl.GL11; + +import java.util.Map; + +public class AngelicaRenderPassConfiguration { + + public static TerrainRenderPass SOLID_PASS, CUTOUT_MIPPED_PASS, TRANSLUCENT_PASS; + public static Material SOLID_MATERIAL, CUTOUT_MIPPED_MATERIAL, TRANSLUCENT_MATERIAL; + + private record AngelicaPipelineState(int pass, boolean disableAlphaTest) implements TerrainRenderPass.PipelineState { + @Override + public void setup() { + if (pass == 0) { + GL11.glAlphaFunc(GL11.GL_GREATER, 0.1F); + } + if (disableAlphaTest) { + GL11.glDisable(GL11.GL_ALPHA_TEST); + } + } + + @Override + public void clear() { + if (disableAlphaTest) { + GL11.glEnable(GL11.GL_ALPHA_TEST); + } + } + } + + private static TerrainRenderPass.TerrainRenderPassBuilder builderForRenderType(int pass, boolean disableAlphaTest, ChunkVertexType vertexType) { + return TerrainRenderPass.builder() + .pipelineState(new AngelicaPipelineState(pass, disableAlphaTest)) + .vertexType(vertexType) + .primitiveType(QuadPrimitiveType.DIRECT); + } + + public static RenderPassConfiguration build(ChunkVertexType vertexType) { + SOLID_PASS = builderForRenderType(0, true, vertexType) + .name("solid") + .fragmentDiscard(false) + .useReverseOrder(false) + .build(); + + CUTOUT_MIPPED_PASS = builderForRenderType(0, false, vertexType) + .name("cutout_mipped") + .fragmentDiscard(true) + .useReverseOrder(false) + .build(); + + TRANSLUCENT_PASS = builderForRenderType(1, false, vertexType) + .name("translucent") + .fragmentDiscard(false) + .useReverseOrder(true) + .useTranslucencySorting(true) + .build(); + + TRANSLUCENT_MATERIAL = new Material(TRANSLUCENT_PASS, AlphaCutoffParameter.ZERO, true); + SOLID_MATERIAL = new Material(SOLID_PASS, AlphaCutoffParameter.ZERO, true); + CUTOUT_MIPPED_MATERIAL = new Material(CUTOUT_MIPPED_PASS, AlphaCutoffParameter.ONE_TENTH, true); + + final ImmutableListMultimap.Builder vanillaRenderStages = ImmutableListMultimap.builder(); + vanillaRenderStages.put(BlockRenderLayer.TRANSLUCENT, TRANSLUCENT_PASS); + vanillaRenderStages.put(BlockRenderLayer.SOLID, SOLID_PASS); + vanillaRenderStages.put(BlockRenderLayer.SOLID, CUTOUT_MIPPED_PASS); + + // Material lookup by terrain layer + final Map renderTypeToMaterialMap = new Reference2ReferenceOpenHashMap<>(4, Reference2ReferenceOpenHashMap.VERY_FAST_LOAD_FACTOR); + renderTypeToMaterialMap.put(BlockRenderLayer.SOLID, CUTOUT_MIPPED_MATERIAL); + renderTypeToMaterialMap.put(BlockRenderLayer.TRANSLUCENT, TRANSLUCENT_MATERIAL); + + return new RenderPassConfiguration<>(renderTypeToMaterialMap, vanillaRenderStages.build().asMap(), CUTOUT_MIPPED_MATERIAL, CUTOUT_MIPPED_MATERIAL, TRANSLUCENT_MATERIAL); + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaRenderSectionManager.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaRenderSectionManager.java new file mode 100644 index 000000000..ea4ad6d6f --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaRenderSectionManager.java @@ -0,0 +1,200 @@ +package com.gtnewhorizons.angelica.rendering.celeritas; + +import com.gtnewhorizons.angelica.rendering.AngelicaRenderQueue; +import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProviderHolder; +import com.gtnewhorizons.angelica.rendering.celeritas.threading.ChunkTaskProvider; +import com.gtnewhorizons.angelica.rendering.celeritas.threading.ChunkTaskRegistry; +import com.gtnewhorizons.angelica.rendering.celeritas.world.cloned.ClonedChunkSectionCache; +import me.jellysquid.mods.sodium.client.SodiumClientMod; +import net.minecraft.client.Minecraft; +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.RenderPassConfiguration; +import org.embeddedt.embeddium.impl.render.chunk.RenderSection; +import org.embeddedt.embeddium.impl.render.chunk.RenderSectionManager; +import org.embeddedt.embeddium.impl.render.viewport.CameraTransform; +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.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.Viewport; +import org.embeddedt.embeddium.impl.util.PositionUtil; +import org.jetbrains.annotations.Nullable; + +import com.gtnewhorizons.angelica.mixins.interfaces.RenderSectionManagerAccessor; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +public class AngelicaRenderSectionManager extends RenderSectionManager { + private boolean initialCameraSectionReady = false; + + private final WorldClient world; + private final ClonedChunkSectionCache sectionCache; + private final ChunkTaskProvider taskProvider; + + 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 */); + this.world = world; + this.sectionCache = new ClonedChunkSectionCache(world); + this.taskProvider = taskProvider; + } + + public static AngelicaRenderSectionManager create(ChunkVertexType vertexType, WorldClient world, int renderDistance, CommandList commandList) { + final ChunkTaskProvider provider = ChunkTaskRegistry.getActiveProvider(); + return new AngelicaRenderSectionManager(AngelicaRenderPassConfiguration.build(vertexType), world, renderDistance, commandList, 0, 16, provider.threadCount(), provider); + } + + public void setCameraPosition(double x, double y, double z) { + this.cameraPosition.set(x, y, z); + } + + private boolean isChunkNotLoaded(int chunkX, int chunkZ) { + return this.world.getChunkFromChunkCoords(chunkX, chunkZ).isEmpty(); + } + + @Override + public void onSectionAdded(int x, int y, int z) { + super.onSectionAdded(x, y, z); + + // If chunk isn't actually loaded (EmptyChunk placeholder), make sections opaque for main pass. + // This prevents BFS from traversing through chunks we haven't received from the server. + if (isChunkNotLoaded(x, z)) { + renderListManager.updateVisibilityData(x, y, z, 0L); + } + } + + @Override + public void update(Viewport positionedViewport, int frame, boolean spectator) { + if (!isInShadowPass() && !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); + } + + @Override + protected AsyncOcclusionMode getAsyncOcclusionMode() { + return AsyncOcclusionMode.EVERYTHING; + } + + @Override + protected boolean shouldRespectUpdateTaskQueueSizeLimit() { + return true; + } + + @Override + protected boolean useFogOcclusion() { + return true; + } + + @Override + protected boolean isDebugInfoShown() { + return Minecraft.getMinecraft().gameSettings.showDebugInfo; + } + + @Override + protected boolean shouldUseOcclusionCulling(Viewport positionedViewport, boolean spectator) { + if (!spectator) return true; + + final var camBlockPos = positionedViewport.getBlockCoord(); + return !this.world.getBlock(camBlockPos.x(), camBlockPos.y(), camBlockPos.z()).isOpaqueCube(); + } + + @Override + protected boolean isSectionVisuallyEmpty(int x, int y, int z) { + final Chunk chunk = this.world.getChunkFromChunkCoords(x, z); + if (chunk.isEmpty()) { + return true; + } + final var array = chunk.getBlockStorageArray(); + if (y < 0 || y >= array.length) { + return true; + } + return array[y] == null || array[y].isEmpty(); + } + + @Override + protected @Nullable ChunkBuilderTask createRebuildTask(RenderSection render, int frame) { + if (isSectionVisuallyEmpty(render.getChunkX(), render.getChunkY(), render.getChunkZ())) { + return null; + } + + return this.taskProvider.createRebuildTask(render, frame, this.cameraPosition, this.sectionCache); + } + + @Override + protected void invalidateCachedSectionData(RenderSection section) { + super.invalidateCachedSectionData(section); + this.sectionCache.invalidate(section.getChunkX(), section.getChunkY(), section.getChunkZ()); + } + + @Override + public void updateChunks(boolean updateImmediately) { + this.sectionCache.cleanup(); + super.updateChunks(updateImmediately); + } + + @Override + protected boolean allowImportantRebuilds() { + return !SodiumClientMod.options().performance.alwaysDeferChunkUpdates; + } + + @Override + protected @Nullable SectionTicker createSectionTicker() { + return new GenericSectionSpriteTicker<>(AngelicaRenderSectionManager::markSpriteActive); + } + + private static void markSpriteActive(TextureAtlasSprite sprite) { + ((SpriteExtension) sprite).celeritas$markActive(); + } + + @Override + public boolean isInShadowPass() { + return IrisShaderProviderHolder.isShadowPass(); + } + + @Override + public Collection getDebugStrings() { + List list = new ArrayList<>(super.getDebugStrings()); + + // Add thread info + var builder = getBuilder(); + int busyThreads = builder.getBusyThreadCount(); + int totalThreads = builder.getTotalThreadCount(); + + if (totalThreads > 0) { + list.add(String.format("Chunk Workers: %d/%d busy", busyThreads, totalThreads)); + } else { + list.add("Chunk Workers: single-threaded"); + } + + // Main thread queue metrics + final int queueDepth = AngelicaRenderQueue.getQueueDepth(); + final int tasksRan = AngelicaRenderQueue.getLastFrameTasksRan(); + final double mtTimeMs = AngelicaRenderQueue.getLastFrameTimeNs() / 1_000_000.0; + list.add(String.format("MT Queue: %d, ran %d (%.1fms)", queueDepth, tasksRan, mtTimeMs)); + + 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()) { + finishAllGraphUpdates(); + } + super.renderLayer(matrices, pass, occlusionCamera, camera); + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/BlockRenderLayer.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/BlockRenderLayer.java new file mode 100644 index 000000000..5e46d3fbd --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/BlockRenderLayer.java @@ -0,0 +1,12 @@ +package com.gtnewhorizons.angelica.rendering.celeritas; + +public enum BlockRenderLayer { + SOLID, // vanilla pass 0 + TRANSLUCENT; // vanilla pass 1 + + private static final BlockRenderLayer[] VALUES = values(); + + public static BlockRenderLayer fromVanillaPass(int pass) { + return VALUES[pass]; + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/CeleritasDebug.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/CeleritasDebug.java new file mode 100644 index 000000000..cfcec8605 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/CeleritasDebug.java @@ -0,0 +1,15 @@ +package com.gtnewhorizons.angelica.rendering.celeritas; + +import java.util.concurrent.atomic.AtomicInteger; + +public class CeleritasDebug { + private static final AtomicInteger chunkUpdateCounter = new AtomicInteger(0); + + public static void incrementChunkUpdateCounter() { + chunkUpdateCounter.getAndIncrement(); + } + + public static int readAndResetChunkUpdateCounter() { + return chunkUpdateCounter.getAndSet(0); + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/CeleritasDebugScreenHandler.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/CeleritasDebugScreenHandler.java new file mode 100644 index 000000000..ca10350e4 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/CeleritasDebugScreenHandler.java @@ -0,0 +1,30 @@ +package com.gtnewhorizons.angelica.rendering.celeritas; + +import com.gtnewhorizons.angelica.Tags; +import cpw.mods.fml.common.eventhandler.EventPriority; +import cpw.mods.fml.common.eventhandler.SubscribeEvent; +import net.minecraft.client.Minecraft; +import net.minecraft.util.EnumChatFormatting; +import net.minecraftforge.client.event.RenderGameOverlayEvent; + +public class CeleritasDebugScreenHandler { + public static final CeleritasDebugScreenHandler INSTANCE = new CeleritasDebugScreenHandler(); + + @SubscribeEvent(priority = EventPriority.LOW) + public void onRenderGameOverlayTextEvent(RenderGameOverlayEvent.Text event) { + final Minecraft mc = Minecraft.getMinecraft(); + if (!mc.gameSettings.showDebugInfo) { + return; + } + + final CeleritasWorldRenderer renderer = CeleritasWorldRenderer.getInstance(); + if (renderer == null) { + return; + } + + event.right.add(""); + event.right.add(EnumChatFormatting.GREEN + "Angelica " + Tags.VERSION + " [Celeritas Renderer]"); + event.right.addAll(renderer.getDebugStrings()); + event.right.add(""); + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/CeleritasWorldRenderer.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/CeleritasWorldRenderer.java new file mode 100644 index 000000000..625b46f51 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/CeleritasWorldRenderer.java @@ -0,0 +1,269 @@ +package com.gtnewhorizons.angelica.rendering.celeritas; + +import com.gtnewhorizons.angelica.dynamiclights.DynamicLights; +import com.gtnewhorizons.angelica.dynamiclights.IDynamicLightWorldRenderer; +import com.gtnewhorizons.angelica.glsm.GLStateManager; +import com.gtnewhorizons.angelica.rendering.RenderingState; +import net.coderbot.iris.pipeline.ShadowRenderer; +import net.minecraft.client.Minecraft; +import net.minecraft.client.multiplayer.WorldClient; +import net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher; +import net.minecraft.entity.Entity; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.AxisAlignedBB; +import net.minecraftforge.client.MinecraftForgeClient; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.embeddedt.embeddium.impl.gl.device.CommandList; +import org.embeddedt.embeddium.impl.render.chunk.ChunkRenderMatrices; +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.vertex.format.ChunkMeshFormats; +import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkVertexType; +import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProvider; +import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProviderHolder; +import me.jellysquid.mods.sodium.client.SodiumClientMod; +import org.embeddedt.embeddium.impl.render.terrain.SimpleWorldRenderer; +import org.embeddedt.embeddium.impl.render.viewport.Viewport; +import org.joml.Matrix4f; + +import java.util.Iterator; +import java.util.List; + +public class CeleritasWorldRenderer extends SimpleWorldRenderer implements IDynamicLightWorldRenderer { + private static final Logger LOGGER = LogManager.getLogger("Angelica"); + private final Minecraft mc; + private static CeleritasWorldRenderer instance; + + private final TileEntityRenderContext teRenderContext = new TileEntityRenderContext(); + private boolean useEntityCulling = true; + + // 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 CeleritasWorldRenderer(Minecraft mc) { + // Private constructor for singleton + this.mc = mc; + } + + public static CeleritasWorldRenderer create(Minecraft mc) { + instance = new CeleritasWorldRenderer(mc); + return instance; + } + + public static CeleritasWorldRenderer getInstance() { + if (instance == null) { + throw new IllegalStateException("CeleritasWorldRenderer not initialized"); + } + return instance; + } + + public AngelicaRenderSectionManager getRenderSectionManager() { + return this.renderSectionManager; + } + + @Override + public boolean isActive() { + return this.world != null; + } + + @Override + protected void loadWorld(WorldClient world) { + super.loadWorld(world); + DynamicLights.setActiveRenderer(this); + } + + @Override + protected void unloadWorld() { + DynamicLights.setActiveRenderer(null); + super.unloadWorld(); + } + + @Override + public int getEffectiveRenderDistance() { + return mc.gameSettings.renderDistanceChunks; + } + + @Override + public int getMinimumBuildHeight() { + return 0; + } + + @Override + public int getMaximumBuildHeight() { + return 256; + } + + @Override + protected ChunkRenderMatrices createChunkRenderMatrices() { + final boolean shadowPass = renderSectionManager.isInShadowPass(); + final Matrix4f projection = shadowPass ? ShadowRenderer.PROJECTION : RenderingState.INSTANCE.getProjectionMatrix(); + final Matrix4f modelView = shadowPass ? ShadowRenderer.MODELVIEW : RenderingState.INSTANCE.getModelViewMatrix(); + return new ChunkRenderMatrices(projection, modelView); + } + + private ChunkVertexType chooseVertexType() { + final IrisShaderProvider provider = IrisShaderProviderHolder.getProvider(); + if (provider != null && provider.isShadersEnabled()) { + final ChunkVertexType extended = provider.getVertexType(ChunkMeshFormats.VANILLA_LIKE); + if (extended != ChunkMeshFormats.VANILLA_LIKE) { + return extended; + } + } + + if (SodiumClientMod.options().advanced.useCompactVertexFormat) { + return ChunkMeshFormats.COMPACT; + } + return ChunkMeshFormats.VANILLA_LIKE; + } + + @Override + protected AngelicaRenderSectionManager createRenderSectionManager(CommandList commandList) { + return AngelicaRenderSectionManager.create(chooseVertexType(), this.world, this.renderDistance, commandList); + } + + @Override + protected void renderBlockEntityList(List list, TileEntityRenderContext context) { + for (TileEntity tileEntity : list) { + renderTE(tileEntity, context.pass, context.partialTicks); + } + } + + @Override + public void setupTerrain(Viewport viewport, CameraState cameraState, int frame, boolean spectator, boolean updateChunksImmediately) { + var transform = viewport.getTransform(); + + if (transform.x == 0 && transform.y == 0 && transform.z == 0) { + return; + } + + renderSectionManager.setCameraPosition(transform.x, transform.y, transform.z); + + this.useEntityCulling = true; + + super.setupTerrain(viewport, cameraState, frame, spectator, updateChunksImmediately); + + // Collect tile entities for shadow pass rendering + if (renderSectionManager.isInShadowPass() && IrisShaderProviderHolder.isActive()) { + collectTileEntitiesForShadow(); + } + } + + public void setCurrentViewport(Viewport viewport) { + this.currentViewport = viewport; + } + + @SuppressWarnings("unchecked") + private void collectTileEntitiesForShadow() { + final SortedRenderLists renderLists = renderSectionManager.getRenderLists(); + final Iterator 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) mcData.culledBlockEntities; + ShadowRenderer.visibleTileEntities.addAll(culledEntities); + } + } + } + + for (var renderSection : renderSectionManager.getSectionsWithGlobalEntities()) { + final var context = renderSection.getBuiltContext(); + if (context instanceof MinecraftBuiltRenderSectionData mcData) { + final var globalEntities = (List) mcData.globalBlockEntities; + ShadowRenderer.globalTileEntities.addAll(globalEntities); + } + } + } + + @Override + public void drawChunkLayer(BlockRenderLayer renderLayer, double x, double y, double z) { + super.drawChunkLayer(renderLayer, x, y, z); + GLStateManager.glColor4f(1, 1, 1, 1); + } + + public int renderBlockEntities(float partialTicks) { + final int pass = MinecraftForgeClient.getRenderPass(); + return super.renderBlockEntities(teRenderContext.set(partialTicks, pass)); + } + + private void renderTE(TileEntity tileEntity, int pass, float partialTicks) { + if (!tileEntity.shouldRenderInPass(pass)) { + return; + } + + final AxisAlignedBB aabb = tileEntity.getRenderBoundingBox(); + + if (aabb != TileEntity.INFINITE_EXTENT_AABB && !this.currentViewport.isBoxVisible(aabb.minX, aabb.minY, aabb.minZ, aabb.maxX, aabb.maxY, aabb.maxZ)) { + return; + } + + try { + TileEntityRendererDispatcher.instance.renderTileEntity(tileEntity, partialTicks); + } catch (RuntimeException e) { + if (tileEntity.isInvalid()) { + LOGGER.warn("Suppressed exception rendering invalid TileEntity {} at ({}, {}, {})", tileEntity.getClass().getName(), tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord, e); + } else { + throw e; + } + } + } + + private static boolean isInfiniteExtentsBox(AxisAlignedBB box) { + return box == null || Double.isInfinite(box.minX) || Double.isInfinite(box.minY) || Double.isInfinite(box.minZ) + || Double.isInfinite(box.maxX) || Double.isInfinite(box.maxY) || Double.isInfinite(box.maxZ); + } + + public boolean isEntityVisible(Entity entity) { + // During shadow pass, don't cull entities - shadow rendering uses different frustum + if (!this.useEntityCulling || this.renderSectionManager.isInShadowPass()) { + return true; + } + + AxisAlignedBB box = entity.getBoundingBox(); + if (box == null) { + box = entity.boundingBox; + } + + if (isInfiniteExtentsBox(box)) { + 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 { + public float partialTicks; + public int pass; + + public TileEntityRenderContext set(float partialTicks, int pass) { + this.partialTicks = partialTicks; + this.pass = pass; + return this; + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/SmoothBiomeColorCache.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/SmoothBiomeColorCache.java new file mode 100644 index 000000000..c2b84e9b1 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/SmoothBiomeColorCache.java @@ -0,0 +1,40 @@ +package com.gtnewhorizons.angelica.rendering.celeritas; + +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.biome.BiomeGenBase; +import org.embeddedt.embeddium.impl.biome.BiomeColorCache; + +public class SmoothBiomeColorCache extends BiomeColorCache { + private static final ThreadLocal activeCache = new ThreadLocal<>(); + + public static void setActiveCache(SmoothBiomeColorCache cache) { + activeCache.set(cache); + } + + public static void clearActiveCache() { + activeCache.remove(); + } + + public static SmoothBiomeColorCache getActiveCache() { + return activeCache.get(); + } + + public SmoothBiomeColorCache(IBlockAccess blockAccess) { + super((x, y, z) -> blockAccess.getBiomeGenForCoords(x, z), 3); + } + + @Override + protected int resolveColor(ColorType type, BiomeGenBase biome, int relativeX, int relativeY, int relativeZ) { + return switch (type) { + case GRASS -> biome.getBiomeGrassColor(relativeX, relativeY, relativeZ); + case FOLIAGE -> biome.getBiomeFoliageColor(relativeX, relativeY, relativeZ); + case WATER -> biome.getWaterColorMultiplier(); + }; + } + + public enum ColorType { + GRASS, + FOLIAGE, + WATER + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/SpriteExtension.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/SpriteExtension.java new file mode 100644 index 000000000..f0d8a9515 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/SpriteExtension.java @@ -0,0 +1,13 @@ +package com.gtnewhorizons.angelica.rendering.celeritas; + +import org.embeddedt.embeddium.impl.render.chunk.sprite.SpriteTransparencyLevel; + +public interface SpriteExtension { + SpriteTransparencyLevel celeritas$getTransparencyLevel(); + + /** Marks sprite as active for animation. */ + void celeritas$markActive(); + + /** One-shot: returns true if marked, then resets. */ + boolean celeritas$shouldUpdate(); +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/TextureMapExtension.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/TextureMapExtension.java new file mode 100644 index 000000000..e17628bf4 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/TextureMapExtension.java @@ -0,0 +1,7 @@ +package com.gtnewhorizons.angelica.rendering.celeritas; + +import net.minecraft.client.renderer.texture.TextureAtlasSprite; + +public interface TextureMapExtension { + TextureAtlasSprite celeritas$findFromUV(float u, float v); +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/WorldClientExtension.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/WorldClientExtension.java new file mode 100644 index 000000000..4a44b11b7 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/WorldClientExtension.java @@ -0,0 +1,5 @@ +package com.gtnewhorizons.angelica.rendering.celeritas; + +public interface WorldClientExtension { + SmoothBiomeColorCache celeritas$getSmoothBiomeColorCache(); +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/api/IrisShaderProvider.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/api/IrisShaderProvider.java new file mode 100644 index 000000000..e7d58e301 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/api/IrisShaderProvider.java @@ -0,0 +1,34 @@ +package com.gtnewhorizons.angelica.rendering.celeritas.api; + +import it.unimi.dsi.fastutil.objects.Object2IntMap; +import net.minecraft.block.Block; +import org.embeddedt.embeddium.impl.gl.shader.GlProgram; +import org.embeddedt.embeddium.impl.render.chunk.RenderPassConfiguration; +import org.embeddedt.embeddium.impl.render.chunk.shader.ChunkShaderInterface; +import org.embeddedt.embeddium.impl.render.chunk.terrain.TerrainRenderPass; +import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkVertexType; +import com.gtnewhorizons.angelica.compat.toremove.RenderLayer; +import org.jetbrains.annotations.Nullable; + +import java.util.Map; + +public interface IrisShaderProvider { + + boolean isShadersEnabled(); + + boolean isShadowPass(); + + boolean shouldUseFaceCulling(); + + @Nullable GlProgram getShaderOverride(TerrainRenderPass pass); + + ChunkVertexType getVertexType(ChunkVertexType defaultType); + + void setRenderPassConfiguration(RenderPassConfiguration configuration); + + /** Block render layer overrides from shader pack */ + @Nullable Map getBlockTypeIds(); + + /** Block ID matches for extended vertex data */ + @Nullable Object2IntMap getBlockMatches(); +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/api/IrisShaderProviderHolder.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/api/IrisShaderProviderHolder.java new file mode 100644 index 000000000..d35e43ca5 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/api/IrisShaderProviderHolder.java @@ -0,0 +1,31 @@ +package com.gtnewhorizons.angelica.rendering.celeritas.api; + +import org.jetbrains.annotations.Nullable; + +public final class IrisShaderProviderHolder { + + private static IrisShaderProvider provider; + + private IrisShaderProviderHolder() {} + + public static void setProvider(@Nullable IrisShaderProvider provider) { + IrisShaderProviderHolder.provider = provider; + } + + @Nullable + public static IrisShaderProvider getProvider() { + return provider; + } + + public static boolean isActive() { + return provider != null && provider.isShadersEnabled(); + } + + public static boolean isShadowPass() { + return provider != null && provider.isShadowPass(); + } + + public static boolean shouldUseFaceCulling() { + return provider == null || provider.shouldUseFaceCulling(); + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/iris/BlockRenderContext.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/iris/BlockRenderContext.java new file mode 100644 index 000000000..396364fa5 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/iris/BlockRenderContext.java @@ -0,0 +1,23 @@ +package com.gtnewhorizons.angelica.rendering.celeritas.iris; + +public class BlockRenderContext { + public int localPosX, localPosY, localPosZ; + public short blockId = -1; + public short renderType = -1; + public byte lightValue; + + public void set(int localX, int localY, int localZ, short blockId, short renderType, byte lightValue) { + this.localPosX = localX; + this.localPosY = localY; + this.localPosZ = localZ; + this.blockId = blockId; + this.renderType = renderType; + this.lightValue = lightValue; + } + + public void reset() { + blockId = -1; + renderType = -1; + lightValue = 0; + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/iris/CeleritasQuadView.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/iris/CeleritasQuadView.java new file mode 100644 index 000000000..46023637b --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/iris/CeleritasQuadView.java @@ -0,0 +1,46 @@ +package com.gtnewhorizons.angelica.rendering.celeritas.iris; + +import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*; + +import net.coderbot.iris.vertices.IrisQuadView; + +public class CeleritasQuadView implements IrisQuadView { + private long writePointer; + private int stride; + + public void setup(long ptr, int stride) { + this.writePointer = ptr; + this.stride = stride; + } + + // VANILLA_LIKE format offsets: + // Position: floats at 0, 4, 8 + // Color: int at 12 + // TexCoord: floats at 16, 20 + // LightCoord: int at 24 + + @Override + public float x(int index) { + return memGetFloat(writePointer - stride * (3L - index)); + } + + @Override + public float y(int index) { + return memGetFloat(writePointer + 4 - stride * (3L - index)); + } + + @Override + public float z(int index) { + return memGetFloat(writePointer + 8 - stride * (3L - index)); + } + + @Override + public float u(int index) { + return memGetFloat(writePointer + 16 - stride * (3L - index)); + } + + @Override + public float v(int index) { + return memGetFloat(writePointer + 20 - stride * (3L - index)); + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/iris/ContextAwareChunkVertexEncoder.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/iris/ContextAwareChunkVertexEncoder.java new file mode 100644 index 000000000..a85111b86 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/iris/ContextAwareChunkVertexEncoder.java @@ -0,0 +1,13 @@ +package com.gtnewhorizons.angelica.rendering.celeritas.iris; + +import net.minecraft.block.Block; +import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkVertexEncoder; + +public interface ContextAwareChunkVertexEncoder extends ChunkVertexEncoder { + + void prepareToRenderBlock(BlockRenderContext ctx, Block block, short renderType, byte lightValue); + + void prepareToRenderFluid(BlockRenderContext ctx, Block block, byte lightValue); + + void finishRenderingBlock(); +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/iris/IrisExtendedChunkVertexEncoder.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/iris/IrisExtendedChunkVertexEncoder.java new file mode 100644 index 000000000..047cd0899 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/iris/IrisExtendedChunkVertexEncoder.java @@ -0,0 +1,127 @@ +package com.gtnewhorizons.angelica.rendering.celeritas.iris; + +import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*; +import static com.gtnewhorizons.angelica.rendering.celeritas.iris.IrisExtendedChunkVertexType.STRIDE; +import static com.gtnewhorizons.angelica.rendering.celeritas.iris.IrisExtendedChunkVertexType.encodeMidTexture; + +import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProvider; +import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProviderHolder; +import it.unimi.dsi.fastutil.objects.Object2IntMap; +import lombok.Setter; +import net.coderbot.iris.vertices.ExtendedDataHelper; +import net.coderbot.iris.vertices.NormalHelper; +import net.coderbot.iris.vertices.NormI8; +import net.minecraft.block.Block; +import org.embeddedt.embeddium.impl.render.chunk.terrain.material.Material; +import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkVertexEncoder; +import org.joml.Vector3f; + +/** + * Writes Iris-extended vertices. Delegates base 28 bytes to VANILLA_LIKE encoder. + */ +public class IrisExtendedChunkVertexEncoder implements ContextAwareChunkVertexEncoder { + // Offsets derived from format definition + private static final int MID_TEX_OFFSET = IrisExtendedChunkVertexType.VERTEX_FORMAT.getAttribute("mc_midTexCoord").getPointer(); + private static final int TANGENT_OFFSET = IrisExtendedChunkVertexType.VERTEX_FORMAT.getAttribute("at_tangent").getPointer(); + private static final int NORMAL_OFFSET = IrisExtendedChunkVertexType.VERTEX_FORMAT.getAttribute("iris_Normal").getPointer(); + private static final int MC_ENTITY_OFFSET = IrisExtendedChunkVertexType.VERTEX_FORMAT.getAttribute("mc_Entity").getPointer(); + private static final int MID_BLOCK_OFFSET = IrisExtendedChunkVertexType.VERTEX_FORMAT.getAttribute("at_midBlock").getPointer(); + + private final ChunkVertexEncoder baseEncoder = IrisExtendedChunkVertexType.BASE_TYPE.createEncoder(); + private final CeleritasQuadView quad = new CeleritasQuadView(); + private final Vector3f normal = new Vector3f(); + private final Object2IntMap blockMatches; + + public IrisExtendedChunkVertexEncoder() { + final IrisShaderProvider provider = IrisShaderProviderHolder.getProvider(); + this.blockMatches = provider != null ? provider.getBlockMatches() : null; + } + + // Per-quad accumulators + private int vertexCount; + private float uSum; + private float vSum; + + @Setter + private BlockRenderContext context; + + @Override + public void prepareToRenderBlock(BlockRenderContext ctx, Block block, short renderType, byte lightValue) { + this.context = ctx; + ctx.blockId = (short) (blockMatches != null ? blockMatches.getOrDefault(block, -1) : -1); + ctx.renderType = renderType; + ctx.lightValue = lightValue; + } + + @Override + public void prepareToRenderFluid(BlockRenderContext ctx, Block block, byte lightValue) { + this.context = ctx; + ctx.blockId = (short) (blockMatches != null ? blockMatches.getOrDefault(block, -1) : -1); + ctx.renderType = ExtendedDataHelper.FLUID_RENDER_TYPE; + ctx.lightValue = lightValue; + } + + @Override + public void finishRenderingBlock() { + if (context != null) { + context.reset(); + } + } + + @Override + public long write(long ptr, Material material, Vertex vertex, int sectionIndex) { + uSum += vertex.u; + vSum += vertex.v; + vertexCount++; + + final BlockRenderContext ctx = context; + + baseEncoder.write(ptr, material, vertex, sectionIndex); + + // Per-vertex: renderType, midBlock, lightValue + memPutShort(ptr + MC_ENTITY_OFFSET + 2, ctx.renderType); + final int midBlock = ExtendedDataHelper.computeMidBlock(vertex.x, vertex.y, vertex.z, ctx.localPosX, ctx.localPosY, ctx.localPosZ); + memPutInt(ptr + MID_BLOCK_OFFSET, midBlock); + memPutByte(ptr + MID_BLOCK_OFFSET + 3, ctx.lightValue); + + // Per-quad: midTexCoord, blockId, normal, tangent + if (vertexCount == 4) { + vertexCount = 0; + + final float midU = uSum * 0.25f; + final float midV = vSum * 0.25f; + final int midUV = encodeMidTexture(midU, midV); + + memPutInt(ptr + MID_TEX_OFFSET, midUV); + memPutInt(ptr + MID_TEX_OFFSET - STRIDE, midUV); + memPutInt(ptr + MID_TEX_OFFSET - STRIDE * 2, midUV); + memPutInt(ptr + MID_TEX_OFFSET - STRIDE * 3, midUV); + + memPutShort(ptr + MC_ENTITY_OFFSET, ctx.blockId); + memPutShort(ptr + MC_ENTITY_OFFSET - STRIDE, ctx.blockId); + memPutShort(ptr + MC_ENTITY_OFFSET - STRIDE * 2, ctx.blockId); + memPutShort(ptr + MC_ENTITY_OFFSET - STRIDE * 3, ctx.blockId); + + quad.setup(ptr, STRIDE); + NormalHelper.computeFaceNormal(normal, quad); + final int packedNormal = NormI8.pack(normal); + + memPutInt(ptr + NORMAL_OFFSET, packedNormal); + memPutInt(ptr + NORMAL_OFFSET - STRIDE, packedNormal); + memPutInt(ptr + NORMAL_OFFSET - STRIDE * 2, packedNormal); + memPutInt(ptr + NORMAL_OFFSET - STRIDE * 3, packedNormal); + + final int tangent = NormalHelper.computeTangent(normal.x, normal.y, normal.z, quad); + + memPutInt(ptr + TANGENT_OFFSET, tangent); + memPutInt(ptr + TANGENT_OFFSET - STRIDE, tangent); + memPutInt(ptr + TANGENT_OFFSET - STRIDE * 2, tangent); + memPutInt(ptr + TANGENT_OFFSET - STRIDE * 3, tangent); + + uSum = 0; + vSum = 0; + } + + return ptr + STRIDE; + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/iris/IrisExtendedChunkVertexType.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/iris/IrisExtendedChunkVertexType.java new file mode 100644 index 000000000..6f70079db --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/iris/IrisExtendedChunkVertexType.java @@ -0,0 +1,65 @@ +package com.gtnewhorizons.angelica.rendering.celeritas.iris; + +import org.embeddedt.embeddium.impl.gl.attribute.GlVertexAttributeFormat; +import org.embeddedt.embeddium.impl.gl.attribute.GlVertexFormat; +import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkMeshFormats; +import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkVertexEncoder; +import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkVertexType; + +/** + * VANILLA_LIKE (28 bytes) + Iris extensions (20 bytes) = 48 bytes total. + * + * Iris extensions: + * mc_midTexCoord ushort[2] - quad center UV (average of 4 vertices) + * at_tangent byte[4] - tangent vector, normalized + * iris_Normal byte[3]+1 - face normal, normalized + * mc_Entity short[2] - (blockId, renderType) + * at_midBlock byte[4] - (xyz offset from block center, lightValue) + */ +public class IrisExtendedChunkVertexType implements ChunkVertexType { + public static final ChunkVertexType BASE_TYPE = ChunkMeshFormats.VANILLA_LIKE; + public static final int STRIDE = 48; + + public static final GlVertexFormat VERTEX_FORMAT = GlVertexFormat.builder(STRIDE) + .addAllElements(BASE_TYPE.getVertexFormat()) + .addElement("mc_midTexCoord", GlVertexFormat.NEXT_ALIGNED_POINTER, GlVertexAttributeFormat.UNSIGNED_SHORT, 2, false, false) + .addElement("at_tangent", GlVertexFormat.NEXT_ALIGNED_POINTER, GlVertexAttributeFormat.BYTE, 4, true, false) + .addElement("iris_Normal", GlVertexFormat.NEXT_ALIGNED_POINTER, GlVertexAttributeFormat.BYTE, 3, true, false) + .addElement("mc_Entity", GlVertexFormat.NEXT_ALIGNED_POINTER, GlVertexAttributeFormat.SHORT, 2, false, false) + .addElement("at_midBlock", GlVertexFormat.NEXT_ALIGNED_POINTER, GlVertexAttributeFormat.BYTE, 4, false, false) + .build(); + + private static final int TEXTURE_MAX_VALUE = 32768; + public static final float MID_TEX_SCALE = 1.0f / TEXTURE_MAX_VALUE; + + /** Pack UV as two unsigned shorts: low=u, high=v. */ + public static int encodeMidTexture(float u, float v) { + return ((Math.round(u * TEXTURE_MAX_VALUE) & 0xFFFF)) | + ((Math.round(v * TEXTURE_MAX_VALUE) & 0xFFFF) << 16); + } + + @Override + public ChunkVertexEncoder createEncoder() { + return new IrisExtendedChunkVertexEncoder(); + } + + @Override + public float getPositionScale() { + return BASE_TYPE.getPositionScale(); + } + + @Override + public float getPositionOffset() { + return BASE_TYPE.getPositionOffset(); + } + + @Override + public float getTextureScale() { + return BASE_TYPE.getTextureScale(); + } + + @Override + public GlVertexFormat getVertexFormat() { + return VERTEX_FORMAT; + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/threading/ChunkTaskProvider.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/threading/ChunkTaskProvider.java new file mode 100644 index 000000000..51384bc67 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/threading/ChunkTaskProvider.java @@ -0,0 +1,25 @@ +package com.gtnewhorizons.angelica.rendering.celeritas.threading; + +import com.gtnewhorizons.angelica.rendering.celeritas.world.cloned.ClonedChunkSectionCache; +import org.embeddedt.embeddium.impl.render.chunk.RenderSection; +import org.embeddedt.embeddium.impl.render.chunk.compile.ChunkBuildOutput; +import org.embeddedt.embeddium.impl.render.chunk.compile.tasks.ChunkBuilderTask; +import org.joml.Vector3d; + +public interface ChunkTaskProvider { + ChunkBuilderTask createRebuildTask(RenderSection render, int frame, Vector3d cameraPosition); + + default ChunkBuilderTask createRebuildTask(RenderSection render, int frame, Vector3d cameraPosition, ClonedChunkSectionCache sectionCache) { + return createRebuildTask(render, frame, cameraPosition); + } + + /** @return -1 = single-threaded, 0 = auto-detect, >0 = specific count */ + int threadCount(); + + /** Lower = higher priority */ + int priority(); + + default boolean isEnabled() { + return true; + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/threading/ChunkTaskRegistry.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/threading/ChunkTaskRegistry.java new file mode 100644 index 000000000..a16477a73 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/threading/ChunkTaskRegistry.java @@ -0,0 +1,47 @@ +package com.gtnewhorizons.angelica.rendering.celeritas.threading; + +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +import java.util.ArrayList; +import java.util.Comparator; +import java.util.List; + +public final class ChunkTaskRegistry { + private static final Logger LOGGER = LogManager.getLogger("ChunkTaskRegistry"); + private static final List providers = new ArrayList<>(); + private static ChunkTaskProvider activeProvider; + + private ChunkTaskRegistry() {} + + public static synchronized void registerProvider(ChunkTaskProvider provider) { + providers.add(provider); + providers.sort(Comparator.comparingInt(ChunkTaskProvider::priority)); + activeProvider = null; + LOGGER.info("Registered chunk task provider: {} (priority={})", + provider.getClass().getSimpleName(), provider.priority()); + } + + public static synchronized ChunkTaskProvider getActiveProvider() { + for (ChunkTaskProvider provider : providers) { + if (provider.isEnabled()) { + if (activeProvider != provider) { + activeProvider = provider; + LOGGER.info("Active chunk task provider: {} (threads={})", activeProvider.getClass().getSimpleName(), activeProvider.threadCount()); + } + return activeProvider; + } + } + + if (activeProvider != DefaultChunkTaskProvider.INSTANCE) { + activeProvider = DefaultChunkTaskProvider.INSTANCE; + LOGGER.info("Active chunk task provider: single-threaded fallback"); + } + return activeProvider; + } + + public static synchronized void reset() { + providers.clear(); + activeProvider = null; + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/threading/DefaultChunkTaskProvider.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/threading/DefaultChunkTaskProvider.java new file mode 100644 index 000000000..97d5ba0fa --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/threading/DefaultChunkTaskProvider.java @@ -0,0 +1,28 @@ +package com.gtnewhorizons.angelica.rendering.celeritas.threading; + +import com.gtnewhorizons.angelica.rendering.celeritas.AngelicaMainThreadMeshingTask; +import org.embeddedt.embeddium.impl.render.chunk.RenderSection; +import org.embeddedt.embeddium.impl.render.chunk.compile.ChunkBuildOutput; +import org.embeddedt.embeddium.impl.render.chunk.compile.tasks.ChunkBuilderTask; +import org.joml.Vector3d; + +public final class DefaultChunkTaskProvider implements ChunkTaskProvider { + public static final DefaultChunkTaskProvider INSTANCE = new DefaultChunkTaskProvider(); + + private DefaultChunkTaskProvider() {} + + @Override + public ChunkBuilderTask createRebuildTask(RenderSection render, int frame, Vector3d cameraPosition) { + return new AngelicaMainThreadMeshingTask(render, frame, cameraPosition); + } + + @Override + public int threadCount() { + return -1; + } + + @Override + public int priority() { + return Integer.MAX_VALUE; + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/threading/RenderPassHelper.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/threading/RenderPassHelper.java new file mode 100644 index 000000000..b545f7df6 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/threading/RenderPassHelper.java @@ -0,0 +1,26 @@ +package com.gtnewhorizons.angelica.rendering.celeritas.threading; + +import com.gtnewhorizons.angelica.glsm.GLStateManager; +import net.minecraftforge.client.ForgeHooksClient; + +public final class RenderPassHelper { + private static final ThreadLocal threadLocalPass = ThreadLocal.withInitial(() -> -1); + + private RenderPassHelper() {} + + public static int getWorldRenderPass() { + return GLStateManager.isMainThread() ? ForgeHooksClient.worldRenderPass : threadLocalPass.get(); + } + + public static void setWorldRenderPass(int pass) { + if (GLStateManager.isMainThread()) { + ForgeHooksClient.worldRenderPass = pass; + } else { + threadLocalPass.set(pass); + } + } + + public static void resetWorldRenderPass() { + setWorldRenderPass(-1); + } +} 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 new file mode 100644 index 000000000..1d294b34c --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/threading/ThreadedAngelicaChunkBuilderMeshingTask.java @@ -0,0 +1,118 @@ +package com.gtnewhorizons.angelica.rendering.celeritas.threading; + +import com.gtnewhorizon.gtnhlib.client.renderer.TessellatorManager; +import com.gtnewhorizons.angelica.rendering.AngelicaBlockSafetyRegistry; +import com.gtnewhorizons.angelica.rendering.celeritas.AngelicaChunkBuilderMeshingTask; +import com.gtnewhorizons.angelica.rendering.celeritas.SmoothBiomeColorCache; +import com.gtnewhorizons.angelica.rendering.celeritas.WorldClientExtension; +import com.gtnewhorizons.angelica.rendering.celeritas.world.WorldSlice; +import com.gtnewhorizons.angelica.rendering.celeritas.world.cloned.ChunkRenderContext; +import net.minecraft.block.Block; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.crash.CrashReportCategory; +import net.minecraft.world.ChunkCache; +import net.minecraft.world.IBlockAccess; +import org.embeddedt.embeddium.impl.render.chunk.RenderSection; +import org.embeddedt.embeddium.impl.render.chunk.compile.ChunkBuildContext; +import org.embeddedt.embeddium.impl.render.chunk.compile.ChunkBuildOutput; +import org.embeddedt.embeddium.impl.util.position.SectionPos; +import org.embeddedt.embeddium.impl.util.task.CancellationToken; +import org.jetbrains.annotations.Nullable; +import org.joml.Vector3d; +import com.gtnewhorizons.angelica.rendering.celeritas.AngelicaChunkBuildContext; + +public class ThreadedAngelicaChunkBuilderMeshingTask extends AngelicaChunkBuilderMeshingTask { + /** Vanilla render types (0-41) are thread-safe. ISBRHs (42+) need @ThreadSafeISBRH. */ + private static final int MAX_VANILLA_RENDER_TYPE = 41; + + private final @Nullable ChunkRenderContext renderContext; + + private IBlockAccess blockAccess; + private SmoothBiomeColorCache biomeColorCache; + private boolean enteredLocalMode; + + public ThreadedAngelicaChunkBuilderMeshingTask(RenderSection render, @Nullable ChunkRenderContext renderContext, int time, Vector3d camera) { + super(render, time, camera); + this.renderContext = renderContext; + } + + @Override + public ChunkBuildOutput execute(ChunkBuildContext context, CancellationToken cancellationToken) { + initBlockAccess((AngelicaChunkBuildContext) context); + return super.execute(context, cancellationToken); + } + + private void initBlockAccess(AngelicaChunkBuildContext buildContext) { + final int minX = this.render.getOriginX(); + final int minY = this.render.getOriginY(); + final int minZ = this.render.getOriginZ(); + + if (this.renderContext != null) { + final WorldSlice worldSlice = buildContext.getWorldSlice(); + worldSlice.copyData(this.renderContext); + this.blockAccess = worldSlice; + this.biomeColorCache = new SmoothBiomeColorCache(worldSlice); + this.biomeColorCache.update(new SectionPos(this.render.getChunkX(), this.render.getChunkY(), this.render.getChunkZ())); + } 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); + } + } + + @Override + protected Tessellator getTessellator() { + return Tessellator.instance; + } + + @Override + protected void setRenderPass(int pass) { + RenderPassHelper.setWorldRenderPass(pass); + } + + @Override + protected IBlockAccess getBlockAccess() { + return blockAccess; + } + + @Override + protected SmoothBiomeColorCache getBiomeColorCache() { + return biomeColorCache; + } + + @Override + protected boolean isThreaded() { + return enteredLocalMode; + } + + @Override + protected boolean canRenderOffThread(Block block) { + final int renderType = block.getRenderType(); + return (renderType >= 0 && renderType <= MAX_VANILLA_RENDER_TYPE) + || AngelicaBlockSafetyRegistry.canBlockRenderOffThread(block, true, true); + } + + @Override + protected void onEnterExecute() { + enteredLocalMode = !TessellatorManager.isOnMainThread(); + if (enteredLocalMode) { + TessellatorManager.enterLocalMode(); + } + } + + @Override + protected void onExitExecute() { + if (enteredLocalMode) { + RenderPassHelper.resetWorldRenderPass(); + TessellatorManager.exitLocalMode(); + } + } + + @Override + protected void addExtraCrashInfo(CrashReportCategory category) { + category.addCrashSection("Thread", Thread.currentThread().getName()); + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/threading/ThreadedChunkTaskProvider.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/threading/ThreadedChunkTaskProvider.java new file mode 100644 index 000000000..054d43412 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/threading/ThreadedChunkTaskProvider.java @@ -0,0 +1,45 @@ +package com.gtnewhorizons.angelica.rendering.celeritas.threading; + +import com.gtnewhorizons.angelica.compat.mojang.ChunkSectionPos; +import com.gtnewhorizons.angelica.config.AngelicaConfig; +import com.gtnewhorizons.angelica.rendering.celeritas.world.WorldSlice; +import com.gtnewhorizons.angelica.rendering.celeritas.world.cloned.ChunkRenderContext; +import com.gtnewhorizons.angelica.rendering.celeritas.world.cloned.ClonedChunkSectionCache; +import net.minecraft.client.Minecraft; +import org.embeddedt.embeddium.impl.render.chunk.RenderSection; +import org.embeddedt.embeddium.impl.render.chunk.compile.ChunkBuildOutput; +import org.embeddedt.embeddium.impl.render.chunk.compile.tasks.ChunkBuilderTask; +import org.joml.Vector3d; + +public final class ThreadedChunkTaskProvider implements ChunkTaskProvider { + public static final ThreadedChunkTaskProvider INSTANCE = new ThreadedChunkTaskProvider(); + + private ThreadedChunkTaskProvider() {} + + @Override + public ChunkBuilderTask createRebuildTask(RenderSection render, int frame, Vector3d cameraPosition) { + return new ThreadedAngelicaChunkBuilderMeshingTask(render, null, frame, cameraPosition); + } + + @Override + public ChunkBuilderTask createRebuildTask(RenderSection render, int frame, Vector3d cameraPosition, ClonedChunkSectionCache sectionCache) { + final ChunkSectionPos origin = ChunkSectionPos.from(render.getChunkX(), render.getChunkY(), render.getChunkZ()); + final ChunkRenderContext context = WorldSlice.prepare(Minecraft.getMinecraft().theWorld, origin, sectionCache); + return context == null ? null : new ThreadedAngelicaChunkBuilderMeshingTask(render, context, frame, cameraPosition); + } + + @Override + public int threadCount() { + return AngelicaConfig.chunkBuilderThreadCount; + } + + @Override + public int priority() { + return 1000; + } + + @Override + public boolean isEnabled() { + return AngelicaConfig.enableThreadedChunkBuilding; + } +} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/world/WorldSlice.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/world/WorldSlice.java similarity index 79% rename from src/main/java/me/jellysquid/mods/sodium/client/world/WorldSlice.java rename to src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/world/WorldSlice.java index 7073f0544..b6c5599e7 100644 --- a/src/main/java/me/jellysquid/mods/sodium/client/world/WorldSlice.java +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/world/WorldSlice.java @@ -1,17 +1,14 @@ -package me.jellysquid.mods.sodium.client.world; +package com.gtnewhorizons.angelica.rendering.celeritas.world; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing; import com.gtnewhorizons.angelica.api.IBlockAccessExtended; import com.gtnewhorizons.angelica.compat.ModStatus; import com.gtnewhorizons.angelica.compat.mojang.ChunkSectionPos; import com.gtnewhorizons.angelica.compat.mojang.CompatMathHelper; import com.gtnewhorizons.angelica.dynamiclights.DynamicLights; +import com.gtnewhorizons.angelica.rendering.celeritas.world.cloned.ChunkRenderContext; +import com.gtnewhorizons.angelica.rendering.celeritas.world.cloned.ClonedChunkSection; +import com.gtnewhorizons.angelica.rendering.celeritas.world.cloned.ClonedChunkSectionCache; import cpw.mods.fml.common.Optional; -import java.util.Arrays; -import lombok.Getter; -import me.jellysquid.mods.sodium.client.world.cloned.ChunkRenderContext; -import me.jellysquid.mods.sodium.client.world.cloned.ClonedChunkSection; -import me.jellysquid.mods.sodium.client.world.cloned.ClonedChunkSectionCache; import mega.fluidlogged.api.FLBlockAccess; import net.minecraft.block.Block; import net.minecraft.client.multiplayer.WorldClient; @@ -29,6 +26,8 @@ import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.Fluid; import org.jetbrains.annotations.Nullable; +import java.util.Arrays; + /** * Takes a slice of world state (block states, biome and light data arrays) and copies the data for use in off-thread * operations. This allows chunk build tasks to see a consistent snapshot of chunk data at the exact moment the task was @@ -41,6 +40,7 @@ import org.jetbrains.annotations.Nullable; */ @Optional.Interface(iface = "mega.fluidlogged.api.FLBlockAccess", modid = "fluidlogged") public class WorldSlice implements IBlockAccessExtended, FLBlockAccess { + private static final EnumSkyBlock[] LIGHT_TYPES = EnumSkyBlock.values(); // The number of blocks on each axis in a section. @@ -71,7 +71,7 @@ public class WorldSlice implements IBlockAccessExtended, FLBlockAccess { // The world this slice has copied data from private final WorldClient world; - // Local Section->BlockState table. + // Local Section->Block table private final Block[][] blockArrays; private final Fluid[][] fluidArrays; private final int[][] metadataArrays; @@ -79,7 +79,7 @@ public class WorldSlice implements IBlockAccessExtended, FLBlockAccess { // Local Section->Light table private final NibbleArray[][] lightArrays; - // Local section copies. Read-only. + // Local section copies private ClonedChunkSection[] sections; // Biome data for each chunk section @@ -89,32 +89,29 @@ public class WorldSlice implements IBlockAccessExtended, FLBlockAccess { private int baseX, baseY, baseZ; private final int worldHeight; - private final int[] defaultLightValues; // The chunk origin of this slice - @Getter private ChunkSectionPos origin; - - StructureBoundingBox volume; + private StructureBoundingBox volume; public static ChunkRenderContext prepare(World world, ChunkSectionPos origin, ClonedChunkSectionCache sectionCache) { final Chunk chunk = world.getChunkFromChunkCoords(origin.x, origin.z); final ExtendedBlockStorage section = chunk.getBlockStorageArray()[origin.y]; - // If the chunk section is absent or empty, simply terminate now. There will never be anything in this chunk - // section to render, so we need to signal that a chunk render task shouldn't created. This saves a considerable - // amount of time in queueing instant build tasks and greatly accelerates how quickly the world can be loaded. + // If the chunk section is absent or empty, terminate early if (section == null || section.isEmpty()) { return null; } - final StructureBoundingBox volume = new StructureBoundingBox(origin.getMinX() - NEIGHBOR_BLOCK_RADIUS, - origin.getMinY() - NEIGHBOR_BLOCK_RADIUS, - origin.getMinZ() - NEIGHBOR_BLOCK_RADIUS, - origin.getMaxX() + NEIGHBOR_BLOCK_RADIUS, - origin.getMaxY() + NEIGHBOR_BLOCK_RADIUS, - origin.getMaxZ() + NEIGHBOR_BLOCK_RADIUS); + final StructureBoundingBox volume = new StructureBoundingBox( + origin.getMinX() - NEIGHBOR_BLOCK_RADIUS, + origin.getMinY() - NEIGHBOR_BLOCK_RADIUS, + origin.getMinZ() - NEIGHBOR_BLOCK_RADIUS, + origin.getMaxX() + NEIGHBOR_BLOCK_RADIUS, + origin.getMaxY() + NEIGHBOR_BLOCK_RADIUS, + origin.getMaxZ() + NEIGHBOR_BLOCK_RADIUS + ); // The min/max bounds of the chunks copied by this slice final int minChunkX = origin.x - NEIGHBOR_CHUNK_RADIUS; @@ -130,7 +127,8 @@ public class WorldSlice implements IBlockAccessExtended, FLBlockAccess { for (int chunkX = minChunkX; chunkX <= maxChunkX; chunkX++) { for (int chunkZ = minChunkZ; chunkZ <= maxChunkZ; chunkZ++) { for (int chunkY = minChunkY; chunkY <= maxChunkY; chunkY++) { - sections[getLocalSectionIndex(chunkX - minChunkX, chunkY - minChunkY, chunkZ - minChunkZ)] = sectionCache.acquire(chunkX, chunkY, chunkZ); + sections[getLocalSectionIndex(chunkX - minChunkX, chunkY - minChunkY, chunkZ - minChunkZ)] = + sectionCache.acquire(chunkX, chunkY, chunkZ); } } } @@ -145,7 +143,7 @@ public class WorldSlice implements IBlockAccessExtended, FLBlockAccess { this.defaultLightValues[EnumSkyBlock.Sky.ordinal()] = world.provider.hasNoSky ? 0 : EnumSkyBlock.Sky.defaultLightValue; this.defaultLightValues[EnumSkyBlock.Block.ordinal()] = EnumSkyBlock.Block.defaultLightValue; - this.sections = new ClonedChunkSection[SECTION_TABLE_ARRAY_SIZE]; + // Note: sections array is assigned in copyData() from ChunkRenderContext this.blockArrays = new Block[SECTION_TABLE_ARRAY_SIZE][]; this.metadataArrays = new int[SECTION_TABLE_ARRAY_SIZE][]; this.biomeData = new BiomeGenBase[SECTION_TABLE_ARRAY_SIZE][]; @@ -187,12 +185,11 @@ public class WorldSlice implements IBlockAccessExtended, FLBlockAccess { for (int y = 0; y < SECTION_LENGTH; y++) { for (int z = 0; z < SECTION_LENGTH; z++) { final int idx = getLocalSectionIndex(x, y, z); - final ClonedChunkSection section = this.sections[idx]; this.unpackBlockData(this.blockArrays[idx], this.metadataArrays[idx], section, context.getVolume()); - if (ModStatus.isFluidLoggedLoaded) { + if (ModStatus.isFluidLoggedLoaded && this.fluidArrays != null) { this.unpackFluidLoggedData(this.fluidArrays[idx], section, context.getVolume()); } @@ -205,6 +202,10 @@ public class WorldSlice implements IBlockAccessExtended, FLBlockAccess { } } + public ChunkSectionPos getOrigin() { + return this.origin; + } + @Override public int getLightBrightnessForSkyBlocks(int x, int y, int z, int min) { if (y < 0 || y >= 256 || x < -30_000_000 || z < -30_000_000 || x >= 30_000_000 || z >= 30_000_000) { @@ -262,12 +263,10 @@ public class WorldSlice implements IBlockAccessExtended, FLBlockAccess { } final int relX = x - this.baseX; - final int relY = 0; final int relZ = z - this.baseZ; - final BiomeGenBase biome = this.biomeData[getLocalSectionIndex(relX >> 4, relY >> 4, relZ >> 4)] + final BiomeGenBase biome = this.biomeData[getLocalSectionIndex(relX >> 4, 0, relZ >> 4)] [(x & 15) | (z & 15) << 4]; - // can be null if biome wasn't generated yet return biome == null ? BiomeGenBase.plains : biome; } @@ -286,109 +285,7 @@ public class WorldSlice implements IBlockAccessExtended, FLBlockAccess { return getBlock(x, y, z).isSideSolid(this, x, y, z, side); } - private void unpackFluidLoggedData(Fluid[] fluids, ClonedChunkSection section, StructureBoundingBox box) { - if (this.origin.equals(section.getPosition())) { - this.unpackFluidLoggedDataZ(fluids, section); - } else { - this.unpackFluidLoggedDataR(fluids, section, box); - } - } - - private void unpackBlockData(Block[] blocks, int[] metas, ClonedChunkSection section, StructureBoundingBox box) { - if (this.origin.equals(section.getPosition())) { - this.unpackBlockDataZ(blocks, metas, section); - } else { - this.unpackBlockDataR(blocks, metas, section, box); - } - } - - private void unpackFluidLoggedDataR(Fluid[] fluids, ClonedChunkSection section, StructureBoundingBox box) { - final ChunkSectionPos pos = section.getPosition(); - - final int minBlockX = Math.max(box.minX, pos.getMinX()); - final int maxBlockX = Math.min(box.maxX, pos.getMaxX()); - - final int minBlockY = Math.max(box.minY, pos.getMinY()); - final int maxBlockY = Math.min(box.maxY, pos.getMaxY()); - - final int minBlockZ = Math.max(box.minZ, pos.getMinZ()); - final int maxBlockZ = Math.min(box.maxZ, pos.getMaxZ()); - - copyFluids(fluids, section, minBlockY, maxBlockY, minBlockZ, maxBlockZ, minBlockX, maxBlockX); - } - - private void unpackFluidLoggedDataZ(Fluid[] fluids, ClonedChunkSection section) { - // TODO: Look into a faster copy for this? - final ChunkSectionPos pos = section.getPosition(); - - final int minBlockX = pos.getMinX(); - final int maxBlockX = pos.getMaxX(); - - final int minBlockY = pos.getMinY(); - final int maxBlockY = pos.getMaxY(); - - final int minBlockZ = pos.getMinZ(); - final int maxBlockZ = pos.getMaxZ(); - - // TODO: Can this be optimized? - copyFluids(fluids, section, minBlockY, maxBlockY, minBlockZ, maxBlockZ, minBlockX, maxBlockX); - } - - private static void copyFluids(Fluid[] fluids, ClonedChunkSection section, int minBlockY, int maxBlockY, int minBlockZ, int maxBlockZ, int minBlockX, int maxBlockX) { - for (int y = minBlockY; y <= maxBlockY; y++) { - for (int z = minBlockZ; z <= maxBlockZ; z++) { - for (int x = minBlockX; x <= maxBlockX; x++) { - final int blockIdx = getLocalBlockIndex(x & 15, y & 15, z & 15); - fluids[blockIdx] = section.getFluid(x & 15, y & 15, z & 15); - } - } - } - } - - private static void copyBlocks(Block[] blocks, int[] metas, ClonedChunkSection section, int minBlockY, int maxBlockY, int minBlockZ, int maxBlockZ, int minBlockX, int maxBlockX) { - for (int y = minBlockY; y <= maxBlockY; y++) { - for (int z = minBlockZ; z <= maxBlockZ; z++) { - for (int x = minBlockX; x <= maxBlockX; x++) { - final int blockIdx = getLocalBlockIndex(x & 15, y & 15, z & 15); - blocks[blockIdx] = section.getBlock(x & 15, y & 15, z & 15); - metas[blockIdx] = section.getBlockMetadata(x & 15, y & 15, z & 15); - } - } - } - } - - private void unpackBlockDataR(Block[] blocks, int metas[], ClonedChunkSection section, StructureBoundingBox box) { - final ChunkSectionPos pos = section.getPosition(); - - final int minBlockX = Math.max(box.minX, pos.getMinX()); - final int maxBlockX = Math.min(box.maxX, pos.getMaxX()); - - final int minBlockY = Math.max(box.minY, pos.getMinY()); - final int maxBlockY = Math.min(box.maxY, pos.getMaxY()); - - final int minBlockZ = Math.max(box.minZ, pos.getMinZ()); - final int maxBlockZ = Math.min(box.maxZ, pos.getMaxZ()); - - copyBlocks(blocks, metas, section, minBlockY, maxBlockY, minBlockZ, maxBlockZ, minBlockX, maxBlockX); - } - - private void unpackBlockDataZ(Block[] blocks, int[] metas, ClonedChunkSection section) { - // TODO: Look into a faster copy for this? - final ChunkSectionPos pos = section.getPosition(); - - final int minBlockX = pos.getMinX(); - final int maxBlockX = pos.getMaxX(); - - final int minBlockY = pos.getMinY(); - final int maxBlockY = pos.getMaxY(); - - final int minBlockZ = pos.getMinZ(); - final int maxBlockZ = pos.getMaxZ(); - - // TODO: Can this be optimized? - copyBlocks(blocks, metas, section, minBlockY, maxBlockY, minBlockZ, maxBlockZ, minBlockX, maxBlockX); - } - + @Override public Block getBlock(int x, int y, int z) { if (!blockBoxContains(this.volume, x, y, z)) { return Blocks.air; @@ -444,13 +341,120 @@ public class WorldSlice implements IBlockAccessExtended, FLBlockAccess { final NibbleArray lightArray = this.lightArrays[getLocalSectionIndex(relX >> 4, relY >> 4, relZ >> 4)][type.ordinal()]; if (lightArray == null) { - // If the array is null, it means the dimension for the current world does not support that light type return this.defaultLightValues[type.ordinal()]; } return lightArray.get(relX & 15, relY & 15, relZ & 15); } + @Override + public World getWorld() { + return this.world; + } + + // FluidLogged API support + + public @Nullable Fluid fl$getFluid(int x, int y, int z) { + if (!blockBoxContains(this.volume, x, y, z) || this.fluidArrays == null) { + return null; + } + + final int relX = x - this.baseX; + final int relY = y - this.baseY; + final int relZ = z - this.baseZ; + return this.fluidArrays[getLocalSectionIndex(relX >> 4, relY >> 4, relZ >> 4)][getLocalBlockIndex(relX & 15, relY & 15, relZ & 15)]; + } + + public void fl$setFluid(int x, int y, int z, @Nullable Fluid fluid) { + throw new UnsupportedOperationException("Cannot set fluids in a world slice. WorldSlice is read-only"); + } + + // Internal helper methods + + private void unpackBlockData(Block[] blocks, int[] metas, ClonedChunkSection section, StructureBoundingBox box) { + if (this.origin.equals(section.getPosition())) { + this.unpackBlockDataZ(blocks, metas, section); + } else { + this.unpackBlockDataR(blocks, metas, section, box); + } + } + + private void unpackFluidLoggedData(Fluid[] fluids, ClonedChunkSection section, StructureBoundingBox box) { + if (this.origin.equals(section.getPosition())) { + this.unpackFluidLoggedDataZ(fluids, section); + } else { + this.unpackFluidLoggedDataR(fluids, section, box); + } + } + + private void unpackBlockDataZ(Block[] blocks, int[] metas, ClonedChunkSection section) { + final ChunkSectionPos pos = section.getPosition(); + + for (int y = pos.getMinY(); y <= pos.getMaxY(); y++) { + for (int z = pos.getMinZ(); z <= pos.getMaxZ(); z++) { + for (int x = pos.getMinX(); x <= pos.getMaxX(); x++) { + final int blockIdx = getLocalBlockIndex(x & 15, y & 15, z & 15); + blocks[blockIdx] = section.getBlock(x & 15, y & 15, z & 15); + metas[blockIdx] = section.getBlockMetadata(x & 15, y & 15, z & 15); + } + } + } + } + + private void unpackBlockDataR(Block[] blocks, int[] metas, ClonedChunkSection section, StructureBoundingBox box) { + final ChunkSectionPos pos = section.getPosition(); + + final int minBlockX = Math.max(box.minX, pos.getMinX()); + final int maxBlockX = Math.min(box.maxX, pos.getMaxX()); + final int minBlockY = Math.max(box.minY, pos.getMinY()); + final int maxBlockY = Math.min(box.maxY, pos.getMaxY()); + final int minBlockZ = Math.max(box.minZ, pos.getMinZ()); + final int maxBlockZ = Math.min(box.maxZ, pos.getMaxZ()); + + for (int y = minBlockY; y <= maxBlockY; y++) { + for (int z = minBlockZ; z <= maxBlockZ; z++) { + for (int x = minBlockX; x <= maxBlockX; x++) { + final int blockIdx = getLocalBlockIndex(x & 15, y & 15, z & 15); + blocks[blockIdx] = section.getBlock(x & 15, y & 15, z & 15); + metas[blockIdx] = section.getBlockMetadata(x & 15, y & 15, z & 15); + } + } + } + } + + private void unpackFluidLoggedDataZ(Fluid[] fluids, ClonedChunkSection section) { + final ChunkSectionPos pos = section.getPosition(); + + for (int y = pos.getMinY(); y <= pos.getMaxY(); y++) { + for (int z = pos.getMinZ(); z <= pos.getMaxZ(); z++) { + for (int x = pos.getMinX(); x <= pos.getMaxX(); x++) { + final int blockIdx = getLocalBlockIndex(x & 15, y & 15, z & 15); + fluids[blockIdx] = section.getFluid(x & 15, y & 15, z & 15); + } + } + } + } + + private void unpackFluidLoggedDataR(Fluid[] fluids, ClonedChunkSection section, StructureBoundingBox box) { + final ChunkSectionPos pos = section.getPosition(); + + final int minBlockX = Math.max(box.minX, pos.getMinX()); + final int maxBlockX = Math.min(box.maxX, pos.getMaxX()); + final int minBlockY = Math.max(box.minY, pos.getMinY()); + final int maxBlockY = Math.min(box.maxY, pos.getMaxY()); + final int minBlockZ = Math.max(box.minZ, pos.getMinZ()); + final int maxBlockZ = Math.min(box.maxZ, pos.getMaxZ()); + + for (int y = minBlockY; y <= maxBlockY; y++) { + for (int z = minBlockZ; z <= maxBlockZ; z++) { + for (int x = minBlockX; x <= maxBlockX; x++) { + final int blockIdx = getLocalBlockIndex(x & 15, y & 15, z & 15); + fluids[blockIdx] = section.getFluid(x & 15, y & 15, z & 15); + } + } + } + } + public static int getLocalBlockIndex(int x, int y, int z) { return y << 8 | z << 4 | x; } @@ -459,54 +463,9 @@ public class WorldSlice implements IBlockAccessExtended, FLBlockAccess { return y << TABLE_BITS << TABLE_BITS | z << TABLE_BITS | x; } - public static int getLocalChunkIndex(int x, int z) { - return z << TABLE_BITS | x; - } - - /// Modern checks if the sky is darkened, which only happens in the nether. However, I think 1.7.10's hasNoSky is - /// close enough. - public float getBrightness(ModelQuadFacing direction, boolean shaded) { - - if (!shaded) { - return world.provider.hasNoSky ? 0.9f : 1.0f; - } - return switch (direction) { - case NEG_Y -> 0.5f; - case POS_Y -> 1.0f; - case NEG_Z, POS_Z -> 0.8f; - default -> 0.6f; - }; - } - - @Override - public World getWorld() { - return this.world; - } private static boolean blockBoxContains(StructureBoundingBox box, int x, int y, int z) { - return x >= box.minX && - x <= box.maxX && - y >= box.minY && - y <= box.maxY && - z >= box.minZ && - z <= box.maxZ; - } - - public @Nullable Fluid fl$getFluid(int x, int y, int z) { - if (!blockBoxContains(this.volume, x, y, z)) { - return null; - } - - final int relX = x - this.baseX; - final int relY = y - this.baseY; - final int relZ = z - this.baseZ; - return this.fluidArrays[getLocalSectionIndex(relX >> 4, relY >> 4, relZ >> 4)][getLocalBlockIndex(relX & 15, relY & 15, relZ & 15)]; - } - - public Fluid getFluidRelative(int x, int y, int z) { - return this.fluidArrays[getLocalSectionIndex(x >> 4, y >> 4, z >> 4)][getLocalBlockIndex(x & 15, y & 15, z & 15)]; - } - - public void fl$setFluid(int x, int y, int z, @Nullable Fluid fluid) { - throw new UnsupportedOperationException("Cannot set fluids in a world slice. WorldSlice is read-only"); + return x >= box.minX && x <= box.maxX && + y >= box.minY && y <= box.maxY && + z >= box.minZ && z <= box.maxZ; } } diff --git a/src/main/java/me/jellysquid/mods/sodium/client/world/cloned/ChunkRenderContext.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/world/cloned/ChunkRenderContext.java similarity index 73% rename from src/main/java/me/jellysquid/mods/sodium/client/world/cloned/ChunkRenderContext.java rename to src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/world/cloned/ChunkRenderContext.java index 19dfd8d01..1b9806316 100644 --- a/src/main/java/me/jellysquid/mods/sodium/client/world/cloned/ChunkRenderContext.java +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/world/cloned/ChunkRenderContext.java @@ -1,9 +1,10 @@ -package me.jellysquid.mods.sodium.client.world.cloned; +package com.gtnewhorizons.angelica.rendering.celeritas.world.cloned; import com.gtnewhorizons.angelica.compat.mojang.ChunkSectionPos; import net.minecraft.world.gen.structure.StructureBoundingBox; public class ChunkRenderContext { + private final ChunkSectionPos origin; private final ClonedChunkSection[] sections; private final StructureBoundingBox volume; @@ -14,23 +15,15 @@ public class ChunkRenderContext { this.volume = volume; } - public ClonedChunkSection[] getSections() { - return this.sections; - } - public ChunkSectionPos getOrigin() { return this.origin; } + public ClonedChunkSection[] getSections() { + return this.sections; + } + public StructureBoundingBox getVolume() { return this.volume; } - - public void releaseResources() { - for (ClonedChunkSection section : sections) { - if (section != null) { - section.getBackingCache().release(section); - } - } - } } diff --git a/src/main/java/me/jellysquid/mods/sodium/client/world/cloned/ClonedChunkSection.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/world/cloned/ClonedChunkSection.java similarity index 67% rename from src/main/java/me/jellysquid/mods/sodium/client/world/cloned/ClonedChunkSection.java rename to src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/world/cloned/ClonedChunkSection.java index de0ec7f03..c2eae231b 100644 --- a/src/main/java/me/jellysquid/mods/sodium/client/world/cloned/ClonedChunkSection.java +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/world/cloned/ClonedChunkSection.java @@ -1,4 +1,4 @@ -package me.jellysquid.mods.sodium.client.world.cloned; +package com.gtnewhorizons.angelica.rendering.celeritas.world.cloned; import com.falsepattern.endlessids.mixin.helpers.ChunkBiomeHook; import com.gtnewhorizons.angelica.compat.ExtendedBlockStorageExt; @@ -6,7 +6,6 @@ import com.gtnewhorizons.angelica.compat.ModStatus; import com.gtnewhorizons.angelica.compat.mojang.ChunkSectionPos; import it.unimi.dsi.fastutil.shorts.Short2ObjectMap; import it.unimi.dsi.fastutil.shorts.Short2ObjectOpenHashMap; -import lombok.Getter; import mega.fluidlogged.internal.mixin.hook.FLSubChunk; import net.minecraft.block.Block; import net.minecraft.tileentity.TileEntity; @@ -18,24 +17,17 @@ import net.minecraft.world.chunk.NibbleArray; import net.minecraft.world.chunk.storage.ExtendedBlockStorage; import net.minecraftforge.fluids.Fluid; -import java.util.concurrent.atomic.AtomicInteger; - public class ClonedChunkSection { private static final ExtendedBlockStorage EMPTY_SECTION = new ExtendedBlockStorage(0, false); - private final AtomicInteger referenceCount = new AtomicInteger(0); private final ClonedChunkSectionCache backingCache; - - private final Short2ObjectMap tileEntities; - - private ExtendedBlockStorageExt data; private final World world; private ChunkSectionPos pos; - - @Getter + private ExtendedBlockStorageExt data; private BiomeGenBase[] biomeData; + private final Short2ObjectMap tileEntities; private long lastUsedTimestamp = Long.MAX_VALUE; @@ -54,7 +46,7 @@ public class ClonedChunkSection { ExtendedBlockStorage section = getChunkSection(chunk, pos); - if (section == null /*WorldChunk.EMPTY_SECTION*/ /*ChunkSection.isEmpty(section)*/) { + if (section == null) { section = EMPTY_SECTION; } @@ -63,7 +55,7 @@ public class ClonedChunkSection { int bArrLength; if (ModStatus.isEIDBiomeLoaded) { - bArrLength = ((ChunkBiomeHook)chunk).getBiomeShortArray().length; + bArrLength = ((ChunkBiomeHook) chunk).getBiomeShortArray().length; } else { bArrLength = chunk.getBiomeArray().length; } @@ -72,20 +64,18 @@ public class ClonedChunkSection { this.tileEntities.clear(); // Check for tile entities - for(int y = pos.getMinY(); y <= pos.getMaxY(); y++) { - for(int z = pos.getMinZ(); z <= pos.getMaxZ(); z++) { - for(int x = pos.getMinX(); x <= pos.getMaxX(); x++) { - int lX = x & 15, lY = y & 15, lZ = z & 15; + for (int y = pos.getMinY(); y <= pos.getMaxY(); y++) { + for (int z = pos.getMinZ(); z <= pos.getMaxZ(); z++) { + for (int x = pos.getMinX(); x <= pos.getMaxX(); x++) { + final int lX = x & 15, lY = y & 15, lZ = z & 15; // We have to use this insanity because in 1.7 the tile entity isn't guaranteed to be created // when the chunk gets scheduled for rendering. So we might have to create it. // Cloning is done on the main thread so this will not introduce threading issues - Block block = data.getBlockByExtId(lX, lY, lZ); - if(block.hasTileEntity(data.getExtBlockMetadata(lX, lY, lZ))) { - TileEntity tileentity = chunk.func_150806_e(x & 15, y, z & 15); - - if (tileentity != null) - { - this.tileEntities.put(ChunkSectionPos.packLocal(tileentity.xCoord & 15, tileentity.yCoord & 15, tileentity.zCoord & 15), tileentity); + final Block block = data.getBlockByExtId(lX, lY, lZ); + if (block.hasTileEntity(data.getExtBlockMetadata(lX, lY, lZ))) { + final TileEntity tileEntity = chunk.func_150806_e(x & 15, y, z & 15); + if (tileEntity != null) { + this.tileEntities.put(ChunkSectionPos.packLocal(tileEntity.xCoord & 15, tileEntity.yCoord & 15, tileEntity.zCoord & 15), tileEntity); } } } @@ -93,9 +83,9 @@ public class ClonedChunkSection { } // Fill biome data - for(int z = pos.getMinZ(); z <= pos.getMaxZ(); z++) { - for(int x = pos.getMinX(); x <= pos.getMaxX(); x++) { - this.biomeData[((z & 15) << 4) | (x & 15)] = world.getBiomeGenForCoords(x, z); + for (int z = pos.getMinZ(); z <= pos.getMaxZ(); z++) { + for (int x = pos.getMinX(); x <= pos.getMaxX(); x++) { + this.biomeData[(x & 15) | ((z & 15) << 4)] = world.getBiomeGenForCoords(x, z); } } } @@ -104,56 +94,46 @@ public class ClonedChunkSection { return data.getBlockByExtId(x, y, z); } - public Fluid getFluid(int x, int y, int z) { - if (ModStatus.isFluidLoggedLoaded) { - return ((FLSubChunk) data).fl$getFluid(x, y, z); - } - - return null; - } - public int getBlockMetadata(int x, int y, int z) { return data.getExtBlockMetadata(x, y, z); } + public Fluid getFluid(int x, int y, int z) { + if (ModStatus.isFluidLoggedLoaded) { + return ((FLSubChunk) data).fl$getFluid(x, y, z); + } + return null; + } + public NibbleArray getLightArray(EnumSkyBlock type) { - if(type == EnumSkyBlock.Sky) { + if (type == EnumSkyBlock.Sky) { return (!world.provider.hasNoSky && data.hasSky) ? data.getSkylightArray() : null; } return data.getBlocklightArray(); } - public BiomeGenBase getBiomeForNoiseGen(int x, int y, int z) { - return this.biomeData[x | z << 4]; + public BiomeGenBase[] getBiomeData() { + return this.biomeData; + } + public BiomeGenBase getBiomeForNoiseGen(int x, int z) { + return this.biomeData[(x & 15) | ((z & 15) << 4)]; } public TileEntity getBlockEntity(int x, int y, int z) { - return this.tileEntities.get(packLocal(x, y, z)); + return this.tileEntities.get(ChunkSectionPos.packLocal(x, y, z)); } public ChunkSectionPos getPosition() { return this.pos; } - public static boolean isOutOfBuildLimitVertically(int y) { - return y < 0 || y >= 256; + public ExtendedBlockStorageExt getData() { + return this.data; } - private static ExtendedBlockStorage getChunkSection(Chunk chunk, ChunkSectionPos pos) { - if (!isOutOfBuildLimitVertically(ChunkSectionPos.getBlockCoord(pos.y()))) { - return chunk.getBlockStorageArray()[pos.y]; - } - - return null; - } - - public void acquireReference() { - this.referenceCount.incrementAndGet(); - } - - public boolean releaseReference() { - return this.referenceCount.decrementAndGet() <= 0; + public ClonedChunkSectionCache getBackingCache() { + return this.backingCache; } public long getLastUsedTimestamp() { @@ -164,17 +144,14 @@ public class ClonedChunkSection { this.lastUsedTimestamp = timestamp; } - public ClonedChunkSectionCache getBackingCache() { - return this.backingCache; + public static boolean isOutOfBuildLimitVertically(int y) { + return y < 0 || y >= 256; } - /** - * @param x The local x-coordinate - * @param y The local y-coordinate - * @param z The local z-coordinate - * @return An index which can be used to key entities or blocks within a chunk - */ - private static short packLocal(int x, int y, int z) { - return (short) (x << 8 | z << 4 | y); + private static ExtendedBlockStorage getChunkSection(Chunk chunk, ChunkSectionPos pos) { + if (!isOutOfBuildLimitVertically(ChunkSectionPos.getBlockCoord(pos.y))) { + return chunk.getBlockStorageArray()[pos.y]; + } + return null; } } diff --git a/src/main/java/me/jellysquid/mods/sodium/client/world/cloned/ClonedChunkSectionCache.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/world/cloned/ClonedChunkSectionCache.java similarity index 68% rename from src/main/java/me/jellysquid/mods/sodium/client/world/cloned/ClonedChunkSectionCache.java rename to src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/world/cloned/ClonedChunkSectionCache.java index 3d2866520..807e8f78e 100644 --- a/src/main/java/me/jellysquid/mods/sodium/client/world/cloned/ClonedChunkSectionCache.java +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/world/cloned/ClonedChunkSectionCache.java @@ -1,4 +1,4 @@ -package me.jellysquid.mods.sodium.client.world.cloned; +package com.gtnewhorizons.angelica.rendering.celeritas.world.cloned; import com.gtnewhorizons.angelica.compat.mojang.ChunkSectionPos; import it.unimi.dsi.fastutil.longs.Long2ReferenceLinkedOpenHashMap; @@ -7,13 +7,12 @@ import net.minecraft.world.World; import java.util.concurrent.TimeUnit; public class ClonedChunkSectionCache { - private static final int MAX_CACHE_SIZE = 512; /* number of entries */ - private static final long MAX_CACHE_DURATION = TimeUnit.SECONDS.toNanos(5); /* number of nanoseconds */ + private static final int MAX_CACHE_SIZE = 512; + private static final long MAX_CACHE_DURATION = TimeUnit.SECONDS.toNanos(5); private final World world; - private final Long2ReferenceLinkedOpenHashMap byPosition = new Long2ReferenceLinkedOpenHashMap<>(); - private long time; // updated once per frame to be the elapsed time since application start + private long time; public ClonedChunkSectionCache(World world) { this.world = world; @@ -26,30 +25,25 @@ public class ClonedChunkSectionCache { } public synchronized ClonedChunkSection acquire(int x, int y, int z) { - long key = ChunkSectionPos.asLong(x, y, z); - ClonedChunkSection section = this.byPosition.get(key); + final long key = ChunkSectionPos.asLong(x, y, z); + ClonedChunkSection section = this.byPosition.getAndMoveToLast(key); if (section == null) { while (this.byPosition.size() >= MAX_CACHE_SIZE) { this.byPosition.removeFirst(); } - section = this.createSection(x, y, z); } section.setLastUsedTimestamp(this.time); - return section; } private ClonedChunkSection createSection(int x, int y, int z) { - ClonedChunkSection section = this.allocate(); - - ChunkSectionPos pos = ChunkSectionPos.from(x, y, z); + final ClonedChunkSection section = new ClonedChunkSection(this, this.world); + final ChunkSectionPos pos = ChunkSectionPos.from(x, y, z); section.init(pos); - this.byPosition.putAndMoveToLast(pos.asLong(), section); - return section; } @@ -57,16 +51,7 @@ public class ClonedChunkSectionCache { this.byPosition.remove(ChunkSectionPos.asLong(x, y, z)); } - public void release(ClonedChunkSection section) { - - } - - private ClonedChunkSection allocate() { - return new ClonedChunkSection(this, this.world); - } - private static long getMonotonicTimeSource() { - // Should be monotonic in JDK 17 on sane platforms... return System.nanoTime(); } } diff --git a/src/main/java/jss/notfine/gui/NotFineGameOptionPages.java b/src/main/java/jss/notfine/gui/NotFineGameOptionPages.java index e09e83db6..eea594698 100644 --- a/src/main/java/jss/notfine/gui/NotFineGameOptionPages.java +++ b/src/main/java/jss/notfine/gui/NotFineGameOptionPages.java @@ -22,7 +22,6 @@ import me.jellysquid.mods.sodium.client.gui.options.named.LightingQuality; import me.jellysquid.mods.sodium.client.gui.options.named.ParticleMode; import me.jellysquid.mods.sodium.client.gui.options.storage.MinecraftOptionsStorage; import me.jellysquid.mods.sodium.client.gui.options.storage.SodiumOptionsStorage; -import me.jellysquid.mods.sodium.client.render.chunk.backends.multidraw.MultidrawChunkRenderBackend; import net.coderbot.iris.Iris; import net.coderbot.iris.gui.option.IrisVideoSettings; import net.minecraft.client.Minecraft; @@ -285,7 +284,7 @@ public class NotFineGameOptionPages { .setBinding((opts, value) -> opts.advanced.useChunkMultidraw = value, opts -> opts.advanced.useChunkMultidraw) .setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD) .setImpact(OptionImpact.EXTREME) - .setEnabled(MultidrawChunkRenderBackend.isSupported(sodiumOpts.getData().advanced.ignoreDriverBlacklist)) + .setEnabled(true) .build()) .add(OptionImpl.createBuilder(boolean.class, sodiumOpts) .setName(I18n.format("sodium.options.use_vertex_objects.name")) diff --git a/src/main/java/me/jellysquid/mods/sodium/client/SodiumDebugScreenHandler.java b/src/main/java/me/jellysquid/mods/sodium/client/SodiumDebugScreenHandler.java deleted file mode 100644 index cdd8e1df1..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/SodiumDebugScreenHandler.java +++ /dev/null @@ -1,40 +0,0 @@ -package me.jellysquid.mods.sodium.client; - -import cpw.mods.fml.common.eventhandler.EventPriority; -import cpw.mods.fml.common.eventhandler.SubscribeEvent; -import me.jellysquid.mods.sodium.client.render.SodiumWorldRenderer; -import me.jellysquid.mods.sodium.client.render.chunk.ChunkRenderBackend; -import net.minecraft.client.Minecraft; -import net.minecraftforge.client.event.RenderGameOverlayEvent; - -import java.lang.management.ManagementFactory; -import java.util.ArrayList; -import java.util.List; - -public class SodiumDebugScreenHandler { - public static final SodiumDebugScreenHandler INSTANCE = new SodiumDebugScreenHandler(); - @SubscribeEvent(priority = EventPriority.LOW) - public void onRenderGameOverlayTextEvent(RenderGameOverlayEvent.Text event) { - final Minecraft mc = Minecraft.getMinecraft(); - if (mc.gameSettings.showDebugInfo) { - event.right.add(Math.min(event.right.size(), 2), "Off-Heap: +" + ManagementFactory.getMemoryMXBean().getNonHeapMemoryUsage().getUsed() / 1024L / 1024L + "MB"); - - event.right.add(""); - event.right.add("Sodium (Embeddium) Renderer"); - event.right.addAll(getChunkRendererDebugStrings()); - - } - } - - private static List getChunkRendererDebugStrings() { - ChunkRenderBackend backend = SodiumWorldRenderer.getInstance().getChunkRenderer(); - - List strings = new ArrayList<>(5); - strings.add("Chunk Renderer: " + backend.getRendererName()); - strings.add("Block Renderer: " + "Sodium"); - strings.addAll(backend.getDebugStrings()); - - return strings; - } - -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/GlObject.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/GlObject.java deleted file mode 100644 index d75f94ece..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/GlObject.java +++ /dev/null @@ -1,48 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl; - -import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; - -/** - * An abstract object used to represent objects in OpenGL code safely. This class hides the direct handle to a OpenGL - * object, requiring that it first be checked by all callers to prevent null pointer de-referencing. However, this will - * not stop code from cloning the handle and trying to use it after it has been deleted and as such should not be - * relied on too heavily. - */ -public class GlObject { - private static final int INVALID_HANDLE = Integer.MIN_VALUE; - - protected final RenderDevice device; - private int handle = INVALID_HANDLE; - - public GlObject(RenderDevice owner) { - this.device = owner; - } - - protected final void setHandle(int handle) { - this.handle = handle; - } - - public final int handle() { - this.checkHandle(); - - return this.handle; - } - - protected final void checkHandle() { - if (!this.isHandleValid()) { - throw new IllegalStateException("Handle is not valid"); - } - } - - protected final boolean isHandleValid() { - return this.handle != INVALID_HANDLE; - } - - public final void invalidateHandle() { - this.handle = INVALID_HANDLE; - } - - public RenderDevice getDevice() { - return this.device; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/arena/GlBufferArena.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/arena/GlBufferArena.java deleted file mode 100644 index 8d727b614..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/arena/GlBufferArena.java +++ /dev/null @@ -1,169 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.arena; - -import it.unimi.dsi.fastutil.objects.ObjectLinkedOpenHashSet; -import me.jellysquid.mods.sodium.client.gl.buffer.GlBuffer; -import me.jellysquid.mods.sodium.client.gl.buffer.GlBufferTarget; -import me.jellysquid.mods.sodium.client.gl.buffer.GlBufferUsage; -import me.jellysquid.mods.sodium.client.gl.buffer.GlMutableBuffer; -import me.jellysquid.mods.sodium.client.gl.device.CommandList; -import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; - -import java.util.Set; - -public class GlBufferArena { - private static final GlBufferUsage BUFFER_USAGE = GlBufferUsage.GL_DYNAMIC_DRAW; - - private final RenderDevice device; - private final int resizeIncrement; - - private final Set freeRegions = new ObjectLinkedOpenHashSet<>(); - - private GlMutableBuffer vertexBuffer; - - private int position; - private int capacity; - private int allocCount; - - public GlBufferArena(RenderDevice device, int initialSize, int resizeIncrement) { - this.device = device; - - try (CommandList commands = device.createCommandList()) { - this.vertexBuffer = commands.createMutableBuffer(BUFFER_USAGE); - commands.allocateBuffer(GlBufferTarget.COPY_WRITE_BUFFER, this.vertexBuffer, initialSize); - } - - this.resizeIncrement = resizeIncrement; - this.capacity = initialSize; - } - - private void resize(CommandList commandList, int newCapacity) { - GlMutableBuffer src = this.vertexBuffer; - GlMutableBuffer dst = commandList.createMutableBuffer(BUFFER_USAGE); - - commandList.allocateBuffer(GlBufferTarget.COPY_WRITE_BUFFER, dst, newCapacity); - commandList.copyBufferSubData(src, dst, 0, 0, this.position); - commandList.deleteBuffer(src); - - this.vertexBuffer = dst; - this.capacity = newCapacity; - } - - public void prepareBuffer(CommandList commandList, int bytes) { - if (this.position + bytes >= this.capacity) { - this.resize(commandList, this.getNextSize(bytes)); - } - } - - public GlBufferSegment uploadBuffer(CommandList commandList, GlBuffer readBuffer, int readOffset, int byteCount) { - this.prepareBuffer(commandList, byteCount); - - GlBufferSegment segment = this.alloc(byteCount); - - commandList.copyBufferSubData(readBuffer, this.vertexBuffer, readOffset, segment.getStart(), byteCount); - - return segment; - } - - private int getNextSize(int len) { - return Math.max(this.capacity + this.resizeIncrement, this.capacity + len); - } - - public void free(GlBufferSegment segment) { - if (this.freeRegions.contains(segment)) { - throw new IllegalArgumentException("Segment already freed"); - } - - // Attempt merging - GlBufferSegment prev = null, next = null; - int selfEnd = segment.getEnd(); - for (GlBufferSegment freeSeg : this.freeRegions) { - if (prev != null && next != null) - break; - if (freeSeg.getStart() == selfEnd) { - next = freeSeg; - } else if (freeSeg.getEnd() == segment.getStart()) { - prev = freeSeg; - } - } - - if(prev != null || next != null) { - int start, end; - - if(prev != null) { - this.freeRegions.remove(prev); - start = prev.getStart(); - } else { - start = segment.getStart(); - } - - if(next != null) { - this.freeRegions.remove(next); - end = next.getEnd(); - } else { - end = segment.getEnd(); - } - - segment = new GlBufferSegment(this, start, end - start); - } - - this.freeRegions.add(segment); - - this.allocCount--; - } - - private GlBufferSegment alloc(int len) { - GlBufferSegment segment = this.allocReuse(len); - - if (segment == null) { - segment = new GlBufferSegment(this, this.position, len); - - this.position += len; - } - - this.allocCount++; - - return segment; - } - - private GlBufferSegment allocReuse(int len) { - GlBufferSegment bestSegment = null; - - for (GlBufferSegment segment : this.freeRegions) { - if (segment.getLength() < len) { - continue; - } - - if (bestSegment == null || bestSegment.getLength() > segment.getLength()) { - bestSegment = segment; - } - } - - if (bestSegment == null) { - return null; - } - - this.freeRegions.remove(bestSegment); - - int excess = bestSegment.getLength() - len; - - if (excess > 0) { - this.freeRegions.add(new GlBufferSegment(this, bestSegment.getStart() + len, excess)); - } - - return new GlBufferSegment(this, bestSegment.getStart(), len); - } - - public void delete() { - try (CommandList commands = this.device.createCommandList()) { - commands.deleteBuffer(this.vertexBuffer); - } - } - - public boolean isEmpty() { - return this.allocCount <= 0; - } - - public GlBuffer getBuffer() { - return this.vertexBuffer; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/arena/GlBufferSegment.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/arena/GlBufferSegment.java deleted file mode 100644 index c9f4d3432..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/arena/GlBufferSegment.java +++ /dev/null @@ -1,29 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.arena; - -public class GlBufferSegment { - private final GlBufferArena arena; - private final int start; - private final int len; - - GlBufferSegment(GlBufferArena arena, int start, int len) { - this.arena = arena; - this.start = start; - this.len = len; - } - - public int getStart() { - return this.start; - } - - public int getLength() { - return this.len; - } - - public int getEnd() { - return this.start + this.len; - } - - public void delete() { - this.arena.free(this); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/array/GlVertexArray.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/array/GlVertexArray.java deleted file mode 100644 index d72612acc..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/array/GlVertexArray.java +++ /dev/null @@ -1,22 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.array; - -import me.jellysquid.mods.sodium.client.gl.GlObject; -import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; -import me.jellysquid.mods.sodium.client.gl.func.GlFunctions; - -/** - * Provides Vertex Array functionality on supported platforms. - */ -public class GlVertexArray extends GlObject { - public static final int NULL_ARRAY_ID = 0; - - public GlVertexArray(RenderDevice owner) { - super(owner); - - if (!GlFunctions.isVertexArraySupported()) { - throw new UnsupportedOperationException("Vertex arrays are unsupported on this platform"); - } - - this.setHandle(GlFunctions.VERTEX_ARRAY.glGenVertexArrays()); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/attribute/BufferVertexFormat.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/attribute/BufferVertexFormat.java deleted file mode 100644 index 9fda9d775..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/attribute/BufferVertexFormat.java +++ /dev/null @@ -1,11 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.attribute; - -import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat; - -public interface BufferVertexFormat { - static BufferVertexFormat from(VertexFormat format) { - return (BufferVertexFormat) format; - } - - int getStride(); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/attribute/GlVertexAttribute.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/attribute/GlVertexAttribute.java deleted file mode 100644 index 0cadb2432..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/attribute/GlVertexAttribute.java +++ /dev/null @@ -1,55 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.attribute; - -public class GlVertexAttribute { - private final int format; - private final int count; - private final int pointer; - private final int size; - private final int stride; - - private final boolean normalized; - - /** - * @param format The format used - * @param count The number of components in the vertex attribute - * @param normalized Specifies whether or not fixed-point data values should be normalized (true) or used directly - * as fixed-point values (false) - * @param pointer The offset to the first component in the attribute - */ - public GlVertexAttribute(GlVertexAttributeFormat format, int count, boolean normalized, int pointer, int stride) { - this(format.getGlFormat(), format.getSize() * count, count, normalized, pointer, stride); - } - - protected GlVertexAttribute(int format, int size, int count, boolean normalized, int pointer, int stride) { - this.format = format; - this.size = size; - this.count = count; - this.normalized = normalized; - this.pointer = pointer; - this.stride = stride; - } - - public int getSize() { - return this.size; - } - - public int getPointer() { - return this.pointer; - } - - public int getCount() { - return this.count; - } - - public int getFormat() { - return this.format; - } - - public boolean isNormalized() { - return this.normalized; - } - - public int getStride() { - return this.stride; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/attribute/GlVertexAttributeBinding.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/attribute/GlVertexAttributeBinding.java deleted file mode 100644 index 233808eaa..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/attribute/GlVertexAttributeBinding.java +++ /dev/null @@ -1,17 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.attribute; - -import me.jellysquid.mods.sodium.client.gl.shader.ShaderBindingPoint; - -public class GlVertexAttributeBinding extends GlVertexAttribute { - private final int index; - - public GlVertexAttributeBinding(ShaderBindingPoint bindingPoint, GlVertexAttribute attribute) { - super(attribute.getFormat(), attribute.getSize(), attribute.getCount(), attribute.isNormalized(), attribute.getPointer(), attribute.getStride()); - - this.index = bindingPoint.getGenericAttributeIndex(); - } - - public int getIndex() { - return this.index; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/attribute/GlVertexAttributeFormat.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/attribute/GlVertexAttributeFormat.java deleted file mode 100644 index 11ba3aa27..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/attribute/GlVertexAttributeFormat.java +++ /dev/null @@ -1,28 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.attribute; - -import org.lwjgl.opengl.GL11; - -/** - * An enumeration over the supported data types that can be used for vertex attributes. - */ -public class GlVertexAttributeFormat { - public static final GlVertexAttributeFormat FLOAT = new GlVertexAttributeFormat(GL11.GL_FLOAT, 4); - public static final GlVertexAttributeFormat UNSIGNED_SHORT = new GlVertexAttributeFormat(GL11.GL_UNSIGNED_SHORT, 2); - public static final GlVertexAttributeFormat UNSIGNED_BYTE = new GlVertexAttributeFormat(GL11.GL_UNSIGNED_BYTE, 1); - - private final int glId; - private final int size; - - public GlVertexAttributeFormat(int glId, int size) { - this.glId = glId; - this.size = size; - } - - public int getSize() { - return this.size; - } - - public int getGlFormat() { - return this.glId; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/attribute/GlVertexFormat.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/attribute/GlVertexFormat.java deleted file mode 100644 index 655abbe55..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/attribute/GlVertexFormat.java +++ /dev/null @@ -1,133 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.attribute; - -import lombok.Getter; -import me.jellysquid.mods.sodium.client.render.chunk.format.ChunkMeshAttribute; - -import java.util.EnumMap; - -/** - * Provides a generic vertex format which contains the attributes defined by {@param T}. Other code can then retrieve - * the attributes and work with encoded data in a generic manner without needing to rely on a specific format. - * - * @param The enumeration over the vertex attributes - */ -public class GlVertexFormat> implements BufferVertexFormat { - // Iris - private static final GlVertexAttribute EMPTY = new GlVertexAttribute(GlVertexAttributeFormat.FLOAT, 0, false, 0, 0); - - private final Class attributeEnum; - private final EnumMap attributesKeyed; - private final GlVertexAttribute[] attributesArray; - - /** - * -- GETTER -- - * - * The stride (or the size of) the vertex format in bytes - */ - @Getter - private final int stride; - - public GlVertexFormat(Class attributeEnum, EnumMap attributesKeyed, int stride) { - this.attributeEnum = attributeEnum; - this.attributesKeyed = attributesKeyed; - this.attributesArray = attributesKeyed.values().toArray(new GlVertexAttribute[0]); - this.stride = stride; - } - - public static > Builder builder(Class type, int stride) { - return new Builder<>(type, stride); - } - - /** - * Returns the {@link GlVertexAttribute} of this vertex format bound to the type {@param name}. - * @throws NullPointerException If the attribute does not exist in this format - */ - public GlVertexAttribute getAttribute(T name) { - final GlVertexAttribute attr = this.attributesKeyed.get(name); - - if (attr == null) { - throw new NullPointerException("No attribute exists for " + name.toString()); - } - - return attr; - } - - @Override - public String toString() { - return String.format("GlVertexFormat<%s>{attributes=%d,stride=%d}", this.attributeEnum.getName(), - this.attributesKeyed.size(), this.stride); - } - - public GlVertexAttribute[] getAttributesArray() { - return this.attributesArray; - } - - public static class Builder> { - private final EnumMap attributes; - private final Class type; - private final int stride; - - public Builder(Class type, int stride) { - this.type = type; - this.attributes = new EnumMap<>(type); - this.stride = stride; - } - - public Builder addElement(T type, int pointer, GlVertexAttributeFormat format, int count, boolean normalized) { - return this.addElement(type, new GlVertexAttribute(format, count, normalized, pointer, this.stride)); - } - - /** - * Adds an vertex attribute which will be bound to the given generic attribute type. - * - * @param type The generic attribute type - * @param attribute The attribute to bind - * @throws IllegalStateException If an attribute is already bound to the generic type - */ - private Builder addElement(T type, GlVertexAttribute attribute) { - if ((attribute.getPointer() >= this.stride)) { - throw new IllegalArgumentException("Element starts outside vertex format"); - } - - if ((attribute.getPointer() + attribute.getSize() > this.stride)) { - throw new IllegalArgumentException("Element extends outside vertex format"); - } - - if (this.attributes.put(type, attribute) != null) { - throw new IllegalStateException("Generic attribute " + type.name() + " already defined in vertex format"); - } - - return this; - } - - /** - * Creates a {@link GlVertexFormat} from the current builder. - */ - public GlVertexFormat build() { - int size = 0; - - for (T key : this.type.getEnumConstants()) { - GlVertexAttribute attribute = this.attributes.get(key); - - if (attribute == null) { - if(key == ChunkMeshAttribute.NORMAL || key == ChunkMeshAttribute.TANGENT || key == ChunkMeshAttribute.MID_TEX_COORD || key == ChunkMeshAttribute.BLOCK_ID || key == ChunkMeshAttribute.MID_BLOCK) { - // Missing these attributes is acceptable and will be handled properly. - attribute = EMPTY; - } else { - throw new NullPointerException("Generic attribute not assigned to enumeration " + key.name()); - } - } - - size = Math.max(size, attribute.getPointer() + attribute.getSize()); - } - - // The stride must be large enough to cover all attributes. This still allows for additional padding - // to be added to the end of the vertex to accommodate alignment restrictions. - if (this.stride < size) { - throw new IllegalArgumentException("Stride is too small"); - } - - return new GlVertexFormat<>(this.type, this.attributes, this.stride); - } - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/buffer/GlBuffer.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/buffer/GlBuffer.java deleted file mode 100644 index 0aa420a93..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/buffer/GlBuffer.java +++ /dev/null @@ -1,23 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.buffer; - -import me.jellysquid.mods.sodium.client.gl.GlObject; -import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; -import org.lwjgl.opengl.GL15; - -public abstract class GlBuffer extends GlObject { - public static final int NULL_BUFFER_ID = 0; - - protected final GlBufferUsage usage; - - protected GlBuffer(RenderDevice owner, GlBufferUsage usage) { - super(owner); - - this.setHandle(GL15.glGenBuffers()); - - this.usage = usage; - } - - public GlBufferUsage getUsageHint() { - return this.usage; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/buffer/GlBufferTarget.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/buffer/GlBufferTarget.java deleted file mode 100644 index 8de59ec0d..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/buffer/GlBufferTarget.java +++ /dev/null @@ -1,31 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.buffer; - -import org.lwjgl.opengl.GL15; -import org.lwjgl.opengl.GL31; -import org.lwjgl.opengl.GL40; - -public enum GlBufferTarget { - ARRAY_BUFFER(GL15.GL_ARRAY_BUFFER, GL15.GL_ARRAY_BUFFER_BINDING), - COPY_READ_BUFFER(GL31.GL_COPY_READ_BUFFER, GL31.GL_COPY_READ_BUFFER), - COPY_WRITE_BUFFER(GL31.GL_COPY_WRITE_BUFFER, GL31.GL_COPY_WRITE_BUFFER), - DRAW_INDIRECT_BUFFER(GL40.GL_DRAW_INDIRECT_BUFFER, GL40.GL_DRAW_INDIRECT_BUFFER_BINDING); - - public static final GlBufferTarget[] VALUES = GlBufferTarget.values(); - public static final int COUNT = VALUES.length; - - private final int target; - private final int binding; - - GlBufferTarget(int target, int binding) { - this.target = target; - this.binding = binding; - } - - public int getTargetParameter() { - return this.target; - } - - public int getBindingParameter() { - return this.binding; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/buffer/GlBufferUsage.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/buffer/GlBufferUsage.java deleted file mode 100644 index d779dad5c..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/buffer/GlBufferUsage.java +++ /dev/null @@ -1,25 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.buffer; - -import org.lwjgl.opengl.GL15; - -public enum GlBufferUsage { - GL_STREAM_DRAW(GL15.GL_STREAM_DRAW), - GL_STREAM_READ(GL15.GL_STREAM_READ), - GL_STREAM_COPY(GL15.GL_STREAM_COPY), - GL_STATIC_DRAW(GL15.GL_STATIC_DRAW), - GL_STATIC_READ(GL15.GL_STATIC_READ), - GL_STATIC_COPY(GL15.GL_STATIC_COPY), - GL_DYNAMIC_DRAW(GL15.GL_DYNAMIC_DRAW), - GL_DYNAMIC_READ(GL15.GL_DYNAMIC_READ), - GL_DYNAMIC_COPY(GL15.GL_DYNAMIC_COPY); - - private final int id; - - GlBufferUsage(int id) { - this.id = id; - } - - public int getId() { - return this.id; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/buffer/GlMutableBuffer.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/buffer/GlMutableBuffer.java deleted file mode 100644 index 7f1ec5bb2..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/buffer/GlMutableBuffer.java +++ /dev/null @@ -1,23 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.buffer; - -import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; - -/** - * A mutable buffer type which is supported with OpenGL 1.5+. The buffer's storage can be reallocated at any time - * without needing to re-create the buffer itself. - */ -public class GlMutableBuffer extends GlBuffer { - private long size = 0L; - - public GlMutableBuffer(RenderDevice owner, GlBufferUsage usage) { - super(owner, usage); - } - - public void setSize(long size) { - this.size = size; - } - - public long getSize() { - return this.size; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/buffer/VertexData.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/buffer/VertexData.java deleted file mode 100644 index d27aba592..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/buffer/VertexData.java +++ /dev/null @@ -1,18 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.buffer; - -import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexFormat; - -import java.nio.ByteBuffer; - -/** - * Helper type for tagging the vertex format alongside the raw buffer data. - */ -public class VertexData { - public final GlVertexFormat format; - public final ByteBuffer buffer; - - public VertexData(ByteBuffer buffer, GlVertexFormat format) { - this.format = format; - this.buffer = buffer; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/compat/FogHelper.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/compat/FogHelper.java deleted file mode 100644 index 186075d2f..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/compat/FogHelper.java +++ /dev/null @@ -1,57 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.compat; - -import com.gtnewhorizons.angelica.glsm.GLStateManager; -import me.jellysquid.mods.sodium.client.render.chunk.shader.ChunkFogMode; -import org.lwjgl.opengl.GL11; - -public class FogHelper { - private static final float FAR_PLANE_THRESHOLD_EXP = (float) Math.log(1.0f / 0.0019f); - private static final float FAR_PLANE_THRESHOLD_EXP2 = (float) Math.sqrt(FAR_PLANE_THRESHOLD_EXP); - - public static float red, green, blue; - - public static float getFogEnd() { - return GLStateManager.getFogState().getEnd(); - } - - public static float getFogStart() { - return GLStateManager.getFogState().getStart(); - } - - public static float getFogDensity() { - return GLStateManager.getFogState().getDensity(); - } - - /** - * Retrieves the current fog mode from the fixed-function pipeline. - */ - public static ChunkFogMode getFogMode() { - final int mode = GLStateManager.getFogState().getFogMode(); - - if(mode == 0 || !GLStateManager.getFogMode().isEnabled()) - return ChunkFogMode.NONE; - - return switch (mode) { - case GL11.GL_EXP2, GL11.GL_EXP -> ChunkFogMode.EXP2; - case GL11.GL_LINEAR -> ChunkFogMode.LINEAR; - default -> throw new UnsupportedOperationException("Unknown fog mode: " + mode); - }; - } - - public static float getFogCutoff() { - int mode = GLStateManager.getFogState().getFogMode(); - - return switch (mode) { - case GL11.GL_LINEAR -> getFogEnd(); - case GL11.GL_EXP -> FAR_PLANE_THRESHOLD_EXP / getFogDensity(); - case GL11.GL_EXP2 -> FAR_PLANE_THRESHOLD_EXP2 / getFogDensity(); - default -> 0.0f; - }; - } - - public static float[] getFogColor() { - // TODO: Sodium -// return new float[]{BackgroundRenderer.red, BackgroundRenderer.green, BackgroundRenderer.blue, 1.0F}; - return new float[]{red, green, blue, 1.0F}; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/device/CommandList.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/device/CommandList.java deleted file mode 100644 index f1678c6f7..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/device/CommandList.java +++ /dev/null @@ -1,56 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.device; - -import me.jellysquid.mods.sodium.client.gl.array.GlVertexArray; -import me.jellysquid.mods.sodium.client.gl.buffer.GlBuffer; -import me.jellysquid.mods.sodium.client.gl.buffer.GlBufferTarget; -import me.jellysquid.mods.sodium.client.gl.buffer.GlBufferUsage; -import me.jellysquid.mods.sodium.client.gl.buffer.GlMutableBuffer; -import me.jellysquid.mods.sodium.client.gl.buffer.VertexData; -import me.jellysquid.mods.sodium.client.gl.tessellation.GlPrimitiveType; -import me.jellysquid.mods.sodium.client.gl.tessellation.GlTessellation; -import me.jellysquid.mods.sodium.client.gl.tessellation.TessellationBinding; - -import java.nio.ByteBuffer; - -public interface CommandList extends AutoCloseable { - GlVertexArray createVertexArray(); - - GlMutableBuffer createMutableBuffer(GlBufferUsage usage); - - GlTessellation createTessellation(GlPrimitiveType primitiveType, TessellationBinding[] bindings); - - void bindVertexArray(GlVertexArray array); - - default void uploadData(GlMutableBuffer glBuffer, VertexData data) { - this.uploadData(glBuffer, data.buffer); - } - - void uploadData(GlMutableBuffer glBuffer, ByteBuffer byteBuffer); - - void copyBufferSubData(GlBuffer src, GlMutableBuffer dst, long readOffset, long writeOffset, long bytes); - - void bindBuffer(GlBufferTarget target, GlBuffer buffer); - - void unbindBuffer(GlBufferTarget target); - - void unbindVertexArray(); - - void invalidateBuffer(GlMutableBuffer glBuffer); - - void allocateBuffer(GlBufferTarget target, GlMutableBuffer buffer, long bufferSize); - - void deleteBuffer(GlBuffer buffer); - - void deleteVertexArray(GlVertexArray vertexArray); - - void flush(); - - DrawCommandList beginTessellating(GlTessellation tessellation); - - void deleteTessellation(GlTessellation tessellation); - - @Override - default void close() { - this.flush(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/device/DrawCommandList.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/device/DrawCommandList.java deleted file mode 100644 index 3e9994183..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/device/DrawCommandList.java +++ /dev/null @@ -1,20 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.device; - -import java.nio.ByteBuffer; -import java.nio.IntBuffer; - -public interface DrawCommandList extends AutoCloseable { - void multiDrawArrays(IntBuffer first, IntBuffer count); - - void multiDrawArraysIndirect(ByteBuffer pointer, int count, int stride); - void multiDrawArraysIndirect(long pointer, int count, int stride); - - void endTessellating(); - - void flush(); - - @Override - default void close() { - this.flush(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/device/GLRenderDevice.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/device/GLRenderDevice.java deleted file mode 100644 index a741022fe..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/device/GLRenderDevice.java +++ /dev/null @@ -1,225 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.device; - -import me.jellysquid.mods.sodium.client.gl.array.GlVertexArray; -import me.jellysquid.mods.sodium.client.gl.buffer.GlBuffer; -import me.jellysquid.mods.sodium.client.gl.buffer.GlBufferTarget; -import me.jellysquid.mods.sodium.client.gl.buffer.GlBufferUsage; -import me.jellysquid.mods.sodium.client.gl.buffer.GlMutableBuffer; -import me.jellysquid.mods.sodium.client.gl.func.GlFunctions; -import me.jellysquid.mods.sodium.client.gl.state.GlStateTracker; -import me.jellysquid.mods.sodium.client.gl.tessellation.GlFallbackTessellation; -import me.jellysquid.mods.sodium.client.gl.tessellation.GlPrimitiveType; -import me.jellysquid.mods.sodium.client.gl.tessellation.GlTessellation; -import me.jellysquid.mods.sodium.client.gl.tessellation.GlVertexArrayTessellation; -import me.jellysquid.mods.sodium.client.gl.tessellation.TessellationBinding; -import org.lwjgl.opengl.GL14; -import org.lwjgl.opengl.GL15; -import org.lwjgl.opengl.GL31; - -import java.nio.ByteBuffer; -import java.nio.IntBuffer; - -public class GLRenderDevice implements RenderDevice { - private final GlStateTracker stateTracker = new GlStateTracker(); - private final CommandList commandList = new ImmediateCommandList(this.stateTracker); - private final DrawCommandList drawCommandList = new ImmediateDrawCommandList(); - - private boolean isActive; - private GlTessellation activeTessellation; - - @Override - public CommandList createCommandList() { - GLRenderDevice.this.checkDeviceActive(); - - return this.commandList; - } - - @Override - public void makeActive() { - if (this.isActive) { - return; - } - - this.stateTracker.clearRestoreState(); - this.isActive = true; - } - - @Override - public void makeInactive() { - if (!this.isActive) { - return; - } - - this.stateTracker.applyRestoreState(); - this.isActive = false; - } - - private void checkDeviceActive() { - if (!this.isActive) { - throw new IllegalStateException("Tried to access device from unmanaged context"); - } - } - - private class ImmediateCommandList implements CommandList { - private final GlStateTracker stateTracker; - - private ImmediateCommandList(GlStateTracker stateTracker) { - this.stateTracker = stateTracker; - } - - @Override - public void bindVertexArray(GlVertexArray array) { - if (this.stateTracker.makeVertexArrayActive(array)) { - GlFunctions.VERTEX_ARRAY.glBindVertexArray(array.handle()); - } - } - - @Override - public void uploadData(GlMutableBuffer glBuffer, ByteBuffer byteBuffer) { - this.bindBuffer(GlBufferTarget.ARRAY_BUFFER, glBuffer); - - GL15.glBufferData(GlBufferTarget.ARRAY_BUFFER.getTargetParameter(), byteBuffer, glBuffer.getUsageHint().getId()); - - glBuffer.setSize(byteBuffer.limit()); - } - - @Override - public void copyBufferSubData(GlBuffer src, GlMutableBuffer dst, long readOffset, long writeOffset, long bytes) { - if (writeOffset + bytes > dst.getSize()) { - throw new IllegalArgumentException("Not enough space in destination buffer (writeOffset + bytes > bufferSize)"); - } - - this.bindBuffer(GlBufferTarget.COPY_READ_BUFFER, src); - this.bindBuffer(GlBufferTarget.COPY_WRITE_BUFFER, dst); - - GlFunctions.BUFFER_COPY.glCopyBufferSubData(GL31.GL_COPY_READ_BUFFER, GL31.GL_COPY_WRITE_BUFFER, readOffset, writeOffset, bytes); - } - - @Override - public void bindBuffer(GlBufferTarget target, GlBuffer buffer) { - if (this.stateTracker.makeBufferActive(target, buffer)) { - GL15.glBindBuffer(target.getTargetParameter(), buffer.handle()); - } - } - - @Override - public void unbindBuffer(GlBufferTarget target) { - if (this.stateTracker.makeBufferActive(target, null)) { - GL15.glBindBuffer(target.getTargetParameter(), GlBuffer.NULL_BUFFER_ID); - } - } - - @Override - public void unbindVertexArray() { - if (this.stateTracker.makeVertexArrayActive(null)) { - GlFunctions.VERTEX_ARRAY.glBindVertexArray(GlVertexArray.NULL_ARRAY_ID); - } - } - - @Override - public void invalidateBuffer(GlMutableBuffer glBuffer) { - this.allocateBuffer(GlBufferTarget.ARRAY_BUFFER, glBuffer, 0L); - } - - @Override - public void allocateBuffer(GlBufferTarget target, GlMutableBuffer buffer, long bufferSize) { - this.bindBuffer(target, buffer); - - GL15.glBufferData(target.getTargetParameter(), bufferSize, buffer.getUsageHint().getId()); - buffer.setSize(bufferSize); - } - - @Override - public void deleteBuffer(GlBuffer buffer) { - final int handle = buffer.handle(); - buffer.invalidateHandle(); - - GL15.glDeleteBuffers(handle); - } - - @Override - public void deleteVertexArray(GlVertexArray array) { - final int handle = array.handle(); - array.invalidateHandle(); - - GlFunctions.VERTEX_ARRAY.glDeleteVertexArrays(handle); - } - - @Override - public void flush() { - // NO-OP - } - - @Override - public DrawCommandList beginTessellating(GlTessellation tessellation) { - GLRenderDevice.this.activeTessellation = tessellation; - GLRenderDevice.this.activeTessellation.bind(GLRenderDevice.this.commandList); - - return GLRenderDevice.this.drawCommandList; - } - - @Override - public void deleteTessellation(GlTessellation tessellation) { - tessellation.delete(this); - } - - @Override - public GlVertexArray createVertexArray() { - return new GlVertexArray(GLRenderDevice.this); - } - - @Override - public GlMutableBuffer createMutableBuffer(GlBufferUsage usage) { - return new GlMutableBuffer(GLRenderDevice.this, usage); - } - - @Override - public GlTessellation createTessellation(GlPrimitiveType primitiveType, TessellationBinding[] bindings) { - if (GlVertexArrayTessellation.isSupported()) { - final GlVertexArrayTessellation tessellation = new GlVertexArrayTessellation(new GlVertexArray(GLRenderDevice.this), primitiveType, bindings); - tessellation.init(this); - - return tessellation; - } else { - return new GlFallbackTessellation(primitiveType, bindings); - } - } - } - - private class ImmediateDrawCommandList implements DrawCommandList { - public ImmediateDrawCommandList() { - - } - - @Override - public void multiDrawArrays(IntBuffer first, IntBuffer count) { - final GlPrimitiveType primitiveType = GLRenderDevice.this.activeTessellation.getPrimitiveType(); - GL14.glMultiDrawArrays(primitiveType.getId(), first, count); - } - - @Override - public void multiDrawArraysIndirect(ByteBuffer pointer, int count, int stride) { - final GlPrimitiveType primitiveType = GLRenderDevice.this.activeTessellation.getPrimitiveType(); - GlFunctions.INDIRECT_DRAW.glMultiDrawArraysIndirect(primitiveType.getId(), pointer, count, stride); - } - - @Override - public void multiDrawArraysIndirect(long pointer, int count, int stride) { - final GlPrimitiveType primitiveType = GLRenderDevice.this.activeTessellation.getPrimitiveType(); - GlFunctions.INDIRECT_DRAW.glMultiDrawArraysIndirect(primitiveType.getId(), pointer, count, stride); - } - - @Override - public void endTessellating() { - GLRenderDevice.this.activeTessellation.unbind(GLRenderDevice.this.commandList); - GLRenderDevice.this.activeTessellation = null; - } - - @Override - public void flush() { - if (GLRenderDevice.this.activeTessellation != null) { - this.endTessellating(); - } - } - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/device/RenderDevice.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/device/RenderDevice.java deleted file mode 100644 index ffbf2a8e5..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/device/RenderDevice.java +++ /dev/null @@ -1,18 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.device; - -public interface RenderDevice { - RenderDevice INSTANCE = new GLRenderDevice(); - - CommandList createCommandList(); - - static void enterManagedCode() { - RenderDevice.INSTANCE.makeActive(); - } - - static void exitManagedCode() { - RenderDevice.INSTANCE.makeInactive(); - } - - void makeActive(); - void makeInactive(); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/func/GlBufferCopyFunctions.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/func/GlBufferCopyFunctions.java deleted file mode 100644 index 1ea1d8501..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/func/GlBufferCopyFunctions.java +++ /dev/null @@ -1,41 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.func; - -import org.lwjgl.opengl.ARBCopyBuffer; -import org.lwjgl.opengl.ContextCapabilities; -import org.lwjgl.opengl.GL31; - -/** - * Requires OpenGL 3.1+ or the ARB_copy_buffer extension. - */ -public enum GlBufferCopyFunctions { - CORE { - @Override - public void glCopyBufferSubData(int readTarget, int writeTarget, long readOffset, long writeOffset, long size) { - GL31.glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); - } - }, - ARB { - @Override - public void glCopyBufferSubData(int readTarget, int writeTarget, long readOffset, long writeOffset, long size) { - ARBCopyBuffer.glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); - } - }, - UNSUPPORTED { - @Override - public void glCopyBufferSubData(int readTarget, int writeTarget, long readOffset, long writeOffset, long size) { - throw new UnsupportedOperationException(); - } - }; - - static GlBufferCopyFunctions load(ContextCapabilities capabilities) { - if (capabilities.OpenGL31) { - return GlBufferCopyFunctions.CORE; - } else if (capabilities.GL_ARB_copy_buffer) { - return GlBufferCopyFunctions.ARB; - } else { - return GlBufferCopyFunctions.UNSUPPORTED; - } - } - - public abstract void glCopyBufferSubData(int readTarget, int writeTarget, long readOffset, long writeOffset, long size); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/func/GlFunctions.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/func/GlFunctions.java deleted file mode 100644 index 3ee84b09c..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/func/GlFunctions.java +++ /dev/null @@ -1,29 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.func; - -import org.lwjgl.opengl.ContextCapabilities; -import org.lwjgl.opengl.GLContext; - -public class GlFunctions { - private static final ContextCapabilities capabilities = GLContext.getCapabilities(); - - public static final GlVertexArrayFunctions VERTEX_ARRAY = GlVertexArrayFunctions.load(capabilities); - public static final GlBufferCopyFunctions BUFFER_COPY = GlBufferCopyFunctions.load(capabilities); - public static final GlIndirectMultiDrawFunctions INDIRECT_DRAW = GlIndirectMultiDrawFunctions.load(capabilities); - public static final GlInstancedArrayFunctions INSTANCED_ARRAY = GlInstancedArrayFunctions.load(capabilities); - - public static boolean isVertexArraySupported() { - return VERTEX_ARRAY != GlVertexArrayFunctions.UNSUPPORTED; - } - - public static boolean isBufferCopySupported() { - return BUFFER_COPY != GlBufferCopyFunctions.UNSUPPORTED; - } - - public static boolean isIndirectMultiDrawSupported() { - return INDIRECT_DRAW != GlIndirectMultiDrawFunctions.UNSUPPORTED; - } - - public static boolean isInstancedArraySupported() { - return INSTANCED_ARRAY != GlInstancedArrayFunctions.UNSUPPORTED; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/func/GlIndirectMultiDrawFunctions.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/func/GlIndirectMultiDrawFunctions.java deleted file mode 100644 index dc101050f..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/func/GlIndirectMultiDrawFunctions.java +++ /dev/null @@ -1,57 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.func; - -import java.nio.ByteBuffer; - -import org.lwjgl.opengl.ARBMultiDrawIndirect; -import org.lwjgl.opengl.ContextCapabilities; -import org.lwjgl.opengl.GL43; - -public enum GlIndirectMultiDrawFunctions { - CORE { - @Override - public void glMultiDrawArraysIndirect(int mode, ByteBuffer indirect, int primcount, int stride) { - GL43.glMultiDrawArraysIndirect(mode, indirect, primcount, stride); - } - - @Override - public void glMultiDrawArraysIndirect(int mode, long indirect, int primcount, int stride) { - GL43.glMultiDrawArraysIndirect(mode, indirect, primcount, stride); - } - }, - ARB { - @Override - public void glMultiDrawArraysIndirect(int mode, ByteBuffer indirect, int primcount, int stride) { - ARBMultiDrawIndirect.glMultiDrawArraysIndirect(mode, indirect, primcount, stride); - } - - @Override - public void glMultiDrawArraysIndirect(int mode, long indirect, int primcount, int stride) { - ARBMultiDrawIndirect.glMultiDrawArraysIndirect(mode, indirect, primcount, stride); - } - }, - UNSUPPORTED { - @Override - public void glMultiDrawArraysIndirect(int mode, ByteBuffer indirect, int primcount, int stride) { - throw new UnsupportedOperationException(); - } - - @Override - public void glMultiDrawArraysIndirect(int mode, long indirect, int primcount, int stride) { - throw new UnsupportedOperationException(); - } - }; - - public static GlIndirectMultiDrawFunctions load(ContextCapabilities capabilities) { - if (capabilities.OpenGL43) { - return CORE; - } else if (capabilities.GL_ARB_multi_draw_indirect && capabilities.GL_ARB_draw_indirect) { - return ARB; - } else { - return UNSUPPORTED; - } - } - - public abstract void glMultiDrawArraysIndirect(int mode, ByteBuffer indirect, int primcount, int stride); - public abstract void glMultiDrawArraysIndirect(int mode, long indirect, int primcount, int stride); - -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/func/GlInstancedArrayFunctions.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/func/GlInstancedArrayFunctions.java deleted file mode 100644 index 4ec13d7e4..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/func/GlInstancedArrayFunctions.java +++ /dev/null @@ -1,38 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.func; - -import org.lwjgl.opengl.ARBInstancedArrays; -import org.lwjgl.opengl.ContextCapabilities; -import org.lwjgl.opengl.GL33; - -public enum GlInstancedArrayFunctions { - CORE { - @Override - public void glVertexAttribDivisor(int index, int divisor) { - GL33.glVertexAttribDivisor(index, divisor); - } - }, - ARB { - @Override - public void glVertexAttribDivisor(int index, int divisor) { - ARBInstancedArrays.glVertexAttribDivisorARB(index, divisor); - } - }, - UNSUPPORTED { - @Override - public void glVertexAttribDivisor(int index, int divisor) { - throw new UnsupportedOperationException(); - } - }; - - public static GlInstancedArrayFunctions load(ContextCapabilities capabilities) { - if (capabilities.OpenGL33) { - return CORE; - } else if (capabilities.GL_ARB_instanced_arrays) { - return ARB; - } else { - return UNSUPPORTED; - } - } - - public abstract void glVertexAttribDivisor(int index, int divisor); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/func/GlVertexArrayFunctions.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/func/GlVertexArrayFunctions.java deleted file mode 100644 index 1a9bab73b..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/func/GlVertexArrayFunctions.java +++ /dev/null @@ -1,75 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.func; - -import org.lwjgl.opengl.ARBVertexArrayObject; -import org.lwjgl.opengl.ContextCapabilities; -import org.lwjgl.opengl.GL30; - -/** - * Requires OpenGL 3.0+ or the ARB_vertex_array_object extension. - */ -public enum GlVertexArrayFunctions { - BASE { - @Override - public void glBindVertexArray(int id) { - GL30.glBindVertexArray(id); - } - - @Override - public int glGenVertexArrays() { - return GL30.glGenVertexArrays(); - } - - @Override - public void glDeleteVertexArrays(int id) { - GL30.glDeleteVertexArrays(id); - } - }, - ARB { - @Override - public void glBindVertexArray(int id) { - ARBVertexArrayObject.glBindVertexArray(id); - } - - @Override - public int glGenVertexArrays() { - return ARBVertexArrayObject.glGenVertexArrays(); - } - - @Override - public void glDeleteVertexArrays(int id) { - ARBVertexArrayObject.glDeleteVertexArrays(id); - } - }, - UNSUPPORTED { - @Override - public void glBindVertexArray(int id) { - throw new UnsupportedOperationException(); - } - - @Override - public int glGenVertexArrays() { - throw new UnsupportedOperationException(); - } - - @Override - public void glDeleteVertexArrays(int id) { - throw new UnsupportedOperationException(); - } - }; - - static GlVertexArrayFunctions load(ContextCapabilities capabilities) { - if (capabilities.OpenGL30) { - return BASE; - } else if (capabilities.GL_ARB_vertex_array_object) { - return ARB; - } - - return UNSUPPORTED; - } - - public abstract void glBindVertexArray(int id); - - public abstract int glGenVertexArrays(); - - public abstract void glDeleteVertexArrays(int id); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/shader/GlProgram.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/shader/GlProgram.java deleted file mode 100644 index bc262afe1..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/shader/GlProgram.java +++ /dev/null @@ -1,119 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.shader; - -import com.gtnewhorizons.angelica.glsm.GLDebug; -import me.jellysquid.mods.sodium.client.gl.GlObject; -import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; -import net.minecraft.util.ResourceLocation; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; -import org.lwjgl.opengl.GL11; -import org.lwjgl.opengl.GL20; -import org.lwjgl.opengl.KHRDebug; - -/** - * An OpenGL shader program. - */ -public abstract class GlProgram extends GlObject { - private static final Logger LOGGER = LogManager.getLogger(GlProgram.class); - - private final ResourceLocation name; - - protected GlProgram(RenderDevice owner, ResourceLocation name, int program) { - super(owner); - - this.name = name; - this.setHandle(program); - } - - public static Builder builder(ResourceLocation identifier) { - return new Builder(identifier); - } - - public void bind() { - GL20.glUseProgram(this.handle()); - } - - public void unbind() { - GL20.glUseProgram(0); - } - - public ResourceLocation getName() { - return this.name; - } - - /** - * Retrieves the index of the uniform with the given name. - * @param name The name of the uniform to find the index of - * @return The uniform's index - * @throws NullPointerException If no uniform exists with the given name - */ - public int getUniformLocation(String name) { - final int index = GL20.glGetUniformLocation(this.handle(), name); - - if (index < 0) { - throw new NullPointerException("No uniform exists with name: " + name); - } - - return index; - } - - public void delete() { - GL20.glDeleteProgram(this.handle()); - - this.invalidateHandle(); - } - - public static class Builder { - private final ResourceLocation name; - private final int program; - - public Builder(ResourceLocation name) { - this.name = name; - this.program = GL20.glCreateProgram(); - GLDebug.nameObject(KHRDebug.GL_PROGRAM, program, name.toString()); - } - - public Builder attachShader(GlShader shader) { - GL20.glAttachShader(this.program, shader.handle()); - - return this; - } - - /** - * Links the attached shaders to this program and returns a user-defined container which wraps the shader - * program. This container can, for example, provide methods for updating the specific uniforms of that shader - * set. - * - * @param factory The factory which will create the shader program's container - * @param

The type which should be instantiated with the new program's handle - * @return An instantiated shader container as provided by the factory - */ - public

P build(ProgramFactory

factory) { - GL20.glLinkProgram(this.program); - - final String log = GL20.glGetProgramInfoLog(this.program, GL20.GL_INFO_LOG_LENGTH); - - if (!log.isEmpty()) { - LOGGER.warn("Program link log for " + this.name + ": " + log); - } - - final int result = GL20.glGetProgrami(this.program, GL20.GL_LINK_STATUS); - - if (result != GL11.GL_TRUE) { - throw new RuntimeException("Shader program linking failed, see log for details"); - } - - return factory.create(this.name, this.program); - } - - public Builder bindAttribute(String name, ShaderBindingPoint binding) { - GL20.glBindAttribLocation(this.program, binding.getGenericAttributeIndex(), name); - - return this; - } - } - - public interface ProgramFactory

{ - P create(ResourceLocation name, int handle); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/shader/GlShader.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/shader/GlShader.java deleted file mode 100644 index 97a2ecc52..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/shader/GlShader.java +++ /dev/null @@ -1,92 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.shader; - -import me.jellysquid.mods.sodium.client.gl.GlObject; -import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; -import net.minecraft.util.ResourceLocation; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; -import org.lwjgl.opengl.GL11; -import org.lwjgl.opengl.GL20; - -import java.io.BufferedReader; -import java.io.IOException; -import java.io.StringReader; - -/** - * A compiled OpenGL shader object. - */ -public class GlShader extends GlObject { - private static final Logger LOGGER = LogManager.getLogger(GlShader.class); - - private final ResourceLocation name; - - public GlShader(RenderDevice owner, ShaderType type, ResourceLocation name, String src, ShaderConstants constants) { - super(owner); - - this.name = name; - - src = processShader(src, constants); - - int handle = GL20.glCreateShader(type.id); - // TODO: ShaderWorkaround - GL20.glShaderSource(handle, src); - GL20.glCompileShader(handle); - - String log = GL20.glGetShaderInfoLog(handle, GL20.GL_INFO_LOG_LENGTH); - - if (!log.isEmpty()) { - LOGGER.warn("Shader compilation log for " + this.name + ": " + log); - } - - int result = GL20.glGetShaderi(handle, GL20.GL_COMPILE_STATUS); - - if (result != GL11.GL_TRUE) { - throw new RuntimeException("Shader compilation failed, see log for details"); - } - - this.setHandle(handle); - } - - /** - * Adds an additional list of defines to the top of a GLSL shader file just after the version declaration. This - * allows for ghetto shader specialization. - */ - private static String processShader(String src, ShaderConstants constants) { - StringBuilder builder = new StringBuilder(src.length()); - boolean patched = false; - - try (BufferedReader reader = new BufferedReader(new StringReader(src))) { - String line; - - while ((line = reader.readLine()) != null) { - // Write the line out to the patched GLSL code string - builder.append(line).append("\n"); - - // Now, see if the line we just wrote declares the version - // If we haven't already added our define declarations, add them just after the version declaration - if (!patched && line.startsWith("#version")) { - for (String macro : constants.getDefineStrings()) { - builder.append(macro).append('\n'); - } - - // We did our work, don't add them again - patched = true; - } - } - } catch (IOException e) { - throw new RuntimeException("Could not process shader source", e); - } - - return builder.toString(); - } - - public ResourceLocation getName() { - return this.name; - } - - public void delete() { - GL20.glDeleteShader(this.handle()); - - this.invalidateHandle(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/shader/ShaderBindingPoint.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/shader/ShaderBindingPoint.java deleted file mode 100644 index 4da44924f..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/shader/ShaderBindingPoint.java +++ /dev/null @@ -1,13 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.shader; - -public class ShaderBindingPoint { - private final int genericAttributeIndex; - - public ShaderBindingPoint(int genericAttributeIndex) { - this.genericAttributeIndex = genericAttributeIndex; - } - - public int getGenericAttributeIndex() { - return genericAttributeIndex; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/shader/ShaderConstants.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/shader/ShaderConstants.java deleted file mode 100644 index c8ba2caef..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/shader/ShaderConstants.java +++ /dev/null @@ -1,74 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.shader; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -public class ShaderConstants { - private final List defines; - - private ShaderConstants(List defines) { - this.defines = defines; - } - - public List getDefineStrings() { - return this.defines; - } - - public static ShaderConstants fromStringList(List defines) { - Builder builder = new Builder(); - - for (String define : defines) { - builder.define(define); - } - - return builder.build(); - } - - public static Builder builder() { - return new Builder(); - } - - public static class Builder { - private static final String EMPTY_VALUE = ""; - - private final HashMap constants = new HashMap<>(); - - private Builder() { - - } - - public void define(String name) { - this.define(name, EMPTY_VALUE); - } - - public void define(String name, String value) { - String prev = this.constants.get(name); - - if (prev != null) { - throw new IllegalArgumentException("Constant " + name + " is already defined with value " + prev); - } - - this.constants.put(name, value); - } - - public ShaderConstants build() { - List defines = new ArrayList<>(this.constants.size()); - - for (Map.Entry entry : this.constants.entrySet()) { - String key = entry.getKey(); - String value = entry.getValue(); - - if (value.length() <= 0) { - defines.add("#define " + key); - } else { - defines.add("#define " + key + " " + value); - } - } - - return new ShaderConstants(Collections.unmodifiableList(defines)); - } - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/shader/ShaderLoader.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/shader/ShaderLoader.java deleted file mode 100644 index eca711854..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/shader/ShaderLoader.java +++ /dev/null @@ -1,52 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.shader; - -import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; -import net.minecraft.util.ResourceLocation; -import org.apache.commons.io.IOUtils; - -import java.io.IOException; -import java.io.InputStream; -import java.nio.charset.StandardCharsets; -import java.util.List; - -public class ShaderLoader { - /** - * Creates an OpenGL shader from GLSL sources. The GLSL source file should be made available on the classpath at the - * path of `/assets/{namespace}/shaders/{path}`. User defines can be used to declare variables in the shader source - * after the version header, allowing for conditional compilation with macro code. - * - * - * @param device - * @param type The type of shader to create - * @param name The ResourceLocation used to locate the shader source file - * @param constants A list of constants for shader specialization - * @return An OpenGL shader object compiled with the given user defines - */ - public static GlShader loadShader(RenderDevice device, ShaderType type, ResourceLocation name, ShaderConstants constants) { - return new GlShader(device, type, name, getShaderSource(getShaderPath(name, type)), constants); - } - - /** - * Use {@link ShaderLoader#loadShader(RenderDevice, ShaderType, ResourceLocation, ShaderConstants)} instead. This will be removed. - */ - @Deprecated - public static GlShader loadShader(RenderDevice device, ShaderType type, ResourceLocation name, List constants) { - return new GlShader(device, type, name, getShaderSource(getShaderPath(name, type)), ShaderConstants.fromStringList(constants)); - } - - public static String getShaderPath(ResourceLocation name, ShaderType type) { - return String.format("/assets/%s/shaders/%s.%s.glsl", name.getResourceDomain(), name.getResourcePath(), type == ShaderType.VERTEX ? "v" : "f"); - } - - private static String getShaderSource(String path) { - try (InputStream in = ShaderLoader.class.getResourceAsStream(path)) { - if (in == null) { - throw new RuntimeException("Shader not found: " + path); - } - - return IOUtils.toString(in, StandardCharsets.UTF_8); - } catch (IOException e) { - throw new RuntimeException("Could not read shader sources", e); - } - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/shader/ShaderType.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/shader/ShaderType.java deleted file mode 100644 index 23d16313b..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/shader/ShaderType.java +++ /dev/null @@ -1,19 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.shader; - -import org.lwjgl.opengl.GL20; -import org.lwjgl.opengl.GL32; - -/** - * An enumeration over the supported OpenGL shader types. - */ -public enum ShaderType { - VERTEX(GL20.GL_VERTEX_SHADER), - FRAGMENT(GL20.GL_FRAGMENT_SHADER), - GEOMETRY(GL32.GL_GEOMETRY_SHADER); - - public final int id; - - ShaderType(int id) { - this.id = id; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/state/GlStateTracker.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/state/GlStateTracker.java deleted file mode 100644 index 972e3bb1a..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/state/GlStateTracker.java +++ /dev/null @@ -1,70 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.state; - -import me.jellysquid.mods.sodium.client.gl.array.GlVertexArray; -import me.jellysquid.mods.sodium.client.gl.buffer.GlBuffer; -import me.jellysquid.mods.sodium.client.gl.buffer.GlBufferTarget; -import me.jellysquid.mods.sodium.client.gl.func.GlFunctions; -import org.lwjgl.opengl.GL15; -import org.lwjgl.opengl.GL30; - -import java.util.Arrays; -import java.util.EnumSet; - -public class GlStateTracker { - private static final int UNASSIGNED_HANDLE = -1; - - private final int[] bufferState = new int[GlBufferTarget.COUNT]; - //private final int[] bufferRestoreState = new int[GlBufferTarget.COUNT]; - private final EnumSet mutatedBuffers = EnumSet.noneOf(GlBufferTarget.class); - - private int vertexArrayState; - //private int vertexArrayRestoreState; - - public GlStateTracker() { - this.clearRestoreState(); - } - - public boolean makeBufferActive(GlBufferTarget target, GlBuffer buffer) { - return this.makeBufferActive(target, buffer == null ? GlBuffer.NULL_BUFFER_ID : buffer.handle()); - } - - private boolean makeBufferActive(GlBufferTarget target, int buffer) { - int prevBuffer = this.bufferState[target.ordinal()]; - - this.bufferState[target.ordinal()] = buffer; - - mutatedBuffers.add(target); - - return prevBuffer != buffer; - } - - public boolean makeVertexArrayActive(GlVertexArray array) { - return this.makeVertexArrayActive(array == null ? GlVertexArray.NULL_ARRAY_ID : array.handle()); - } - - private boolean makeVertexArrayActive(int array) { - int prevArray = this.vertexArrayState; - - this.vertexArrayState = array; - - return prevArray != array; - } - - public void applyRestoreState() { - mutatedBuffers.forEach(target -> { - GL15.glBindBuffer(target.getTargetParameter(), 0); - }); - mutatedBuffers.clear(); - if(GlFunctions.isVertexArraySupported()) { - GL30.glBindVertexArray(0); - } - } - - public void clearRestoreState() { - Arrays.fill(this.bufferState, UNASSIGNED_HANDLE); - //Arrays.fill(this.bufferRestoreState, UNASSIGNED_HANDLE); - - this.vertexArrayState = UNASSIGNED_HANDLE; - //this.vertexArrayRestoreState = UNASSIGNED_HANDLE; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/tessellation/GlAbstractTessellation.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/tessellation/GlAbstractTessellation.java deleted file mode 100644 index 95a46cb7a..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/tessellation/GlAbstractTessellation.java +++ /dev/null @@ -1,37 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.tessellation; - -import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexAttributeBinding; -import me.jellysquid.mods.sodium.client.gl.buffer.GlBufferTarget; -import me.jellysquid.mods.sodium.client.gl.device.CommandList; -import me.jellysquid.mods.sodium.client.gl.func.GlFunctions; -import org.lwjgl.opengl.GL20; - -public abstract class GlAbstractTessellation implements GlTessellation { - protected final GlPrimitiveType primitiveType; - protected final TessellationBinding[] bindings; - - protected GlAbstractTessellation(GlPrimitiveType primitiveType, TessellationBinding[] bindings) { - this.primitiveType = primitiveType; - this.bindings = bindings; - } - - @Override - public GlPrimitiveType getPrimitiveType() { - return this.primitiveType; - } - - protected void bindAttributes(CommandList commandList) { - for (TessellationBinding binding : this.bindings) { - commandList.bindBuffer(GlBufferTarget.ARRAY_BUFFER, binding.getBuffer()); - - for (GlVertexAttributeBinding attrib : binding.getAttributeBindings()) { - GL20.glVertexAttribPointer(attrib.getIndex(), attrib.getCount(), attrib.getFormat(), attrib.isNormalized(), attrib.getStride(), attrib.getPointer()); - GL20.glEnableVertexAttribArray(attrib.getIndex()); - - if (binding.isInstanced()) { - GlFunctions.INSTANCED_ARRAY.glVertexAttribDivisor(attrib.getIndex(), 1); - } - } - } - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/tessellation/GlFallbackTessellation.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/tessellation/GlFallbackTessellation.java deleted file mode 100644 index 2cb9531d2..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/tessellation/GlFallbackTessellation.java +++ /dev/null @@ -1,30 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.tessellation; - -import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexAttributeBinding; -import me.jellysquid.mods.sodium.client.gl.device.CommandList; -import org.lwjgl.opengl.GL20; - -public class GlFallbackTessellation extends GlAbstractTessellation { - public GlFallbackTessellation(GlPrimitiveType primitiveType, TessellationBinding[] bindings) { - super(primitiveType, bindings); - } - - @Override - public void delete(CommandList commandList) { - - } - - @Override - public void bind(CommandList commandList) { - this.bindAttributes(commandList); - } - - @Override - public void unbind(CommandList commandList) { - for (TessellationBinding binding : this.bindings) { - for (GlVertexAttributeBinding attrib : binding.getAttributeBindings()) { - GL20.glDisableVertexAttribArray(attrib.getIndex()); - } - } - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/tessellation/GlPrimitiveType.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/tessellation/GlPrimitiveType.java deleted file mode 100644 index 20d4aa72b..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/tessellation/GlPrimitiveType.java +++ /dev/null @@ -1,19 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.tessellation; - -import org.lwjgl.opengl.GL11; - -public enum GlPrimitiveType { - LINES(GL11.GL_LINES), - TRIANGLES(GL11.GL_TRIANGLES), - QUADS(GL11.GL_QUADS); - - private final int id; - - GlPrimitiveType(int id) { - this.id = id; - } - - public int getId() { - return this.id; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/tessellation/GlTessellation.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/tessellation/GlTessellation.java deleted file mode 100644 index cf7aeb70a..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/tessellation/GlTessellation.java +++ /dev/null @@ -1,13 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.tessellation; - -import me.jellysquid.mods.sodium.client.gl.device.CommandList; - -public interface GlTessellation { - void delete(CommandList commandList); - - void bind(CommandList commandList); - - void unbind(CommandList commandList); - - GlPrimitiveType getPrimitiveType(); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/tessellation/GlVertexArrayTessellation.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/tessellation/GlVertexArrayTessellation.java deleted file mode 100644 index f09f3bfef..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/tessellation/GlVertexArrayTessellation.java +++ /dev/null @@ -1,40 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.tessellation; - -import me.jellysquid.mods.sodium.client.gl.array.GlVertexArray; -import me.jellysquid.mods.sodium.client.gl.device.CommandList; -import me.jellysquid.mods.sodium.client.gl.func.GlFunctions; - -public class GlVertexArrayTessellation extends GlAbstractTessellation { - private final GlVertexArray array; - - public GlVertexArrayTessellation(GlVertexArray array, GlPrimitiveType primitiveType, TessellationBinding[] bindings) { - super(primitiveType, bindings); - - this.array = array; - } - - public static boolean isSupported() { - return GlFunctions.isVertexArraySupported(); - } - - public void init(CommandList commandList) { - this.bind(commandList); - this.bindAttributes(commandList); - this.unbind(commandList); - } - - @Override - public void delete(CommandList commandList) { - commandList.deleteVertexArray(this.array); - } - - @Override - public void bind(CommandList commandList) { - commandList.bindVertexArray(this.array); - } - - @Override - public void unbind(CommandList commandList) { - commandList.unbindVertexArray(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/tessellation/TessellationBinding.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/tessellation/TessellationBinding.java deleted file mode 100644 index 33accfc69..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/tessellation/TessellationBinding.java +++ /dev/null @@ -1,24 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.tessellation; - -import lombok.Getter; -import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexAttributeBinding; -import me.jellysquid.mods.sodium.client.gl.buffer.GlBuffer; - -public class TessellationBinding { - @Getter - private final GlBuffer buffer; - private final GlVertexAttributeBinding[] bindings; - @Getter - private final boolean instanced; - - public TessellationBinding(GlBuffer buffer, GlVertexAttributeBinding[] bindings, boolean instanced) { - this.buffer = buffer; - this.bindings = bindings; - this.instanced = instanced; - } - - public GlVertexAttributeBinding[] getAttributeBindings() { - return this.bindings; - } - -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/util/BufferSlice.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/util/BufferSlice.java deleted file mode 100644 index 898d3f9ca..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/util/BufferSlice.java +++ /dev/null @@ -1,22 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.util; - -public class BufferSlice { - public final int start, len; - - public BufferSlice(int start, int len) { - this.start = start; - this.len = len; - } - - public static long pack(int start, int len) { - return (long) start & 0xffffffffL | ((long) len & 0xffffffffL) << 32; - } - - public static int unpackStart(long slice) { - return (int) (slice & 0xffffffffL); - } - - public static int unpackLength(long slice) { - return (int) (slice >>> 32 & 0xffffffffL); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gl/util/GlMultiDrawBatch.java b/src/main/java/me/jellysquid/mods/sodium/client/gl/util/GlMultiDrawBatch.java deleted file mode 100644 index 0199af4b6..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/gl/util/GlMultiDrawBatch.java +++ /dev/null @@ -1,69 +0,0 @@ -package me.jellysquid.mods.sodium.client.gl.util; - -import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*; - -import org.lwjgl.opengl.GL20; - - -import java.nio.IntBuffer; - -/** - * Provides a fixed-size queue for batching draw calls for vertex data in the same buffer. This internally - * uses {@link GL20#glMultiDrawArrays(int, IntBuffer, IntBuffer)} and should be compatible on any relevant platform. - */ -public class GlMultiDrawBatch { - private IntBuffer bufIndices; - private IntBuffer bufLen; - private int count; - private boolean isBuilding; - - public GlMultiDrawBatch(int capacity) { - this.bufIndices = memAllocInt(capacity); - this.bufLen = memAllocInt(capacity); - } - - public IntBuffer getIndicesBuffer() { - return this.bufIndices; - } - - public IntBuffer getLengthBuffer() { - return this.bufLen; - } - - public void begin() { - this.bufIndices.clear(); - this.bufLen.clear(); - this.count = 0; - - this.isBuilding = true; - } - - public void end() { - this.bufIndices.limit(this.count); - this.bufLen.limit(this.count); - - this.isBuilding = false; - } - - public boolean isEmpty() { - return this.count <= 0; - } - - public void addChunkRender(int first, int count) { - int i = this.count++; - this.bufIndices.put(i, first); - this.bufLen.put(i, count); - } - - public boolean isBuilding() { - return this.isBuilding; - } - - public void delete() { - memFree(this.bufIndices); - memFree(this.bufLen); - - this.bufIndices = null; - this.bufLen = null; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/gui/SodiumGameOptionPages.java b/src/main/java/me/jellysquid/mods/sodium/client/gui/SodiumGameOptionPages.java index d09aca580..9305ee723 100644 --- a/src/main/java/me/jellysquid/mods/sodium/client/gui/SodiumGameOptionPages.java +++ b/src/main/java/me/jellysquid/mods/sodium/client/gui/SodiumGameOptionPages.java @@ -23,7 +23,6 @@ import me.jellysquid.mods.sodium.client.gui.options.named.ParticleMode; import me.jellysquid.mods.sodium.client.gui.options.storage.AngelicaOptionsStorage; import me.jellysquid.mods.sodium.client.gui.options.storage.MinecraftOptionsStorage; import me.jellysquid.mods.sodium.client.gui.options.storage.SodiumOptionsStorage; -import me.jellysquid.mods.sodium.client.render.chunk.backends.multidraw.MultidrawChunkRenderBackend; import net.coderbot.iris.Iris; import net.coderbot.iris.gui.option.IrisVideoSettings; import net.minecraft.client.Minecraft; @@ -292,15 +291,6 @@ public class SodiumGameOptionPages { final List groups = new ArrayList<>(); groups.add(OptionGroup.createBuilder() - .add(OptionImpl.createBuilder(boolean.class, sodiumOpts) - .setName(I18n.format("sodium.options.use_chunk_multidraw.name")) - .setTooltip(I18n.format("sodium.options.use_chunk_multidraw.tooltip")) - .setControl(TickBoxControl::new) - .setBinding((opts, value) -> opts.advanced.useChunkMultidraw = value, opts -> opts.advanced.useChunkMultidraw) - .setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD) - .setImpact(OptionImpact.EXTREME) - .setEnabled(MultidrawChunkRenderBackend.isSupported(sodiumOpts.getData().advanced.ignoreDriverBlacklist)) - .build()) .add(OptionImpl.createBuilder(boolean.class, sodiumOpts) .setName(I18n.format("sodium.options.use_vertex_objects.name")) .setTooltip(I18n.format("sodium.options.use_vertex_objects.tooltip")) @@ -418,6 +408,15 @@ public class SodiumGameOptionPages { final List groups = new ArrayList<>(); groups.add(OptionGroup.createBuilder() + .add(OptionImpl.createBuilder(boolean.class, angelicaOpts) + .setName(I18n.format("options.angelica.threadedChunkBuilding")) + .setTooltip(I18n.format("options.angelica.threadedChunkBuilding.tooltip")) + .setControl(TickBoxControl::new) + .setImpact(OptionImpact.HIGH) + .setBinding((opts, value) -> AngelicaConfig.enableThreadedChunkBuilding = value, opts -> AngelicaConfig.enableThreadedChunkBuilding) + .setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD) + .build() + ) .add(OptionImpl.createBuilder(int.class, sodiumOpts) .setName(I18n.format("sodium.options.chunk_update_threads.name")) .setTooltip(I18n.format("sodium.options.chunk_update_threads.tooltip")) diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/light/EntityLighter.java b/src/main/java/me/jellysquid/mods/sodium/client/model/light/EntityLighter.java deleted file mode 100644 index 78b08607a..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/light/EntityLighter.java +++ /dev/null @@ -1,101 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.light; - -import com.gtnewhorizon.gtnhlib.blockpos.BlockPos; -import net.minecraft.util.MathHelper; -import net.minecraft.entity.Entity; -import net.minecraft.world.EnumSkyBlock; - -import static org.joml.Math.lerp; - -public class EntityLighter { - private static final double MIN_BOX_SIZE = 0.001D; - - private static final double MAX_LIGHT_VAL = 15.0; - private static final double MAX_LIGHTMAP_COORD = 240.0D; - - public static int getBlendedLight(Entity entity, float tickDelta) { - final boolean calcBlockLight = !entity.isBurning(); - - // Find the interpolated position of the entity - final double x1 = lerp(entity.prevPosX, entity.posX, tickDelta); - final double y1 = lerp(entity.prevPosY, entity.posY, tickDelta); - final double z1 = lerp(entity.prevPosZ, entity.posZ, tickDelta); - - // Bounding boxes with no volume cause issues, ensure they're non-zero - // Notably, armor stands in "Marker" mode decide this is a cute thing to do - // https://github.com/jellysquid3/sodium-fabric/issues/60 - final double width = Math.max(entity.width, MIN_BOX_SIZE); - final double height = Math.max(entity.height, MIN_BOX_SIZE); - - final double x2 = x1 + width; - final double y2 = y1 + height; - final double z2 = z1 + width; - - // The sampling volume of blocks which could possibly contribute light to this entity - final int bMinX = MathHelper.floor_double(x1); - final int bMinY = MathHelper.floor_double(y1); - final int bMinZ = MathHelper.floor_double(z1); - final int bMaxX = MathHelper.ceiling_double_int(x2); - final int bMaxY = MathHelper.ceiling_double_int(y2); - final int bMaxZ = MathHelper.ceiling_double_int(z2); - - // The maximum amount of light that could be contributed - double max = 0.0D; - - // The sampled light values contributed by all sources - double sl = 0; - double bl = 0; - - final BlockPos pos = new BlockPos(); - - // Iterate over every block in the sampling volume - for (int bX = bMinX; bX < bMaxX; bX++) { - final double ix1 = Math.max(bX, x1); - final double ix2 = Math.min(bX + 1, x2); - - for (int bY = bMinY; bY < bMaxY; bY++) { - final double iy1 = Math.max(bY, y1); - final double iy2 = Math.min(bY + 1, y2); - - for (int bZ = bMinZ; bZ < bMaxZ; bZ++) { - pos.set(bX, bY, bZ); - - // Do not consider light-blocking volumes - if (entity.worldObj.getBlock(pos.x, pos.y, pos.z).isOpaqueCube() - && entity.worldObj.getBlockLightValue(pos.x, pos.y, pos.z) <= 0) { - continue; - } - - // Find the intersecting volume between the entity box and the block's bounding box - final double iz1 = Math.max(bZ, z1); - final double iz2 = Math.min(bZ + 1, z2); - - // The amount of light this block can contribute is the volume of the intersecting box - final double weight = (ix2 - ix1) * (iy2 - iy1) * (iz2 - iz1); - - // Keep count of how much light could've been contributed - max += weight; - - // note: lighter.bridge$getSkyLight(entity, pos) and lighter.bridge$getBlockLight(entity, pos) - // were replaced, mixin+this method de-generified. as far as I can tell they only existed because - // Sodium had a weird setup just for paintings, don't think we need it. - - // Sum the light actually contributed by this volume - sl += weight * (entity.worldObj.getSkyBlockTypeBrightness(EnumSkyBlock.Sky, pos.x, pos.y, pos.z) / MAX_LIGHT_VAL); - - if (calcBlockLight) { - bl += weight * (entity.worldObj.getSkyBlockTypeBrightness(EnumSkyBlock.Block, pos.x, pos.y, pos.z) / MAX_LIGHT_VAL); - } else { - bl += weight; - } - } - } - } - - // The final light value is calculated from the percentage of light contributed out of the total maximum - final int bli = MathHelper.floor_double((bl / max) * MAX_LIGHTMAP_COORD); - final int sli = MathHelper.floor_double((sl / max) * MAX_LIGHTMAP_COORD); - - return ((sli & 0xFFFF) << 16) | (bli & 0xFFFF); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/light/LightMode.java b/src/main/java/me/jellysquid/mods/sodium/client/model/light/LightMode.java deleted file mode 100644 index 90133268c..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/light/LightMode.java +++ /dev/null @@ -1,6 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.light; - -public enum LightMode { - SMOOTH, - FLAT -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/light/LightPipeline.java b/src/main/java/me/jellysquid/mods/sodium/client/model/light/LightPipeline.java deleted file mode 100644 index c142608ac..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/light/LightPipeline.java +++ /dev/null @@ -1,22 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.light; - -import com.gtnewhorizon.gtnhlib.blockpos.BlockPos; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.ModelQuadView; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing; -import me.jellysquid.mods.sodium.client.model.light.data.QuadLightData; - -/** - * Light pipelines allow model quads for any location in the world to be lit using various backends, including fluids - * and block entities. - */ -public interface LightPipeline { - /** - * Calculates the light data for a given block model quad, storing the result in {@param out}. - * @param quad The block model quad - * @param pos The block position of the model this quad belongs to - * @param out The data arrays which will store the calculated light data results - * @param face The pre-computed facing vector of the quad - * @param shade True if the block is shaded by ambient occlusion - */ - void calculate(ModelQuadView quad, BlockPos pos, QuadLightData out, ModelQuadFacing cullFace, ModelQuadFacing face, boolean shade); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/light/LightPipelineProvider.java b/src/main/java/me/jellysquid/mods/sodium/client/model/light/LightPipelineProvider.java deleted file mode 100644 index 49fb74188..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/light/LightPipelineProvider.java +++ /dev/null @@ -1,26 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.light; - -import me.jellysquid.mods.sodium.client.model.light.data.LightDataAccess; -import me.jellysquid.mods.sodium.client.model.light.flat.FlatLightPipeline; -import me.jellysquid.mods.sodium.client.model.light.smooth.SmoothLightPipeline; - -import java.util.EnumMap; - -public class LightPipelineProvider { - private final EnumMap lighters = new EnumMap<>(LightMode.class); - - public LightPipelineProvider(LightDataAccess cache) { - this.lighters.put(LightMode.SMOOTH, new SmoothLightPipeline(cache)); - this.lighters.put(LightMode.FLAT, new FlatLightPipeline(cache)); - } - - public LightPipeline getLighter(LightMode type) { - LightPipeline pipeline = this.lighters.get(type); - - if (pipeline == null) { - throw new NullPointerException("No lighter exists for mode: " + type.name()); - } - - return pipeline; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/light/cache/ArrayLightDataCache.java b/src/main/java/me/jellysquid/mods/sodium/client/model/light/cache/ArrayLightDataCache.java deleted file mode 100644 index 70121bf38..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/light/cache/ArrayLightDataCache.java +++ /dev/null @@ -1,57 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.light.cache; - -import com.gtnewhorizons.angelica.compat.mojang.ChunkSectionPos; -import me.jellysquid.mods.sodium.client.model.light.data.LightDataAccess; -import me.jellysquid.mods.sodium.client.world.WorldSlice; - -import java.util.Arrays; - -/** - * A light data cache which uses a flat-array to store the light data for the blocks in a given chunk and its direct - * neighbors. This is considerably faster than using a hash table to lookup values for a given block position and - * can be re-used by {@link WorldSlice} to avoid allocations. - */ -public class ArrayLightDataCache extends LightDataAccess { - private static final int NEIGHBOR_BLOCK_RADIUS = 2; - private static final int BLOCK_LENGTH = 16 + (NEIGHBOR_BLOCK_RADIUS * 2); - - private final long[] light; - - private int xOffset, yOffset, zOffset; - - public ArrayLightDataCache(WorldSlice world) { - this.world = world; - this.light = new long[BLOCK_LENGTH * BLOCK_LENGTH * BLOCK_LENGTH]; - } - - public void reset(ChunkSectionPos origin) { - this.xOffset = origin.getMinX() - NEIGHBOR_BLOCK_RADIUS; - this.yOffset = origin.getMinY() - NEIGHBOR_BLOCK_RADIUS; - this.zOffset = origin.getMinZ() - NEIGHBOR_BLOCK_RADIUS; - - Arrays.fill(this.light, 0L); - } - - private int index(int x, int y, int z) { - int x2 = x - this.xOffset; - int y2 = y - this.yOffset; - int z2 = z - this.zOffset; - - return (z2 * BLOCK_LENGTH * BLOCK_LENGTH) + (y2 * BLOCK_LENGTH) + x2; - } - - @Override - public long get(int x, int y, int z) { - DynamicLightsPos.get().set(x, y, z); - int l = this.index(x, y, z); - - long word = this.light[l]; - - if (word != 0) { - return word; - } - - return this.light[l] = this.compute(x, y, z); - } - -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/light/cache/HashLightDataCache.java b/src/main/java/me/jellysquid/mods/sodium/client/model/light/cache/HashLightDataCache.java deleted file mode 100644 index e8c10ebaa..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/light/cache/HashLightDataCache.java +++ /dev/null @@ -1,39 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.light.cache; - -import com.gtnewhorizon.gtnhlib.blockpos.IBlockPos; -import it.unimi.dsi.fastutil.longs.Long2LongLinkedOpenHashMap; -import me.jellysquid.mods.sodium.client.model.light.data.LightDataAccess; -import me.jellysquid.mods.sodium.client.world.WorldSlice; - - -/** - * A light data cache which uses a hash table to store previously accessed values. - */ -public class HashLightDataCache extends LightDataAccess { - private final Long2LongLinkedOpenHashMap map = new Long2LongLinkedOpenHashMap(1024, 0.50f); - - public HashLightDataCache(WorldSlice world) { - this.world = world; - } - - @Override - public long get(int x, int y, int z) { - DynamicLightsPos.get().set(x, y, z); - long key = IBlockPos.asLong(x, y, z); - long word = this.map.getAndMoveToFirst(key); - - if (word == 0) { - if (this.map.size() > 1024) { - this.map.removeLastLong(); - } - - this.map.put(key, word = this.compute(x, y, z)); - } - - return word; - } - - public void clearCache() { - this.map.clear(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/light/data/LightDataAccess.java b/src/main/java/me/jellysquid/mods/sodium/client/model/light/data/LightDataAccess.java deleted file mode 100644 index 70358f2c2..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/light/data/LightDataAccess.java +++ /dev/null @@ -1,139 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.light.data; - -import com.gtnewhorizon.gtnhlib.blockpos.BlockPos; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing; -import com.gtnewhorizons.angelica.dynamiclights.DynamicLights; -import me.jellysquid.mods.sodium.client.util.StateUtil; -import me.jellysquid.mods.sodium.client.world.WorldSlice; -import net.minecraft.block.Block; - -/** - * The light data cache is used to make accessing the light data and occlusion properties of blocks cheaper. The data - * for each block is stored as a long integer with packed fields in order to work around the lack of value types in Java. - * - * This code is not very pretty, but it does perform significantly faster than the vanilla implementation and has - * good cache locality. - * - * Each long integer contains the following fields: - * - OP: Block opacity test, true if opaque - * - FO: Full block opaque test, true if opaque - * - AO: Ambient occlusion, floating point value in the range of 0.0..1.0 encoded as an 12-bit unsigned integer - * - LM: Light map texture coordinates, two packed UV shorts in an integer - * - * You can use the various static pack/unpack methods to extract these values in a usable format. - */ -public abstract class LightDataAccess { - public static final ThreadLocal DynamicLightsPos = ThreadLocal.withInitial(BlockPos::new); - protected WorldSlice world; - - public long get(int x, int y, int z, ModelQuadFacing d1, ModelQuadFacing d2) { - return this.get(x + d1.getStepX() + d2.getStepX(), y + d1.getStepY() + d2.getStepY(), z + d1.getStepZ() + d2.getStepZ()); - } - - public long get(int x, int y, int z, ModelQuadFacing dir) { - return this.get(x + dir.getStepX(), y + dir.getStepY(), z + dir.getStepZ()); - } - - public long get(BlockPos pos, ModelQuadFacing dir) { - return this.get(pos.x, pos.y, pos.z, dir); - } - - public long get(BlockPos pos) { - return this.get(pos.x, pos.y, pos.getZ()); - } - - /** - * Returns the light data for the block at the given position. The property fields can then be accessed using - * the various unpack methods below. - */ - public abstract long get(int x, int y, int z); - - protected long compute(int x, int y, int z) { - - final WorldSlice world = this.world; - - final Block block = world.getBlock(x, y, z); - - final float ao; - final boolean em; - - if (block.getLightValue() == 0) { - ao = block.getAmbientOcclusionLightValue(); - em = false; //state.hasEmissiveLighting(world, pos); - } else { - ao = 1.0f; - em = true; - } - - // First is shouldBlockVision on modern - final boolean op = !block.isOpaqueCube() || block.getLightOpacity() == 0; - final boolean fo = block.isOpaqueCube(); - // Should be isFullCube, but this is probably close enough - final boolean fc = StateUtil.areBoundsFullCube(block); - - // OPTIMIZE: Do not calculate lightmap data if the block is full and opaque. - // FIX: Calculate lightmap data for light-emitting or emissive blocks, even though they are full and opaque. - final int lm = (fo && !em) ? 0 : block.getMixedBrightnessForBlock(world, x, y, z); - - return packAO(ao) | packLM(lm) | packOP(op) | packFO(fo) | packFC(fc) | (1L << 60); - } - - public static long packOP(boolean opaque) { - return (opaque ? 1L : 0L) << 56; - } - - public static boolean unpackOP(long word) { - return ((word >>> 56) & 0b1) != 0; - } - - public static long packFO(boolean opaque) { - return (opaque ? 1L : 0L) << 57; - } - - public static boolean unpackFO(long word) { - return ((word >>> 57) & 0b1) != 0; - } - - public static long packFC(boolean fullCube) { - return (fullCube ? 1L : 0L) << 58; - } - - public static boolean unpackFC(long word) { - return ((word >>> 58) & 0b1) != 0; - } - - public static long packLM(int lm) { - return (long) lm & 0xFFFFFFFFL; - } - - public static int unpackLM(long word) { - return (int) (word & 0xFFFFFFFFL); - } - - public static long packAO(float ao) { - int aoi = (int) (ao * 4096.0f); - return ((long) aoi & 0xFFFFL) << 32; - } - - public static float unpackAO(long word) { - int aoi = (int) (word >>> 32 & 0xFFFFL); - return aoi * (1.0f / 4096.0f); - } - - public static int getLightMap(long originWord) { - if (!DynamicLights.isEnabled()) { - return unpackLM(originWord); - } - if (unpackFO(originWord)){ - return unpackLM(originWord); - } - - double dynamic = DynamicLights.get().getDynamicLightLevel(DynamicLightsPos.get()); - return DynamicLights.get().getLightmapWithDynamicLight(dynamic, unpackLM(originWord)); - - } - - public WorldSlice getWorld() { - return this.world; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/light/data/QuadLightData.java b/src/main/java/me/jellysquid/mods/sodium/client/model/light/data/QuadLightData.java deleted file mode 100644 index 1342e1dcf..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/light/data/QuadLightData.java +++ /dev/null @@ -1,17 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.light.data; - -/** - * Stores the computed light data for a block model quad. The vertex order of each array is defined as that of the - * quad's vertex order. - */ -public class QuadLightData { - /** - * The brightness of each vertex in the quad as normalized floats. - */ - public final float[] br = new float[4]; - - /** - * The lightmap texture coordinates for each vertex in the quad. - */ - public final int[] lm = new int[4]; -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/light/flat/FlatLightPipeline.java b/src/main/java/me/jellysquid/mods/sodium/client/model/light/flat/FlatLightPipeline.java deleted file mode 100644 index 2fbbdbda7..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/light/flat/FlatLightPipeline.java +++ /dev/null @@ -1,70 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.light.flat; - -import com.gtnewhorizon.gtnhlib.blockpos.BlockPos; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.ModelQuadView; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFlags; -import java.util.Arrays; -import net.coderbot.iris.Iris; -import me.jellysquid.mods.sodium.client.model.light.LightPipeline; -import me.jellysquid.mods.sodium.client.model.light.data.LightDataAccess; -import me.jellysquid.mods.sodium.client.model.light.data.QuadLightData; -import net.coderbot.iris.block_rendering.BlockRenderingSettings; -import net.minecraftforge.common.util.ForgeDirection; - -/** - * A light pipeline which implements "classic-style" lighting through simply using the light value of the adjacent - * block to a face. - */ -public class FlatLightPipeline implements LightPipeline { - /** - * The cache which light data will be accessed from. - */ - private final LightDataAccess lightCache; - - public FlatLightPipeline(LightDataAccess lightCache) { - this.lightCache = lightCache; - } - - @Override - public void calculate(ModelQuadView quad, BlockPos pos, QuadLightData out, ModelQuadFacing cullFace, ModelQuadFacing face, boolean shade) { - int lightmap; - - // To match vanilla behavior, use the cull face if it exists/is available - if (cullFace != null) { - lightmap = getOffsetLightmap(pos, cullFace); - } else { - int flags = quad.getFlags(); - // If the face is aligned, use the light data above it - // To match vanilla behavior, also treat the face as aligned if it is parallel and the block state is a full cube - if ((flags & ModelQuadFlags.IS_ALIGNED) != 0 || ((flags & ModelQuadFlags.IS_PARALLEL) != 0 && LightDataAccess.unpackFC(this.lightCache.get(pos)))) { - lightmap = getOffsetLightmap(pos, face); - } else { - lightmap = LightDataAccess.getLightMap(this.lightCache.get(pos)); - } - } - - Arrays.fill(out.lm, lightmap); - final float brightness = (Iris.enabled && BlockRenderingSettings.INSTANCE.shouldDisableDirectionalShading()) - ? 1.0F : this.lightCache.getWorld().getBrightness(face, shade); - Arrays.fill(out.br, brightness); - } - - /** - * When vanilla computes an offset lightmap with flat lighting, it passes the original BlockState but the - * offset BlockPos to WorldRenderer#getLightmapCoordinates(BlockRenderView, BlockState, BlockPos) - * This does not make much sense but fixes certain issues, primarily dark quads on light-emitting blocks - * behind tinted glass. {@link LightDataAccess} cannot efficiently store lightmaps computed with - * inconsistent values so this method exists to mirror vanilla behavior as closely as possible. - */ - private int getOffsetLightmap(BlockPos pos, ModelQuadFacing face) { - int lightmap = LightDataAccess.getLightMap(this.lightCache.get(pos, face)); - // If the block light is not 15 (max)... - if ((lightmap & 0xF0) != 0xF0) { - int originLightmap = LightDataAccess.getLightMap(this.lightCache.get(pos)); - // ...take the maximum combined block light at the origin and offset positions - lightmap = (lightmap & ~0xFF) | Math.max(lightmap & 0xFF, originLightmap & 0xFF); - } - return lightmap; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/light/smooth/AoCompletionFlags.java b/src/main/java/me/jellysquid/mods/sodium/client/model/light/smooth/AoCompletionFlags.java deleted file mode 100644 index 4dd78bcc4..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/light/smooth/AoCompletionFlags.java +++ /dev/null @@ -1,16 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.light.smooth; - -/** - * Bit flags to indicate which light properties have been computed for a given face. - */ -class AoCompletionFlags { - /** - * The light data has been retrieved from the cache. - */ - public static final int HAS_LIGHT_DATA = 0b01; - - /** - * The light data has been unpacked into normalized floating point values. - */ - public static final int HAS_UNPACKED_LIGHT_DATA = 0b10; -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/light/smooth/AoFaceData.java b/src/main/java/me/jellysquid/mods/sodium/client/model/light/smooth/AoFaceData.java deleted file mode 100644 index e4227c333..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/light/smooth/AoFaceData.java +++ /dev/null @@ -1,227 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.light.smooth; - -import static me.jellysquid.mods.sodium.client.model.light.cache.ArrayLightDataCache.getLightMap; -import static me.jellysquid.mods.sodium.client.model.light.cache.ArrayLightDataCache.unpackAO; -import static me.jellysquid.mods.sodium.client.model.light.cache.ArrayLightDataCache.unpackFO; -import static me.jellysquid.mods.sodium.client.model.light.cache.ArrayLightDataCache.unpackOP; - -import com.gtnewhorizon.gtnhlib.blockpos.BlockPos; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing; -import me.jellysquid.mods.sodium.client.model.light.data.LightDataAccess; - -class AoFaceData { - public final int[] lm = new int[4]; - - public final float[] ao = new float[4]; - public final float[] bl = new float[4]; - public final float[] sl = new float[4]; - - private int flags; - - public void initLightData(LightDataAccess cache, BlockPos pos, ModelQuadFacing direction, boolean offset) { - final int x = pos.x; - final int y = pos.y; - final int z = pos.z; - - final int adjX; - final int adjY; - final int adjZ; - - if (offset) { - adjX = x + direction.getStepX(); - adjY = y + direction.getStepY(); - adjZ = z + direction.getStepZ(); - } else { - adjX = x; - adjY = y; - adjZ = z; - } - - long adjWord = cache.get(adjX, adjY, adjZ); - - final int calm; - - // Use the origin block's light values if the adjacent one is opaque - if (offset && unpackFO(adjWord)) { - calm = getLightMap(cache.get(x, y, z)); - } else { - calm = getLightMap(adjWord); - } - - final float caao = unpackAO(adjWord); - - var faces = AoNeighborInfo.get(direction).faces; - - final long e0 = cache.get(adjX, adjY, adjZ, faces[0]); - final int e0lm = getLightMap(e0); - final float e0ao = unpackAO(e0); - final boolean e0op = unpackOP(e0); - - final long e1 = cache.get(adjX, adjY, adjZ, faces[1]); - final int e1lm = getLightMap(e1); - final float e1ao = unpackAO(e1); - final boolean e1op = unpackOP(e1); - - final long e2 = cache.get(adjX, adjY, adjZ, faces[2]); - final int e2lm = getLightMap(e2); - final float e2ao = unpackAO(e2); - final boolean e2op = unpackOP(e2); - - final long e3 = cache.get(adjX, adjY, adjZ, faces[3]); - final int e3lm = getLightMap(e3); - final float e3ao = unpackAO(e3); - final boolean e3op = unpackOP(e3); - - // If neither edge of a corner is occluded, then use the light - final int c0lm; - final float c0ao; - - if (!e2op && !e0op) { - c0lm = e0lm; - c0ao = e0ao; - } else { - long d0 = cache.get(adjX, adjY, adjZ, faces[0], faces[2]); - c0lm = getLightMap(d0); - c0ao = unpackAO(d0); - } - - final int c1lm; - final float c1ao; - - if (!e3op && !e0op) { - c1lm = e0lm; - c1ao = e0ao; - } else { - long d1 = cache.get(adjX, adjY, adjZ, faces[0], faces[3]); - c1lm = getLightMap(d1); - c1ao = unpackAO(d1); - } - - final int c2lm; - final float c2ao; - - if (!e2op && !e1op) { - // FIX: Use e1 instead of c0 to fix lighting errors in some directions - c2lm = e1lm; - c2ao = e1ao; - } else { - long d2 = cache.get(adjX, adjY, adjZ, faces[1], faces[2]); - c2lm = getLightMap(d2); - c2ao = unpackAO(d2); - } - - final int c3lm; - final float c3ao; - - if (!e3op && !e1op) { - // FIX: Use e1 instead of c0 to fix lighting errors in some directions - c3lm = e1lm; - c3ao = e1ao; - } else { - long d3 = cache.get(adjX, adjY, adjZ, faces[1], faces[3]); - c3lm = getLightMap(d3); - c3ao = unpackAO(d3); - } - - float[] ao = this.ao; - ao[0] = (e3ao + e0ao + c1ao + caao) * 0.25f; - ao[1] = (e2ao + e0ao + c0ao + caao) * 0.25f; - ao[2] = (e2ao + e1ao + c2ao + caao) * 0.25f; - ao[3] = (e3ao + e1ao + c3ao + caao) * 0.25f; - - int[] cb = this.lm; - cb[0] = calculateCornerBrightness(e3lm, e0lm, c1lm, calm); - cb[1] = calculateCornerBrightness(e2lm, e0lm, c0lm, calm); - cb[2] = calculateCornerBrightness(e2lm, e1lm, c2lm, calm); - cb[3] = calculateCornerBrightness(e3lm, e1lm, c3lm, calm); - - this.flags |= AoCompletionFlags.HAS_LIGHT_DATA; - } - - public void unpackLightData() { - int[] lm = this.lm; - - float[] bl = this.bl; - float[] sl = this.sl; - - bl[0] = unpackBlockLight(lm[0]); - bl[1] = unpackBlockLight(lm[1]); - bl[2] = unpackBlockLight(lm[2]); - bl[3] = unpackBlockLight(lm[3]); - - sl[0] = unpackSkyLight(lm[0]); - sl[1] = unpackSkyLight(lm[1]); - sl[2] = unpackSkyLight(lm[2]); - sl[3] = unpackSkyLight(lm[3]); - - this.flags |= AoCompletionFlags.HAS_UNPACKED_LIGHT_DATA; - } - - public float getBlendedSkyLight(float[] w) { - return weightedSum(this.sl, w); - } - - public float getBlendedBlockLight(float[] w) { - return weightedSum(this.bl, w); - } - - public float getBlendedShade(float[] w) { - return weightedSum(this.ao, w); - } - - private static float weightedSum(float[] v, float[] w) { - float t0 = v[0] * w[0]; - float t1 = v[1] * w[1]; - float t2 = v[2] * w[2]; - float t3 = v[3] * w[3]; - - return t0 + t1 + t2 + t3; - } - - private static float unpackSkyLight(int i) { - return (i >> 16) & 0xFF; - } - - private static float unpackBlockLight(int i) { - return i & 0xFF; - } - - private static int calculateCornerBrightness(int a, int b, int c, int d) { - // FIX: Normalize corner vectors correctly to the minimum non-zero value between each one to prevent - // strange issues - if ((a == 0) || (b == 0) || (c == 0) || (d == 0)) { - // Find the minimum value between all corners - final int min = minNonZero(minNonZero(a, b), minNonZero(c, d)); - - // Normalize the corner values - a = Math.max(a, min); - b = Math.max(b, min); - c = Math.max(c, min); - d = Math.max(d, min); - } - - return ((a + b + c + d) >> 2) & 0xFF00FF; - } - - private static int minNonZero(int a, int b) { - if (a == 0) { - return b; - } else if (b == 0) { - return a; - } - - return Math.min(a, b); - } - - public boolean hasLightData() { - return (this.flags & AoCompletionFlags.HAS_LIGHT_DATA) != 0; - } - - public boolean hasUnpackedLightData() { - return (this.flags & AoCompletionFlags.HAS_UNPACKED_LIGHT_DATA) != 0; - } - - public void reset() { - this.flags = 0; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/light/smooth/AoNeighborInfo.java b/src/main/java/me/jellysquid/mods/sodium/client/model/light/smooth/AoNeighborInfo.java deleted file mode 100644 index 5a4a29493..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/light/smooth/AoNeighborInfo.java +++ /dev/null @@ -1,257 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.light.smooth; - -import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.NEG_X; -import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.NEG_Y; -import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.NEG_Z; -import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.POS_X; -import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.POS_Y; -import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.POS_Z; - -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing; -import org.jetbrains.annotations.NotNull; - -/** - * The neighbor information for each face of a block, used when performing smooth lighting in order to calculate - * the occlusion of each corner. - */ -enum AoNeighborInfo { - EAST(new ModelQuadFacing[] { NEG_Y, POS_Y, NEG_Z, POS_Z }, 0.6F) { - @Override - public void calculateCornerWeights(float x, float y, float z, float[] out) { - final float u = z; - final float v = 1.0f - y; - - out[0] = v * u; - out[1] = v * (1.0f - u); - out[2] = (1.0f - v) * (1.0f - u); - out[3] = (1.0f - v) * u; - } - - @Override - public void mapCorners(int[] lm0, float[] ao0, int[] lm1, float[] ao1) { - lm1[1] = lm0[0]; - lm1[2] = lm0[1]; - lm1[3] = lm0[2]; - lm1[0] = lm0[3]; - - ao1[1] = ao0[0]; - ao1[2] = ao0[1]; - ao1[3] = ao0[2]; - ao1[0] = ao0[3]; - } - - @Override - public float getDepth(float x, float y, float z) { - return 1.0f - x; - } - }, - UP(new ModelQuadFacing[] { POS_X, NEG_X, NEG_Z, POS_Z }, 1.0F) { - @Override - public void calculateCornerWeights(float x, float y, float z, float[] out) { - final float u = z; - final float v = x; - - out[0] = v * u; - out[1] = v * (1.0f - u); - out[2] = (1.0f - v) * (1.0f - u); - out[3] = (1.0f - v) * u; - } - - @Override - public void mapCorners(int[] lm0, float[] ao0, int[] lm1, float[] ao1) { - lm1[2] = lm0[0]; - lm1[3] = lm0[1]; - lm1[0] = lm0[2]; - lm1[1] = lm0[3]; - - ao1[2] = ao0[0]; - ao1[3] = ao0[1]; - ao1[0] = ao0[2]; - ao1[1] = ao0[3]; - } - - @Override - public float getDepth(float x, float y, float z) { - return 1.0f - y; - } - }, - SOUTH(new ModelQuadFacing[] { NEG_X, POS_X, NEG_Y, POS_Y }, 0.8F) { - @Override - public void calculateCornerWeights(float x, float y, float z, float[] out) { - final float u = y; - final float v = 1.0f - x; - - out[0] = u * v; - out[1] = (1.0f - u) * v; - out[2] = (1.0f - u) * (1.0f - v); - out[3] = u * (1.0f - v); - } - - @Override - public void mapCorners(int[] lm0, float[] ao0, int[] lm1, float[] ao1) { - lm1[0] = lm0[0]; - lm1[1] = lm0[1]; - lm1[2] = lm0[2]; - lm1[3] = lm0[3]; - - ao1[0] = ao0[0]; - ao1[1] = ao0[1]; - ao1[2] = ao0[2]; - ao1[3] = ao0[3]; - } - - @Override - public float getDepth(float x, float y, float z) { - return 1.0f - z; - } - }, - WEST(new ModelQuadFacing[] { POS_Y, NEG_Y, NEG_Z, POS_Z }, 0.6F) { - @Override - public void calculateCornerWeights(float x, float y, float z, float[] out) { - final float u = z; - final float v = y; - - out[0] = v * u; - out[1] = v * (1.0f - u); - out[2] = (1.0f - v) * (1.0f - u); - out[3] = (1.0f - v) * u; - } - - @Override - public void mapCorners(int[] lm0, float[] ao0, int[] lm1, float[] ao1) { - lm1[3] = lm0[0]; - lm1[0] = lm0[1]; - lm1[1] = lm0[2]; - lm1[2] = lm0[3]; - - ao1[3] = ao0[0]; - ao1[0] = ao0[1]; - ao1[1] = ao0[2]; - ao1[2] = ao0[3]; - } - - @Override - public float getDepth(float x, float y, float z) { - return x; - } - }, - DOWN(new ModelQuadFacing[] { NEG_X, POS_X, NEG_Z, POS_Z }, 0.5F) { - @Override - public void calculateCornerWeights(float x, float y, float z, float[] out) { - final float u = z; - final float v = 1.0f - x; - - out[0] = v * u; - out[1] = v * (1.0f - u); - out[2] = (1.0f - v) * (1.0f - u); - out[3] = (1.0f - v) * u; - } - - @Override - public void mapCorners(int[] lm0, float[] ao0, int[] lm1, float[] ao1) { - lm1[0] = lm0[0]; - lm1[1] = lm0[1]; - lm1[2] = lm0[2]; - lm1[3] = lm0[3]; - - ao1[0] = ao0[0]; - ao1[1] = ao0[1]; - ao1[2] = ao0[2]; - ao1[3] = ao0[3]; - } - - @Override - public float getDepth(float x, float y, float z) { - return y; - } - }, - NORTH(new ModelQuadFacing[] { POS_Y, NEG_Y, POS_X, NEG_X }, 0.8F) { - @Override - public void calculateCornerWeights(float x, float y, float z, float[] out) { - final float u = 1.0f - x; - final float v = y; - - out[0] = v * u; - out[1] = v * (1.0f - u); - out[2] = (1.0f - v) * (1.0f - u); - out[3] = (1.0f - v) * u; - } - - @Override - public void mapCorners(int[] lm0, float[] ao0, int[] lm1, float[] ao1) { - lm1[3] = lm0[0]; - lm1[0] = lm0[1]; - lm1[1] = lm0[2]; - lm1[2] = lm0[3]; - - ao1[3] = ao0[0]; - ao1[0] = ao0[1]; - ao1[1] = ao0[2]; - ao1[2] = ao0[3]; - } - - @Override - public float getDepth(float x, float y, float z) { - return z; - } - }; - - /** - * The direction of each corner block from this face, which can be retrieved by offsetting the position of the origin - * block by the direction vector. - */ - public final ModelQuadFacing[] faces; - - /** - * The constant brightness modifier for this face. This data exists to emulate the results of the OpenGL lighting - * model which gives a faux directional light appearance to blocks in the game. Not currently used. - */ - public final float strength; - - AoNeighborInfo(ModelQuadFacing[] directions, float strength) { - this.faces = directions; - this.strength = strength; - } - - /** - * Calculates how much each corner contributes to the final "darkening" of the vertex at the specified position. The - * weight is a function of the distance from the vertex's position to the corner block's position. - * - * @param x The x-position of the vertex - * @param y The y-position of the vertex - * @param z The z-position of the vertex - * @param out The weight values for each corner - */ - public abstract void calculateCornerWeights(float x, float y, float z, float[] out); - - /** - * Maps the light map and occlusion value arrays {@param lm0} and {@param ao0} from {@link AoFaceData} to the - * correct corners for this facing. - * - * @param lm0 The input light map texture coordinates array - * @param ao0 The input ambient occlusion color array - * @param lm1 The re-orientated output light map texture coordinates array - * @param ao1 The re-orientated output ambient occlusion color array - */ - public abstract void mapCorners(int[] lm0, float[] ao0, int[] lm1, float[] ao1); - - /** - * Calculates the depth (or inset) of the vertex into this facing of the block. Used to determine - * how much shadow is contributed by the direct neighbors of a block. - * - * @param x The x-position of the vertex - * @param y The y-position of the vertex - * @param z The z-position of the vertex - * @return The depth of the vertex into this face - */ - public abstract float getDepth(float x, float y, float z); - - private static final AoNeighborInfo[] VALUES = AoNeighborInfo.values(); - - /** - * @return Returns the {@link AoNeighborInfo} which corresponds with the specified direction - */ - public static AoNeighborInfo get(@NotNull ModelQuadFacing direction) { - return VALUES[direction.ordinal()]; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/light/smooth/SmoothLightPipeline.java b/src/main/java/me/jellysquid/mods/sodium/client/model/light/smooth/SmoothLightPipeline.java deleted file mode 100644 index c16b4bbaa..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/light/smooth/SmoothLightPipeline.java +++ /dev/null @@ -1,285 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.light.smooth; - -import com.google.common.math.DoubleMath; -import com.gtnewhorizon.gtnhlib.blockpos.BlockPos; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.ModelQuadView; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFlags; -import me.jellysquid.mods.sodium.client.model.light.LightPipeline; -import net.coderbot.iris.Iris; -import me.jellysquid.mods.sodium.client.model.light.data.LightDataAccess; -import me.jellysquid.mods.sodium.client.model.light.data.QuadLightData; -import net.coderbot.iris.block_rendering.BlockRenderingSettings; - - -/** - * A light pipeline which produces smooth interpolated lighting and ambient occlusion for model quads. This - * implementation makes a number of improvements over vanilla's own "smooth lighting" option. In no particular order: - * - * - Ambient occlusion of block slopes underwater no longer produces broken results (fixes MC-149211) - * - Smooth lighting now works when underwater (fixes MC-68129) - * - Corner blocks are now selected from the correct set of neighbors above block faces (fixes MC-148689 and MC-12558) - * - Shading issues caused by anisotropy are fixed by re-orientating quads to a consistent ordering (fixes MC-136302) - * - Inset block faces are correctly shaded by their neighbors, fixing a number of problems with non-full blocks such as - * grass paths (fixes MC-11783 and MC-108621) - * - Synchronization issues between the main render thread's light engine and chunk build worker threads are corrected - * by copying light data alongside block states, fixing a number of inconsistencies in baked chunks (no open issue) - * - * This implementation also includes a significant number of optimizations: - * - * - Computed light data for a given block face is cached and re-used again when multiple quads exist for a given - * facing, making complex block models less expensive to render - * - The light data cache encodes as much information as possible into integer words to improve cache locality and - * to eliminate the multiple array lookups that would otherwise be needed, significantly speeding up this section - * - Block faces aligned to the block grid use a fast-path for mapping corner light values to vertices without expensive - * interpolation or blending, speeding up most block renders - * - Some critical code paths have been re-written to hit the JVM's happy path, allowing it to perform auto-vectorization - * of the blend functions - * - Information about a given model quad is cached to enable the light pipeline to make certain assumptions and skip - * unnecessary computation - */ -public class SmoothLightPipeline implements LightPipeline { - public static final double TOLERANCE = 1.0E-5F; - - public static final boolean useSmoothLightingOptimizations = false; - /** - * The cache which light data will be accessed from. - */ - private final LightDataAccess lightCache; - - /** - * The cached face data for each side of a block, both inset and outset. - */ - private final AoFaceData[] cachedFaceData = new AoFaceData[6 * 2]; - - /** - * The position at which the cached face data was taken at. - */ - private long cachedPos = Long.MIN_VALUE; - - /** - * A temporary array for storing the intermediary results of weight data for non-aligned face blending. - */ - private final float[] weights = new float[4]; - - public SmoothLightPipeline(LightDataAccess cache) { - this.lightCache = cache; - - for (int i = 0; i < this.cachedFaceData.length; i++) { - this.cachedFaceData[i] = new AoFaceData(); - } - } - - @Override - public void calculate(ModelQuadView quad, BlockPos pos, QuadLightData out, ModelQuadFacing cullFace, ModelQuadFacing face, boolean shade) { - this.updateCachedData(pos.asLong()); - - final int flags = quad.getFlags(); - - final AoNeighborInfo neighborInfo = AoNeighborInfo.get(face); - - // If the model quad is aligned to the block's face and covers it entirely, we can take a fast path and directly - // map the corner values onto this quad's vertices. This covers most situations during rendering and provides - // a modest speed-up. - // To match vanilla behavior, also treat the face as aligned if it is parallel and the block state is a full cube - if (useSmoothLightingOptimizations) { - if ((flags & ModelQuadFlags.IS_ALIGNED) != 0 || ((flags & ModelQuadFlags.IS_PARALLEL) != 0 && LightDataAccess.unpackFC(this.lightCache.get(pos)))) { - if ((flags & ModelQuadFlags.IS_PARTIAL) == 0) { - this.applyAlignedFullFace(neighborInfo, pos, face, out); - } else { - this.applyAlignedPartialFace(neighborInfo, quad, pos, face, out); - } - } else if ((flags & ModelQuadFlags.IS_PARALLEL) != 0) { - this.applyParallelFace(neighborInfo, quad, pos, face, out); - } else { - this.applyNonParallelFace(neighborInfo, quad, pos, face, out); - } - } else { - this.applyNonParallelFace(neighborInfo, quad, pos, face, out); - } - - this.applySidedBrightness(out, face, shade); - } - - /** - * Quickly calculates the light data for a full grid-aligned quad. This represents the most common case (outward - * facing quads on a full-block model) and avoids interpolation between neighbors as each corner will only ever - * have two contributing sides. - * Flags: IS_ALIGNED, !IS_PARTIAL - */ - private void applyAlignedFullFace(AoNeighborInfo neighborInfo, BlockPos pos, ModelQuadFacing dir, QuadLightData out) { - final AoFaceData faceData = this.getCachedFaceData(pos, dir, true); - neighborInfo.mapCorners(faceData.lm, faceData.ao, out.lm, out.br); - } - - /** - * Calculates the light data for a grid-aligned quad that does not cover the entire block volume's face. - * Flags: IS_ALIGNED, IS_PARTIAL - */ - private void applyAlignedPartialFace(AoNeighborInfo neighborInfo, ModelQuadView quad, BlockPos pos, ModelQuadFacing dir, QuadLightData out) { - for (int i = 0; i < 4; i++) { - // Clamp the vertex positions to the block's boundaries to prevent weird errors in lighting - final float cx = clamp(quad.getX(i)); - final float cy = clamp(quad.getY(i)); - final float cz = clamp(quad.getZ(i)); - - final float[] weights = this.weights; - neighborInfo.calculateCornerWeights(cx, cy, cz, weights); - this.applyAlignedPartialFaceVertex(pos, dir, weights, i, out, true); - } - } - - /** - * This method is the same as {@link #applyNonParallelFace(AoNeighborInfo, ModelQuadView, BlockPos, ModelQuadFacing, - * QuadLightData)} but with the check for a depth of approximately 0 removed. If the quad is parallel but not - * aligned, all of its vertices will have the same depth and this depth must be approximately greater than 0, - * meaning the check for 0 will always return false. - * Flags: !IS_ALIGNED, IS_PARALLEL - */ - private void applyParallelFace(AoNeighborInfo neighborInfo, ModelQuadView quad, BlockPos pos, ModelQuadFacing dir, QuadLightData out) { - for (int i = 0; i < 4; i++) { - // Clamp the vertex positions to the block's boundaries to prevent weird errors in lighting - final float cx = clamp(quad.getX(i)); - final float cy = clamp(quad.getY(i)); - final float cz = clamp(quad.getZ(i)); - - final float[] weights = this.weights; - neighborInfo.calculateCornerWeights(cx, cy, cz, weights); - - final float depth = neighborInfo.getDepth(cx, cy, cz); - - // If the quad is approximately grid-aligned (not inset) to the other side of the block, avoid unnecessary - // computation by treating it is as aligned - if (DoubleMath.fuzzyEquals(depth, 1.0F, TOLERANCE)) { - this.applyAlignedPartialFaceVertex(pos, dir, weights, i, out, false); - } else { - // Blend the occlusion factor between the blocks directly beside this face and the blocks above it - // based on how inset the face is. This fixes a few issues with blocks such as farmland and paths. - this.applyInsetPartialFaceVertex(pos, dir, depth, 1.0f - depth, weights, i, out); - } - } - } - - /** - * Flags: !IS_ALIGNED, !IS_PARALLEL - */ - private void applyNonParallelFace(AoNeighborInfo neighborInfo, ModelQuadView quad, BlockPos pos, ModelQuadFacing dir, QuadLightData out) { - for (int i = 0; i < 4; i++) { - // Clamp the vertex positions to the block's boundaries to prevent weird errors in lighting - final float cx = clamp(quad.getX(i)); - final float cy = clamp(quad.getY(i)); - final float cz = clamp(quad.getZ(i)); - - final float[] weights = this.weights; - neighborInfo.calculateCornerWeights(cx, cy, cz, weights); - - final float depth = neighborInfo.getDepth(cx, cy, cz); - - // If the quad is approximately grid-aligned (not inset), avoid unnecessary computation by treating it is as aligned - if (DoubleMath.fuzzyEquals(depth, 0.0F, TOLERANCE)) { - this.applyAlignedPartialFaceVertex(pos, dir, weights, i, out, true); - } else if (DoubleMath.fuzzyEquals(depth, 1.0F, TOLERANCE)) { - this.applyAlignedPartialFaceVertex(pos, dir, weights, i, out, false); - } else { - // Blend the occlusion factor between the blocks directly beside this face and the blocks above it - // based on how inset the face is. This fixes a few issues with blocks such as farmland and paths. - this.applyInsetPartialFaceVertex(pos, dir, depth, 1.0f - depth, weights, i, out); - } - } - } - - private void applyAlignedPartialFaceVertex(BlockPos pos, ModelQuadFacing dir, float[] w, int i, QuadLightData out, boolean offset) { - final AoFaceData faceData = this.getCachedFaceData(pos, dir, offset); - - if (!faceData.hasUnpackedLightData()) { - faceData.unpackLightData(); - } - - final float sl = faceData.getBlendedSkyLight(w); - final float bl = faceData.getBlendedBlockLight(w); - final float ao = faceData.getBlendedShade(w); - - out.br[i] = ao; - out.lm[i] = getLightMapCoord(sl, bl); - } - - private void applyInsetPartialFaceVertex(BlockPos pos, ModelQuadFacing dir, float n1d, float n2d, float[] w, int i, QuadLightData out) { - final AoFaceData n1 = this.getCachedFaceData(pos, dir, false); - - if (!n1.hasUnpackedLightData()) { - n1.unpackLightData(); - } - - AoFaceData n2 = this.getCachedFaceData(pos, dir, true); - - if (!n2.hasUnpackedLightData()) { - n2.unpackLightData(); - } - - // Blend between the direct neighbors and above based on the passed weights - final float ao = (n1.getBlendedShade(w) * n1d) + (n2.getBlendedShade(w) * n2d); - final float sl = (n1.getBlendedSkyLight(w) * n1d) + (n2.getBlendedSkyLight(w) * n2d); - final float bl = (n1.getBlendedBlockLight(w) * n1d) + (n2.getBlendedBlockLight(w) * n2d); - - out.br[i] = ao; - out.lm[i] = getLightMapCoord(sl, bl); - } - - private void applySidedBrightness(QuadLightData out, ModelQuadFacing face, boolean shade) { - if(Iris.enabled && BlockRenderingSettings.INSTANCE.shouldDisableDirectionalShading()) { - return; - } - - final float brightness = this.lightCache.getWorld().getBrightness(face, shade); - final float[] br = out.br; - - for (int i = 0; i < br.length; i++) { - br[i] *= brightness; - } - } - - /** - * Returns the cached data for a given facing or calculates it if it hasn't been cached. - */ - private AoFaceData getCachedFaceData(BlockPos pos, ModelQuadFacing face, boolean offset) { - - final AoFaceData data = this.cachedFaceData[offset ? face.ordinal() : face.ordinal() + 6]; - - if (!data.hasLightData()) { - data.initLightData(this.lightCache, pos, face, offset); - } - - return data; - } - - private void updateCachedData(long key) { - if (this.cachedPos != key) { - for (AoFaceData data : this.cachedFaceData) { - data.reset(); - } - - this.cachedPos = key; - } - } - - /** - * Clamps the given float to the range [0.0, 1.0]. - */ - private static float clamp(float v) { - if (v < 0.0f) { - return 0.0f; - } else if (v > 1.0f) { - return 1.0f; - } - - return v; - } - - /** - * Returns a texture coordinate on the light map texture for the given block and sky light values. - */ - private static int getLightMapCoord(float sl, float bl) { - return (((int) sl & 0xFF) << 16) | ((int) bl & 0xFF); - } - -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/VanillaVertexTypes.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/VanillaVertexTypes.java deleted file mode 100644 index 4d2ab7857..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/VanillaVertexTypes.java +++ /dev/null @@ -1,21 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex; - -import me.jellysquid.mods.sodium.client.model.vertex.formats.glyph.GlyphVertexSink; -import me.jellysquid.mods.sodium.client.model.vertex.formats.glyph.GlyphVertexType; -import me.jellysquid.mods.sodium.client.model.vertex.formats.line.LineVertexSink; -import me.jellysquid.mods.sodium.client.model.vertex.formats.line.LineVertexType; -import me.jellysquid.mods.sodium.client.model.vertex.formats.particle.ParticleVertexSink; -import me.jellysquid.mods.sodium.client.model.vertex.formats.particle.ParticleVertexType; -import me.jellysquid.mods.sodium.client.model.vertex.formats.quad.QuadVertexSink; -import me.jellysquid.mods.sodium.client.model.vertex.formats.quad.QuadVertexType; -import me.jellysquid.mods.sodium.client.model.vertex.formats.screen_quad.BasicScreenQuadVertexSink; -import me.jellysquid.mods.sodium.client.model.vertex.formats.screen_quad.BasicScreenQuadVertexType; -import me.jellysquid.mods.sodium.client.model.vertex.type.VanillaVertexType; - -public class VanillaVertexTypes { - public static final VanillaVertexType QUADS = new QuadVertexType(); - public static final VanillaVertexType LINES = new LineVertexType(); - public static final VanillaVertexType GLYPHS = new GlyphVertexType(); - public static final VanillaVertexType PARTICLES = new ParticleVertexType(); - public static final VanillaVertexType BASIC_SCREEN_QUADS = new BasicScreenQuadVertexType(); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/VertexDrain.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/VertexDrain.java deleted file mode 100644 index 699beaf0b..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/VertexDrain.java +++ /dev/null @@ -1,29 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex; - -import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer; -import me.jellysquid.mods.sodium.client.model.vertex.type.VertexType; - -/** - * A drain allows the instantiation of {@link VertexSink} and is implemented on outputs which take vertex data. - */ -public interface VertexDrain { - /** - * Returns a {@link VertexDrain} implementation on the provided {@link VertexConsumer}. Since the interface - * is always implemented on a given VertexConsumer, this is simply implemented as a cast internally. - * @param consumer The {@link VertexConsumer} - * @return A {@link VertexDrain} - */ - static VertexDrain of(VertexConsumer consumer) { - return (VertexDrain) consumer; - } - - /** - * Returns a {@link VertexSink} of type {@link T}, created from {@param factory}, which transforms and writes - * vertices through this vertex drain. - * - * @param factory The factory to create a vertex sink using - * @param The vertex sink's type - * @return A new {@link VertexSink} of type {@link T} - */ - T createSink(VertexType factory); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/VertexSink.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/VertexSink.java deleted file mode 100644 index 4d932b365..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/VertexSink.java +++ /dev/null @@ -1,36 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex; - -/** - * Vertex sinks allow vertex data to be quickly written out to a {@link VertexDrain} while providing - * compile-time data format contracts. Generally, you will want a format-specific vertex sink, such as - * {@link me.jellysquid.mods.sodium.client.model.vertex.formats.quad.QuadVertexSink} in order to write - * vertex data. - */ -public interface VertexSink { - /** - * Ensures the backing storage to this sink has enough space for the given number of vertices to be written. This - * should be called with the number of vertices you expect to write before you make calls to write vertices. - * - * If the caller tries to write vertices without calling this method, or writes more vertices than they ensured - * there was capacity for, an {@link java.nio.BufferUnderflowException} may occur. - * - * When writing batches of vertices (such as those belonging to a primitive or a large model), it is best practice - * to simply call this method once at the start with the number of vertices you plan to write. This ensures the - * backing storage will only be resized once (if necessary) to fit the incoming vertex data. - * - * @param count The number of vertices - */ - void ensureCapacity(int count); - - /** - * Flushes any written vertex data to the {@link VertexDrain} this sink is connected to, ensuring it is actually - * written to the backing storage. This should be called after vertex data has been written to this sink. - * - * It is valid to flush a sink at any time. Only vertices that have been written since the last flush will be - * flushed when calling this method. If no vertices need to be flushed, this method does nothing. - * - * For optimal performance, callers should wait until they have written out as much vertex data as possible before - * flushing, in effect batching their writes. - */ - void flush(); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/buffer/VertexBufferBuilder.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/buffer/VertexBufferBuilder.java deleted file mode 100644 index 62b7ed4aa..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/buffer/VertexBufferBuilder.java +++ /dev/null @@ -1,92 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.buffer; - -import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*; - -import me.jellysquid.mods.sodium.client.gl.attribute.BufferVertexFormat; - -import java.nio.ByteBuffer; - -public class VertexBufferBuilder implements VertexBufferView { - private final BufferVertexFormat vertexFormat; - - private ByteBuffer buffer; - private int writerOffset; - private int capacity; - - public VertexBufferBuilder(BufferVertexFormat vertexFormat, int initialCapacity) { - this.vertexFormat = vertexFormat; - - this.buffer = memAlloc(initialCapacity); - this.capacity = initialCapacity; - this.writerOffset = 0; - } - - private void grow(int len) { - // The new capacity will at least as large as the write it needs to service - final int cap = Math.max(this.capacity * 2, this.capacity + len); - - this.buffer = memRealloc(this.buffer, cap); - this.capacity = cap; - } - - @Override - public boolean ensureBufferCapacity(int bytes) { - if (this.writerOffset + bytes <= this.capacity) { - return false; - } - - this.grow(bytes); - - return true; - } - - @Override - public ByteBuffer getDirectBuffer() { - return this.buffer; - } - - @Override - public int getWriterPosition() { - return this.writerOffset; - } - - @Override - public void flush(int vertexCount, BufferVertexFormat format) { - if (this.vertexFormat != format) { - throw new IllegalStateException("Mis-matched vertex format (expected: [" + format + "], currently using: [" + this.vertexFormat + "])"); - } - - this.writerOffset += vertexCount * format.getStride(); - } - - @Override - public BufferVertexFormat getVertexFormat() { - return this.vertexFormat; - } - - public boolean isEmpty() { - return this.writerOffset == 0; - } - - public int getSize() { - return this.writerOffset; - } - - /** - * Ends the stream of written data and makes a copy of it to be passed around. - */ - public void copyInto(ByteBuffer dst) { - // Mark the slice of memory that needs to be copied - this.buffer.position(0); - this.buffer.limit(this.writerOffset); - - // Allocate a new buffer which is just large enough to contain the slice of vertex data - // The buffer is then flipped after the operation so the callee sees a range of bytes from (0,len] which can - // then be immediately passed to native libraries or the graphics driver - dst.put(this.buffer.slice()); - - // Reset the position and limit set earlier of the backing scratch buffer - this.buffer.clear(); - this.writerOffset = 0; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/buffer/VertexBufferView.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/buffer/VertexBufferView.java deleted file mode 100644 index 0ae537fc1..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/buffer/VertexBufferView.java +++ /dev/null @@ -1,43 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.buffer; - -import me.jellysquid.mods.sodium.client.gl.attribute.BufferVertexFormat; - -import java.nio.ByteBuffer; - -/** - * Provides a view into {@link net.minecraft.client.render.BufferBuilder} and similar types. - */ -public interface VertexBufferView { - /** - * Ensures there is capacity in the buffer for the given number of bytes. - * @param bytes The number of bytes to allocate space for - * @return True if the buffer was resized, otherwise false - */ - boolean ensureBufferCapacity(int bytes); - - /** - * Returns a handle to the internal storage of this buffer. The buffer can be directly written into at the - * base address provided by {@link VertexBufferView#getWriterPosition()}. - * - * @return A {@link ByteBuffer} in off-heap space - */ - ByteBuffer getDirectBuffer(); - - /** - * @return The position at which new data should be written to, in bytes - */ - int getWriterPosition(); - - /** - * Flushes the given number of vertices to this buffer. This ensures that all constraints are still valid, and if - * so, advances the vertex counter and writer pointer to the end of the data that was written by the caller. - * @param vertexCount The number of vertices to flush - * @param format The format of each vertex - */ - void flush(int vertexCount, BufferVertexFormat format); - - /** - * @return The current vertex format of the buffer - */ - BufferVertexFormat getVertexFormat(); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/buffer/VertexBufferWriter.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/buffer/VertexBufferWriter.java deleted file mode 100644 index 48e7727c4..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/buffer/VertexBufferWriter.java +++ /dev/null @@ -1,53 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.buffer; - -import me.jellysquid.mods.sodium.client.gl.attribute.BufferVertexFormat; -import me.jellysquid.mods.sodium.client.model.vertex.VertexSink; -import me.jellysquid.mods.sodium.client.model.vertex.type.BufferVertexType; - -/** - * Base implementation of a {@link VertexSink} which writes into a {@link VertexBufferView} directly. - */ -public abstract class VertexBufferWriter implements VertexSink { - protected final VertexBufferView backingBuffer; - - protected final BufferVertexFormat vertexFormat; - protected final int vertexStride; - - private int vertexCount; - - protected VertexBufferWriter(VertexBufferView backingBuffer, BufferVertexType vertexType) { - this.backingBuffer = backingBuffer; - - this.vertexFormat = vertexType.getBufferVertexFormat(); - this.vertexStride = this.vertexFormat.getStride(); - - this.onBufferStorageChanged(); - } - - @Override - public void ensureCapacity(int count) { - if (this.backingBuffer.ensureBufferCapacity((this.vertexCount + count) * this.vertexStride)) { - this.onBufferStorageChanged(); - } - } - - @Override - public void flush() { - this.backingBuffer.flush(this.vertexCount, this.vertexFormat); - this.vertexCount = 0; - } - - /** - * Advances the write pointer forward by the stride of one vertex. This should always be called after a - * vertex is written. Implementations which override this should always call invoke the super implementation. - */ - protected void advance() { - this.vertexCount++; - } - - /** - * Called when the underlying memory buffer to the backing storage changes. When this is called, the implementation - * should update any pointers - */ - protected abstract void onBufferStorageChanged(); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/buffer/VertexBufferWriterNio.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/buffer/VertexBufferWriterNio.java deleted file mode 100644 index c444c4714..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/buffer/VertexBufferWriterNio.java +++ /dev/null @@ -1,32 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.buffer; - -import me.jellysquid.mods.sodium.client.model.vertex.type.BufferVertexType; - -import java.nio.ByteBuffer; - -/** - * A safe {@link VertexBufferWriter} implementation which uses Java's NIO library to write into memory buffers. All - * write operations are checked and will throw an exception if an invalid memory access is detected. Supported on all - * platforms. - */ -public abstract class VertexBufferWriterNio extends VertexBufferWriter { - protected ByteBuffer byteBuffer; - protected int writeOffset; - - protected VertexBufferWriterNio(VertexBufferView backingBuffer, BufferVertexType vertexType) { - super(backingBuffer, vertexType); - } - - @Override - protected void onBufferStorageChanged() { - this.byteBuffer = this.backingBuffer.getDirectBuffer(); - this.writeOffset = this.backingBuffer.getWriterPosition(); - } - - @Override - protected void advance() { - this.writeOffset += this.vertexStride; - - super.advance(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/buffer/VertexBufferWriterUnsafe.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/buffer/VertexBufferWriterUnsafe.java deleted file mode 100644 index 90994d7b2..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/buffer/VertexBufferWriterUnsafe.java +++ /dev/null @@ -1,34 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.buffer; - -import me.jellysquid.mods.sodium.client.model.vertex.type.BufferVertexType; -import org.lwjgl.MemoryUtil; - -/** - * An unsafe {@link VertexBufferWriter} implementation which uses direct memory operations to enable fast blitting of - * data into memory buffers. Only available on JVMs which support {@link sun.misc.Unsafe}, but generally produces much - * better optimized code than other implementations. The implementation does not check for invalid memory accesses, - * meaning that errors can corrupt process memory. - */ -public abstract class VertexBufferWriterUnsafe extends VertexBufferWriter { - /** - * The write pointer into the buffer storage. This is advanced by the vertex stride every time - * {@link VertexBufferWriterUnsafe#advance()} is called. - */ - protected long writePointer; - - protected VertexBufferWriterUnsafe(VertexBufferView backingBuffer, BufferVertexType vertexType) { - super(backingBuffer, vertexType); - } - - @Override - protected void onBufferStorageChanged() { - this.writePointer = MemoryUtil.getAddress(this.backingBuffer.getDirectBuffer(), this.backingBuffer.getWriterPosition()); - } - - @Override - protected void advance() { - this.writePointer += this.vertexStride; - - super.advance(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/fallback/VertexWriterFallback.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/fallback/VertexWriterFallback.java deleted file mode 100644 index c4e94727c..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/fallback/VertexWriterFallback.java +++ /dev/null @@ -1,31 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.fallback; - -import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer; -import me.jellysquid.mods.sodium.client.model.vertex.VertexSink; - - -/** - * The base implementation for a {@link VertexSink} which writes to a black-boxed {@link VertexConsumer}. This is the - * fallback path used when direct-writing optimizations cannot be used because the drain has no accessible backing - * memory. This implementation is very slow and should be avoided where possible. - * - * This sink does not support explicit batching/flushing and as such, all written vertices are immediately flushed - * to the backing implementation. - */ -public abstract class VertexWriterFallback implements VertexSink { - protected final VertexConsumer consumer; - - protected VertexWriterFallback(VertexConsumer consumer) { - this.consumer = consumer; - } - - @Override - public void ensureCapacity(int count) { - // NO-OP - } - - @Override - public void flush() { - // NO-OP - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/glyph/GlyphVertexSink.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/glyph/GlyphVertexSink.java deleted file mode 100644 index 2502e5c28..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/glyph/GlyphVertexSink.java +++ /dev/null @@ -1,43 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.glyph; - - - -import com.gtnewhorizon.gtnhlib.client.renderer.vertex.DefaultVertexFormat; -import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat; -import me.jellysquid.mods.sodium.client.model.vertex.VertexSink; -import me.jellysquid.mods.sodium.client.util.math.Matrix4fExtended; -import me.jellysquid.mods.sodium.client.util.math.MatrixUtil; -import org.joml.Matrix4f; - -public interface GlyphVertexSink extends VertexSink { - VertexFormat VERTEX_FORMAT = DefaultVertexFormat.POSITION_TEXTURE_COLOR_LIGHT; - - /** - * Writes a glyph vertex to the sink. - * - * @param matrix The transformation matrix to apply to the vertex's position - * @see GlyphVertexSink#writeGlyph(float, float, float, int, float, float, int) - */ - default void writeGlyph(Matrix4f matrix, float x, float y, float z, int color, float u, float v, int light) { - Matrix4fExtended matrixExt = MatrixUtil.getExtendedMatrix(matrix); - - float x2 = matrixExt.transformVecX(x, y, z); - float y2 = matrixExt.transformVecY(x, y, z); - float z2 = matrixExt.transformVecZ(x, y, z); - - this.writeGlyph(x2, y2, z2, color, u, v, light); - } - - /** - * Writes a glyph vertex to the sink. - * - * @param x The x-position of the vertex - * @param y The y-position of the vertex - * @param z The z-position of the vertex - * @param color The ABGR-packed color of the vertex - * @param u The u-texture of the vertex - * @param v The v-texture of the vertex - * @param light The packed light map texture coordinates of the vertex - */ - void writeGlyph(float x, float y, float z, int color, float u, float v, int light); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/glyph/GlyphVertexType.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/glyph/GlyphVertexType.java deleted file mode 100644 index d0b0091fd..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/glyph/GlyphVertexType.java +++ /dev/null @@ -1,34 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.glyph; - -import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat; -import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer; - -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; -import me.jellysquid.mods.sodium.client.model.vertex.formats.glyph.writer.GlyphVertexBufferWriterNio; -import me.jellysquid.mods.sodium.client.model.vertex.formats.glyph.writer.GlyphVertexBufferWriterUnsafe; -import me.jellysquid.mods.sodium.client.model.vertex.formats.glyph.writer.GlyphVertexWriterFallback; -import me.jellysquid.mods.sodium.client.model.vertex.type.BlittableVertexType; -import me.jellysquid.mods.sodium.client.model.vertex.type.VanillaVertexType; - - -public class GlyphVertexType implements VanillaVertexType, BlittableVertexType { - @Override - public GlyphVertexSink createBufferWriter(VertexBufferView buffer, boolean direct) { - return direct ? new GlyphVertexBufferWriterUnsafe(buffer) : new GlyphVertexBufferWriterNio(buffer); - } - - @Override - public GlyphVertexSink createFallbackWriter(VertexConsumer consumer) { - return new GlyphVertexWriterFallback(consumer); - } - - @Override - public VertexFormat getVertexFormat() { - return GlyphVertexSink.VERTEX_FORMAT; - } - - @Override - public BlittableVertexType asBlittable() { - return this; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/glyph/writer/GlyphVertexBufferWriterNio.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/glyph/writer/GlyphVertexBufferWriterNio.java deleted file mode 100644 index ab8384b3a..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/glyph/writer/GlyphVertexBufferWriterNio.java +++ /dev/null @@ -1,30 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.glyph.writer; - -import me.jellysquid.mods.sodium.client.model.vertex.VanillaVertexTypes; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferWriterNio; -import me.jellysquid.mods.sodium.client.model.vertex.formats.glyph.GlyphVertexSink; - -import java.nio.ByteBuffer; - -public class GlyphVertexBufferWriterNio extends VertexBufferWriterNio implements GlyphVertexSink { - public GlyphVertexBufferWriterNio(VertexBufferView backingBuffer) { - super(backingBuffer, VanillaVertexTypes.GLYPHS); - } - - @Override - public void writeGlyph(float x, float y, float z, int color, float u, float v, int light) { - int i = this.writeOffset; - - ByteBuffer buffer = this.byteBuffer; - buffer.putFloat(i, x); - buffer.putFloat(i + 4, y); - buffer.putFloat(i + 8, z); - buffer.putInt(i + 12, color); - buffer.putFloat(i + 16, u); - buffer.putFloat(i + 20, v); - buffer.putInt(i + 24, light); - - this.advance(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/glyph/writer/GlyphVertexBufferWriterUnsafe.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/glyph/writer/GlyphVertexBufferWriterUnsafe.java deleted file mode 100644 index 896c751ff..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/glyph/writer/GlyphVertexBufferWriterUnsafe.java +++ /dev/null @@ -1,30 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.glyph.writer; - -import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*; - -import me.jellysquid.mods.sodium.client.model.vertex.VanillaVertexTypes; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferWriterUnsafe; -import me.jellysquid.mods.sodium.client.model.vertex.formats.glyph.GlyphVertexSink; - -public class GlyphVertexBufferWriterUnsafe extends VertexBufferWriterUnsafe implements GlyphVertexSink { - public GlyphVertexBufferWriterUnsafe(VertexBufferView backingBuffer) { - super(backingBuffer, VanillaVertexTypes.GLYPHS); - } - - @Override - public void writeGlyph(float x, float y, float z, int color, float u, float v, int light) { - long i = this.writePointer; - - memPutFloat(i, x); - memPutFloat(i + 4, y); - memPutFloat(i + 8, z); - memPutInt(i + 12, color); - memPutFloat(i + 16, u); - memPutFloat(i + 20, v); - memPutInt(i + 24, light); - - this.advance(); - - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/glyph/writer/GlyphVertexWriterFallback.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/glyph/writer/GlyphVertexWriterFallback.java deleted file mode 100644 index c88afbd7b..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/glyph/writer/GlyphVertexWriterFallback.java +++ /dev/null @@ -1,23 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.glyph.writer; - -import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.ColorABGR; -import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer; -import me.jellysquid.mods.sodium.client.model.vertex.fallback.VertexWriterFallback; -import me.jellysquid.mods.sodium.client.model.vertex.formats.glyph.GlyphVertexSink; - - -public class GlyphVertexWriterFallback extends VertexWriterFallback implements GlyphVertexSink { - public GlyphVertexWriterFallback(VertexConsumer consumer) { - super(consumer); - } - - @Override - public void writeGlyph(float x, float y, float z, int color, float u, float v, int light) { - VertexConsumer consumer = this.consumer; - consumer.vertex(x, y, z); - consumer.color(ColorABGR.unpackRed(color), ColorABGR.unpackGreen(color), ColorABGR.unpackBlue(color), ColorABGR.unpackAlpha(color)); - consumer.texture(u, v); - consumer.light(light); - consumer.next(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/line/LineVertexSink.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/line/LineVertexSink.java deleted file mode 100644 index 52cc62ae2..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/line/LineVertexSink.java +++ /dev/null @@ -1,10 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.line; - -import com.gtnewhorizon.gtnhlib.client.renderer.vertex.DefaultVertexFormat; -import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat; -import me.jellysquid.mods.sodium.client.model.vertex.VertexSink; - -public interface LineVertexSink extends VertexSink { - VertexFormat VERTEX_FORMAT = DefaultVertexFormat.POSITION_COLOR; - -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/line/LineVertexType.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/line/LineVertexType.java deleted file mode 100644 index a0581bc30..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/line/LineVertexType.java +++ /dev/null @@ -1,34 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.line; - -import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat; -import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer; - -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; -import me.jellysquid.mods.sodium.client.model.vertex.formats.line.writer.LineVertexBufferWriterNio; -import me.jellysquid.mods.sodium.client.model.vertex.formats.line.writer.LineVertexBufferWriterUnsafe; -import me.jellysquid.mods.sodium.client.model.vertex.formats.line.writer.LineVertexWriterFallback; -import me.jellysquid.mods.sodium.client.model.vertex.type.BlittableVertexType; -import me.jellysquid.mods.sodium.client.model.vertex.type.VanillaVertexType; - - -public class LineVertexType implements VanillaVertexType, BlittableVertexType { - @Override - public LineVertexSink createBufferWriter(VertexBufferView buffer, boolean direct) { - return direct ? new LineVertexBufferWriterUnsafe(buffer) : new LineVertexBufferWriterNio(buffer); - } - - @Override - public LineVertexSink createFallbackWriter(VertexConsumer consumer) { - return new LineVertexWriterFallback(consumer); - } - - @Override - public VertexFormat getVertexFormat() { - return LineVertexSink.VERTEX_FORMAT; - } - - @Override - public BlittableVertexType asBlittable() { - return this; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/line/writer/LineVertexBufferWriterNio.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/line/writer/LineVertexBufferWriterNio.java deleted file mode 100644 index c7a903c05..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/line/writer/LineVertexBufferWriterNio.java +++ /dev/null @@ -1,13 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.line.writer; - -import me.jellysquid.mods.sodium.client.model.vertex.VanillaVertexTypes; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferWriterNio; -import me.jellysquid.mods.sodium.client.model.vertex.formats.line.LineVertexSink; - -public class LineVertexBufferWriterNio extends VertexBufferWriterNio implements LineVertexSink { - public LineVertexBufferWriterNio(VertexBufferView backingBuffer) { - super(backingBuffer, VanillaVertexTypes.LINES); - } - -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/line/writer/LineVertexBufferWriterUnsafe.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/line/writer/LineVertexBufferWriterUnsafe.java deleted file mode 100644 index 1f3656a38..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/line/writer/LineVertexBufferWriterUnsafe.java +++ /dev/null @@ -1,13 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.line.writer; - -import me.jellysquid.mods.sodium.client.model.vertex.VanillaVertexTypes; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferWriterUnsafe; -import me.jellysquid.mods.sodium.client.model.vertex.formats.line.LineVertexSink; - -public class LineVertexBufferWriterUnsafe extends VertexBufferWriterUnsafe implements LineVertexSink { - public LineVertexBufferWriterUnsafe(VertexBufferView backingBuffer) { - super(backingBuffer, VanillaVertexTypes.LINES); - } - -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/line/writer/LineVertexWriterFallback.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/line/writer/LineVertexWriterFallback.java deleted file mode 100644 index 3b74e4719..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/line/writer/LineVertexWriterFallback.java +++ /dev/null @@ -1,13 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.line.writer; - -import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer; -import me.jellysquid.mods.sodium.client.model.vertex.fallback.VertexWriterFallback; -import me.jellysquid.mods.sodium.client.model.vertex.formats.line.LineVertexSink; - - -public class LineVertexWriterFallback extends VertexWriterFallback implements LineVertexSink { - public LineVertexWriterFallback(VertexConsumer consumer) { - super(consumer); - } - -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/particle/ParticleVertexSink.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/particle/ParticleVertexSink.java deleted file mode 100644 index a6fa46910..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/particle/ParticleVertexSink.java +++ /dev/null @@ -1,23 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.particle; - - - -import com.gtnewhorizon.gtnhlib.client.renderer.vertex.DefaultVertexFormat; -import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat; -import me.jellysquid.mods.sodium.client.model.vertex.VertexSink; - - -public interface ParticleVertexSink extends VertexSink { - VertexFormat VERTEX_FORMAT = DefaultVertexFormat.POSITION_TEXTURE_COLOR_LIGHT; - - /** - * @param x The x-position of the vertex - * @param y The y-position of the vertex - * @param z The z-position of the vertex - * @param u The u-texture of the vertex - * @param v The v-texture of the vertex - * @param color The ABGR-packed color of the vertex - * @param light The packed light map texture coordinates of the vertex - */ - void writeParticle(float x, float y, float z, float u, float v, int color, int light); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/particle/ParticleVertexType.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/particle/ParticleVertexType.java deleted file mode 100644 index 2209a92ec..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/particle/ParticleVertexType.java +++ /dev/null @@ -1,33 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.particle; - -import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat; -import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer; - -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; -import me.jellysquid.mods.sodium.client.model.vertex.formats.particle.writer.ParticleVertexBufferWriterNio; -import me.jellysquid.mods.sodium.client.model.vertex.formats.particle.writer.ParticleVertexBufferWriterUnsafe; -import me.jellysquid.mods.sodium.client.model.vertex.formats.particle.writer.ParticleVertexWriterFallback; -import me.jellysquid.mods.sodium.client.model.vertex.type.BlittableVertexType; -import me.jellysquid.mods.sodium.client.model.vertex.type.VanillaVertexType; - -public class ParticleVertexType implements VanillaVertexType, BlittableVertexType { - @Override - public ParticleVertexSink createBufferWriter(VertexBufferView buffer, boolean direct) { - return direct ? new ParticleVertexBufferWriterUnsafe(buffer) : new ParticleVertexBufferWriterNio(buffer); - } - - @Override - public ParticleVertexSink createFallbackWriter(VertexConsumer consumer) { - return new ParticleVertexWriterFallback(consumer); - } - - @Override - public BlittableVertexType asBlittable() { - return this; - } - - @Override - public VertexFormat getVertexFormat() { - return ParticleVertexSink.VERTEX_FORMAT; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/particle/writer/ParticleVertexBufferWriterNio.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/particle/writer/ParticleVertexBufferWriterNio.java deleted file mode 100644 index 72a6db372..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/particle/writer/ParticleVertexBufferWriterNio.java +++ /dev/null @@ -1,30 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.particle.writer; - -import me.jellysquid.mods.sodium.client.model.vertex.VanillaVertexTypes; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferWriterNio; -import me.jellysquid.mods.sodium.client.model.vertex.formats.particle.ParticleVertexSink; - -import java.nio.ByteBuffer; - -public class ParticleVertexBufferWriterNio extends VertexBufferWriterNio implements ParticleVertexSink { - public ParticleVertexBufferWriterNio(VertexBufferView backingBuffer) { - super(backingBuffer, VanillaVertexTypes.PARTICLES); - } - - @Override - public void writeParticle(float x, float y, float z, float u, float v, int color, int light) { - int i = this.writeOffset; - - ByteBuffer buffer = this.byteBuffer; - buffer.putFloat(i, x); - buffer.putFloat(i + 4, y); - buffer.putFloat(i + 8, z); - buffer.putFloat(i + 12, u); - buffer.putFloat(i + 16, v); - buffer.putInt(i + 20, color); - buffer.putInt(i + 24, light); - - this.advance(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/particle/writer/ParticleVertexBufferWriterUnsafe.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/particle/writer/ParticleVertexBufferWriterUnsafe.java deleted file mode 100644 index 2714d0aa4..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/particle/writer/ParticleVertexBufferWriterUnsafe.java +++ /dev/null @@ -1,29 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.particle.writer; - -import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*; - -import me.jellysquid.mods.sodium.client.model.vertex.VanillaVertexTypes; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferWriterUnsafe; -import me.jellysquid.mods.sodium.client.model.vertex.formats.particle.ParticleVertexSink; - -public class ParticleVertexBufferWriterUnsafe extends VertexBufferWriterUnsafe implements ParticleVertexSink { - public ParticleVertexBufferWriterUnsafe(VertexBufferView backingBuffer) { - super(backingBuffer, VanillaVertexTypes.PARTICLES); - } - - @Override - public void writeParticle(float x, float y, float z, float u, float v, int color, int light) { - long i = this.writePointer; - - memPutFloat(i, x); - memPutFloat(i + 4, y); - memPutFloat(i + 8, z); - memPutFloat(i + 12, u); - memPutFloat(i + 16, v); - memPutInt(i + 20, color); - memPutInt(i + 24, light); - - this.advance(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/particle/writer/ParticleVertexWriterFallback.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/particle/writer/ParticleVertexWriterFallback.java deleted file mode 100644 index 87d291739..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/particle/writer/ParticleVertexWriterFallback.java +++ /dev/null @@ -1,23 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.particle.writer; - -import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.ColorABGR; -import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer; -import me.jellysquid.mods.sodium.client.model.vertex.fallback.VertexWriterFallback; -import me.jellysquid.mods.sodium.client.model.vertex.formats.particle.ParticleVertexSink; - - -public class ParticleVertexWriterFallback extends VertexWriterFallback implements ParticleVertexSink { - public ParticleVertexWriterFallback(VertexConsumer consumer) { - super(consumer); - } - - @Override - public void writeParticle(float x, float y, float z, float u, float v, int color, int light) { - VertexConsumer consumer = this.consumer; - consumer.vertex(x, y, z); - consumer.texture(u, v); - consumer.color(ColorABGR.unpackRed(color), ColorABGR.unpackGreen(color), ColorABGR.unpackBlue(color), ColorABGR.unpackAlpha(color)); - consumer.light(light); - consumer.next(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/quad/QuadVertexSink.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/quad/QuadVertexSink.java deleted file mode 100644 index a6f755ac5..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/quad/QuadVertexSink.java +++ /dev/null @@ -1,47 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.quad; - - -import com.gtnewhorizon.gtnhlib.client.renderer.vertex.DefaultVertexFormat; -import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat; -import com.gtnewhorizons.angelica.compat.toremove.MatrixStack; - -import me.jellysquid.mods.sodium.client.model.vertex.VertexSink; -import me.jellysquid.mods.sodium.client.util.math.Matrix4fExtended; -import me.jellysquid.mods.sodium.client.util.math.MatrixUtil; - - -public interface QuadVertexSink extends VertexSink { - VertexFormat VERTEX_FORMAT = DefaultVertexFormat.POSITION_COLOR_TEXTURE_LIGHT_NORMAL; - - /** - * Writes a quad vertex to this sink. - * - * @param x The x-position of the vertex - * @param y The y-position of the vertex - * @param z The z-position of the vertex - * @param color The ABGR-packed color of the vertex - * @param u The u-texture of the vertex - * @param v The y-texture of the vertex - * @param light The packed light-map coordinates of the vertex - * @param overlay The packed overlay-map coordinates of the vertex - * @param normal The 3-byte packed normal vector of the vertex - */ - void writeQuad(float x, float y, float z, int color, float u, float v, int light, int overlay, int normal); - - /** - * Writes a quad vertex to the sink, transformed by the given matrices. - * - * @param matrices The matrices to transform the vertex's position and normal vectors by - */ - default void writeQuad(MatrixStack.Entry matrices, float x, float y, float z, int color, float u, float v, int light, int overlay, int normal) { - Matrix4fExtended modelMatrix = MatrixUtil.getExtendedMatrix(matrices.getModel()); - - float x2 = modelMatrix.transformVecX(x, y, z); - float y2 = modelMatrix.transformVecY(x, y, z); - float z2 = modelMatrix.transformVecZ(x, y, z); - - int norm = MatrixUtil.transformPackedNormal(normal, matrices.getNormal()); - - this.writeQuad(x2, y2, z2, color, u, v, light, overlay, norm); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/quad/QuadVertexType.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/quad/QuadVertexType.java deleted file mode 100644 index 59de53b00..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/quad/QuadVertexType.java +++ /dev/null @@ -1,34 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.quad; - -import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat; -import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer; - -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; -import me.jellysquid.mods.sodium.client.model.vertex.formats.quad.writer.QuadVertexBufferWriterNio; -import me.jellysquid.mods.sodium.client.model.vertex.formats.quad.writer.QuadVertexBufferWriterUnsafe; -import me.jellysquid.mods.sodium.client.model.vertex.formats.quad.writer.QuadVertexWriterFallback; -import me.jellysquid.mods.sodium.client.model.vertex.type.BlittableVertexType; -import me.jellysquid.mods.sodium.client.model.vertex.type.VanillaVertexType; - - -public class QuadVertexType implements VanillaVertexType, BlittableVertexType { - @Override - public QuadVertexSink createFallbackWriter(VertexConsumer consumer) { - return new QuadVertexWriterFallback(consumer); - } - - @Override - public QuadVertexSink createBufferWriter(VertexBufferView buffer, boolean direct) { - return direct ? new QuadVertexBufferWriterUnsafe(buffer) : new QuadVertexBufferWriterNio(buffer); - } - - @Override - public VertexFormat getVertexFormat() { - return QuadVertexSink.VERTEX_FORMAT; - } - - @Override - public BlittableVertexType asBlittable() { - return this; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/quad/writer/QuadVertexBufferWriterNio.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/quad/writer/QuadVertexBufferWriterNio.java deleted file mode 100644 index d70b4e669..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/quad/writer/QuadVertexBufferWriterNio.java +++ /dev/null @@ -1,32 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.quad.writer; - -import me.jellysquid.mods.sodium.client.model.vertex.VanillaVertexTypes; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferWriterNio; -import me.jellysquid.mods.sodium.client.model.vertex.formats.quad.QuadVertexSink; - -import java.nio.ByteBuffer; - -public class QuadVertexBufferWriterNio extends VertexBufferWriterNio implements QuadVertexSink { - public QuadVertexBufferWriterNio(VertexBufferView backingBuffer) { - super(backingBuffer, VanillaVertexTypes.QUADS); - } - - @Override - public void writeQuad(float x, float y, float z, int color, float u, float v, int light, int overlay, int normal) { - final int i = this.writeOffset; - - final ByteBuffer buf = this.byteBuffer; - buf.putFloat(i, x); - buf.putFloat(i + 4, y); - buf.putFloat(i + 8, z); - buf.putInt(i + 12, color); - buf.putFloat(i + 16, u); - buf.putFloat(i + 20, v); - buf.putInt(i + 24, overlay); - buf.putInt(i + 28, light); - buf.putInt(i + 32, normal); - - this.advance(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/quad/writer/QuadVertexBufferWriterUnsafe.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/quad/writer/QuadVertexBufferWriterUnsafe.java deleted file mode 100644 index bab1953d7..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/quad/writer/QuadVertexBufferWriterUnsafe.java +++ /dev/null @@ -1,31 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.quad.writer; - -import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*; - -import me.jellysquid.mods.sodium.client.model.vertex.VanillaVertexTypes; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferWriterUnsafe; -import me.jellysquid.mods.sodium.client.model.vertex.formats.quad.QuadVertexSink; - -public class QuadVertexBufferWriterUnsafe extends VertexBufferWriterUnsafe implements QuadVertexSink { - public QuadVertexBufferWriterUnsafe(VertexBufferView backingBuffer) { - super(backingBuffer, VanillaVertexTypes.QUADS); - } - - @Override - public void writeQuad(float x, float y, float z, int color, float u, float v, int light, int overlay, int normal) { - final long i = this.writePointer; - - memPutFloat(i, x); - memPutFloat(i + 4, y); - memPutFloat(i + 8, z); - memPutInt(i + 12, color); - memPutFloat(i + 16, u); - memPutFloat(i + 20, v); - memPutInt(i + 24, overlay); - memPutInt(i + 28, light); - memPutInt(i + 32, normal); - - this.advance(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/quad/writer/QuadVertexWriterFallback.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/quad/writer/QuadVertexWriterFallback.java deleted file mode 100644 index 095b03ee9..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/quad/writer/QuadVertexWriterFallback.java +++ /dev/null @@ -1,26 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.quad.writer; - -import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.ColorABGR; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.NormI8; -import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer; -import me.jellysquid.mods.sodium.client.model.vertex.fallback.VertexWriterFallback; -import me.jellysquid.mods.sodium.client.model.vertex.formats.quad.QuadVertexSink; - - -public class QuadVertexWriterFallback extends VertexWriterFallback implements QuadVertexSink { - public QuadVertexWriterFallback(VertexConsumer consumer) { - super(consumer); - } - - @Override - public void writeQuad(float x, float y, float z, int color, float u, float v, int light, int overlay, int normal) { - VertexConsumer consumer = this.consumer; - consumer.vertex(x, y, z); - consumer.color(ColorABGR.unpackRed(color), ColorABGR.unpackGreen(color), ColorABGR.unpackBlue(color), ColorABGR.unpackAlpha(color)); - consumer.texture(u, v); - consumer.overlay(overlay); - consumer.light(light); - consumer.normal(NormI8.unpackX(normal), NormI8.unpackY(normal), NormI8.unpackZ(normal)); - consumer.next(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/screen_quad/BasicScreenQuadVertexSink.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/screen_quad/BasicScreenQuadVertexSink.java deleted file mode 100644 index 1d2e286d0..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/screen_quad/BasicScreenQuadVertexSink.java +++ /dev/null @@ -1,39 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.screen_quad; - - - -import com.gtnewhorizon.gtnhlib.client.renderer.vertex.DefaultVertexFormat; -import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat; -import me.jellysquid.mods.sodium.client.model.vertex.VertexSink; -import me.jellysquid.mods.sodium.client.util.math.Matrix4fExtended; -import me.jellysquid.mods.sodium.client.util.math.MatrixUtil; -import org.joml.Matrix4f; - -public interface BasicScreenQuadVertexSink extends VertexSink { - VertexFormat VERTEX_FORMAT = DefaultVertexFormat.POSITION_COLOR; - - /** - * Writes a quad vertex to this sink. - * - * @param x The x-position of the vertex - * @param y The y-position of the vertex - * @param z The z-position of the vertex - * @param color The ABGR-packed color of the vertex - */ - void writeQuad(float x, float y, float z, int color); - - /** - * Writes a quad vertex to the sink, transformed by the given matrix. - * - * @param matrix The matrix to transform the vertex's position by - */ - default void writeQuad(Matrix4f matrix, float x, float y, float z, int color) { - Matrix4fExtended modelMatrix = MatrixUtil.getExtendedMatrix(matrix); - - float x2 = modelMatrix.transformVecX(x, y, z); - float y2 = modelMatrix.transformVecY(x, y, z); - float z2 = modelMatrix.transformVecZ(x, y, z); - - this.writeQuad(x2, y2, z2, color); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/screen_quad/BasicScreenQuadVertexType.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/screen_quad/BasicScreenQuadVertexType.java deleted file mode 100644 index 1f9d9fea0..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/screen_quad/BasicScreenQuadVertexType.java +++ /dev/null @@ -1,34 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.screen_quad; - -import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat; -import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer; - -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; -import me.jellysquid.mods.sodium.client.model.vertex.formats.screen_quad.writer.BasicScreenQuadVertexBufferWriterNio; -import me.jellysquid.mods.sodium.client.model.vertex.formats.screen_quad.writer.BasicScreenQuadVertexBufferWriterUnsafe; -import me.jellysquid.mods.sodium.client.model.vertex.formats.screen_quad.writer.BasicScreenQuadVertexWriterFallback; -import me.jellysquid.mods.sodium.client.model.vertex.type.BlittableVertexType; -import me.jellysquid.mods.sodium.client.model.vertex.type.VanillaVertexType; - - -public class BasicScreenQuadVertexType implements VanillaVertexType, BlittableVertexType { - @Override - public BasicScreenQuadVertexSink createFallbackWriter(VertexConsumer consumer) { - return new BasicScreenQuadVertexWriterFallback(consumer); - } - - @Override - public BasicScreenQuadVertexSink createBufferWriter(VertexBufferView buffer, boolean direct) { - return direct ? new BasicScreenQuadVertexBufferWriterUnsafe(buffer) : new BasicScreenQuadVertexBufferWriterNio(buffer); - } - - @Override - public VertexFormat getVertexFormat() { - return BasicScreenQuadVertexSink.VERTEX_FORMAT; - } - - @Override - public BlittableVertexType asBlittable() { - return this; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/screen_quad/writer/BasicScreenQuadVertexBufferWriterNio.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/screen_quad/writer/BasicScreenQuadVertexBufferWriterNio.java deleted file mode 100644 index 9de639cb2..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/screen_quad/writer/BasicScreenQuadVertexBufferWriterNio.java +++ /dev/null @@ -1,27 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.screen_quad.writer; - -import me.jellysquid.mods.sodium.client.model.vertex.VanillaVertexTypes; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferWriterNio; -import me.jellysquid.mods.sodium.client.model.vertex.formats.screen_quad.BasicScreenQuadVertexSink; - -import java.nio.ByteBuffer; - -public class BasicScreenQuadVertexBufferWriterNio extends VertexBufferWriterNio implements BasicScreenQuadVertexSink { - public BasicScreenQuadVertexBufferWriterNio(VertexBufferView backingBuffer) { - super(backingBuffer, VanillaVertexTypes.BASIC_SCREEN_QUADS); - } - - @Override - public void writeQuad(float x, float y, float z, int color) { - int i = this.writeOffset; - - ByteBuffer buf = this.byteBuffer; - buf.putFloat(i, x); - buf.putFloat(i + 4, y); - buf.putFloat(i + 8, z); - buf.putInt(i + 12, color); - - this.advance(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/screen_quad/writer/BasicScreenQuadVertexBufferWriterUnsafe.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/screen_quad/writer/BasicScreenQuadVertexBufferWriterUnsafe.java deleted file mode 100644 index 511d61a20..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/screen_quad/writer/BasicScreenQuadVertexBufferWriterUnsafe.java +++ /dev/null @@ -1,26 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.screen_quad.writer; - -import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*; - -import me.jellysquid.mods.sodium.client.model.vertex.VanillaVertexTypes; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferWriterUnsafe; -import me.jellysquid.mods.sodium.client.model.vertex.formats.screen_quad.BasicScreenQuadVertexSink; - -public class BasicScreenQuadVertexBufferWriterUnsafe extends VertexBufferWriterUnsafe implements BasicScreenQuadVertexSink { - public BasicScreenQuadVertexBufferWriterUnsafe(VertexBufferView backingBuffer) { - super(backingBuffer, VanillaVertexTypes.BASIC_SCREEN_QUADS); - } - - @Override - public void writeQuad(float x, float y, float z, int color) { - long i = this.writePointer; - - memPutFloat(i, x); - memPutFloat(i + 4, y); - memPutFloat(i + 8, z); - memPutInt(i + 12, color); - - this.advance(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/screen_quad/writer/BasicScreenQuadVertexWriterFallback.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/screen_quad/writer/BasicScreenQuadVertexWriterFallback.java deleted file mode 100644 index 93df85f76..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/formats/screen_quad/writer/BasicScreenQuadVertexWriterFallback.java +++ /dev/null @@ -1,21 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.formats.screen_quad.writer; - -import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.ColorABGR; -import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer; -import me.jellysquid.mods.sodium.client.model.vertex.fallback.VertexWriterFallback; -import me.jellysquid.mods.sodium.client.model.vertex.formats.screen_quad.BasicScreenQuadVertexSink; - - -public class BasicScreenQuadVertexWriterFallback extends VertexWriterFallback implements BasicScreenQuadVertexSink { - public BasicScreenQuadVertexWriterFallback(VertexConsumer consumer) { - super(consumer); - } - - @Override - public void writeQuad(float x, float y, float z, int color) { - VertexConsumer consumer = this.consumer; - consumer.vertex(x, y, z); - consumer.color(ColorABGR.unpackRed(color), ColorABGR.unpackGreen(color), ColorABGR.unpackBlue(color), ColorABGR.unpackAlpha(color)); - consumer.next(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/transformers/AbstractVertexTransformer.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/transformers/AbstractVertexTransformer.java deleted file mode 100644 index bb616beab..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/transformers/AbstractVertexTransformer.java +++ /dev/null @@ -1,26 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.transformers; - -import me.jellysquid.mods.sodium.client.model.vertex.VertexSink; - -/** - * A vertex transformer wraps an {@link VertexSink} interface to modify incoming vertex data, delegating any - * actual logic to the inner sink. - * @param The {@link VertexSink} interface this transformer wraps - */ -public abstract class AbstractVertexTransformer implements VertexSink { - protected final T delegate; - - protected AbstractVertexTransformer(T delegate) { - this.delegate = delegate; - } - - @Override - public void ensureCapacity(int count) { - this.delegate.ensureCapacity(count); - } - - @Override - public void flush() { - this.delegate.flush(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/transformers/SpriteTexturedVertexTransformer.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/transformers/SpriteTexturedVertexTransformer.java deleted file mode 100644 index 2ed30abb8..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/transformers/SpriteTexturedVertexTransformer.java +++ /dev/null @@ -1,80 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.transformers; - -import me.jellysquid.mods.sodium.client.model.vertex.VertexSink; -import me.jellysquid.mods.sodium.client.model.vertex.formats.glyph.GlyphVertexSink; -import me.jellysquid.mods.sodium.client.model.vertex.formats.particle.ParticleVertexSink; -import me.jellysquid.mods.sodium.client.model.vertex.formats.quad.QuadVertexSink; -import net.minecraft.client.renderer.texture.TextureAtlasSprite; - -/** - * Base implementation for a {@link VertexSink} which transforms texture coordinates relative to a sprite's bounds. - * - * @param The {@link VertexSink} interface this transformer wraps - */ -public abstract class SpriteTexturedVertexTransformer extends AbstractVertexTransformer { - private final float uMin; - private final float vMin; - - private final float uMaxMin; - private final float vMaxMin; - - public SpriteTexturedVertexTransformer(T delegate, TextureAtlasSprite sprite) { - super(delegate); - - this.uMin = sprite.getMinU(); - this.vMin = sprite.getMinV(); - - this.uMaxMin = sprite.getMaxU() - this.uMin; - this.vMaxMin = sprite.getMaxV() - this.vMin; - } - - protected float transformTextureU(float u) { - return (this.uMaxMin * u) + this.uMin; - } - - protected float transformTextureV(float v) { - return (this.vMaxMin * v) + this.vMin; - } - - public static class Quad extends SpriteTexturedVertexTransformer implements QuadVertexSink { - public Quad(QuadVertexSink delegate, TextureAtlasSprite sprite) { - super(delegate, sprite); - } - - @Override - public void writeQuad(float x, float y, float z, int color, float u, float v, int light, int overlay, int normal) { - u = this.transformTextureU(u); - v = this.transformTextureV(v); - - this.delegate.writeQuad(x, y, z, color, u, v, light, overlay, normal); - } - } - - public static class Particle extends SpriteTexturedVertexTransformer implements ParticleVertexSink { - public Particle(ParticleVertexSink delegate, TextureAtlasSprite sprite) { - super(delegate, sprite); - } - - @Override - public void writeParticle(float x, float y, float z, float u, float v, int color, int light) { - u = this.transformTextureU(u); - v = this.transformTextureV(v); - - this.delegate.writeParticle(x, y, z, u, v, color, light); - } - } - - public static class Glyph extends SpriteTexturedVertexTransformer implements GlyphVertexSink { - public Glyph(GlyphVertexSink delegate, TextureAtlasSprite sprite) { - super(delegate, sprite); - } - - @Override - public void writeGlyph(float x, float y, float z, int color, float u, float v, int light) { - u = this.transformTextureU(u); - v = this.transformTextureV(v); - - this.delegate.writeGlyph(x, y, z, color, u, v, light); - } - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/type/BlittableVertexType.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/type/BlittableVertexType.java deleted file mode 100644 index 8ac1a1977..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/type/BlittableVertexType.java +++ /dev/null @@ -1,15 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.type; - -import me.jellysquid.mods.sodium.client.model.vertex.VertexSink; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; - -public interface BlittableVertexType extends BufferVertexType { - /** - * Creates a {@link VertexSink} which writes into a {@link VertexBufferView}. This allows for specialization - * when the memory storage is known. - * - * @param buffer The backing vertex buffer - * @param direct True if direct memory access is allowed, otherwise false - */ - T createBufferWriter(VertexBufferView buffer, boolean direct); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/type/BufferVertexType.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/type/BufferVertexType.java deleted file mode 100644 index 2a4cdaa65..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/type/BufferVertexType.java +++ /dev/null @@ -1,14 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.type; - -import me.jellysquid.mods.sodium.client.gl.attribute.BufferVertexFormat; -import me.jellysquid.mods.sodium.client.model.vertex.VertexSink; - -/** - * A blittable {@link VertexType} which supports direct copying into a {@link net.minecraft.client.render.BufferBuilder} - * provided the buffer's vertex format matches that required by the {@link VertexSink}. - * - * @param The {@link VertexSink} type this factory produces - */ -public interface BufferVertexType extends VertexType { - BufferVertexFormat getBufferVertexFormat(); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/type/ChunkVertexType.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/type/ChunkVertexType.java deleted file mode 100644 index ad7aaee1b..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/type/ChunkVertexType.java +++ /dev/null @@ -1,16 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.type; - -import me.jellysquid.mods.sodium.client.render.chunk.format.ChunkMeshAttribute; -import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexSink; - -public interface ChunkVertexType extends BlittableVertexType, CustomVertexType { - /** - * @return The scale to be applied to vertex coordinates - */ - float getModelScale(); - - /** - * @return The scale to be applied to texture coordinates - */ - float getTextureScale(); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/type/CustomVertexType.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/type/CustomVertexType.java deleted file mode 100644 index 980c01015..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/type/CustomVertexType.java +++ /dev/null @@ -1,17 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.type; - -import me.jellysquid.mods.sodium.client.gl.attribute.BufferVertexFormat; -import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexFormat; -import me.jellysquid.mods.sodium.client.model.vertex.VertexSink; - -public interface CustomVertexType> extends BufferVertexType { - /** - * @return The {@link GlVertexFormat} required for blitting (direct writing into buffers) - */ - GlVertexFormat getCustomVertexFormat(); - - @Override - default BufferVertexFormat getBufferVertexFormat() { - return this.getCustomVertexFormat(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/type/VanillaVertexType.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/type/VanillaVertexType.java deleted file mode 100644 index bc675371f..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/type/VanillaVertexType.java +++ /dev/null @@ -1,14 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.type; - - -import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat; -import me.jellysquid.mods.sodium.client.gl.attribute.BufferVertexFormat; -import me.jellysquid.mods.sodium.client.model.vertex.VertexSink; - -public interface VanillaVertexType extends BufferVertexType { - default BufferVertexFormat getBufferVertexFormat() { - return BufferVertexFormat.from(this.getVertexFormat()); - } - - VertexFormat getVertexFormat(); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/type/VertexType.java b/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/type/VertexType.java deleted file mode 100644 index 689c2a9ee..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/model/vertex/type/VertexType.java +++ /dev/null @@ -1,27 +0,0 @@ -package me.jellysquid.mods.sodium.client.model.vertex.type; - -import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer; -import me.jellysquid.mods.sodium.client.model.vertex.VertexSink; - -/** - * Provides factories which create a {@link VertexSink} for the given vertex format. - * - * @param The {@link VertexSink} type this factory produces - */ -public interface VertexType { - /** - * Creates a {@link VertexSink} which can write into any {@link VertexConsumer}. This is generally used when - * a special implementation of {@link VertexConsumer} is used that cannot be optimized for, or when - * complex/unsupported transformations need to be performed using vanilla code paths. - * @param consumer The {@link VertexConsumer} to write into - */ - T createFallbackWriter(VertexConsumer consumer); - - /** - * If this vertex type supports {@link BufferVertexType}, then this method returns this vertex type as a - * blittable type, performing a safe cast. - */ - default BlittableVertexType asBlittable() { - return null; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/GameRendererContext.java b/src/main/java/me/jellysquid/mods/sodium/client/render/GameRendererContext.java deleted file mode 100644 index 44244961a..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/GameRendererContext.java +++ /dev/null @@ -1,29 +0,0 @@ -package me.jellysquid.mods.sodium.client.render; - -import com.gtnewhorizon.gtnhlib.bytebuf.MemoryStack; -import com.gtnewhorizons.angelica.compat.toremove.MatrixStack; -import com.gtnewhorizons.angelica.rendering.RenderingState; -import net.coderbot.iris.Iris; -import java.nio.FloatBuffer; -import net.coderbot.iris.shadows.ShadowRenderingState; -import org.joml.Matrix4f; - -public class GameRendererContext { - /** - * Obtains a model-view-projection matrix by multiplying the projection matrix with the model-view matrix - * from {@param matrices}. - * - * @return A float-buffer on the stack containing the model-view-projection matrix in a format suitable for - * uploading as uniform state - */ - public static FloatBuffer getModelViewProjectionMatrix(MatrixStack.Entry matrices, MemoryStack stack) { - final FloatBuffer bufModelViewProjection = stack.mallocFloat(16); - final Matrix4f projectionMatrix = (Iris.enabled && ShadowRenderingState.areShadowsCurrentlyBeingRendered()) ? ShadowRenderingState.getShadowOrthoMatrix() : RenderingState.INSTANCE.getProjectionMatrix(); - final Matrix4f matrix = new Matrix4f(projectionMatrix); - matrix.mul(matrices.getModel()); - - matrix.get(bufModelViewProjection); - - return bufModelViewProjection; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/SodiumWorldRenderer.java b/src/main/java/me/jellysquid/mods/sodium/client/render/SodiumWorldRenderer.java deleted file mode 100644 index deed18275..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/SodiumWorldRenderer.java +++ /dev/null @@ -1,537 +0,0 @@ -package me.jellysquid.mods.sodium.client.render; - -import com.gtnewhorizons.angelica.compat.mojang.Camera; -import com.gtnewhorizons.angelica.compat.toremove.MatrixStack; -import com.gtnewhorizons.angelica.compat.toremove.RenderLayer; -import com.gtnewhorizons.angelica.dynamiclights.DynamicLights; -import net.coderbot.iris.Iris; -import com.gtnewhorizons.angelica.glsm.GLStateManager; -import com.gtnewhorizons.angelica.rendering.RenderingState; -import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet; -import jss.notfine.core.SettingsManager; -import lombok.Getter; -import me.jellysquid.mods.sodium.client.SodiumClientMod; -import me.jellysquid.mods.sodium.client.gl.compat.FogHelper; -import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; -import me.jellysquid.mods.sodium.client.gui.SodiumGameOptions; -import me.jellysquid.mods.sodium.client.model.vertex.type.ChunkVertexType; -import me.jellysquid.mods.sodium.client.render.chunk.ChunkRenderBackend; -import me.jellysquid.mods.sodium.client.render.chunk.ChunkRenderManager; -import me.jellysquid.mods.sodium.client.render.chunk.backends.multidraw.MultidrawChunkRenderBackend; -import me.jellysquid.mods.sodium.client.render.chunk.backends.oneshot.ChunkRenderBackendOneshot; -import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkRenderData; -import me.jellysquid.mods.sodium.client.render.chunk.format.DefaultModelVertexFormats; -import me.jellysquid.mods.sodium.client.render.chunk.map.ChunkTracker; -import me.jellysquid.mods.sodium.client.render.chunk.map.ChunkTrackerHolder; -import me.jellysquid.mods.sodium.client.render.chunk.passes.BlockRenderPass; -import me.jellysquid.mods.sodium.client.render.pipeline.context.ChunkRenderCacheShared; -import me.jellysquid.mods.sodium.client.util.math.FrustumExtended; -import me.jellysquid.mods.sodium.common.util.ListUtil; -import net.coderbot.iris.block_rendering.BlockRenderingSettings; -import net.coderbot.iris.layer.GbufferPrograms; -import net.coderbot.iris.pipeline.ShadowRenderer; -import net.coderbot.iris.shadows.ShadowRenderingState; -import net.coderbot.iris.sodium.shadow_map.SwappableChunkRenderManager; -import net.coderbot.iris.sodium.vertex_format.IrisModelVertexFormats; -import net.coderbot.iris.uniforms.CapturedRenderingState; -import net.minecraft.block.Block; -import net.minecraft.client.Minecraft; -import net.minecraft.client.multiplayer.WorldClient; -import net.minecraft.client.renderer.WorldRenderer; -import net.minecraft.client.renderer.culling.Frustrum; -import net.minecraft.client.renderer.culling.ICamera; -import net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher; -import net.minecraft.entity.Entity; -import net.minecraft.entity.EntityLiving; -import net.minecraft.entity.EntityLivingBase; -import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.profiler.Profiler; -import net.minecraft.tileentity.TileEntity; -import net.minecraft.util.AxisAlignedBB; -import net.minecraft.util.MathHelper; -import net.minecraftforge.client.MinecraftForgeClient; -import org.joml.Vector3d; - -import java.util.Set; - -/** - * Provides an extension to vanilla's {@link WorldRenderer}. - */ -public class SodiumWorldRenderer { - private static SodiumWorldRenderer instance; - - private final Minecraft client; - - private WorldClient world; - private int renderDistance; - - private double lastCameraX, lastCameraY, lastCameraZ; - private float lastFov; - private double lastCameraPitch, lastCameraYaw; - private float lastFogDistance; - - private boolean useEntityCulling; - - private final Set globalTileEntities = new ObjectOpenHashSet<>(); - - - @Getter private Frustrum frustum; - private ChunkRenderManager chunkRenderManager; - private ChunkRenderBackend chunkRenderBackend; - - // Iris - private boolean wasRenderingShadows = false; - - private double iris$swapLastCameraX, iris$swapLastCameraY, iris$swapLastCameraZ, iris$swapLastCameraPitch, iris$swapLastCameraYaw; - /** - * Instantiates Sodium's world renderer. This should be called at the time of the world renderer initialization. - */ - public static SodiumWorldRenderer create(Minecraft mc) { - if (instance == null) { - instance = new SodiumWorldRenderer(mc); - } - - return instance; - } - - /** - * @throws IllegalStateException If the renderer has not yet been created - * @return The current instance of this type - */ - public static SodiumWorldRenderer getInstance() { - if (instance == null) { - throw new IllegalStateException("Renderer not initialized"); - } - - return instance; - } - - private SodiumWorldRenderer(Minecraft client) { - this.client = client; - } - - public void setWorld(WorldClient world) { - // Check that the world is actually changing - if (this.world == world) { - return; - } - - // If we have a world is already loaded, unload the renderer - if (this.world != null) { - if (DynamicLights.isEnabled()){ - DynamicLights.get().clearLightSources(); - } - this.unloadWorld(); - } - - // If we're loading a new world, load the renderer - if (world != null) { - this.loadWorld(world); - } - - } - - private void loadWorld(WorldClient world) { - this.world = world; - - ChunkRenderCacheShared.createRenderContext(this.world); - - this.initRenderer(); - } - - private void unloadWorld() { - ChunkRenderCacheShared.destroyRenderContext(this.world); - - if (this.chunkRenderManager != null) { - this.chunkRenderManager.destroy(); - this.chunkRenderManager = null; - } - - if (this.chunkRenderBackend != null) { - this.chunkRenderBackend.delete(); - this.chunkRenderBackend = null; - } - - this.globalTileEntities.clear(); - - this.world = null; - } - - /** - * @return The number of chunk renders which are visible in the current camera's frustum - */ - public int getVisibleChunkCount() { - return this.chunkRenderManager.getVisibleChunkCount(); - } - - /** - * Notifies the chunk renderer that the graph scene has changed and should be re-computed. - */ - public void scheduleTerrainUpdate() { - if (this.chunkRenderManager != null) { - if(Iris.enabled) iris$ensureStateSwapped(); - this.chunkRenderManager.markDirty(); - } - } - - /** - * @return True if no chunks are pending rebuilds - */ - public boolean isTerrainRenderComplete() { - return this.chunkRenderManager.isBuildComplete(); - } - - // We'll keep it to have compatibility with Oculus' older versions - public static boolean hasChanges = false; - - /** - * Called prior to any chunk rendering in order to update necessary state. - */ - public void updateChunks(Camera camera, Frustrum frustum, boolean hasForcedFrustum, int frame, boolean spectator) { - this.frustum = frustum; - - this.processChunkEvents(); - - this.useEntityCulling = SodiumClientMod.options().advanced.useEntityCulling; - - if (this.client.gameSettings.renderDistanceChunks != this.renderDistance) { - this.reload(); - } - - Profiler profiler = this.client.mcProfiler; - profiler.startSection("camera_setup"); - - EntityPlayer player = this.client.thePlayer; - - if (player == null) { - throw new IllegalStateException("Client instance has no active player entity"); - } - - Vector3d pos = camera.getPos(); - - this.chunkRenderManager.setCameraPosition(pos.x, pos.y, pos.z); - - float pitch = camera.getPitch(); - float yaw = camera.getYaw(); - - float fogDistance = FogHelper.getFogCutoff(); - - float fov = RenderingState.INSTANCE.getFov(); - - boolean dirty = pos.x != this.lastCameraX || pos.y != this.lastCameraY || pos.z != this.lastCameraZ || - pitch != this.lastCameraPitch || yaw != this.lastCameraYaw || fogDistance != this.lastFogDistance || fov != this.lastFov; - - if(Iris.enabled) { - iris$ensureStateSwapped(); - if (ShadowRenderingState.areShadowsCurrentlyBeingRendered()) { - dirty = true; - } - } - if (dirty) { - this.chunkRenderManager.markDirty(); - } - - this.lastCameraX = pos.x; - this.lastCameraY = pos.y; - this.lastCameraZ = pos.z; - this.lastCameraPitch = pitch; - this.lastCameraYaw = yaw; - this.lastFogDistance = fogDistance; - this.lastFov = fov; - - profiler.endStartSection("chunk_update"); - - this.chunkRenderManager.updateChunks(); - - if (!hasForcedFrustum && this.chunkRenderManager.isDirty()) { - profiler.endStartSection("chunk_graph_rebuild"); - - this.chunkRenderManager.update(camera, (FrustumExtended) frustum, frame, spectator); - } - - profiler.endStartSection("visible_chunk_tick"); - - this.chunkRenderManager.tickVisibleRenders(); - - profiler.endSection(); - - SodiumGameOptions.EntityRenderDistance.setRenderDistanceMult(MathHelper.clamp_double((double) this.client.gameSettings.renderDistanceChunks / 8.0D, 1.0D, 2.5D) * (double) 1.0F * (SettingsManager.entityRenderScaleFactor)); - if(Iris.enabled) { - if (ShadowRenderingState.areShadowsCurrentlyBeingRendered()) { - ShadowRenderer.visibleTileEntities.addAll(this.chunkRenderManager.getVisibleTileEntities()); - ShadowRenderer.globalTileEntities.addAll(this.globalTileEntities); - } - } - } - - private void processChunkEvents() { - var tracker = ChunkTrackerHolder.get(this.world); - tracker.forEachEvent(this.chunkRenderManager::onChunkAdded, this.chunkRenderManager::onChunkRemoved); - } - - /** - * Performs a render pass for the given {@link RenderLayer} and draws all visible chunks for it. - */ - public void drawChunkLayer(BlockRenderPass pass, MatrixStack matrixStack, double x, double y, double z) { - // This fix a long-standing issue with culling state leaking because of mods, - // or other factors as having clouds disabled. - GLStateManager.enableCull(); - - if(Iris.enabled) iris$ensureStateSwapped(); - // startDrawing/endDrawing are handled by 1.7 already - // pass.startDrawing(); - - this.chunkRenderManager.renderLayer(matrixStack, pass, x, y, z); - - //pass.endDrawing(); - GLStateManager.clearCurrentColor(); - } - - public void reload() { - if (this.world == null) { - return; - } - - this.initRenderer(); - } - - private void initRenderer() { - if (this.chunkRenderManager != null) { - this.chunkRenderManager.destroy(); - this.chunkRenderManager = null; - } - - if (this.chunkRenderBackend != null) { - this.chunkRenderBackend.delete(); - this.chunkRenderBackend = null; - } - - this.globalTileEntities.clear(); - - RenderDevice device = RenderDevice.INSTANCE; - - this.renderDistance = this.client.gameSettings.renderDistanceChunks; - - SodiumGameOptions opts = SodiumClientMod.options(); - - final ChunkVertexType vertexFormat; - - if(Iris.enabled && BlockRenderingSettings.INSTANCE.shouldUseExtendedVertexFormat()) { - vertexFormat = IrisModelVertexFormats.MODEL_VERTEX_XHFP; - } else if (opts.advanced.useCompactVertexFormat) { - vertexFormat = DefaultModelVertexFormats.MODEL_VERTEX_HFP; - } else { - vertexFormat = DefaultModelVertexFormats.MODEL_VERTEX_SFP; - } - - this.chunkRenderBackend = createChunkRenderBackend(device, opts, vertexFormat); - this.chunkRenderBackend.createShaders(device); - - this.chunkRenderManager = new ChunkRenderManager<>(this, this.chunkRenderBackend, this.world, this.renderDistance); - - var tracker = ChunkTrackerHolder.get(this.world); - ChunkTracker.forEachChunk(tracker.getReadyChunks(), this.chunkRenderManager::onChunkAdded); - } - - private static ChunkRenderBackend createChunkRenderBackend(RenderDevice device, SodiumGameOptions options, ChunkVertexType vertexFormat) { - boolean disableBlacklist = SodiumClientMod.options().advanced.ignoreDriverBlacklist; - - if (options.advanced.useChunkMultidraw && MultidrawChunkRenderBackend.isSupported(disableBlacklist)) { - return new MultidrawChunkRenderBackend(device, vertexFormat); - } else { - return new ChunkRenderBackendOneshot(vertexFormat); - } - } - - private boolean checkBEVisibility(TileEntity entity) { - var aabb = entity.getRenderBoundingBox(); - if (aabb == TileEntity.INFINITE_EXTENT_AABB) { - return true; - } - return frustum.isBoundingBoxInFrustum(aabb); - } - - private void renderTE(TileEntity tileEntity, int pass, float partialTicks) { - if(!tileEntity.shouldRenderInPass(pass) || !checkBEVisibility(tileEntity)) - return; - - try { - if(Iris.enabled) { - final Block block = tileEntity.getWorldObj().getBlock(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord); - CapturedRenderingState.INSTANCE.setCurrentBlockEntity(Block.getIdFromBlock(block)); - } - TileEntityRendererDispatcher.instance.renderTileEntity(tileEntity, partialTicks); - - } catch(RuntimeException e) { - if(tileEntity.isInvalid()) { - SodiumClientMod.logger().error("Suppressing crash from invalid tile entity", e); - } else { - throw e; - } - } - finally { - if(Iris.enabled) { - CapturedRenderingState.INSTANCE.setCurrentBlockEntity(-1); - } - } - } - - public void renderTileEntities(EntityLivingBase entity, ICamera camera, float partialTicks) { - if (Iris.enabled) { - GbufferPrograms.beginBlockEntities(); - GbufferPrograms.setBlockEntityDefaults(); - } - - final int pass = MinecraftForgeClient.getRenderPass(); - for (TileEntity tileEntity : this.chunkRenderManager.getVisibleTileEntities()) { - renderTE(tileEntity, pass, partialTicks); - } - - for (TileEntity tileEntity : this.globalTileEntities) { - renderTE(tileEntity, pass, partialTicks); - } - - if (Iris.enabled) { - GbufferPrograms.endBlockEntities(); - } - } - - public void onChunkRenderUpdated(int x, int y, int z, ChunkRenderData meshBefore, ChunkRenderData meshAfter) { - ListUtil.updateList(this.globalTileEntities, meshBefore.getGlobalTileEntities(), meshAfter.getGlobalTileEntities()); - - this.chunkRenderManager.onChunkRenderUpdates(x, y, z, meshAfter); - } - - private static boolean isInfiniteExtentsBox(AxisAlignedBB box) { - return Double.isInfinite(box.minX) || Double.isInfinite(box.minY) || Double.isInfinite(box.minZ) - || Double.isInfinite(box.maxX) || Double.isInfinite(box.maxY) || Double.isInfinite(box.maxZ); - } - - /** - * Returns whether or not the entity intersects with any visible chunks in the graph. - * @return True if the entity is visible, otherwise false - */ - public boolean isEntityVisible(Entity entity) { - if (!this.useEntityCulling || entity.ignoreFrustumCheck) { - return true; - } - - AxisAlignedBB box = entity.boundingBox; - - // Entities outside the valid world height will never map to a rendered chunk - // Always render these entities or they'll be culled incorrectly! - if (box.maxY < 0.5D || box.minY > 255.5D) { - return true; - } - - if (isInfiniteExtentsBox(box)) { - return true; - } - - // Ensure entities with outlines or nametags are always visible - // TODO: Sodium - Outlines - if (/*this.client.hasOutline(entity) || */ (entity instanceof EntityLiving living && living.hasCustomNameTag())) { - return true; - } - - int minX = MathHelper.floor_double(box.minX - 0.5D) >> 4; - int minY = MathHelper.floor_double(box.minY - 0.5D) >> 4; - int minZ = MathHelper.floor_double(box.minZ - 0.5D) >> 4; - - int maxX = MathHelper.floor_double(box.maxX + 0.5D) >> 4; - int maxY = MathHelper.floor_double(box.maxY + 0.5D) >> 4; - int maxZ = MathHelper.floor_double(box.maxZ + 0.5D) >> 4; - - for (int x = minX; x <= maxX; x++) { - for (int z = minZ; z <= maxZ; z++) { - for (int y = minY; y <= maxY; y++) { - if (this.chunkRenderManager.isChunkVisible(x, y, z)) { - return true; - } - } - } - } - - return false; - } - - public String getChunksDebugString() { - // C: visible/total - // TODO: add dirty and queued counts - return String.format("C: %s/%s S: %s Q: %s+%si ", this.chunkRenderManager.getVisibleChunkCount(), this.chunkRenderManager.getTotalSections(), this.chunkRenderManager.getSubmitted(), this.chunkRenderManager.getRebuildQueueSize(), this.chunkRenderManager.getImportantRebuildQueueSize()); - } - - /** - * Schedules chunk rebuilds for all chunks in the specified block region. - */ - public void scheduleRebuildForBlockArea(int minX, int minY, int minZ, int maxX, int maxY, int maxZ, boolean important) { - this.scheduleRebuildForChunks(minX >> 4, minY >> 4, minZ >> 4, maxX >> 4, maxY >> 4, maxZ >> 4, important); - } - - /** - * Schedules chunk rebuilds for all chunks in the specified chunk region. - */ - public void scheduleRebuildForChunks(int minX, int minY, int minZ, int maxX, int maxY, int maxZ, boolean important) { - for (int chunkX = minX; chunkX <= maxX; chunkX++) { - for (int chunkY = minY; chunkY <= maxY; chunkY++) { - for (int chunkZ = minZ; chunkZ <= maxZ; chunkZ++) { - this.scheduleRebuildForChunk(chunkX, chunkY, chunkZ, important); - } - } - } - } - - /** - * Schedules a chunk rebuild for the render belonging to the given chunk section position. - */ - public void scheduleRebuildForChunk(int x, int y, int z, boolean important) { - this.chunkRenderManager.scheduleRebuild(x, y, z, important); - } - - public ChunkRenderBackend getChunkRenderer() { - return this.chunkRenderBackend; - } - - // Iris - private void swapCachedCameraPositions() { - double tmp; - - tmp = lastCameraX; - lastCameraX = iris$swapLastCameraX; - iris$swapLastCameraX = tmp; - - tmp = lastCameraY; - lastCameraY = iris$swapLastCameraY; - iris$swapLastCameraY = tmp; - - tmp = lastCameraZ; - lastCameraZ = iris$swapLastCameraZ; - iris$swapLastCameraZ = tmp; - - tmp = lastCameraPitch; - lastCameraPitch = iris$swapLastCameraPitch; - iris$swapLastCameraPitch = tmp; - - tmp = lastCameraYaw; - lastCameraYaw = iris$swapLastCameraYaw; - iris$swapLastCameraYaw = tmp; - } - - private void iris$ensureStateSwapped() { - if (!wasRenderingShadows && ShadowRenderingState.areShadowsCurrentlyBeingRendered()) { - if (this.chunkRenderManager instanceof SwappableChunkRenderManager) { - ((SwappableChunkRenderManager) this.chunkRenderManager).iris$swapVisibilityState(); - swapCachedCameraPositions(); - } - - wasRenderingShadows = true; - } else if (wasRenderingShadows && !ShadowRenderingState.areShadowsCurrentlyBeingRendered()) { - if (this.chunkRenderManager instanceof SwappableChunkRenderManager) { - ((SwappableChunkRenderManager) this.chunkRenderManager).iris$swapVisibilityState(); - swapCachedCameraPositions(); - } - - wasRenderingShadows = false; - } - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/ChunkCameraContext.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/ChunkCameraContext.java deleted file mode 100644 index 3610c382e..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/ChunkCameraContext.java +++ /dev/null @@ -1,21 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk; - -public class ChunkCameraContext { - public final int blockOriginX, blockOriginY, blockOriginZ; - public final float originX, originY, originZ; - - public ChunkCameraContext(double x, double y, double z) { - this.blockOriginX = (int) x; - this.blockOriginY = (int) y; - this.blockOriginZ = (int) z; - - this.originX = (float) (x - this.blockOriginX); - this.originY = (float) (y - this.blockOriginY); - this.originZ = (float) (z - this.blockOriginZ); - } - - public float getChunkModelOffset(int chunkBlockPos, int cameraBlockPos, float cameraPos) { - int t = chunkBlockPos - cameraBlockPos; - return t - cameraPos; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/ChunkGraphicsState.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/ChunkGraphicsState.java deleted file mode 100644 index 0c74e0c4b..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/ChunkGraphicsState.java +++ /dev/null @@ -1,39 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk; - -import me.jellysquid.mods.sodium.client.gl.device.CommandList; - -import java.nio.ByteBuffer; - -public abstract class ChunkGraphicsState { - private final int x, y, z; - - private ByteBuffer translucencyData; - - protected ChunkGraphicsState(ChunkRenderContainer container) { - this.x = container.getRenderX(); - this.y = container.getRenderY(); - this.z = container.getRenderZ(); - } - - public abstract void delete(CommandList commandList); - - public int getX() { - return this.x; - } - - public int getY() { - return this.y; - } - - public int getZ() { - return this.z; - } - - public ByteBuffer getTranslucencyData() { - return this.translucencyData; - } - - public void setTranslucencyData(ByteBuffer data) { - this.translucencyData = data; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/ChunkRenderBackend.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/ChunkRenderBackend.java deleted file mode 100644 index f45907e31..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/ChunkRenderBackend.java +++ /dev/null @@ -1,62 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk; - -import com.gtnewhorizons.angelica.compat.toremove.MatrixStack; -import me.jellysquid.mods.sodium.client.gl.device.CommandList; -import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; -import me.jellysquid.mods.sodium.client.model.vertex.type.ChunkVertexType; -import me.jellysquid.mods.sodium.client.render.chunk.compile.ChunkBuildResult; -import me.jellysquid.mods.sodium.client.render.chunk.lists.ChunkRenderListIterator; -import me.jellysquid.mods.sodium.client.render.chunk.passes.BlockRenderPass; - -import java.util.Collections; -import java.util.Iterator; -import java.util.List; - -/** - * The chunk render backend takes care of managing the graphics resource state of chunk render containers. This includes - * the handling of uploading their data to the graphics card and rendering responsibilities. - * @param The type of graphics state to be used in chunk render containers - */ -public interface ChunkRenderBackend { - /** - * Drains the iterator of items and processes each build task's result serially. After this method returns, all - * drained results should be processed. - */ - void upload(CommandList commandList, Iterator> queue); - - /** - * Renders the given chunk render list to the active framebuffer. - * @param commandList The command list which OpenGL commands should be serialized to - * @param renders An iterator over the list of chunks to be rendered - * @param camera The camera context containing chunk offsets for the current render - */ - void render(CommandList commandList, ChunkRenderListIterator renders, ChunkCameraContext camera); - - void createShaders(RenderDevice device); - - void begin(MatrixStack matrixStack); - - void end(MatrixStack matrixStack); - - /** - * Deletes this render backend and any resources attached to it. - */ - void delete(); - - /** - * Returns the vertex format used by this chunk render backend for rendering meshes. - */ - ChunkVertexType getVertexType(); - - Class getGraphicsStateType(); - - default String getRendererName() { - return this.getClass().getSimpleName(); - } - - default List getDebugStrings() { - return Collections.emptyList(); - } - - void iris$begin(MatrixStack matrixStack, BlockRenderPass pass); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/ChunkRenderColumn.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/ChunkRenderColumn.java deleted file mode 100644 index 5871ef8e2..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/ChunkRenderColumn.java +++ /dev/null @@ -1,86 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk; - -import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.HORIZONTAL_DIRECTIONS; -import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.NEG_X; -import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.NEG_Z; -import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.POS_X; -import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.POS_Z; - -import net.minecraftforge.common.util.ForgeDirection; - -public class ChunkRenderColumn { - @SuppressWarnings("unchecked") - private final ChunkRenderContainer[] renders = new ChunkRenderContainer[16]; - - @SuppressWarnings("unchecked") - private final ChunkRenderColumn[] adjacent = new ChunkRenderColumn[6]; - - private final int x, z; - - public ChunkRenderColumn(int x, int z) { - this.x = x; - this.z = z; - - this.setAdjacentColumn(ForgeDirection.UP, this); - this.setAdjacentColumn(ForgeDirection.DOWN, this); - } - - public void setAdjacentColumn(ForgeDirection dir, ChunkRenderColumn column) { - this.adjacent[dir.ordinal()] = column; - } - - public ChunkRenderColumn getAdjacentColumn(ForgeDirection dir) { - return this.adjacent[dir.ordinal()]; - } - - public void setRender(int y, ChunkRenderContainer render) { - this.renders[y] = render; - } - - public ChunkRenderContainer getRender(int y) { - if (y < 0 || y >= this.renders.length) { - return null; - } - return this.renders[y]; - } - - public int getX() { - return this.x; - } - - public int getZ() { - return this.z; - } - - public boolean areNeighborsPresent() { - for (var dir : HORIZONTAL_DIRECTIONS) { - ChunkRenderColumn adj = this.adjacent[dir.ordinal()]; - - if (adj == null) { - return false; - } - - ForgeDirection corner; - - // Access the adjacent corner chunk from the neighbor in this direction - if (dir == NEG_Z) { - corner = ForgeDirection.EAST; - } else if (dir == POS_Z) { - corner = ForgeDirection.WEST; - } else if (dir == NEG_X) { - corner = ForgeDirection.NORTH; - } else if (dir == POS_X) { - corner = ForgeDirection.SOUTH; - } else { - continue; - } - - // If no neighbor has been attached, the chunk is not present - if (adj.getAdjacentColumn(corner) == null) { - return false; - } - } - - return true; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/ChunkRenderContainer.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/ChunkRenderContainer.java deleted file mode 100644 index 8838a6f15..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/ChunkRenderContainer.java +++ /dev/null @@ -1,307 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk; - -import com.gtnewhorizon.gtnhlib.blockpos.BlockPos; -import com.gtnewhorizons.angelica.compat.mojang.ChunkSectionPos; -import com.gtnewhorizons.angelica.utils.AnimationsRenderUtils; -import lombok.Getter; -import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; -import me.jellysquid.mods.sodium.client.render.SodiumWorldRenderer; -import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkRenderBounds; -import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkRenderData; -import me.jellysquid.mods.sodium.client.render.chunk.passes.BlockRenderPass; -import me.jellysquid.mods.sodium.client.util.math.FrustumExtended; -import net.minecraft.client.renderer.texture.TextureAtlasSprite; - -import java.lang.reflect.Array; -import java.util.concurrent.CompletableFuture; - -/** - * The render state object for a chunk section. This contains all the graphics state for each render pass along with - * data about the render in the chunk visibility graph. - */ -public class ChunkRenderContainer { - private final SodiumWorldRenderer worldRenderer; - @Getter - private final int chunkX; - @Getter - private final int chunkY; - @Getter - private final int chunkZ; - - @Getter - private final T[] graphicsStates; - private final ChunkRenderColumn column; - - @Getter - private ChunkRenderData data = ChunkRenderData.ABSENT; - private CompletableFuture rebuildTask = null; - - private boolean needsRebuild; - private boolean needsImportantRebuild; - - private boolean needsSort; - - @Getter - private boolean tickable; - @Getter - private int id; - - private boolean rebuildableForTranslucents; - - @SuppressWarnings("unchecked") - public ChunkRenderContainer(ChunkRenderBackend backend, SodiumWorldRenderer worldRenderer, int chunkX, int chunkY, int chunkZ, ChunkRenderColumn column) { - this.worldRenderer = worldRenderer; - - this.chunkX = chunkX; - this.chunkY = chunkY; - this.chunkZ = chunkZ; - - //noinspection unchecked - this.graphicsStates = (T[]) Array.newInstance(backend.getGraphicsStateType(), BlockRenderPass.COUNT); - this.rebuildableForTranslucents = false; - this.column = column; - } - - /** - * Cancels any pending tasks to rebuild the chunk. If the result of any pending tasks has not been processed yet, - * those will also be discarded when processing finally happens. - */ - public void cancelRebuildTask() { - this.needsRebuild = false; - this.needsImportantRebuild = false; - this.needsSort = false; - - if (this.rebuildTask != null) { - this.rebuildTask.cancel(false); - this.rebuildTask = null; - } - } - - /** - * @return True if the render's state is out of date with the world state - */ - public boolean needsRebuild() { - return this.needsRebuild; - } - - /** - * @return True if the render's rebuild should be performed as blocking - */ - public boolean needsImportantRebuild() { - return this.needsImportantRebuild; - } - - public boolean needsSort() { - return this.needsSort; - } - - /** - * Deletes all data attached to this render and drops any pending tasks. This should be used when the render falls - * out of view or otherwise needs to be destroyed. After the render has been destroyed, the object can no longer - * be used. - */ - public void delete() { - this.cancelRebuildTask(); - this.setData(ChunkRenderData.ABSENT); - this.deleteGraphicsState(); - } - - private void deleteGraphicsState() { - T[] states = this.graphicsStates; - - for (int i = 0; i < states.length; i++) { - T state = states[i]; - - if (state != null) { - state.delete(RenderDevice.INSTANCE.createCommandList()); - states[i] = null; - } - } - } - - public boolean shouldRebuildForTranslucents() { - return this.rebuildableForTranslucents; - } - - public void setRebuildForTranslucents(boolean flag) { - this.rebuildableForTranslucents = flag; - } - - - public void setData(ChunkRenderData info) { - if (info == null) { - throw new NullPointerException("Mesh information must not be null"); - } - - this.worldRenderer.onChunkRenderUpdated(this.chunkX, this.chunkY, this.chunkZ, this.data, info); - this.data = info; - - this.tickable = !info.getAnimatedSprites().isEmpty(); - } - - /** - * Marks this render as needing an update. Important updates are scheduled as "blocking" and will prevent the next - * frame from being rendered until the update is performed. - * @param important True if the update is blocking, otherwise false - */ - public boolean scheduleRebuild(boolean important) { - boolean changed = !this.needsRebuild || (!this.needsImportantRebuild && important); - - this.needsImportantRebuild = important; - this.needsRebuild = true; - this.needsSort = false; - - return changed; - } - - public boolean scheduleSort(boolean important) { - if (this.needsRebuild) - return false; - - boolean changed = !this.needsSort; - this.needsSort = true; - - return changed; - } - - /** - * @return True if the chunk render contains no data, otherwise false - */ - public boolean isEmpty() { - return this.data.isEmpty(); - } - - /** - * Returns the chunk section position which this render refers to in the world. - */ - public ChunkSectionPos getChunkPos() { - return ChunkSectionPos.from(this.chunkX, this.chunkY, this.chunkZ); - } - - /** - * Tests if the given chunk render is visible within the provided frustum. - * @param frustum The frustum to test against - * @return True if visible, otherwise false - */ - public boolean isOutsideFrustum(FrustumExtended frustum) { - float x = this.getOriginX(); - float y = this.getOriginY(); - float z = this.getOriginZ(); - - return !frustum.fastAabbTest(x, y, z, x + 16.0f, y + 16.0f, z + 16.0f); - } - - /** - * Ensures that all resources attached to the given chunk render are "ticked" forward. This should be called every - * time before this render is drawn if {@link ChunkRenderContainer#isTickable()} is true. - */ - public void tick() { - for (TextureAtlasSprite sprite : this.data.getAnimatedSprites()) { - AnimationsRenderUtils.markBlockTextureForUpdate(sprite); - } - } - - /** - * @return The x-coordinate of the origin position of this chunk render - */ - public int getOriginX() { - return this.chunkX << 4; - } - - /** - * @return The y-coordinate of the origin position of this chunk render - */ - public int getOriginY() { - return this.chunkY << 4; - } - - /** - * @return The z-coordinate of the origin position of this chunk render - */ - public int getOriginZ() { - return this.chunkZ << 4; - } - - public int getRenderX() { - return this.getOriginX() - 8; - } - - public int getRenderY() { - return this.getOriginY() - 8; - } - - public int getRenderZ() { - return this.getOriginZ() - 8; - } - - /** - * @return The squared distance from the center of this chunk in the world to the given position - */ - public double getSquaredDistance(double x, double y, double z) { - double xDist = x - this.getCenterX(); - double yDist = y - this.getCenterY(); - double zDist = z - this.getCenterZ(); - - return (xDist * xDist) + (yDist * yDist) + (zDist * zDist); - } - - /** - * @return The x-coordinate of the center position of this chunk render - */ - private double getCenterX() { - return this.getOriginX() + 8.0D; - } - - /** - * @return The y-coordinate of the center position of this chunk render - */ - private double getCenterY() { - return this.getOriginY() + 8.0D; - } - - /** - * @return The z-coordinate of the center position of this chunk render - */ - private double getCenterZ() { - return this.getOriginZ() + 8.0D; - } - - public BlockPos getRenderOrigin() { - return new BlockPos(this.getRenderX(), this.getRenderY(), this.getRenderZ()); - } - - public void setGraphicsState(BlockRenderPass pass, T state) { - this.graphicsStates[pass.ordinal()] = state; - } - - /** - * @return The squared distance from the center of this chunk in the world to the given position - */ - public double getSquaredDistanceXZ(double x, double z) { - double xDist = x - this.getCenterX(); - double zDist = z - this.getCenterZ(); - - return (xDist * xDist) + (zDist * zDist); - } - - public ChunkRenderBounds getBounds() { - return this.data.getBounds(); - } - - public T getGraphicsState(BlockRenderPass pass) { - return this.graphicsStates[pass.ordinal()]; - } - - public int getFacesWithData() { - return this.data.getFacesWithData(); - } - - public boolean canRebuild() { - return this.column.areNeighborsPresent(); - } - - public void setId(int id) { - this.id = id; - } - -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/ChunkRenderManager.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/ChunkRenderManager.java deleted file mode 100644 index 65ccab24d..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/ChunkRenderManager.java +++ /dev/null @@ -1,716 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk; - -import com.gtnewhorizons.angelica.compat.mojang.Camera; -import com.gtnewhorizons.angelica.compat.mojang.ChunkPos; -import com.gtnewhorizons.angelica.compat.toremove.MatrixStack; -import com.gtnewhorizons.angelica.rendering.AngelicaRenderQueue; -import net.coderbot.iris.Iris; -import it.unimi.dsi.fastutil.ints.IntIterator; -import it.unimi.dsi.fastutil.ints.IntList; -import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap; -import it.unimi.dsi.fastutil.longs.LongCollection; -import it.unimi.dsi.fastutil.longs.LongIterator; -import it.unimi.dsi.fastutil.objects.ObjectArrayFIFOQueue; -import it.unimi.dsi.fastutil.objects.ObjectArrayList; -import it.unimi.dsi.fastutil.objects.ObjectList; -import lombok.Getter; -import me.jellysquid.mods.sodium.client.SodiumClientMod; -import me.jellysquid.mods.sodium.client.gl.compat.FogHelper; -import me.jellysquid.mods.sodium.client.gl.device.CommandList; -import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; -import me.jellysquid.mods.sodium.client.render.SodiumWorldRenderer; -import me.jellysquid.mods.sodium.client.render.chunk.backends.multidraw.MultidrawChunkRenderBackend; -import me.jellysquid.mods.sodium.client.render.chunk.compile.ChunkBuildResult; -import me.jellysquid.mods.sodium.client.render.chunk.compile.ChunkBuilder; -import me.jellysquid.mods.sodium.client.render.chunk.cull.ChunkCuller; -import me.jellysquid.mods.sodium.client.render.chunk.cull.ChunkFaceFlags; -import me.jellysquid.mods.sodium.client.render.chunk.cull.graph.ChunkGraphCuller; -import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkRenderBounds; -import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkRenderData; -import me.jellysquid.mods.sodium.client.render.chunk.lists.ChunkRenderList; -import me.jellysquid.mods.sodium.client.render.chunk.lists.ChunkRenderListIterator; -import me.jellysquid.mods.sodium.client.render.chunk.passes.BlockRenderPass; -import me.jellysquid.mods.sodium.client.util.math.FrustumExtended; -import me.jellysquid.mods.sodium.client.world.ChunkStatusListener; -import me.jellysquid.mods.sodium.common.util.IdTable; -import me.jellysquid.mods.sodium.common.util.collections.FutureDequeDrain; -import net.coderbot.iris.shadows.ShadowRenderingState; -import net.coderbot.iris.sodium.shadow_map.SwappableChunkRenderManager; -import net.minecraft.client.multiplayer.WorldClient; -import net.minecraft.client.renderer.WorldRenderer; -import net.minecraft.tileentity.TileEntity; -import net.minecraft.world.chunk.storage.ExtendedBlockStorage; -import net.minecraftforge.common.util.ForgeDirection; -import org.joml.Vector3d; - -import java.util.ArrayDeque; -import java.util.Collection; -import java.util.Deque; -import java.util.concurrent.CompletableFuture; - -public class ChunkRenderManager implements ChunkStatusListener, SwappableChunkRenderManager { - /** - * The maximum distance a chunk can be from the player's camera in order to be eligible for blocking updates. - */ - private static final double NEARBY_CHUNK_DISTANCE = Math.pow(48, 2.0); - - /** - * The minimum distance the culling plane can be from the player's camera. This helps to prevent mathematical - * errors that occur when the fog distance is less than 8 blocks in width, such as when using a blindness potion. - */ - private static final float FOG_PLANE_MIN_DISTANCE = (float) Math.pow(8.0f, 2.0); - - /** - * The distance past the fog's far plane at which to begin culling. Distance calculations use the center of each - * chunk from the camera's position, and as such, special care is needed to ensure that the culling plane is pushed - * back far enough. I'm sure there's a mathematical formula that should be used here in place of the constant, - * but this value works fine in testing. - */ - private static final float FOG_PLANE_OFFSET = 12.0f; - - private final ChunkBuilder builder; - private final ChunkRenderBackend backend; - - private final Thread renderThread = Thread.currentThread(); - - private final Long2ObjectOpenHashMap> columns = new Long2ObjectOpenHashMap<>(); - private final IdTable> renders = new IdTable<>(16384); - - private final ObjectArrayFIFOQueue> importantRebuildQueue = new ObjectArrayFIFOQueue<>(); - private final ObjectArrayFIFOQueue> rebuildQueue = new ObjectArrayFIFOQueue<>(); - private final ObjectArrayFIFOQueue> sortQueue = new ObjectArrayFIFOQueue<>(); - private final ObjectArrayFIFOQueue> unloadQueue = new ObjectArrayFIFOQueue<>(); - - @SuppressWarnings("unchecked") - private ChunkRenderList[] chunkRenderLists = new ChunkRenderList[BlockRenderPass.COUNT]; - private ObjectList> tickableChunks = new ObjectArrayList<>(); - - private ObjectList visibleTileEntities = new ObjectArrayList<>(); - - private final SodiumWorldRenderer renderer; - private final WorldClient world; - - private final ChunkCuller culler; - private final boolean useBlockFaceCulling; - - private float cameraX, cameraY, cameraZ; - private boolean dirty; - - @Getter - private int submitted; - - private final boolean translucencySorting; - - @Getter - private int visibleChunkCount; - - private boolean useFogCulling; - private double fogRenderCutoff; - - private final int translucencyBlockRenderDistance; - - private boolean alwaysDeferChunkUpdates; - - // Iris - - private ChunkRenderList[] chunkRenderListsSwap; - - private ObjectList> tickableChunksSwap; - - private ObjectList visibleTileEntitiesSwap; - - private int visibleChunkCountSwap; - - private boolean dirtySwap; - - private static final ThreadLocal threadLocalRenderPass = ThreadLocal.withInitial(() -> BlockRenderPass.CUTOUT_MIPPED); - public static int getWorldRenderPass() { - return threadLocalRenderPass.get().ordinal(); - } - public static void setWorldRenderPass(BlockRenderPass pass) { - threadLocalRenderPass.set(pass); - } - - @SuppressWarnings("unchecked") - public ChunkRenderManager(SodiumWorldRenderer renderer, ChunkRenderBackend backend, WorldClient world, int renderDistance) { - this.backend = backend; - this.renderer = renderer; - this.world = world; - - this.builder = new ChunkBuilder<>(backend.getVertexType(), this.backend); - this.builder.init(world); - - this.dirty = true; - - for (int i = 0; i < this.chunkRenderLists.length; i++) { - this.chunkRenderLists[i] = new ChunkRenderList<>(); - } - - this.culler = new ChunkGraphCuller(world, renderDistance); - this.translucencySorting = SodiumClientMod.options().advanced.translucencySorting; - this.translucencyBlockRenderDistance = Math.min(9216, (renderDistance << 4) * (renderDistance << 4)); - - this.useBlockFaceCulling = SodiumClientMod.options().advanced.useBlockFaceCulling; - - if(Iris.enabled) { - this.chunkRenderListsSwap = new ChunkRenderList[BlockRenderPass.COUNT]; - this.tickableChunksSwap = new ObjectArrayList<>(); - this.visibleTileEntitiesSwap = new ObjectArrayList<>(); - - for (int i = 0; i < this.chunkRenderListsSwap.length; i++) { - this.chunkRenderListsSwap[i] = new ChunkRenderList<>(); - } - - this.dirtySwap = true; - } - } - - public void update(Camera camera, FrustumExtended frustum, int frame, boolean spectator) { - this.reset(); - this.unloadPending(); - - this.setup(camera); - this.iterateChunks(camera, frustum, frame, spectator); - - this.dirty = false; - } - - public int getRebuildQueueSize() { - return this.rebuildQueue.size(); - } - - public int getImportantRebuildQueueSize() { - return this.importantRebuildQueue.size(); - } - - private void setup(Camera camera) { - Vector3d cameraPos = camera.getPos(); - - this.cameraX = (float) cameraPos.x; - this.cameraY = (float) cameraPos.y; - this.cameraZ = (float) cameraPos.z; - - this.useFogCulling = false; - this.alwaysDeferChunkUpdates = SodiumClientMod.options().performance.alwaysDeferChunkUpdates; - - if (SodiumClientMod.options().advanced.useFogOcclusion) { - float dist = FogHelper.getFogCutoff() + FOG_PLANE_OFFSET; - - if (dist != 0.0f) { - this.useFogCulling = true; - this.fogRenderCutoff = Math.max(FOG_PLANE_MIN_DISTANCE, dist * dist); - } - } - } - - private void iterateChunks(Camera camera, FrustumExtended frustum, int frame, boolean spectator) { - // Schedule new translucency sorting tasks if the camera has moved - if(this.translucencySorting) { - this.checkTranslucencyCameraMoved(); - if(this.hasCameraMovedTranslucent) { - for(Object o : this.renders.getElements()) { - if(o == null) - continue; - @SuppressWarnings("unchecked") - ChunkRenderContainer render = (ChunkRenderContainer)o; - if(render.getData().isEmpty()) - continue; - if(!render.needsRebuild() && render.canRebuild() && render.shouldRebuildForTranslucents() && render.getSquaredDistance(cameraX, cameraY, cameraZ) < translucencyBlockRenderDistance) { - // put it at the end of the queue, after any "real" rebuild tasks - render.scheduleSort(false); - } - } - } - } - - IntList list = this.culler.computeVisible(camera, frustum, frame, spectator); - IntIterator it = list.iterator(); - - while (it.hasNext()) { - ChunkRenderContainer render = this.renders.get(it.nextInt()); - - this.addChunk(render); - } - } - - private float lastCameraTranslucentX, lastCameraTranslucentY, lastCameraTranslucentZ; - private boolean hasCameraMovedTranslucent; - - private void checkTranslucencyCameraMoved() { - float dx = (cameraX - lastCameraTranslucentX); - float dy = (cameraY - lastCameraTranslucentY); - float dz = (cameraZ - lastCameraTranslucentZ); - if((dx * dx + dy * dy + dz * dz) > 1.0) { - lastCameraTranslucentX = cameraX; - lastCameraTranslucentY = cameraY; - lastCameraTranslucentZ = cameraZ; - hasCameraMovedTranslucent = true; - } else - hasCameraMovedTranslucent = false; - } - - private void addChunk(ChunkRenderContainer render) { - boolean canRebuild = render.canRebuild(); - - if (Iris.enabled && ShadowRenderingState.areShadowsCurrentlyBeingRendered()) { - canRebuild = false; - } - - if (render.needsRebuild() && canRebuild) { - if (!this.alwaysDeferChunkUpdates && render.needsImportantRebuild()) { - this.importantRebuildQueue.enqueue(render); - } else { - this.rebuildQueue.enqueue(render); - } - } else if (canRebuild && !render.getData().isEmpty() && render.needsSort()) { - this.sortQueue.enqueue(render); - } - - if (this.useFogCulling && render.getSquaredDistanceXZ(this.cameraX, this.cameraZ) >= this.fogRenderCutoff) { - return; - } - - if (!render.isEmpty()) { - this.addChunkToRenderLists(render); - this.addEntitiesToRenderLists(render); - } - } - - private void addChunkToRenderLists(ChunkRenderContainer render) { - int visibleFaces = this.computeVisibleFaces(render) & render.getFacesWithData(); - - if (visibleFaces == 0) { - return; - } - - boolean added = false; - T[] states = render.getGraphicsStates(); - - for (int i = 0; i < states.length; i++) { - T state = states[i]; - - if (state != null) { - ChunkRenderList list = this.chunkRenderLists[i]; - list.add(state, (this.translucencySorting && BlockRenderPass.VALUES[i].isTranslucent()) ? (ChunkFaceFlags.ALL & render.getFacesWithData()) : visibleFaces); - - added = true; - } - } - - if (added) { - if (render.isTickable()) { - this.tickableChunks.add(render); - } - - this.visibleChunkCount++; - } - } - - private int computeVisibleFaces(ChunkRenderContainer render) { - if(Iris.enabled) { - // TODO: Enable chunk face culling during the shadow pass - if (ShadowRenderingState.areShadowsCurrentlyBeingRendered()) { - return(ChunkFaceFlags.ALL); - } - } - // If chunk face culling is disabled, render all faces - if (!this.useBlockFaceCulling) { - return ChunkFaceFlags.ALL; - } - - ChunkRenderBounds bounds = render.getBounds(); - - // Always render groups of vertices not belonging to any given face - int visibleFaces = ChunkFaceFlags.UNASSIGNED; - - if (this.cameraY > (bounds.y1 - 3)) { - visibleFaces |= ChunkFaceFlags.UP; - } - - if (this.cameraY < (bounds.y2 + 3)) { - visibleFaces |= ChunkFaceFlags.DOWN; - } - - if (this.cameraX > (bounds.x1 - 3)) { - visibleFaces |= ChunkFaceFlags.EAST; - } - - if (this.cameraX < (bounds.x2 + 3)) { - visibleFaces |= ChunkFaceFlags.WEST; - } - - if (this.cameraZ > (bounds.z1 - 3)) { - visibleFaces |= ChunkFaceFlags.SOUTH; - } - - if (this.cameraZ < (bounds.z2 + 3)) { - visibleFaces |= ChunkFaceFlags.NORTH; - } - - return visibleFaces; - } - - private void addEntitiesToRenderLists(ChunkRenderContainer render) { - Collection tileEntities = render.getData().getTileEntities(); - this.visibleTileEntities.addAll(tileEntities); - } - - public ChunkRenderContainer getRender(int x, int y, int z) { - ChunkRenderColumn column = this.columns.get(ChunkPos.toLong(x, z)); - - if (column == null) { - return null; - } - - return column.getRender(y); - } - - private void reset() { - if(!Iris.enabled || !ShadowRenderingState.areShadowsCurrentlyBeingRendered()) this.rebuildQueue.clear(); - if(!Iris.enabled || !ShadowRenderingState.areShadowsCurrentlyBeingRendered()) this.importantRebuildQueue.clear(); - if(!Iris.enabled || !ShadowRenderingState.areShadowsCurrentlyBeingRendered()) this.sortQueue.clear(); - - this.visibleTileEntities.clear(); - - for (ChunkRenderList list : this.chunkRenderLists) { - list.reset(); - } - - this.tickableChunks.clear(); - - this.visibleChunkCount = 0; - } - - private void unloadPending() { - while (!this.unloadQueue.isEmpty()) { - this.unloadQueue.dequeue() - .delete(); - } - } - - public Collection getVisibleTileEntities() { - return this.visibleTileEntities; - } - - @Override - public void onChunkAdded(int x, int z) { - this.loadChunk(x, z); - } - - @Override - public void onChunkRemoved(int x, int z) { - this.unloadChunk(x, z); - } - - private void loadChunk(int x, int z) { - ChunkRenderColumn column = new ChunkRenderColumn<>(x, z); - ChunkRenderColumn prev; - - if ((prev = this.columns.put(ChunkPos.toLong(x, z), column)) != null) { - this.unloadSections(prev); - } - - this.connectNeighborColumns(column); - this.loadSections(column); - - this.dirty = true; - } - - private void unloadChunk(int x, int z) { - ChunkRenderColumn column = this.columns.remove(ChunkPos.toLong(x, z)); - - if (column == null) { - return; - } - - this.disconnectNeighborColumns(column); - this.unloadSections(column); - - this.dirty = true; - } - - private void loadSections(ChunkRenderColumn column) { - int x = column.getX(); - int z = column.getZ(); - - for (int y = 0; y < 16; y++) { - ChunkRenderContainer render = this.createChunkRender(column, x, y, z); - column.setRender(y, render); - - this.culler.onSectionLoaded(x, y, z, render.getId()); - } - } - - private void unloadSections(ChunkRenderColumn column) { - int x = column.getX(); - int z = column.getZ(); - - for (int y = 0; y < 16; y++) { - ChunkRenderContainer render = column.getRender(y); - - if (render != null) { - this.unloadQueue.enqueue(render); - this.renders.remove(render.getId()); - } - - this.culler.onSectionUnloaded(x, y, z); - } - } - - private void connectNeighborColumns(ChunkRenderColumn column) { - for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) { - ChunkRenderColumn adj = this.getAdjacentColumn(column, dir); - - if (adj != null) { - adj.setAdjacentColumn(dir.getOpposite(), column); - } - - column.setAdjacentColumn(dir, adj); - } - } - - private void disconnectNeighborColumns(ChunkRenderColumn column) { - for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) { - ChunkRenderColumn adj = column.getAdjacentColumn(dir); - - if (adj != null) { - adj.setAdjacentColumn(dir.getOpposite(), null); - } - - column.setAdjacentColumn(dir, null); - } - } - - private ChunkRenderColumn getAdjacentColumn(ChunkRenderColumn column, ForgeDirection dir) { - return this.getColumn(column.getX() + dir.offsetX, column.getZ() + dir.offsetZ); - } - - private ChunkRenderColumn getColumn(int x, int z) { - return this.columns.get(ChunkPos.toLong(x, z)); - } - - private ChunkRenderContainer createChunkRender(ChunkRenderColumn column, int x, int y, int z) { - ChunkRenderContainer render = new ChunkRenderContainer<>(this.backend, this.renderer, x, y, z, column); - final ExtendedBlockStorage array = this.world.getChunkFromChunkCoords(x, z).getBlockStorageArray()[y]; - - if (array == null || array.isEmpty()) { - render.setData(ChunkRenderData.EMPTY); - } else { - render.scheduleRebuild(false); - } - - render.setId(this.renders.add(render)); - - return render; - } - - public void renderLayer(MatrixStack matrixStack, BlockRenderPass pass, double x, double y, double z) { - final ChunkRenderList chunkRenderList = this.chunkRenderLists[pass.ordinal()]; - final ChunkRenderListIterator iterator = chunkRenderList.iterator(pass.isTranslucent()); - - final RenderDevice device = RenderDevice.INSTANCE; - final CommandList commandList = device.createCommandList(); - if(Iris.enabled) this.backend.iris$begin(matrixStack, pass); - else this.backend.begin(matrixStack); - - // Ensure multidraw regions are ordered appropriately - if(this.backend instanceof MultidrawChunkRenderBackend) { - ((MultidrawChunkRenderBackend) this.backend).setReverseRegions(pass.isTranslucent()); - } - this.backend.render(commandList, iterator, new ChunkCameraContext(x, y, z)); - this.backend.end(matrixStack); - - commandList.flush(); - } - - public void tickVisibleRenders() { - for (ChunkRenderContainer render : this.tickableChunks) { - render.tick(); - } - } - - public boolean isChunkVisible(int x, int y, int z) { - return this.culler.isSectionVisible(x, y, z); - } - - public void updateChunks() { - if (Iris.enabled && ShadowRenderingState.areShadowsCurrentlyBeingRendered()) return; - this.builder.cleanupSectionCache(); - - Deque>> futures = new ArrayDeque<>(); - - int budget = this.builder.getSchedulingBudget(); - submitted = 0; - - while (!this.importantRebuildQueue.isEmpty()) { - ChunkRenderContainer render = this.importantRebuildQueue.dequeue(); - - if (render == null) { - continue; - } - - CompletableFuture> futureTask = this.builder.scheduleRebuildTaskAsync(render); - - if (futureTask != null) { - this.dirty = true; - - // Do not allow distant chunks to block rendering - if (this.alwaysDeferChunkUpdates || !this.isChunkPrioritized(render)) { - this.builder.handleCompletion(futureTask); - } else { - futures.add(futureTask); - } - - submitted++; - // Limit quantity of updates submitted if we are deferring all important builds - if (this.alwaysDeferChunkUpdates && submitted >= budget) - break; - } else { - // Immediately submit empty data to the queue and do not count this against the budget - this.builder.enqueueUpload(new ChunkBuildResult<>(render, ChunkRenderData.EMPTY)); - } - } - - while (submitted < budget && !this.rebuildQueue.isEmpty()) { - ChunkRenderContainer render = this.rebuildQueue.dequeue(); - - CompletableFuture> futureTask = this.builder.scheduleRebuildTaskAsync(render); - if(futureTask != null) { - this.builder.handleCompletion(futureTask); - submitted++; - } else { - // Immediately submit empty data to the queue and do not count this against the budget - this.builder.enqueueUpload(new ChunkBuildResult<>(render, ChunkRenderData.EMPTY)); - } - } - - // always do at least one sort - boolean sortedAnything = false; - while ((!sortedAnything || submitted < budget) && !this.sortQueue.isEmpty()) { - ChunkRenderContainer render = this.sortQueue.dequeue(); - - this.builder.deferSort(render); - sortedAnything = true; - submitted++; - } - WorldRenderer.chunksUpdated += submitted; - - this.dirty |= submitted > 0; - - // Try to complete some other work on the main thread while we wait for rebuilds to complete - this.dirty |= this.builder.performPendingUploads(); - - // See if there are failed builds - this.builder.handleFailures(); - - if (!futures.isEmpty()) { - this.dirty = true; - this.backend.upload(RenderDevice.INSTANCE.createCommandList(), this.builder.filterChunkBuilds(new FutureDequeDrain<>(futures))); - } - } - - public void markDirty() { - this.dirty = true; - } - - public boolean isDirty() { - return this.dirty; - } - - public void restoreChunks(LongCollection chunks) { - LongIterator it = chunks.iterator(); - - while (it.hasNext()) { - long pos = it.nextLong(); - - this.loadChunk(ChunkPos.getPackedX(pos), ChunkPos.getPackedZ(pos)); - } - } - - public boolean isBuildComplete() { - return this.builder.isBuildQueueEmpty(); - } - - public void setCameraPosition(double x, double y, double z) { - this.builder.setCameraPosition(x, y, z); - } - - public void destroy() { - this.reset(); - - for (ChunkRenderColumn column : this.columns.values()) { - this.unloadSections(column); - } - - this.columns.clear(); - - this.builder.stopWorkers(); - } - - public int getTotalSections() { - return this.columns.size() * 16; - } - - private void scheduleRebuildOffThread(int x, int y, int z, boolean important) { - AngelicaRenderQueue.executor().execute(() -> this.scheduleRebuild(x, y, z, important)); - } - - public void scheduleRebuild(int x, int y, int z, boolean important) { - // Some mods try to schedule rebuilds off the main thread. This is dangerous, - // but the vanilla renderer seems to tolerate it. Our hashmaps are not thread-safe - // so the best solution is to do what the server chunk system does and handle this - // on the main thread. - if (Thread.currentThread() != renderThread) { - this.scheduleRebuildOffThread(x, y, z, important); - return; - } - - ChunkRenderContainer render = this.getRender(x, y, z); - - if (render != null) { - // Nearby chunks are always rendered immediately - important = important || this.isChunkPrioritized(render); - - // Only enqueue chunks for updates if they aren't already enqueued for an update - if (render.scheduleRebuild(important) && render.canRebuild()) { - (render.needsImportantRebuild() ? this.importantRebuildQueue : this.rebuildQueue) - .enqueue(render); - } - - this.dirty = true; - } - - this.builder.onChunkDataChanged(x, y, z); - } - - public boolean isChunkPrioritized(ChunkRenderContainer render) { - return render != null ? render.getSquaredDistance(this.cameraX, this.cameraY, this.cameraZ) <= NEARBY_CHUNK_DISTANCE : false; - } - - public void onChunkRenderUpdates(int x, int y, int z, ChunkRenderData data) { - this.culler.onSectionStateChanged(x, y, z, data.getOcclusionData()); - } - - // Iris - public void iris$swapVisibilityState() { - ChunkRenderList[] chunkRenderListsTmp = chunkRenderLists; - chunkRenderLists = chunkRenderListsSwap; - chunkRenderListsSwap = chunkRenderListsTmp; - - ObjectList> tickableChunksTmp = tickableChunks; - tickableChunks = tickableChunksSwap; - tickableChunksSwap = tickableChunksTmp; - - ObjectList visibleTileEntitiesTmp = visibleTileEntities; - visibleTileEntities = visibleTileEntitiesSwap; - visibleTileEntitiesSwap = visibleTileEntitiesTmp; - - int visibleChunkCountTmp = visibleChunkCount; - visibleChunkCount = visibleChunkCountSwap; - visibleChunkCountSwap = visibleChunkCountTmp; - - boolean dirtyTmp = dirty; - dirty = dirtySwap; - dirtySwap = dirtyTmp; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/backends/multidraw/ChunkDrawCallBatcher.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/backends/multidraw/ChunkDrawCallBatcher.java deleted file mode 100644 index e9ace34cd..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/backends/multidraw/ChunkDrawCallBatcher.java +++ /dev/null @@ -1,127 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.backends.multidraw; - -import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*; - -import com.gtnewhorizons.angelica.compat.mojang.CompatMathHelper; -import me.jellysquid.mods.sodium.client.SodiumClientMod; -import org.lwjgl.MemoryUtil; - -import java.nio.BufferUnderflowException; -import java.nio.ByteBuffer; - -/** - * Provides a fixed-size buffer which can be used to batch chunk section draw calls. - */ -public abstract class ChunkDrawCallBatcher extends StructBuffer { - protected final int capacity; - - protected boolean isBuilding; - protected int count; - - protected int arrayLength; - - protected ChunkDrawCallBatcher(int capacity) { - super(CompatMathHelper.smallestEncompassingPowerOfTwo(capacity), 16); - - this.capacity = capacity; - } - - public static ChunkDrawCallBatcher create(int capacity) { - return SodiumClientMod.isDirectMemoryAccessEnabled() ? new UnsafeChunkDrawCallBatcher(capacity) : new NioChunkDrawCallBatcher(capacity); - } - - public void begin() { - this.isBuilding = true; - this.count = 0; - this.arrayLength = 0; - - this.buffer.limit(this.buffer.capacity()); - } - - public void end() { - this.isBuilding = false; - - this.arrayLength = this.count * this.stride; - this.buffer.limit(this.arrayLength); - this.buffer.position(0); - } - - public boolean isBuilding() { - return this.isBuilding; - } - - public abstract void addIndirectDrawCall(int first, int count, int baseInstance, int instanceCount); - - public int getCount() { - return this.count; - } - - public boolean isEmpty() { - return this.count <= 0; - } - - public static class UnsafeChunkDrawCallBatcher extends ChunkDrawCallBatcher { - - private final long basePointer; - private long writePointer; - - public UnsafeChunkDrawCallBatcher(int capacity) { - super(capacity); - - this.basePointer = MemoryUtil.getAddress(this.buffer); - } - - @Override - public void begin() { - super.begin(); - - this.writePointer = this.basePointer; - } - - @Override - public void addIndirectDrawCall(int first, int count, int baseInstance, int instanceCount) { - if (this.count++ >= this.capacity) { - throw new BufferUnderflowException(); - } - - memPutInt(this.writePointer , count); // Vertex Count - memPutInt(this.writePointer + 4, instanceCount); // Instance Count - memPutInt(this.writePointer + 8, first); // Vertex Start - memPutInt(this.writePointer + 12, baseInstance); // Base Instance - - this.writePointer += this.stride; - } - } - - public static class NioChunkDrawCallBatcher extends ChunkDrawCallBatcher { - private int writeOffset; - - public NioChunkDrawCallBatcher(int capacity) { - super(capacity); - } - - @Override - public void begin() { - super.begin(); - - this.writeOffset = 0; - } - - @Override - public void addIndirectDrawCall(int first, int count, int baseInstance, int instanceCount) { - ByteBuffer buf = this.buffer; - buf.putInt(this.writeOffset , count); // Vertex Count - buf.putInt(this.writeOffset + 4, instanceCount); // Instance Count - buf.putInt(this.writeOffset + 8, first); // Vertex Start - buf.putInt(this.writeOffset + 12, baseInstance); // Base Instance - - this.writeOffset += this.stride; - this.count++; - } - } - - public int getArrayLength() { - return this.arrayLength; - } - -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/backends/multidraw/ChunkDrawParamsVector.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/backends/multidraw/ChunkDrawParamsVector.java deleted file mode 100644 index cb2b7d23b..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/backends/multidraw/ChunkDrawParamsVector.java +++ /dev/null @@ -1,108 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.backends.multidraw; - -import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*; - -import me.jellysquid.mods.sodium.client.SodiumClientMod; -import org.lwjgl.MemoryUtil; - -import java.nio.ByteBuffer; - -/** - * Provides a resizeable vector backed by native memory that can be used to build an array of chunk draw call - * parameters. - */ -public abstract class ChunkDrawParamsVector extends StructBuffer { - protected int capacity; - protected int count; - - protected ChunkDrawParamsVector(int capacity) { - super(capacity, 16); - - this.capacity = capacity; - } - - public static ChunkDrawParamsVector create(int capacity) { - return SodiumClientMod.isDirectMemoryAccessEnabled() ? new UnsafeChunkDrawCallVector(capacity) : new NioChunkDrawCallVector(capacity); - } - - public abstract void pushChunkDrawParams(float x, float y, float z); - - public void reset() { - this.count = 0; - } - - protected void growBuffer() { - this.capacity = this.capacity * 2; - this.buffer = memRealloc(this.buffer, this.capacity * this.stride); - } - - public static class UnsafeChunkDrawCallVector extends ChunkDrawParamsVector { - private long basePointer; - private long writePointer; - - public UnsafeChunkDrawCallVector(int capacity) { - super(capacity); - - this.basePointer = MemoryUtil.getAddress(this.buffer); - } - - @Override - public void pushChunkDrawParams(float x, float y, float z) { - if (this.count++ >= this.capacity) { - this.growBuffer(); - } - - memPutFloat(this.writePointer , x); - memPutFloat(this.writePointer + 4, y); - memPutFloat(this.writePointer + 8, z); - - this.writePointer += this.stride; - } - - @Override - protected void growBuffer() { - super.growBuffer(); - - long offset = this.writePointer - this.basePointer; - - this.basePointer = memAddress(this.buffer); - this.writePointer = this.basePointer + offset; - } - - @Override - public void reset() { - super.reset(); - - this.writePointer = this.basePointer; - } - } - - public static class NioChunkDrawCallVector extends ChunkDrawParamsVector { - private int writeOffset; - - public NioChunkDrawCallVector(int capacity) { - super(capacity); - } - - @Override - public void pushChunkDrawParams(float x, float y, float z) { - if (this.count++ >= this.capacity) { - this.growBuffer(); - } - - ByteBuffer buf = this.buffer; - buf.putFloat(this.writeOffset , x); - buf.putFloat(this.writeOffset + 4, y); - buf.putFloat(this.writeOffset + 8, z); - - this.writeOffset += this.stride; - } - - @Override - public void reset() { - super.reset(); - - this.writeOffset = 0; - } - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/backends/multidraw/IndirectCommandBufferVector.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/backends/multidraw/IndirectCommandBufferVector.java deleted file mode 100644 index 2b07f2553..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/backends/multidraw/IndirectCommandBufferVector.java +++ /dev/null @@ -1,37 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.backends.multidraw; - -import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*; - -public class IndirectCommandBufferVector extends StructBuffer { - protected IndirectCommandBufferVector(int capacity) { - super(capacity, 16); - } - - public static IndirectCommandBufferVector create(int capacity) { - return new IndirectCommandBufferVector(capacity); - } - - public void begin() { - this.buffer.clear(); - } - - public void end() { - if(this.buffer.position() > 0) { - this.buffer.flip(); - } - } - - public void pushCommandBuffer(ChunkDrawCallBatcher batcher) { - int len = batcher.getArrayLength(); - - if (this.buffer.remaining() < len) { - this.growBuffer(len); - } - - this.buffer.put(batcher.getBuffer()); - } - - protected void growBuffer(int n) { - this.buffer = memRealloc(this.buffer, Math.max(this.buffer.capacity() * 2, this.buffer.capacity() + n)); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/backends/multidraw/MultidrawChunkRenderBackend.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/backends/multidraw/MultidrawChunkRenderBackend.java deleted file mode 100644 index 98ea6780b..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/backends/multidraw/MultidrawChunkRenderBackend.java +++ /dev/null @@ -1,486 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.backends.multidraw; - -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing; -import it.unimi.dsi.fastutil.objects.ObjectArrayFIFOQueue; -import net.coderbot.iris.Iris; -import it.unimi.dsi.fastutil.objects.ObjectArrayList; -import java.nio.ByteBuffer; -import java.util.ArrayList; -import java.util.Comparator; -import java.util.Iterator; -import java.util.List; -import java.util.Objects; -import java.util.regex.Matcher; -import java.util.regex.Pattern; -import lombok.Setter; -import me.jellysquid.mods.sodium.client.gl.arena.GlBufferArena; -import me.jellysquid.mods.sodium.client.gl.arena.GlBufferSegment; -import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexAttribute; -import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexAttributeBinding; -import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexAttributeFormat; -import me.jellysquid.mods.sodium.client.gl.buffer.GlBuffer; -import me.jellysquid.mods.sodium.client.gl.buffer.GlBufferTarget; -import me.jellysquid.mods.sodium.client.gl.buffer.GlBufferUsage; -import me.jellysquid.mods.sodium.client.gl.buffer.GlMutableBuffer; -import me.jellysquid.mods.sodium.client.gl.buffer.VertexData; -import me.jellysquid.mods.sodium.client.gl.device.CommandList; -import me.jellysquid.mods.sodium.client.gl.device.DrawCommandList; -import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; -import me.jellysquid.mods.sodium.client.gl.func.GlFunctions; -import me.jellysquid.mods.sodium.client.gl.tessellation.GlPrimitiveType; -import me.jellysquid.mods.sodium.client.gl.tessellation.GlTessellation; -import me.jellysquid.mods.sodium.client.gl.tessellation.TessellationBinding; -import me.jellysquid.mods.sodium.client.gl.util.BufferSlice; -import me.jellysquid.mods.sodium.client.model.vertex.type.ChunkVertexType; -import me.jellysquid.mods.sodium.client.render.chunk.ChunkCameraContext; -import me.jellysquid.mods.sodium.client.render.chunk.ChunkRenderContainer; -import me.jellysquid.mods.sodium.client.render.chunk.compile.ChunkBuildResult; -import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkMeshData; -import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkRenderData; -import me.jellysquid.mods.sodium.client.render.chunk.format.ChunkMeshAttribute; -import me.jellysquid.mods.sodium.client.render.chunk.lists.ChunkRenderListIterator; -import me.jellysquid.mods.sodium.client.render.chunk.passes.BlockRenderPass; -import me.jellysquid.mods.sodium.client.render.chunk.region.ChunkRegion; -import me.jellysquid.mods.sodium.client.render.chunk.region.ChunkRegionManager; -import me.jellysquid.mods.sodium.client.render.chunk.shader.ChunkRenderShaderBackend; -import me.jellysquid.mods.sodium.client.render.chunk.shader.ChunkShaderBindingPoints; -import net.coderbot.iris.block_rendering.BlockRenderingSettings; -import net.coderbot.iris.sodium.IrisChunkShaderBindingPoints; -import net.minecraft.util.EnumChatFormatting; -import net.minecraft.util.Util; -import org.lwjgl.opengl.GL11; - -/** - * Shader-based chunk renderer which makes use of a custom memory allocator on top of large buffer objects to allow - * for draw call batching without buffer switching. - * - * The biggest bottleneck after setting up vertex attribute state is the sheer number of buffer switches and draw calls - * being performed. In vanilla, the game uses one buffer for every chunk section, which means we need to bind, setup, - * and draw every chunk individually. - * - * In order to reduce the number of these calls, we need to firstly reduce the number of buffer switches. We do this - * through sub-dividing the world into larger "chunk regions" which then have one large buffer object in OpenGL. From - * here, we can allocate slices of this buffer to each individual chunk and then only bind it once before drawing. Then, - * our draw calls can simply point to individual sections within the buffer by manipulating the offset and count - * parameters. - * - * However, an unfortunate consequence is that if we run out of space in a buffer, we need to re-allocate the entire - * storage, which can take a ton of time! With old OpenGL 2.1 code, the only way to do this would be to copy the buffer's - * memory from the graphics card over the host bus into CPU memory, allocate a new buffer, and then copy it back over - * the bus and into graphics card. For reasons that should be obvious, this is extremely inefficient and requires the - * CPU and GPU to be synchronized. - * - * If we make use of more modern OpenGL 3.0 features, we can avoid this transfer over the memory bus and instead just - * perform the copy between buffers in GPU memory with the aptly named "copy buffer" function. It's still not blazing - * fast, but it's much better than what we're stuck with in older versions. We can help prevent these re-allocations by - * sizing our buffers to be a bit larger than what we expect all the chunk data to be, but this wastes memory. - * - * In the initial implementation, this solution worked fine enough, but the amount of time being spent on uploading - * chunks to the large buffers was now a magnitude more than what it was before all of this and it made chunk updates - * *very* slow. It took some tinkering to figure out what was going wrong here, but at least on the NVIDIA drivers, it - * seems that updating sub-regions of buffer memory hits some kind of slow path. A workaround for this problem is to - * create a scratch buffer object and upload the chunk data there *first*, re-allocating the storage each time. Then, - * you can copy the contents of the scratch buffer into the chunk region buffer, rise and repeat. I'm not happy with - * this solution, but it performs surprisingly well across all hardware I tried. - * - * With both of these changes, the amount of CPU time taken by rendering chunks linearly decreases with the reduction - * in buffer bind/setup/draw calls. Using the default settings of 4x2x4 chunk region buffers, the number of calls can be - * reduced up to a factor of ~32x. - */ -public class MultidrawChunkRenderBackend extends ChunkRenderShaderBackend { - private final ChunkRegionManager bufferManager; - - private final ObjectArrayList> pendingBatches = new ObjectArrayList<>(); - private final ObjectArrayFIFOQueue> pendingUploads = new ObjectArrayFIFOQueue<>(); - - private final GlMutableBuffer uploadBuffer; - private final GlMutableBuffer uniformBuffer; - private final GlMutableBuffer commandBuffer; - - private final ChunkDrawParamsVector uniformBufferBuilder; - private final IndirectCommandBufferVector commandClientBufferBuilder; - - public MultidrawChunkRenderBackend(RenderDevice device, ChunkVertexType vertexType) { - super(vertexType); - - this.bufferManager = new ChunkRegionManager<>(device); - - try (CommandList commands = device.createCommandList()) { - this.uploadBuffer = commands.createMutableBuffer(GlBufferUsage.GL_STREAM_DRAW); - this.uniformBuffer = commands.createMutableBuffer(GlBufferUsage.GL_STATIC_DRAW); - this.commandBuffer = isWindowsIntelDriver() ? null : commands.createMutableBuffer(GlBufferUsage.GL_STREAM_DRAW); - } - - this.uniformBufferBuilder = ChunkDrawParamsVector.create(2048); - this.commandClientBufferBuilder = IndirectCommandBufferVector.create(2048); - } - - @Override - public void upload(CommandList commandList, Iterator> queue) { - if(queue != null) { - this.setupUploadBatches(queue); - } - - commandList.bindBuffer(GlBufferTarget.ARRAY_BUFFER, this.uploadBuffer); - - while (!this.pendingUploads.isEmpty()) { - final ChunkRegion region = this.pendingUploads.dequeue(); - - final GlBufferArena arena = region.getBufferArena(); - final GlBuffer buffer = arena.getBuffer(); - - final ObjectArrayList> uploadQueue = region.getUploadQueue(); - arena.prepareBuffer(commandList, getUploadQueuePayloadSize(uploadQueue)); - - for (ChunkBuildResult result : uploadQueue) { - final ChunkRenderContainer render = result.render; - final ChunkRenderData data = result.data; - - for (BlockRenderPass pass : result.passesToUpload) { - final MultidrawGraphicsState graphics = render.getGraphicsState(pass); - - // De-allocate the existing buffer arena for this render - // This will allow it to be cheaply re-allocated just below - if (graphics != null) { - graphics.delete(commandList); - } - - final ChunkMeshData meshData = data.getMesh(pass); - - if (meshData.hasVertexData()) { - final VertexData upload = meshData.takeVertexData(); - - commandList.uploadData(this.uploadBuffer, upload.buffer); - - final GlBufferSegment segment = arena.uploadBuffer(commandList, this.uploadBuffer, 0, upload.buffer.capacity()); - - final MultidrawGraphicsState graphicsState = new MultidrawGraphicsState(render, region, segment, meshData, this.vertexFormat); - if(pass.isTranslucent()) { - upload.buffer.limit(upload.buffer.capacity()); - upload.buffer.position(0); - - graphicsState.setTranslucencyData(upload.buffer); - } - render.setGraphicsState(pass, graphicsState); - } else { - render.setGraphicsState(pass, null); - } - } - - render.setData(data); - } - - // Check if the tessellation needs to be updated - // This happens whenever the backing buffer object for the arena changes, or if it hasn't already been created - if (region.getTessellation() == null || buffer != arena.getBuffer()) { - if (region.getTessellation() != null) { - commandList.deleteTessellation(region.getTessellation()); - } - - region.setTessellation(this.createRegionTessellation(commandList, arena.getBuffer())); - } - - uploadQueue.clear(); - } - - commandList.invalidateBuffer(this.uploadBuffer); - } - - private GlTessellation createRegionTessellation(CommandList commandList, GlBuffer buffer) { - return commandList.createTessellation(GlPrimitiveType.QUADS, new TessellationBinding[] { - new TessellationBinding(buffer,getBindings(), false), - new TessellationBinding(this.uniformBuffer, new GlVertexAttributeBinding[] { - new GlVertexAttributeBinding(ChunkShaderBindingPoints.MODEL_OFFSET, new GlVertexAttribute(GlVertexAttributeFormat.FLOAT, 4, false, 0, 0)) - }, true) - }); - } - - private GlVertexAttributeBinding[] getBindings() { - if(Iris.enabled && BlockRenderingSettings.INSTANCE.shouldUseExtendedVertexFormat()) { - return new GlVertexAttributeBinding[] { - new GlVertexAttributeBinding(ChunkShaderBindingPoints.POSITION, this.vertexFormat.getAttribute(ChunkMeshAttribute.POSITION)), - new GlVertexAttributeBinding(ChunkShaderBindingPoints.COLOR, this.vertexFormat.getAttribute(ChunkMeshAttribute.COLOR)), - new GlVertexAttributeBinding(ChunkShaderBindingPoints.TEX_COORD, this.vertexFormat.getAttribute(ChunkMeshAttribute.TEXTURE)), - new GlVertexAttributeBinding(ChunkShaderBindingPoints.LIGHT_COORD, this.vertexFormat.getAttribute(ChunkMeshAttribute.LIGHT)), - new GlVertexAttributeBinding(IrisChunkShaderBindingPoints.NORMAL, vertexFormat.getAttribute(ChunkMeshAttribute.NORMAL)), - new GlVertexAttributeBinding(IrisChunkShaderBindingPoints.TANGENT, vertexFormat.getAttribute(ChunkMeshAttribute.TANGENT)), - new GlVertexAttributeBinding(IrisChunkShaderBindingPoints.MID_TEX_COORD, vertexFormat.getAttribute(ChunkMeshAttribute.MID_TEX_COORD)), - new GlVertexAttributeBinding(IrisChunkShaderBindingPoints.BLOCK_ID, vertexFormat.getAttribute(ChunkMeshAttribute.BLOCK_ID)), - new GlVertexAttributeBinding(IrisChunkShaderBindingPoints.MID_BLOCK, vertexFormat.getAttribute(ChunkMeshAttribute.MID_BLOCK)) - }; - } else { - return new GlVertexAttributeBinding[] { - new GlVertexAttributeBinding(ChunkShaderBindingPoints.POSITION, this.vertexFormat.getAttribute(ChunkMeshAttribute.POSITION)), - new GlVertexAttributeBinding(ChunkShaderBindingPoints.COLOR, this.vertexFormat.getAttribute(ChunkMeshAttribute.COLOR)), - new GlVertexAttributeBinding(ChunkShaderBindingPoints.TEX_COORD, this.vertexFormat.getAttribute(ChunkMeshAttribute.TEXTURE)), - new GlVertexAttributeBinding(ChunkShaderBindingPoints.LIGHT_COORD, this.vertexFormat.getAttribute(ChunkMeshAttribute.LIGHT)) }; - } - - } - - /** - * -- SETTER -- - * Sets whether to reverse the order in which regions are drawn - */ - @Setter - private boolean reverseRegions = false; - private ChunkCameraContext regionCamera; - - @Override - public void render(CommandList commandList, ChunkRenderListIterator renders, ChunkCameraContext camera) { - this.bufferManager.cleanup(); - - this.setupDrawBatches(commandList, renders, camera); - this.buildCommandBuffer(); - - if (this.commandBuffer != null) { - commandList.bindBuffer(GlBufferTarget.DRAW_INDIRECT_BUFFER, this.commandBuffer); - commandList.uploadData(this.commandBuffer, this.commandClientBufferBuilder.getBuffer()); - } - - long pointer = 0L; - ByteBuffer pointerBuffer; - int originalPointerBufferPos = 0; - if (this.commandBuffer != null) { - pointerBuffer = null; - } else { - pointerBuffer = this.commandClientBufferBuilder.getBuffer(); - originalPointerBufferPos = pointerBuffer.position(); - } - - for (ChunkRegion region : this.pendingBatches) { - final ChunkDrawCallBatcher batch = region.getDrawBatcher(); - - if (!batch.isEmpty()) { - try (DrawCommandList drawCommandList = commandList.beginTessellating(region.getTessellation())) { - if(pointerBuffer == null) { - drawCommandList.multiDrawArraysIndirect(pointer, batch.getCount(), 0 /* tightly packed */); - } else { - drawCommandList.multiDrawArraysIndirect(pointerBuffer, batch.getCount(), 0 /* tightly packed */); - } - } - } - - if(pointerBuffer == null) { - pointer += batch.getArrayLength(); - } else { - pointerBuffer.position(pointerBuffer.position() + batch.getArrayLength()); - } - } - - if (pointerBuffer != null) - pointerBuffer.position(originalPointerBufferPos); - - this.pendingBatches.clear(); - } - - private static final Comparator> REGION_REVERSER = Comparator.>comparingDouble(r -> r.camDistance).reversed(); - - private void buildCommandBuffer() { - this.commandClientBufferBuilder.begin(); - - if(this.reverseRegions) { - final ChunkCameraContext camera = this.regionCamera; - for (ChunkRegion region : this.pendingBatches) { - final float x = camera.getChunkModelOffset(region.getCenterBlockX(), camera.blockOriginX, camera.originX); - final float y = camera.getChunkModelOffset(region.getCenterBlockY(), camera.blockOriginY, camera.originY); - final float z = camera.getChunkModelOffset(region.getCenterBlockZ(), camera.blockOriginZ, camera.originZ); - region.camDistance = x * x + y * y + z * z; - } - - this.pendingBatches.sort(REGION_REVERSER); - } - - for (ChunkRegion region : this.pendingBatches) { - final ChunkDrawCallBatcher batcher = region.getDrawBatcher(); - batcher.end(); - - this.commandClientBufferBuilder.pushCommandBuffer(batcher); - } - - this.commandClientBufferBuilder.end(); - } - - private void setupUploadBatches(Iterator> renders) { - while (renders.hasNext()) { - final ChunkBuildResult result = renders.next(); - - if(result == null) { - continue; - } - - final ChunkRenderContainer render = result.render; - - ChunkRegion region = this.bufferManager.getRegion(render.getChunkX(), render.getChunkY(), render.getChunkZ()); - - if (region == null) { - if (result.data.getMeshSize() <= 0) { - render.setData(result.data); - continue; - } - - region = this.bufferManager.getOrCreateRegion(render.getChunkX(), render.getChunkY(), render.getChunkZ()); - } - - final ObjectArrayList> uploadQueue = region.getUploadQueue(); - - if (uploadQueue.isEmpty()) { - this.pendingUploads.enqueue(region); - } - - uploadQueue.add(result); - } - } - - private void setupDrawBatches(CommandList commandList, ChunkRenderListIterator it, ChunkCameraContext camera) { - this.uniformBufferBuilder.reset(); - this.regionCamera = camera; - - int drawCount = 0; - - while (it.hasNext()) { - final MultidrawGraphicsState state = it.getGraphicsState(); - final int visible = it.getVisibleFaces(); - - final int index = drawCount++; - final float x = camera.getChunkModelOffset(state.getX(), camera.blockOriginX, camera.originX); - final float y = camera.getChunkModelOffset(state.getY(), camera.blockOriginY, camera.originY); - final float z = camera.getChunkModelOffset(state.getZ(), camera.blockOriginZ, camera.originZ); - - this.uniformBufferBuilder.pushChunkDrawParams(x, y, z); - - final ChunkRegion region = state.getRegion(); - final ChunkDrawCallBatcher batch = region.getDrawBatcher(); - - if (!batch.isBuilding()) { - batch.begin(); - - this.pendingBatches.add(region); - } - - int mask = 0b1; - - for (int i = 0; i < ModelQuadFacing.COUNT; i++) { - if ((visible & mask) != 0) { - final long part = state.getModelPart(i); - - batch.addIndirectDrawCall(BufferSlice.unpackStart(part), BufferSlice.unpackLength(part), index, 1); - } - - mask <<= 1; - } - - it.advance(); - } - - commandList.uploadData(this.uniformBuffer, this.uniformBufferBuilder.getBuffer()); - } - - private static int getUploadQueuePayloadSize(List> queue) { - int size = 0; - - for (ChunkBuildResult result : queue) { - size += result.data.getMeshSize(); - } - - return size; - } - - @Override - public void delete() { - super.delete(); - - try (CommandList commands = RenderDevice.INSTANCE.createCommandList()) { - commands.deleteBuffer(this.uploadBuffer); - commands.deleteBuffer(this.uniformBuffer); - - if (this.commandBuffer != null) { - commands.deleteBuffer(this.commandBuffer); - } - } - - this.bufferManager.delete(); - - this.commandClientBufferBuilder.delete(); - this.uniformBufferBuilder.delete(); - } - - @Override - public Class getGraphicsStateType() { - return MultidrawGraphicsState.class; - } - - public static boolean isSupported(boolean disableDriverBlacklist) { - if (!disableDriverBlacklist && isKnownBrokenIntelDriver()) { - return false; - } - - return GlFunctions.isVertexArraySupported() && - GlFunctions.isBufferCopySupported() && - GlFunctions.isIndirectMultiDrawSupported() && - GlFunctions.isInstancedArraySupported(); - } - - // https://www.intel.com/content/www/us/en/support/articles/000005654/graphics.html - private static final Pattern INTEL_BUILD_MATCHER = Pattern.compile("(\\d.\\d.\\d) - Build (\\d+).(\\d+).(\\d+).(\\d+)"); - - private static final String INTEL_VENDOR_NAME = "Intel"; - - /** - * Determines whether or not the current OpenGL renderer is an integrated Intel GPU on Windows. - * These drivers on Windows are known to fail when using command buffers. - */ - private static boolean isWindowsIntelDriver() { - // We only care about Windows - // The open-source drivers on Linux are not known to have driver bugs with indirect command buffers - if (Util.getOSType() != Util.EnumOS.WINDOWS) { - return false; - } - - // Check to see if the GPU vendor is Intel - return Objects.equals(GL11.glGetString(GL11.GL_VENDOR), INTEL_VENDOR_NAME); - } - - /** - * Determines whether or not the current OpenGL renderer is an old integrated Intel GPU (prior to Skylake/Gen8) on - * Windows. These drivers on Windows are unsupported and known to create significant trouble with the multi-draw - * renderer. - */ - private static boolean isKnownBrokenIntelDriver() { - if (!isWindowsIntelDriver()) { - return false; - } - - final String version = GL11.glGetString(GL11.GL_VERSION); - - // The returned version string may be null in the case of an error - if (version == null) { - return false; - } - - final Matcher matcher = INTEL_BUILD_MATCHER.matcher(version); - - // If the version pattern doesn't match, assume we're dealing with something special - if (!matcher.matches()) { - return false; - } - - // Anything with a major build of >=100 is GPU Gen8 or newer - // The fourth group is the major build number - return Integer.parseInt(matcher.group(4)) < 100; - } - - @Override - public String getRendererName() { - return "Multidraw"; - } - - @Override - public List getDebugStrings() { - final List list = new ArrayList<>(); - list.add(String.format("Active Buffers: %s", this.bufferManager.getAllocatedRegionCount())); - list.add(String.format("Submission Mode: %s", this.commandBuffer != null ? EnumChatFormatting.AQUA + "Buffer" : EnumChatFormatting.LIGHT_PURPLE + "Client Memory")); - - return list; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/backends/multidraw/MultidrawGraphicsState.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/backends/multidraw/MultidrawGraphicsState.java deleted file mode 100644 index d008893d8..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/backends/multidraw/MultidrawGraphicsState.java +++ /dev/null @@ -1,53 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.backends.multidraw; - -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing; -import me.jellysquid.mods.sodium.client.gl.arena.GlBufferSegment; -import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexFormat; -import me.jellysquid.mods.sodium.client.gl.device.CommandList; -import me.jellysquid.mods.sodium.client.gl.util.BufferSlice; -import me.jellysquid.mods.sodium.client.render.chunk.ChunkGraphicsState; -import me.jellysquid.mods.sodium.client.render.chunk.ChunkRenderContainer; -import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkMeshData; -import me.jellysquid.mods.sodium.client.render.chunk.region.ChunkRegion; - -import java.util.Map; - -public class MultidrawGraphicsState extends ChunkGraphicsState { - private final ChunkRegion region; - - private final GlBufferSegment segment; - private final long[] parts; - - public MultidrawGraphicsState(ChunkRenderContainer container, ChunkRegion region, GlBufferSegment segment, ChunkMeshData meshData, GlVertexFormat vertexFormat) { - super(container); - - this.region = region; - this.segment = segment; - - this.parts = new long[ModelQuadFacing.COUNT]; - - for (Map.Entry entry : meshData.getSlices()) { - ModelQuadFacing facing = entry.getKey(); - BufferSlice slice = entry.getValue(); - - int start = (segment.getStart() + slice.start) / vertexFormat.getStride(); - int count = slice.len / vertexFormat.getStride(); - - this.parts[facing.ordinal()] = BufferSlice.pack(start, count); - } - } - - @Override - public void delete(CommandList commandList) { - this.segment.delete(); - } - - public ChunkRegion getRegion() { - return this.region; - } - - public long getModelPart(int facing) { - return this.parts[facing]; - } - -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/backends/multidraw/StructBuffer.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/backends/multidraw/StructBuffer.java deleted file mode 100644 index 254938222..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/backends/multidraw/StructBuffer.java +++ /dev/null @@ -1,28 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.backends.multidraw; - -import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*; - -import java.nio.ByteBuffer; - -public abstract class StructBuffer { - protected ByteBuffer buffer; - - protected final int stride; - - protected StructBuffer(int bytes, int stride) { - this.buffer = memAlloc(bytes * stride); - this.stride = stride; - } - - public ByteBuffer getBuffer() { - return this.buffer; - } - - public long getBufferAddress() { - return memAddress(this.buffer); - } - - public void delete() { - // no-op, because Java direct buffers free themselves - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/backends/oneshot/ChunkOneshotGraphicsState.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/backends/oneshot/ChunkOneshotGraphicsState.java deleted file mode 100644 index d1f097552..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/backends/oneshot/ChunkOneshotGraphicsState.java +++ /dev/null @@ -1,110 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.backends.oneshot; - -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing; -import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexAttributeBinding; -import net.coderbot.iris.Iris; -import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexFormat; -import me.jellysquid.mods.sodium.client.gl.buffer.GlBufferUsage; -import me.jellysquid.mods.sodium.client.gl.buffer.GlMutableBuffer; -import me.jellysquid.mods.sodium.client.gl.buffer.VertexData; -import me.jellysquid.mods.sodium.client.gl.device.CommandList; -import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; -import me.jellysquid.mods.sodium.client.gl.tessellation.GlPrimitiveType; -import me.jellysquid.mods.sodium.client.gl.tessellation.GlTessellation; -import me.jellysquid.mods.sodium.client.gl.tessellation.TessellationBinding; -import me.jellysquid.mods.sodium.client.gl.util.BufferSlice; -import me.jellysquid.mods.sodium.client.render.chunk.ChunkGraphicsState; -import me.jellysquid.mods.sodium.client.render.chunk.ChunkRenderContainer; -import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkMeshData; -import me.jellysquid.mods.sodium.client.render.chunk.format.ChunkMeshAttribute; -import me.jellysquid.mods.sodium.client.render.chunk.shader.ChunkShaderBindingPoints; -import net.coderbot.iris.block_rendering.BlockRenderingSettings; -import net.coderbot.iris.sodium.IrisChunkShaderBindingPoints; - -import java.util.Arrays; -import java.util.Map; - -public class ChunkOneshotGraphicsState extends ChunkGraphicsState { - private final GlMutableBuffer vertexBuffer; - - protected GlTessellation tessellation; - - private final long[] parts; - - protected ChunkOneshotGraphicsState(RenderDevice device, ChunkRenderContainer container) { - super(container); - - this.parts = new long[ModelQuadFacing.COUNT]; - - try (CommandList commands = device.createCommandList()) { - this.vertexBuffer = commands.createMutableBuffer(GlBufferUsage.GL_STATIC_DRAW); - } - } - - public long getModelPart(int facing) { - return this.parts[facing]; - } - - protected void setModelPart(ModelQuadFacing facing, long slice) { - this.parts[facing.ordinal()] = slice; - } - - protected void setupModelParts(ChunkMeshData meshData, GlVertexFormat vertexFormat) { - int stride = vertexFormat.getStride(); - - Arrays.fill(this.parts, 0L); - - for (Map.Entry entry : meshData.getSlices()) { - ModelQuadFacing facing = entry.getKey(); - BufferSlice slice = entry.getValue(); - - this.setModelPart(facing, BufferSlice.pack(slice.start / stride, slice.len / stride)); - } - } - - @Override - public void delete(CommandList commandList) { - commandList.deleteBuffer(this.vertexBuffer); - } - - public void upload(CommandList commandList, ChunkMeshData meshData) { - VertexData vertexData = meshData.takeVertexData(); - - commandList.uploadData(this.vertexBuffer, vertexData); - - @SuppressWarnings("unchecked") - GlVertexFormat vertexFormat = (GlVertexFormat) vertexData.format; - - this.tessellation = commandList.createTessellation(GlPrimitiveType.QUADS, new TessellationBinding[] { - new TessellationBinding(this.vertexBuffer, getBindings(vertexFormat), false) - }); - - this.setupModelParts(meshData, vertexData.format); - - vertexData.buffer.limit(vertexData.buffer.capacity()); - vertexData.buffer.position(0); - this.setTranslucencyData(vertexData.buffer); - } - - private GlVertexAttributeBinding[] getBindings(GlVertexFormat vertexFormat) { - if(Iris.enabled && BlockRenderingSettings.INSTANCE.shouldUseExtendedVertexFormat()) { - return new GlVertexAttributeBinding[] { - new GlVertexAttributeBinding(ChunkShaderBindingPoints.POSITION, vertexFormat.getAttribute(ChunkMeshAttribute.POSITION)), - new GlVertexAttributeBinding(ChunkShaderBindingPoints.COLOR, vertexFormat.getAttribute(ChunkMeshAttribute.COLOR)), - new GlVertexAttributeBinding(ChunkShaderBindingPoints.TEX_COORD, vertexFormat.getAttribute(ChunkMeshAttribute.TEXTURE)), - new GlVertexAttributeBinding(ChunkShaderBindingPoints.LIGHT_COORD, vertexFormat.getAttribute(ChunkMeshAttribute.LIGHT)), - new GlVertexAttributeBinding(IrisChunkShaderBindingPoints.BLOCK_ID, vertexFormat.getAttribute(ChunkMeshAttribute.BLOCK_ID)), - new GlVertexAttributeBinding(IrisChunkShaderBindingPoints.MID_TEX_COORD, vertexFormat.getAttribute(ChunkMeshAttribute.MID_TEX_COORD)), - new GlVertexAttributeBinding(IrisChunkShaderBindingPoints.TANGENT, vertexFormat.getAttribute(ChunkMeshAttribute.TANGENT)), - new GlVertexAttributeBinding(IrisChunkShaderBindingPoints.NORMAL, vertexFormat.getAttribute(ChunkMeshAttribute.NORMAL)) - }; - } else { - return new GlVertexAttributeBinding[] { - new GlVertexAttributeBinding(ChunkShaderBindingPoints.POSITION, vertexFormat.getAttribute(ChunkMeshAttribute.POSITION)), - new GlVertexAttributeBinding(ChunkShaderBindingPoints.COLOR, vertexFormat.getAttribute(ChunkMeshAttribute.COLOR)), - new GlVertexAttributeBinding(ChunkShaderBindingPoints.TEX_COORD, vertexFormat.getAttribute(ChunkMeshAttribute.TEXTURE)), - new GlVertexAttributeBinding(ChunkShaderBindingPoints.LIGHT_COORD, vertexFormat.getAttribute(ChunkMeshAttribute.LIGHT)) }; - } - } - -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/backends/oneshot/ChunkRenderBackendOneshot.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/backends/oneshot/ChunkRenderBackendOneshot.java deleted file mode 100644 index fd973e438..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/backends/oneshot/ChunkRenderBackendOneshot.java +++ /dev/null @@ -1,133 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.backends.oneshot; - -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing; -import me.jellysquid.mods.sodium.client.gl.device.CommandList; -import me.jellysquid.mods.sodium.client.gl.device.DrawCommandList; -import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; -import me.jellysquid.mods.sodium.client.gl.util.BufferSlice; -import me.jellysquid.mods.sodium.client.gl.util.GlMultiDrawBatch; -import me.jellysquid.mods.sodium.client.model.vertex.type.ChunkVertexType; -import me.jellysquid.mods.sodium.client.render.chunk.ChunkCameraContext; -import me.jellysquid.mods.sodium.client.render.chunk.ChunkRenderContainer; -import me.jellysquid.mods.sodium.client.render.chunk.compile.ChunkBuildResult; -import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkMeshData; -import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkRenderData; -import me.jellysquid.mods.sodium.client.render.chunk.lists.ChunkRenderListIterator; -import me.jellysquid.mods.sodium.client.render.chunk.passes.BlockRenderPass; -import me.jellysquid.mods.sodium.client.render.chunk.shader.ChunkRenderShaderBackend; -import me.jellysquid.mods.sodium.client.render.chunk.shader.ChunkShaderBindingPoints; -import org.lwjgl.opengl.GL20; - -import java.util.Iterator; - -public class ChunkRenderBackendOneshot extends ChunkRenderShaderBackend { - private final GlMultiDrawBatch batch = new GlMultiDrawBatch(ModelQuadFacing.COUNT); - - public ChunkRenderBackendOneshot(ChunkVertexType vertexType) { - super(vertexType); - } - - @Override - public void upload(CommandList commandList, Iterator> queue) { - while (queue.hasNext()) { - ChunkBuildResult result = queue.next(); - - ChunkRenderContainer render = result.render; - ChunkRenderData data = result.data; - - for (BlockRenderPass pass : result.passesToUpload) { - ChunkOneshotGraphicsState state = render.getGraphicsState(pass); - ChunkMeshData mesh = data.getMesh(pass); - - if (mesh.hasVertexData()) { - if (state == null) { - state = new ChunkOneshotGraphicsState(RenderDevice.INSTANCE, render); - } - - state.upload(commandList, mesh); - // For code simplicity, ChunkOneshotGraphicsState stores the buffer unconditionally - // Reset it here if the pass isn't translucent, as we don't want to store useless - // buffers - if(!pass.isTranslucent()) - state.setTranslucencyData(null); - } else { - if (state != null) { - state.delete(commandList); - } - - state = null; - } - - render.setGraphicsState(pass, state); - } - - render.setData(data); - } - } - - @Override - public void render(CommandList commandList, ChunkRenderListIterator it, ChunkCameraContext camera) { - while (it.hasNext()) { - ChunkOneshotGraphicsState state = it.getGraphicsState(); - int visibleFaces = it.getVisibleFaces(); - - this.buildBatch(state, visibleFaces); - - if (this.batch.isBuilding()) { - this.prepareDrawBatch(camera, state); - this.drawBatch(commandList, state); - } - - it.advance(); - } - } - - protected void prepareDrawBatch(ChunkCameraContext camera, ChunkOneshotGraphicsState state) { - final float modelX = camera.getChunkModelOffset(state.getX(), camera.blockOriginX, camera.originX); - final float modelY = camera.getChunkModelOffset(state.getY(), camera.blockOriginY, camera.originY); - final float modelZ = camera.getChunkModelOffset(state.getZ(), camera.blockOriginZ, camera.originZ); - - GL20.glVertexAttrib4f(ChunkShaderBindingPoints.MODEL_OFFSET.getGenericAttributeIndex(), modelX, modelY, modelZ, 0.0F); - } - - protected void buildBatch(ChunkOneshotGraphicsState state, int visibleFaces) { - GlMultiDrawBatch batch = this.batch; - batch.begin(); - - for (int i = 0; i < ModelQuadFacing.COUNT; i++) { - if ((visibleFaces & (1 << i)) == 0) { - continue; - } - - long part = state.getModelPart(i); - batch.addChunkRender(BufferSlice.unpackStart(part), BufferSlice.unpackLength(part)); - } - } - - protected void drawBatch(CommandList commandList, ChunkOneshotGraphicsState state) { - this.batch.end(); - - if (!batch.isEmpty()) { - try (DrawCommandList drawCommandList = commandList.beginTessellating(state.tessellation)) { - drawCommandList.multiDrawArrays(this.batch.getIndicesBuffer(), this.batch.getLengthBuffer()); - } - } - } - - @Override - public void delete() { - super.delete(); - - this.batch.delete(); - } - - @Override - public Class getGraphicsStateType() { - return ChunkOneshotGraphicsState.class; - } - - @Override - public String getRendererName() { - return "Oneshot"; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/compile/ChunkBufferSorter.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/compile/ChunkBufferSorter.java deleted file mode 100644 index 5cc56c8d8..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/compile/ChunkBufferSorter.java +++ /dev/null @@ -1,173 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.compile; - -import com.google.common.primitives.Floats; -import it.unimi.dsi.fastutil.ints.IntArrays; -import me.jellysquid.mods.sodium.client.model.vertex.type.ChunkVertexType; -import me.jellysquid.mods.sodium.client.render.chunk.format.hfp.HFPModelVertexType; -import me.jellysquid.mods.sodium.client.render.chunk.format.sfp.SFPModelVertexType; -import net.coderbot.iris.sodium.vertex_format.terrain_xhfp.XHFPModelVertexType; - -import java.nio.Buffer; -import java.nio.ByteBuffer; -import java.nio.FloatBuffer; -import java.nio.ShortBuffer; -import java.util.BitSet; - -public class ChunkBufferSorter { - - public static void sortStandardFormat(ChunkVertexType vertexType, ByteBuffer buffer, int bufferLen, float x, float y, float z) { - boolean isCompact; - - if(vertexType.getClass() == HFPModelVertexType.class || vertexType.getClass() == XHFPModelVertexType.class) { - isCompact = true; - } else if(vertexType.getClass() == SFPModelVertexType.class) { - isCompact = false; - } else - return; // ignore unsupported vertex types to avoid corruption - - // Quad stride by Float size - int quadStride = vertexType.getBufferVertexFormat().getStride(); - - int quadStart = ((Buffer)buffer).position(); - int quadCount = bufferLen/quadStride/4; - - float[] distanceArray = new float[quadCount]; - int[] indicesArray = new int[quadCount]; - - if(isCompact) { - ShortBuffer shortBuffer = buffer.asShortBuffer(); - int vertexSizeShort = quadStride / 2; - for (int quadIdx = 0; quadIdx < quadCount; ++quadIdx) { - distanceArray[quadIdx] = getDistanceSqHFP(shortBuffer, x, y, z, vertexSizeShort, quadStart + (quadIdx * quadStride * 2)); - indicesArray[quadIdx] = quadIdx; - } - } else { - FloatBuffer floatBuffer = buffer.asFloatBuffer(); - int vertexSizeInteger = quadStride / 4; - for (int quadIdx = 0; quadIdx < quadCount; ++quadIdx) { - distanceArray[quadIdx] = getDistanceSqSFP(floatBuffer, x, y, z, vertexSizeInteger, quadStart + (quadIdx * quadStride)); - indicesArray[quadIdx] = quadIdx; - } - } - - IntArrays.mergeSort(indicesArray, (a, b) -> Floats.compare(distanceArray[b], distanceArray[a])); - - rearrangeQuads(buffer, indicesArray, quadStride, quadStart); - } - - private static void rearrangeQuads(ByteBuffer quadBuffer, int[] indicesArray, int quadStride, int quadStart) { - FloatBuffer floatBuffer = quadBuffer.asFloatBuffer(); - BitSet bits = new BitSet(); - - FloatBuffer tmp = FloatBuffer.allocate(quadStride); - - for (int l = bits.nextClearBit(0); l < indicesArray.length; l = bits.nextClearBit(l + 1)) { - int m = indicesArray[l]; - - if (m != l) { - sliceQuad(floatBuffer, m, quadStride, quadStart); - ((Buffer)tmp).clear(); - tmp.put(floatBuffer); - - int n = m; - - for (int o = indicesArray[m]; n != l; o = indicesArray[o]) { - sliceQuad(floatBuffer, o, quadStride, quadStart); - FloatBuffer floatBuffer3 = floatBuffer.slice(); - - sliceQuad(floatBuffer, n, quadStride, quadStart); - floatBuffer.put(floatBuffer3); - - bits.set(n); - n = o; - } - - sliceQuad(floatBuffer, l, quadStride, quadStart); - ((Buffer)tmp).flip(); - - floatBuffer.put(tmp); - } - - bits.set(l); - } - } - - private static void sliceQuad(FloatBuffer floatBuffer, int quadIdx, int quadStride, int quadStart) { - int base = quadStart + (quadIdx * quadStride); - - ((Buffer)floatBuffer).limit(base + quadStride); - ((Buffer)floatBuffer).position(base); - } - - private static float getDistanceSqSFP(FloatBuffer buffer, float xCenter, float yCenter, float zCenter, int stride, int start) { - int vertexBase = start; - float x1 = buffer.get(vertexBase); - float y1 = buffer.get(vertexBase + 1); - float z1 = buffer.get(vertexBase + 2); - - //System.out.println("camera: " + xCenter + "," + yCenter + "," + zCenter); - //System.out.println("buffer1: " + x1 + "," + y1 + "," + z1); - - vertexBase += stride; - float x2 = buffer.get(vertexBase); - float y2 = buffer.get(vertexBase + 1); - float z2 = buffer.get(vertexBase + 2); - //System.out.println("buffer2: " + x2 + "," + y2 + "," + z2); - - vertexBase += stride; - float x3 = buffer.get(vertexBase); - float y3 = buffer.get(vertexBase + 1); - float z3 = buffer.get(vertexBase + 2); - //System.out.println("buffer3: " + x3 + "," + y3 + "," + z3); - - vertexBase += stride; - float x4 = buffer.get(vertexBase); - float y4 = buffer.get(vertexBase + 1); - float z4 = buffer.get(vertexBase + 2); - //System.out.println("buffer4: " + x4 + "," + y4 + "," + z4); - - float xDist = ((x1 + x2 + x3 + x4) * 0.25F) - xCenter; - float yDist = ((y1 + y2 + y3 + y4) * 0.25F) - yCenter; - float zDist = ((z1 + z2 + z3 + z4) * 0.25F) - zCenter; - - return (xDist * xDist) + (yDist * yDist) + (zDist * zDist); - } - - private static float normalizeShort(short s) { - return (float)Short.toUnsignedInt(s) / 2048.0f; - } - - private static float getDistanceSqHFP(ShortBuffer buffer, float xCenter, float yCenter, float zCenter, int stride, int start) { - int vertexBase = start; - float x1 = normalizeShort(buffer.get(vertexBase)); - float y1 = normalizeShort(buffer.get(vertexBase + 1)); - float z1 = normalizeShort(buffer.get(vertexBase + 2)); - - //System.out.println("camera: " + xCenter + "," + yCenter + "," + zCenter); - //System.out.println("buffer1: " + x1 + "," + y1 + "," + z1); - - vertexBase += stride; - float x2 = normalizeShort(buffer.get(vertexBase)); - float y2 = normalizeShort(buffer.get(vertexBase + 1)); - float z2 = normalizeShort(buffer.get(vertexBase + 2)); - //System.out.println("buffer2: " + x2 + "," + y2 + "," + z2); - - vertexBase += stride; - float x3 = normalizeShort(buffer.get(vertexBase)); - float y3 = normalizeShort(buffer.get(vertexBase + 1)); - float z3 = normalizeShort(buffer.get(vertexBase + 2)); - //System.out.println("buffer3: " + x3 + "," + y3 + "," + z3); - - vertexBase += stride; - float x4 = normalizeShort(buffer.get(vertexBase)); - float y4 = normalizeShort(buffer.get(vertexBase + 1)); - float z4 = normalizeShort(buffer.get(vertexBase + 2)); - //System.out.println("buffer4: " + x4 + "," + y4 + "," + z4); - - float xDist = ((x1 + x2 + x3 + x4) * 0.25F) - xCenter; - float yDist = ((y1 + y2 + y3 + y4) * 0.25F) - yCenter; - float zDist = ((z1 + z2 + z3 + z4) * 0.25F) - zCenter; - - return (xDist * xDist) + (yDist * yDist) + (zDist * zDist); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/compile/ChunkBuildBuffers.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/compile/ChunkBuildBuffers.java deleted file mode 100644 index 52885936d..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/compile/ChunkBuildBuffers.java +++ /dev/null @@ -1,172 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.compile; - -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing; -import it.unimi.dsi.fastutil.objects.Object2IntMap; -import net.coderbot.iris.Iris; -import java.nio.ByteBuffer; -import java.util.Map; -import lombok.Getter; -import me.jellysquid.mods.sodium.client.SodiumClientMod; -import me.jellysquid.mods.sodium.client.gl.buffer.VertexData; -import me.jellysquid.mods.sodium.client.gl.util.BufferSlice; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferBuilder; -import me.jellysquid.mods.sodium.client.model.vertex.type.ChunkVertexType; -import me.jellysquid.mods.sodium.client.render.chunk.compile.buffers.BakedChunkModelBuffers; -import me.jellysquid.mods.sodium.client.render.chunk.compile.buffers.ChunkModelBuffers; -import me.jellysquid.mods.sodium.client.render.chunk.compile.buffers.ChunkModelVertexTransformer; -import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkMeshData; -import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkRenderData; -import me.jellysquid.mods.sodium.client.render.chunk.format.ChunkModelOffset; -import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexSink; -import me.jellysquid.mods.sodium.client.render.chunk.passes.BlockRenderPass; -import net.coderbot.iris.block_rendering.BlockRenderingSettings; -import net.coderbot.iris.sodium.block_context.BlockContextHolder; -import net.coderbot.iris.sodium.block_context.ChunkBuildBuffersExt; -import net.coderbot.iris.sodium.block_context.ContextAwareVertexWriter; -import net.minecraft.block.Block; -import org.lwjgl.BufferUtils; - -/** - * A collection of temporary buffers for each worker thread which will be used to build chunk meshes for given render - * passes. This makes a best-effort attempt to pick a suitable size for each scratch buffer, but will never try to - * shrink a buffer. - */ -public class ChunkBuildBuffers implements ChunkBuildBuffersExt { - private final ChunkModelBuffers[] delegates; - private final VertexBufferBuilder[][] buffersByLayer; - @Getter - private final ChunkVertexType vertexType; - - private final ChunkModelOffset offset; - - private BlockContextHolder iris$contextHolder; - - public ChunkBuildBuffers(ChunkVertexType vertexType) { - this.vertexType = vertexType; - - this.delegates = new ChunkModelBuffers[BlockRenderPass.COUNT]; - this.buffersByLayer = new VertexBufferBuilder[BlockRenderPass.COUNT][ModelQuadFacing.COUNT]; - - this.offset = new ChunkModelOffset(); - - for (BlockRenderPass pass : BlockRenderPass.VALUES) { - final int passId = pass.ordinal(); - - final VertexBufferBuilder[] buffers = this.buffersByLayer[passId]; - - for (ModelQuadFacing facing : ModelQuadFacing.VALUES) { - buffers[facing.ordinal()] = new VertexBufferBuilder(vertexType.getBufferVertexFormat(), pass.bufferSize() / ModelQuadFacing.COUNT); - } - } - - if(Iris.enabled) { - final Object2IntMap blockMatches = BlockRenderingSettings.INSTANCE.getBlockMatches(); - - if (blockMatches != null) { - this.iris$contextHolder = new BlockContextHolder(blockMatches); - } else { - this.iris$contextHolder = new BlockContextHolder(); - } - } - } - - public void init(ChunkRenderData.Builder renderData) { - for (int i = 0; i < this.buffersByLayer.length; i++) { - ChunkModelVertexTransformer[] writers = new ChunkModelVertexTransformer[ModelQuadFacing.COUNT]; - - for (ModelQuadFacing facing : ModelQuadFacing.VALUES) { - final ModelVertexSink sink = this.vertexType.createBufferWriter(this.buffersByLayer[i][facing.ordinal()], SodiumClientMod.isDirectMemoryAccessEnabled()); - if (Iris.enabled && sink instanceof ContextAwareVertexWriter) { - ((ContextAwareVertexWriter) sink).iris$setContextHolder(iris$contextHolder); - } - writers[facing.ordinal()] = new ChunkModelVertexTransformer(sink, this.offset); - } - - this.delegates[i] = new BakedChunkModelBuffers(writers, renderData); - } - } - - /** - * Return the {@link ChunkModelVertexTransformer} for the given {@link BlockRenderPass} as mapped by the - * {@link BlockRenderPassManager} for this render context. - */ - public ChunkModelBuffers get(BlockRenderPass pass) { - return this.delegates[pass.ordinal()]; - } - - /** - * Creates immutable baked chunk meshes from all non-empty scratch buffers and resets the state of all mesh - * builders. This is used after all blocks have been rendered to pass the finished meshes over to the graphics card. - */ - public ChunkMeshData createMesh(BlockRenderPass pass, float x, float y, float z, boolean sortTranslucent) { - VertexBufferBuilder[] builders = this.buffersByLayer[pass.ordinal()]; - - ChunkMeshData meshData = null; - int bufferLen = 0; - - for (int facingId = 0; facingId < builders.length; facingId++) { - VertexBufferBuilder builder = builders[facingId]; - - if (builder == null || builder.isEmpty()) { - continue; - } - - int start = bufferLen; - int size = builder.getSize(); - - if(meshData == null) { - meshData = new ChunkMeshData(); - } - - meshData.setModelSlice(ModelQuadFacing.VALUES[facingId], new BufferSlice(start, size)); - - bufferLen += size; - } - - if (bufferLen <= 0) { - return null; - } - - ByteBuffer buffer = BufferUtils.createByteBuffer(bufferLen); - - for (Map.Entry entry : meshData.getSlices()) { - BufferSlice slice = entry.getValue(); - buffer.position(slice.start); - - VertexBufferBuilder builder = this.buffersByLayer[pass.ordinal()][entry.getKey().ordinal()]; - builder.copyInto(buffer); - } - - buffer.flip(); - - if (sortTranslucent && pass.isTranslucent()) { - ChunkBufferSorter.sortStandardFormat(vertexType, buffer, bufferLen, x, y, z); - meshData.clearSlices(); - meshData.setModelSlice(ModelQuadFacing.UNASSIGNED, new BufferSlice(0, bufferLen)); - } - - meshData.setVertexData(new VertexData(buffer, this.vertexType.getCustomVertexFormat())); - - return meshData; - } - - public void setRenderOffset(int x, int y, int z) { - this.offset.set(x, y, z); - } - - // Iris Compat - public void iris$setLocalPos(int localPosX, int localPosY, int localPosZ) { - if(!Iris.enabled) return; - this.iris$contextHolder.setLocalPos(localPosX, localPosY, localPosZ); - } - - public void iris$setMaterialId(Block block, short renderType) { - if(!Iris.enabled) return; - this.iris$contextHolder.set(block, renderType); - } - - public void iris$resetBlockContext() { - if(!Iris.enabled) return; - this.iris$contextHolder.reset(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/compile/ChunkBuildResult.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/compile/ChunkBuildResult.java deleted file mode 100644 index bdccb56d0..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/compile/ChunkBuildResult.java +++ /dev/null @@ -1,23 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.compile; - -import me.jellysquid.mods.sodium.client.render.chunk.ChunkGraphicsState; -import me.jellysquid.mods.sodium.client.render.chunk.ChunkRenderContainer; -import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkRenderData; -import me.jellysquid.mods.sodium.client.render.chunk.passes.BlockRenderPass; - -/** - * The result of a chunk rebuild task which contains any and all data that needs to be processed or uploaded on - * the main thread. If a task is cancelled after finishing its work and not before the result is processed, the result - * will instead be discarded. - */ -public class ChunkBuildResult { - public final ChunkRenderContainer render; - public final ChunkRenderData data; - public BlockRenderPass[] passesToUpload; - - public ChunkBuildResult(ChunkRenderContainer render, ChunkRenderData data) { - this.render = render; - this.data = data; - this.passesToUpload = BlockRenderPass.VALUES; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/compile/ChunkBuilder.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/compile/ChunkBuilder.java deleted file mode 100644 index 958cdbdaf..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/compile/ChunkBuilder.java +++ /dev/null @@ -1,533 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.compile; - -import com.gtnewhorizons.angelica.glsm.GLStateManager; -import com.gtnewhorizons.angelica.rendering.AngelicaRenderQueue; -import it.unimi.dsi.fastutil.objects.Reference2ReferenceLinkedOpenHashMap; -import me.jellysquid.mods.sodium.client.SodiumClientMod; -import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; -import me.jellysquid.mods.sodium.client.model.vertex.type.ChunkVertexType; -import me.jellysquid.mods.sodium.client.render.chunk.ChunkGraphicsState; -import me.jellysquid.mods.sodium.client.render.chunk.ChunkRenderBackend; -import me.jellysquid.mods.sodium.client.render.chunk.ChunkRenderContainer; -import me.jellysquid.mods.sodium.client.render.chunk.tasks.ChunkRenderBuildTask; -import me.jellysquid.mods.sodium.client.render.chunk.tasks.ChunkRenderRebuildTask; -import me.jellysquid.mods.sodium.client.render.chunk.tasks.ChunkRenderTranslucencySortTask; -import me.jellysquid.mods.sodium.client.render.pipeline.context.ChunkRenderCacheLocal; -import me.jellysquid.mods.sodium.client.util.task.CancellationSource; -import me.jellysquid.mods.sodium.client.world.WorldSlice; -import me.jellysquid.mods.sodium.client.world.cloned.ChunkRenderContext; -import me.jellysquid.mods.sodium.client.world.cloned.ClonedChunkSectionCache; -import me.jellysquid.mods.sodium.common.util.collections.DequeDrain; -import net.minecraft.client.Minecraft; -import net.minecraft.client.multiplayer.WorldClient; -import net.minecraft.util.MathHelper; -import net.minecraft.util.ReportedException; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; -import org.joml.Vector3d; -import org.jetbrains.annotations.Nullable; - -import java.util.ArrayList; -import java.util.Deque; -import java.util.Iterator; -import java.util.List; -import java.util.concurrent.CancellationException; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.ConcurrentLinkedDeque; -import java.util.concurrent.atomic.AtomicBoolean; -import java.util.concurrent.locks.LockSupport; - -public class ChunkBuilder { - /** - * The maximum number of jobs that can be queued for a given worker thread. - */ - private static final int TASK_QUEUE_LIMIT_PER_WORKER = 2; - - private static final Logger LOGGER = LogManager.getLogger("ChunkBuilder"); - - private final Deque> buildQueue = new ConcurrentLinkedDeque<>(); - // special queue for tasks that will block until the main thread finalizes them - private final Deque> buildQueueKnownBlocking = new ConcurrentLinkedDeque<>(); - private final Deque> uploadQueue = new ConcurrentLinkedDeque<>(); - private final Deque failureQueue = new ConcurrentLinkedDeque<>(); - - private final Object jobNotifier = new Object(); - private final Object jobNotifierKnownBlocking = new Object(); - - private final AtomicBoolean running = new AtomicBoolean(false); - private final List threads = new ArrayList<>(); - - private ClonedChunkSectionCache sectionCache; - - private WorldClient world; - private Vector3d cameraPosition = new Vector3d(); - - private final int limitThreads; - private final int limitThreadsBlocking; - private final ChunkVertexType vertexType; - private final ChunkRenderBackend backend; - - public ChunkBuilder(ChunkVertexType vertexType, ChunkRenderBackend backend) { - this.vertexType = vertexType; - this.backend = backend; - this.limitThreads = getThreadCount(); - this.limitThreadsBlocking = this.limitThreads; - } - - /** - * Returns the remaining number of build tasks which should be scheduled this frame. If an attempt is made to - * spawn more tasks than the budget allows, it will block until resources become available. - */ - public int getSchedulingBudget() { - return Math.max(0, (this.limitThreads * TASK_QUEUE_LIMIT_PER_WORKER) - this.buildQueue.size() - this.buildQueueKnownBlocking.size()); - } - - /** - * Spawns a number of work-stealing threads to process results in the build queue. If the builder is already - * running, this method does nothing and exits. - */ - public void startWorkers() { - if (this.running.getAndSet(true)) { - return; - } - - if (!this.threads.isEmpty()) { - throw new IllegalStateException("Threads are still alive while in the STOPPED state"); - } - - Minecraft client = Minecraft.getMinecraft(); - - for (int i = 0; i < this.limitThreads; i++) { - ChunkBuildBuffers buffers = new ChunkBuildBuffers(this.vertexType); - ChunkRenderCacheLocal pipeline = new ChunkRenderCacheLocal(client, this.world); - - WorkerRunnable worker = new WorkerRunnable(i, buffers, pipeline, this.world, false); - - Thread thread = new Thread(worker, "Chunk Render Task Executor #" + i); - thread.setPriority(Math.max(0, Thread.NORM_PRIORITY - 2)); - thread.start(); - - this.threads.add(thread); - } - - for (int i = 0; i < this.limitThreadsBlocking; i++) { - ChunkBuildBuffers buffers = new ChunkBuildBuffers(this.vertexType); - ChunkRenderCacheLocal pipeline = new ChunkRenderCacheLocal(client, this.world); - - WorkerRunnable worker = new WorkerRunnable(this.limitThreads + i, buffers, pipeline, this.world, true); - - Thread thread = new Thread(worker, "Chunk Render Blocking Task Executor #" + i); - thread.setPriority(Math.max(0, Thread.NORM_PRIORITY - 2)); - thread.start(); - - this.threads.add(thread); - } - - LOGGER.info("Started {} worker threads", this.threads.size()); - } - - private boolean workersAlive() { - for (Thread thread : this.threads) { - if (thread.isAlive()) { - return true; - } - } - return false; - } - - /** - * Notifies all worker threads to stop and blocks until all workers terminate. After the workers have been shut - * down, all tasks are cancelled and the pending queues are cleared. If the builder is already stopped, this - * method does nothing and exits. - */ - public void stopWorkers() { - if (!this.running.getAndSet(false)) { - return; - } - - if (this.threads.isEmpty()) { - throw new IllegalStateException("No threads are alive but the executor is in the RUNNING state"); - } - - LOGGER.info("Stopping worker threads"); - - // Notify all worker threads to wake up, where they will then terminate - synchronized (this.jobNotifier) { - this.jobNotifier.notifyAll(); - } - synchronized (this.jobNotifierKnownBlocking) { - this.jobNotifierKnownBlocking.notifyAll(); - } - - // Keep processing the main thread tasks so the workers don't block forever - AngelicaRenderQueue.managedBlock(() -> !workersAlive()); - - // Ensure every remaining thread has terminated - for (Thread thread : this.threads) { - try { - thread.join(); - } catch (InterruptedException ignored) { - } - } - - this.threads.clear(); - - // Drop any pending work queues and cancel futures - this.uploadQueue.clear(); - this.failureQueue.clear(); - - for (WrappedTask job : this.buildQueue) { - job.future.cancel(true); - } - - for (WrappedTask job : this.buildQueueKnownBlocking) { - job.future.cancel(true); - } - - this.buildQueue.clear(); - this.buildQueueKnownBlocking.clear(); - - this.world = null; - this.sectionCache = null; - } - - public void cleanupSectionCache() { - this.sectionCache.cleanup(); - } - - /** - * Prevent sort updates from taking priority over rebuild updates in the upload queue. - */ - public Iterator> filterChunkBuilds(Iterator> uploadIterator) { - Reference2ReferenceLinkedOpenHashMap, ChunkBuildResult> map = new Reference2ReferenceLinkedOpenHashMap<>(); - - while (uploadIterator.hasNext()) { - ChunkBuildResult result = uploadIterator.next(); - ChunkRenderContainer section = result.render; - - ChunkBuildResult oldResult = map.get(section); - - // Allow a result to replace the previous result in the map if one of the following conditions hold: - // * There is no previous upload in the queue - // * The new upload replaces more render types than the old one (in practice, is a rebuild while the other is a sort) - if(oldResult == null || result.passesToUpload.length >= oldResult.passesToUpload.length) { - map.put(section, result); - } - } - - return map.values().iterator(); - } - - /** - * Processes all pending build task uploads using the chunk render backend. - */ - // TODO: Limit the amount of time this can take per frame - public boolean performPendingUploads() { - if (this.uploadQueue.isEmpty()) { - return false; - } - - this.backend.upload(RenderDevice.INSTANCE.createCommandList(), filterChunkBuilds(new DequeDrain<>(this.uploadQueue))); - - return true; - } - - public void handleFailures() { - Iterator errorIterator = new DequeDrain<>(this.failureQueue); - - if (errorIterator.hasNext()) { - // If there is any exception from the build failure queue, throw it - Throwable ex = errorIterator.next(); - - if (ex instanceof ReportedException) { - // Propagate ReportedExceptions directly to provide extra information - throw (ReportedException)ex; - } else { - throw new RuntimeException("Chunk build failed", ex); - } - } - } - - public CompletableFuture> schedule(ChunkRenderBuildTask task) { - if (!this.running.get()) { - throw new IllegalStateException("Executor is stopped"); - } - - WrappedTask job = new WrappedTask<>(task); - - this.buildQueue.add(job); - - synchronized (this.jobNotifier) { - this.jobNotifier.notify(); - } - - return job.future; - } - - /** - * Sets the current camera position of the player used for task prioritization. - */ - public void setCameraPosition(double x, double y, double z) { - this.cameraPosition = new Vector3d(x, y, z); - } - - /** - * Returns the current camera position of the player used for task prioritization. - */ - public Vector3d getCameraPosition() { - return this.cameraPosition; - } - - /** - * @return True if the build queue is empty - */ - public boolean isBuildQueueEmpty() { - return this.buildQueue.isEmpty() && this.buildQueueKnownBlocking.isEmpty(); - } - - /** - * Initializes this chunk builder for the given world. If the builder is already running (which can happen during - * a world teleportation event), the worker threads will first be stopped and all pending tasks will be discarded - * before being started again. - * @param world The world instance - */ - public void init(WorldClient world) { - if (world == null) { - throw new NullPointerException("World is null"); - } - - this.stopWorkers(); - - this.world = world; - this.sectionCache = new ClonedChunkSectionCache(this.world); - - this.startWorkers(); - } - - /** - * Returns the "optimal" number of threads to be used for chunk build tasks. This is always at least one thread, - * but can be up to the number of available processor threads on the system. - */ - private static int getOptimalThreadCount() { - return MathHelper.clamp_int(Math.max(getMaxThreadCount() / 3, getMaxThreadCount() - 6), 1, 10); - } - - private static int getThreadCount() { - int requested = SodiumClientMod.options().performance.chunkBuilderThreads; - return requested == 0 ? getOptimalThreadCount() : Math.min(requested, getMaxThreadCount()); - } - - private static int getMaxThreadCount() { - return Runtime.getRuntime().availableProcessors(); - } - - /** - * Add a completion handler to the given future task so that the result will be processed on the main thread. - */ - public void handleCompletion(CompletableFuture> future) { - future.whenComplete((res, ex) -> { - if (ex != null) { - this.failureQueue.add(ex); - } else if (res != null) { - this.enqueueUpload(res); - } - }); - } - - /** - * Creates a rebuild task and defers it to the work queue. When the task is completed, it will be moved onto the - * completed uploads queued which will then be drained during the next available synchronization point with the - * main thread. - * @param render The render to rebuild - */ - public void deferSort(ChunkRenderContainer render) { - handleCompletion(this.scheduleSortTaskAsync(render)); - } - - - /** - * Enqueues the build task result to the pending result queue to be later processed during the next available - * synchronization point on the main thread. - * @param result The build task's result - */ - public void enqueueUpload(ChunkBuildResult result) { - this.uploadQueue.add(result); - } - - /** - * Schedules the rebuild task asynchronously on the worker pool, returning a future wrapping the task. - * @param render The render to rebuild - * @return a future representing the rebuild task, or null if the chunk section is empty - */ - @Nullable - public CompletableFuture> scheduleRebuildTaskAsync(ChunkRenderContainer render) { - ChunkRenderBuildTask task = this.createRebuildTask(render); - - if(task != null) { - return this.schedule(task); - } else { - return null; - } - } - - /** - * Schedules the rebuild task asynchronously on the worker pool, returning a future wrapping the task. - * @param render The render to rebuild - */ - public CompletableFuture> scheduleSortTaskAsync(ChunkRenderContainer render) { - return this.schedule(this.createSortTask(render)); - } - - /** - * Creates a task to rebuild the geometry of a {@link ChunkRenderContainer}. - * @param render The render to rebuild - */ - private ChunkRenderBuildTask createRebuildTask(ChunkRenderContainer render) { - render.cancelRebuildTask(); - - ChunkRenderContext context = WorldSlice.prepare(this.world, render.getChunkPos(), this.sectionCache); - - if (context == null) { - return null; - } else { - return new ChunkRenderRebuildTask<>(render, context, render.getRenderOrigin()).withCameraPosition(this.cameraPosition); - } - } - - private ChunkRenderBuildTask createSortTask(ChunkRenderContainer render) { - render.cancelRebuildTask(); - - return new ChunkRenderTranslucencySortTask<>(render, render.getRenderOrigin(), this.cameraPosition); - } - - public void onChunkDataChanged(int x, int y, int z) { - this.sectionCache.invalidate(x, y, z); - } - - private class WorkerRunnable implements Runnable { - private final AtomicBoolean running = ChunkBuilder.this.running; - - // The re-useable build buffers used by this worker for building chunk meshes - private final ChunkBuildBuffers bufferCache; - - // Making this thread-local provides a small boost to performance by avoiding the overhead in synchronizing - // caches between different CPU cores - private final ChunkRenderCacheLocal cache; - - private final WorldClient world; - - private final int i; - - private final boolean allowBlocking; - - public WorkerRunnable(int i, ChunkBuildBuffers bufferCache, ChunkRenderCacheLocal cache, WorldClient world, boolean allowBlocking) { - this.i = i; - this.bufferCache = bufferCache; - this.cache = cache; - this.world = world; - this.allowBlocking = allowBlocking; - } - - @Override - public void run() { - // Run until the chunk builder shuts down - while (this.running.get()) { - WrappedTask job = this.getNextJob(); - - // If the job is null or no longer valid, keep searching for a task - if (job == null || job.isCancelled()) { - continue; - } - - // Relegate tasks that can block for an extended period of time to a separate threadpool. - if (!this.allowBlocking && job.task.willRenderInMainThread(this.cache)) { - ChunkBuilder.this.buildQueueKnownBlocking.add(job); - synchronized (ChunkBuilder.this.jobNotifierKnownBlocking) { - ChunkBuilder.this.jobNotifierKnownBlocking.notify(); - } - continue; - } - - ChunkBuildResult result; - - try { - // Perform the build task with this worker's local resources and obtain the result - result = job.task.performBuild(this.cache, this.bufferCache, job); - } catch (Exception e) { - // Propagate any exception from chunk building - job.future.completeExceptionally(e); - continue; - } finally { - job.task.releaseResources(); - } - - // The result can be null if the task is cancelled - if (result != null) { - // Notify the future that the result is now available - job.future.complete(result); - // Unpark the main thread so it wakes up if it was blocking on the future having completed - LockSupport.unpark(GLStateManager.getMainThread()); - } else if (!job.isCancelled()) { - // If the job wasn't cancelled and no result was produced, we've hit a bug - job.future.completeExceptionally(new RuntimeException("No result was produced by the task " + job.task.getClass() + ": " + job.task)); - } - } - } - - /** - * Returns the next task which this worker can work on or blocks until one becomes available. If no tasks are - * currently available, it will wait on {@link ChunkBuilder#jobNotifier} field until notified. - */ - private WrappedTask getNextJob() { - if (this.allowBlocking) { - WrappedTask job = ChunkBuilder.this.buildQueueKnownBlocking.poll(); - - if (job == null) { - synchronized (ChunkBuilder.this.jobNotifierKnownBlocking) { - try { - ChunkBuilder.this.jobNotifierKnownBlocking.wait(); - } catch (InterruptedException ignored) { - } - } - } - - return job; - } else { - WrappedTask job = ChunkBuilder.this.buildQueue.poll(); - - if (job == null) { - synchronized (ChunkBuilder.this.jobNotifier) { - try { - ChunkBuilder.this.jobNotifier.wait(); - } catch (InterruptedException ignored) { - } - } - } - - return job; - } - } - } - - private static class WrappedTask implements CancellationSource { - private final ChunkRenderBuildTask task; - private final CompletableFuture> future; - - private WrappedTask(ChunkRenderBuildTask task) { - this.task = task; - this.future = new CompletableFuture<>(); - this.future.exceptionally(e -> { - if (!(e instanceof CancellationException)) { - LOGGER.info("Exception thrown while building chunk", e); - } - - return null; - }); - } - - @Override - public boolean isCancelled() { - return this.future.isCancelled(); - } - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/compile/buffers/BakedChunkModelBuffers.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/compile/buffers/BakedChunkModelBuffers.java deleted file mode 100644 index 52a236105..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/compile/buffers/BakedChunkModelBuffers.java +++ /dev/null @@ -1,25 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.compile.buffers; - -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing; -import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkRenderData; -import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexSink; - -public class BakedChunkModelBuffers implements ChunkModelBuffers { - private final ModelVertexSink[] builders; - private final ChunkRenderData.Builder renderData; - - public BakedChunkModelBuffers(ModelVertexSink[] builders, ChunkRenderData.Builder renderData) { - this.builders = builders; - this.renderData = renderData; - } - - @Override - public ModelVertexSink getSink(ModelQuadFacing facing) { - return this.builders[facing.ordinal()]; - } - - @Override - public ChunkRenderData.Builder getRenderData() { - return this.renderData; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/compile/buffers/ChunkModelBuffers.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/compile/buffers/ChunkModelBuffers.java deleted file mode 100644 index 4c26539ca..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/compile/buffers/ChunkModelBuffers.java +++ /dev/null @@ -1,12 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.compile.buffers; - -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing; -import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkRenderData; -import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexSink; - -public interface ChunkModelBuffers { - ModelVertexSink getSink(ModelQuadFacing facing); - - @Deprecated - ChunkRenderData.Builder getRenderData(); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/compile/buffers/ChunkModelVertexTransformer.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/compile/buffers/ChunkModelVertexTransformer.java deleted file mode 100644 index 8e7948774..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/compile/buffers/ChunkModelVertexTransformer.java +++ /dev/null @@ -1,23 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.compile.buffers; - -import me.jellysquid.mods.sodium.client.model.vertex.transformers.AbstractVertexTransformer; -import me.jellysquid.mods.sodium.client.render.chunk.format.ChunkModelOffset; -import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexSink; - -public class ChunkModelVertexTransformer extends AbstractVertexTransformer implements ModelVertexSink { - /** - * The translation to be applied to all quads written into this mesh builder. - */ - private final ChunkModelOffset offset; - - public ChunkModelVertexTransformer(ModelVertexSink delegate, ChunkModelOffset offset) { - super(delegate); - - this.offset = offset; - } - - @Override - public void writeQuad(float x, float y, float z, int color, float u, float v, int light, int shaderBlockId) { - this.delegate.writeQuad(x + this.offset.x, y + this.offset.y, z + this.offset.z, color, u, v, light, shaderBlockId); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/compile/buffers/FallbackChunkModelBuffers.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/compile/buffers/FallbackChunkModelBuffers.java deleted file mode 100644 index 80a3d70f0..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/compile/buffers/FallbackChunkModelBuffers.java +++ /dev/null @@ -1,21 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.compile.buffers; - -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing; -import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkRenderData; -import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexSink; - -public class FallbackChunkModelBuffers implements ChunkModelBuffers { - public FallbackChunkModelBuffers() { - - } - - @Override - public ModelVertexSink getSink(ModelQuadFacing facing) { - return null; - } - - @Override - public ChunkRenderData.Builder getRenderData() { - return null; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/cull/ChunkCuller.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/cull/ChunkCuller.java deleted file mode 100644 index c718516f4..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/cull/ChunkCuller.java +++ /dev/null @@ -1,17 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.cull; - -import com.gtnewhorizons.angelica.compat.mojang.Camera; -import com.gtnewhorizons.angelica.compat.mojang.ChunkOcclusionData; -import it.unimi.dsi.fastutil.ints.IntArrayList; -import me.jellysquid.mods.sodium.client.util.math.FrustumExtended; - - -public interface ChunkCuller { - IntArrayList computeVisible(Camera camera, FrustumExtended frustum, int frame, boolean spectator); - - void onSectionStateChanged(int x, int y, int z, ChunkOcclusionData occlusionData); - void onSectionLoaded(int x, int y, int z, int id); - void onSectionUnloaded(int x, int y, int z); - - boolean isSectionVisible(int x, int y, int z); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/cull/ChunkFaceFlags.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/cull/ChunkFaceFlags.java deleted file mode 100644 index a7675e191..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/cull/ChunkFaceFlags.java +++ /dev/null @@ -1,29 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.cull; - -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing; - -public class ChunkFaceFlags { - public static final int UP = of(ModelQuadFacing.POS_Y); - public static final int DOWN = of(ModelQuadFacing.NEG_Y); - public static final int WEST = of(ModelQuadFacing.NEG_X); - public static final int EAST = of(ModelQuadFacing.POS_X); - public static final int NORTH = of(ModelQuadFacing.NEG_Z); - public static final int SOUTH = of(ModelQuadFacing.POS_Z); - public static final int UNASSIGNED = of(ModelQuadFacing.UNASSIGNED); - - public static final int ALL = all(); - - public static int of(ModelQuadFacing facing) { - return 1 << facing.ordinal(); - } - - private static int all() { - int v = 0; - - for (ModelQuadFacing facing : ModelQuadFacing.VALUES) { - v |= of(facing); - } - - return v; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/cull/graph/ChunkGraphCuller.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/cull/graph/ChunkGraphCuller.java deleted file mode 100644 index ee71255e7..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/cull/graph/ChunkGraphCuller.java +++ /dev/null @@ -1,220 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.cull.graph; - -import com.gtnewhorizon.gtnhlib.blockpos.BlockPos; -import com.gtnewhorizons.angelica.compat.mojang.Camera; -import com.gtnewhorizons.angelica.compat.mojang.ChunkOcclusionData; -import com.gtnewhorizons.angelica.compat.mojang.ChunkSectionPos; -import it.unimi.dsi.fastutil.ints.IntArrayList; -import it.unimi.dsi.fastutil.longs.Long2ObjectMap; -import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap; -import me.jellysquid.mods.sodium.client.render.chunk.cull.ChunkCuller; -import me.jellysquid.mods.sodium.client.util.math.FrustumExtended; -import net.minecraft.block.Block; -import net.minecraft.util.MathHelper; -import net.minecraft.world.World; -import net.minecraftforge.common.util.ForgeDirection; - -import java.util.ArrayList; -import java.util.Comparator; -import java.util.List; - -public class ChunkGraphCuller implements ChunkCuller { - private final Long2ObjectMap nodes = new Long2ObjectOpenHashMap<>(); - - private final ChunkGraphIterationQueue visible = new ChunkGraphIterationQueue(); - private final World world; - private final int renderDistance; - - private FrustumExtended frustum; - private boolean useOcclusionCulling; - - private int activeFrame = 0; - private int centerChunkX, centerChunkZ; - - public ChunkGraphCuller(World world, int renderDistance) { - this.world = world; - this.renderDistance = renderDistance; - } - - @Override - public IntArrayList computeVisible(Camera camera, FrustumExtended frustum, int frame, boolean spectator) { - this.initSearch(camera, frustum, frame, spectator); - - ChunkGraphIterationQueue queue = this.visible; - - for (int i = 0; i < queue.size(); i++) { - ChunkGraphNode node = queue.getNode(i); - short cullData = node.computeQueuePop(); - - for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) { - if (useOcclusionCulling && (cullData & (1 << dir.ordinal())) == 0) { - continue; - } - - ChunkGraphNode adj = node.getConnectedNode(dir); - - if (adj != null && this.isWithinRenderDistance(adj)) { - this.bfsEnqueue(node, adj, dir.getOpposite(), cullData); - } - } - } - - return this.visible.getOrderedIdList(); - } - - private boolean isWithinRenderDistance(ChunkGraphNode adj) { - int x = Math.abs(adj.getChunkX() - this.centerChunkX); - int z = Math.abs(adj.getChunkZ() - this.centerChunkZ); - - return x <= this.renderDistance && z <= this.renderDistance; - } - - private void initSearch(Camera camera, FrustumExtended frustum, int frame, boolean spectator) { - this.activeFrame = frame; - this.frustum = frustum; - this.useOcclusionCulling = true; - - this.visible.clear(); - - final BlockPos origin = camera.getBlockPos(); - - final int chunkX = origin.getX() >> 4; - int chunkY = origin.getY() >> 4; - final int chunkZ = origin.getZ() >> 4; - - this.centerChunkX = chunkX; - this.centerChunkZ = chunkZ; - - final ChunkGraphNode rootNode = this.getNode(chunkX, chunkY, chunkZ); - - if (rootNode != null) { - rootNode.resetCullingState(); - rootNode.setLastVisibleFrame(frame); - - if (spectator) { - final Block block = this.world.getBlock(origin.getX(), origin.getY(), origin.getZ()); - if(block.isOpaqueCube()) { - this.useOcclusionCulling = false; - } - } - - this.visible.add(rootNode); - } else { - chunkY = MathHelper.clamp_int(origin.getY() >> 4, 0, 15); - - final List bestNodes = new ArrayList<>(); - - for (int x2 = -this.renderDistance; x2 <= this.renderDistance; ++x2) { - for (int z2 = -this.renderDistance; z2 <= this.renderDistance; ++z2) { - final ChunkGraphNode node = this.getNode(chunkX + x2, chunkY, chunkZ + z2); - - if (node == null || node.isCulledByFrustum(frustum)) { - continue; - } - - node.resetCullingState(); - node.setLastVisibleFrame(frame); - - bestNodes.add(node); - } - } - - bestNodes.sort(Comparator.comparingDouble(node -> node.getSquaredDistance(origin))); - - for (ChunkGraphNode node : bestNodes) { - this.visible.add(node); - } - } - } - - - private void bfsEnqueue(ChunkGraphNode parent, ChunkGraphNode node, ForgeDirection flow, short parentalData) { - if (node.getLastVisibleFrame() == this.activeFrame) { - node.updateCullingState(flow, parentalData); - return; - } - node.setLastVisibleFrame(this.activeFrame); - - if (node.isCulledByFrustum(this.frustum)) { - return; - } - - node.setCullingState(parentalData); - node.updateCullingState(flow, parentalData); - - this.visible.add(node); - } - - private void connectNeighborNodes(ChunkGraphNode node) { - for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) { - final ChunkGraphNode adj = this.findAdjacentNode(node, dir); - - if (adj != null) { - adj.setAdjacentNode(dir.getOpposite(), node); - } - - node.setAdjacentNode(dir, adj); - } - } - - private void disconnectNeighborNodes(ChunkGraphNode node) { - for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) { - final ChunkGraphNode adj = node.getConnectedNode(dir); - - if (adj != null) { - adj.setAdjacentNode(dir.getOpposite(), null); - } - - node.setAdjacentNode(dir, null); - } - } - - private ChunkGraphNode findAdjacentNode(ChunkGraphNode node, ForgeDirection dir) { - return this.getNode(node.getChunkX() + dir.offsetX, node.getChunkY() + dir.offsetY, node.getChunkZ() + dir.offsetZ); - } - - private ChunkGraphNode getNode(int x, int y, int z) { - return this.nodes.get(ChunkSectionPos.asLong(x, y, z)); - } - - @Override - public void onSectionStateChanged(int x, int y, int z, ChunkOcclusionData occlusionData) { - ChunkGraphNode node = this.getNode(x, y, z); - - if (node != null) { - node.setOcclusionData(occlusionData); - } - } - - @Override - public void onSectionLoaded(int x, int y, int z, int id) { - final ChunkGraphNode node = new ChunkGraphNode(x, y, z, id); - final ChunkGraphNode prev; - - if ((prev = this.nodes.put(ChunkSectionPos.asLong(x, y, z), node)) != null) { - this.disconnectNeighborNodes(prev); - } - - this.connectNeighborNodes(node); - } - - @Override - public void onSectionUnloaded(int x, int y, int z) { - final ChunkGraphNode node = this.nodes.remove(ChunkSectionPos.asLong(x, y, z)); - - if (node != null) { - this.disconnectNeighborNodes(node); - } - } - - @Override - public boolean isSectionVisible(int x, int y, int z) { - final ChunkGraphNode render = this.getNode(x, y, z); - - if (render == null) { - return false; - } - - return render.getLastVisibleFrame() == this.activeFrame; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/cull/graph/ChunkGraphIterationQueue.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/cull/graph/ChunkGraphIterationQueue.java deleted file mode 100644 index 981464e11..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/cull/graph/ChunkGraphIterationQueue.java +++ /dev/null @@ -1,58 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.cull.graph; - -import it.unimi.dsi.fastutil.ints.IntArrayList; - -import java.util.Arrays; - -public class ChunkGraphIterationQueue { - private int[] positions; - private ChunkGraphNode[] nodes; - - private int pos; - private int capacity; - - public ChunkGraphIterationQueue() { - this(4096); - } - - public ChunkGraphIterationQueue(int capacity) { - this.positions = new int[capacity]; - this.nodes = new ChunkGraphNode[capacity]; - - this.capacity = capacity; - } - - public void add(ChunkGraphNode node) { - int i = this.pos++; - - if (i == this.capacity) { - this.resize(); - } - - this.positions[i] = node.getId(); - this.nodes[i] = node; - } - - private void resize() { - this.capacity *= 2; - - this.positions = Arrays.copyOf(this.positions, this.capacity); - this.nodes = Arrays.copyOf(this.nodes, this.capacity); - } - - public ChunkGraphNode getNode(int i) { - return this.nodes[i]; - } - - public void clear() { - this.pos = 0; - } - - public int size() { - return this.pos; - } - - public IntArrayList getOrderedIdList() { - return IntArrayList.wrap(this.positions, this.pos); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/cull/graph/ChunkGraphNode.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/cull/graph/ChunkGraphNode.java deleted file mode 100644 index 7a3416ada..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/cull/graph/ChunkGraphNode.java +++ /dev/null @@ -1,183 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.cull.graph; - -import com.gtnewhorizon.gtnhlib.blockpos.BlockPos; -import com.gtnewhorizons.angelica.compat.mojang.ChunkOcclusionData; -import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkRenderData; -import me.jellysquid.mods.sodium.client.util.math.FrustumExtended; -import net.minecraftforge.common.util.ForgeDirection; - -public class ChunkGraphNode { - private static final long DEFAULT_VISIBILITY_DATA = calculateVisibilityData(ChunkRenderData.EMPTY.getOcclusionData()); - private static final float FRUSTUM_EPSILON = 1.0f /* block model margin */ + 0.125f /* epsilon */; - - private final ChunkGraphNode[] nodes = new ChunkGraphNode[ForgeDirection.VALID_DIRECTIONS.length]; - - private final int id; - private final int chunkX, chunkY, chunkZ; - - private int lastVisibleFrame = -1; - - private long visibilityData; - private short cullingState; - - public ChunkGraphNode(int chunkX, int chunkY, int chunkZ, int id) { - this.chunkX = chunkX; - this.chunkY = chunkY; - this.chunkZ = chunkZ; - this.id = id; - - this.visibilityData = DEFAULT_VISIBILITY_DATA; - } - - public ChunkGraphNode getConnectedNode(ForgeDirection dir) { - return this.nodes[dir.ordinal()]; - } - - public void setLastVisibleFrame(int frame) { - this.lastVisibleFrame = frame; - } - - public int getLastVisibleFrame() { - return this.lastVisibleFrame; - } - - public int getChunkX() { - return this.chunkX; - } - - public int getChunkY() { - return this.chunkY; - } - - public int getChunkZ() { - return this.chunkZ; - } - - public void setAdjacentNode(ForgeDirection dir, ChunkGraphNode node) { - this.nodes[dir.ordinal()] = node; - } - - public void setOcclusionData(ChunkOcclusionData occlusionData) { - this.visibilityData = calculateVisibilityData(occlusionData); - } - - private static long calculateVisibilityData(ChunkOcclusionData occlusionData) { - long visibilityData = 0; - - for (ForgeDirection from : ForgeDirection.VALID_DIRECTIONS) { - for (ForgeDirection to : ForgeDirection.VALID_DIRECTIONS) { - if (occlusionData == null || occlusionData.isVisibleThrough(from, to)) { - visibilityData |= (1L << ((from.ordinal() << 3) + to.ordinal())); - } - } - } - - return visibilityData; - } - - //The way this works now is that the culling state contains 2 inner states - // visited directions mask, and visitable direction mask - //On graph start, the root node(s) have the visit and visitable masks set to all visible - // when a chunk section is popped off the queue, the visited direction mask is anded with the - // visitable direction mask to return a bitfield containing what directions the graph can flow too - //When a chunk is visited in the graph the inbound direction is masked off from the visited direction mask - // and the visitable direction mask is updated (ored) with the visibilityData of the inbound direction - //When a chunk hasnt been visited before, it uses the parents data as the initial visited direction mask - - public short computeQueuePop() { - short retVal = (short) (cullingState & (((cullingState >> 8) & 0xFF) | 0xFF00)); - cullingState = 0; - return retVal; - } - - public void updateCullingState(ForgeDirection flow, short parent) { - int inbound = flow.ordinal(); - this.cullingState |= (visibilityData >> (inbound<<3)) & 0xFF; - this.cullingState &= ~(1 << (inbound + 8)); - //NOTE: this isnt strictly needed, due to the properties provided from the bfs search (never backtracking), - // but just incase/better readability/understandability - this.cullingState &= parent|0x00FF; - } - - public void setCullingState(short parent) { - this.cullingState = (short) (parent & 0xFF00); - } - - public void resetCullingState() { - this.cullingState = -1; - } - - public int getId() { - return this.id; - } - - public boolean isCulledByFrustum(FrustumExtended frustum) { - float x = this.getOriginX(); - float y = this.getOriginY(); - float z = this.getOriginZ(); - - return !frustum.fastAabbTest(x - FRUSTUM_EPSILON, y - FRUSTUM_EPSILON, z - FRUSTUM_EPSILON, - x + 16.0f + FRUSTUM_EPSILON, y + 16.0f + FRUSTUM_EPSILON, z + 16.0f + FRUSTUM_EPSILON); - } - - /** - * @return The x-coordinate of the origin position of this chunk render - */ - public int getOriginX() { - return this.chunkX << 4; - } - - /** - * @return The y-coordinate of the origin position of this chunk render - */ - public int getOriginY() { - return this.chunkY << 4; - } - - /** - * @return The z-coordinate of the origin position of this chunk render - */ - public int getOriginZ() { - return this.chunkZ << 4; - } - - /** - * @return The squared distance from the center of this chunk in the world to the center of the block position - * given by {@param pos} - */ - public double getSquaredDistance(BlockPos pos) { - return this.getSquaredDistance(pos.x + 0.5D, pos.y + 0.5D, pos.z + 0.5D); - } - - /** - * @return The x-coordinate of the center position of this chunk render - */ - private double getCenterX() { - return this.getOriginX() + 8.0D; - } - - /** - * @return The y-coordinate of the center position of this chunk render - */ - private double getCenterY() { - return this.getOriginY() + 8.0D; - } - - /** - * @return The z-coordinate of the center position of this chunk render - */ - private double getCenterZ() { - return this.getOriginZ() + 8.0D; - } - - /** - * @return The squared distance from the center of this chunk in the world to the given position - */ - public double getSquaredDistance(double x, double y, double z) { - double xDist = x - this.getCenterX(); - double yDist = y - this.getCenterY(); - double zDist = z - this.getCenterZ(); - - return (xDist * xDist) + (yDist * yDist) + (zDist * zDist); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/data/ChunkMeshData.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/data/ChunkMeshData.java deleted file mode 100644 index f1b4b4445..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/data/ChunkMeshData.java +++ /dev/null @@ -1,54 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.data; - -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing; -import java.util.EnumMap; -import java.util.Map; -import me.jellysquid.mods.sodium.client.gl.buffer.VertexData; -import me.jellysquid.mods.sodium.client.gl.util.BufferSlice; - -public class ChunkMeshData { - public static final ChunkMeshData EMPTY = new ChunkMeshData(); - - private final EnumMap parts = new EnumMap<>(ModelQuadFacing.class); - private VertexData vertexData; - - public void setVertexData(VertexData vertexData) { - this.vertexData = vertexData; - } - - public void clearSlices() { - this.parts.clear(); - } - - public void setModelSlice(ModelQuadFacing facing, BufferSlice slice) { - this.parts.put(facing, slice); - } - - public VertexData takeVertexData() { - VertexData data = this.vertexData; - - if (data == null) { - throw new NullPointerException("No pending data to upload"); - } - - this.vertexData = null; - - return data; - } - - public boolean hasVertexData() { - return this.vertexData != null; - } - - public int getVertexDataSize() { - if (this.vertexData != null) { - return this.vertexData.buffer.capacity(); - } - - return 0; - } - - public Iterable> getSlices() { - return this.parts.entrySet(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/data/ChunkRenderBounds.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/data/ChunkRenderBounds.java deleted file mode 100644 index 4a06495ab..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/data/ChunkRenderBounds.java +++ /dev/null @@ -1,81 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.data; - -import com.gtnewhorizons.angelica.compat.mojang.ChunkSectionPos; - -public class ChunkRenderBounds { - public static final ChunkRenderBounds ALWAYS_FALSE = new ChunkRenderBounds(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY, - Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY); - - public final float x1, y1, z1; - public final float x2, y2, z2; - - public ChunkRenderBounds(float x1, float y1, float z1, float x2, float y2, float z2) { - this.x1 = x1; - this.y1 = y1; - this.z1 = z1; - - this.x2 = x2; - this.y2 = y2; - this.z2 = z2; - } - - public ChunkRenderBounds(ChunkSectionPos origin) { - this.x1 = origin.getMinX(); - this.y1 = origin.getMinY(); - this.z1 = origin.getMinZ(); - - this.x2 = origin.getMaxX() + 1; - this.y2 = origin.getMaxY() + 1; - this.z2 = origin.getMaxZ() + 1; - } - - public static class Builder { - // Bit-mask of the blocks set on each axis - private int x = 0, y = 0, z = 0; - - public void addBlock(int x, int y, int z) { - // Accumulate bits on each axis for the given block position. This avoids needing to - // branch multiple times trying to determine if the bounds need to grow. The min/max - // value of each axis can later be extracted by counting the trailing/leading zeroes. - this.x |= 1 << x; - this.y |= 1 << y; - this.z |= 1 << z; - } - - public ChunkRenderBounds build(ChunkSectionPos origin) { - // If no bits were set on any axis, return the default bounds - if ((this.x | this.y | this.z) == 0) { - return new ChunkRenderBounds(origin); - } - - int x1 = origin.getMinX() + leftBound(this.x); - int x2 = origin.getMinX() + rightBound(this.x); - - int y1 = origin.getMinY() + leftBound(this.y); - int y2 = origin.getMinY() + rightBound(this.y); - - int z1 = origin.getMinZ() + leftBound(this.z); - int z2 = origin.getMinZ() + rightBound(this.z); - - return new ChunkRenderBounds( - Math.max(x1, origin.getMinX()) - 0.5f, - Math.max(y1, origin.getMinY()) - 0.5f, - Math.max(z1, origin.getMinZ()) - 0.5f, - - Math.min(x2, origin.getMaxX()) + 0.5f, - Math.min(y2, origin.getMaxY()) + 0.5f, - Math.min(z2, origin.getMaxZ()) + 0.5f - ); - } - - // Return the left-bound of the bit-masked axis - private static int leftBound(int i) { - return Integer.numberOfTrailingZeros(i); - } - - // Return the right-bound of the bit-masked axis - private static int rightBound(int i) { - return 32 - Integer.numberOfLeadingZeros(i); - } - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/data/ChunkRenderData.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/data/ChunkRenderData.java deleted file mode 100644 index 329c41298..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/data/ChunkRenderData.java +++ /dev/null @@ -1,200 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.data; - -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing; -import com.gtnewhorizons.angelica.compat.mojang.ChunkOcclusionData; -import com.gtnewhorizons.angelica.mixins.interfaces.ISpriteExt; -import it.unimi.dsi.fastutil.objects.ObjectArrayList; -import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet; -import java.util.ArrayList; -import java.util.Collection; -import java.util.EnumMap; -import java.util.EnumSet; -import java.util.List; -import java.util.Map; -import java.util.Set; -import lombok.Getter; -import me.jellysquid.mods.sodium.client.gl.util.BufferSlice; -import me.jellysquid.mods.sodium.client.render.chunk.passes.BlockRenderPass; -import net.minecraft.client.renderer.texture.TextureAtlasSprite; -import net.minecraft.tileentity.TileEntity; -import net.minecraftforge.common.util.ForgeDirection; - -/** - * The render data for a chunk render container containing all the information about which meshes are attached, the - * block entities contained by it, and any data used for occlusion testing. - */ -public class ChunkRenderData { - public static final ChunkRenderData ABSENT = new Builder() - .build(); - public static final ChunkRenderData EMPTY = createEmptyData(); - - private Set globalTileEntities; - private List tileEntities; - - private EnumMap meshes; - - @Getter - private ChunkOcclusionData occlusionData; - @Getter - private ChunkRenderBounds bounds; - - @Getter - private List animatedSprites; - - private boolean isEmpty; - private int meshByteSize; - @Getter - private int facesWithData; - - /** - * @return True if the chunk has no renderables, otherwise false - */ - public boolean isEmpty() { - return this.isEmpty; - } - - /** - * The collection of block entities contained by this rendered chunk. - */ - public Collection getTileEntities() { - return this.tileEntities; - } - - /** - * The collection of block entities contained by this rendered chunk section which are not part of its culling - * volume. These entities should always be rendered regardless of the render being visible in the frustum. - */ - public Collection getGlobalTileEntities() { - return this.globalTileEntities; - } - - /** - * The collection of chunk meshes belonging to this render. - */ - public ChunkMeshData getMesh(BlockRenderPass pass) { - return this.meshes.get(pass); - } - - public void setMesh(BlockRenderPass pass, ChunkMeshData data) { - if (this.meshes.get(pass) == null) - throw new IllegalStateException("No mesh found"); - this.meshes.put(pass, data); - } - - public int getMeshSize() { - return this.meshByteSize; - } - - public ChunkRenderData copyAndReplaceMesh(Map replacements) { - ChunkRenderData data = new ChunkRenderData(); - data.globalTileEntities = this.globalTileEntities; - data.tileEntities = this.tileEntities; - data.occlusionData = this.occlusionData; - data.meshes = new EnumMap<>(this.meshes); - data.bounds = this.bounds; - data.animatedSprites = new ObjectArrayList<>(this.animatedSprites); - data.meshes.putAll(replacements); - - int facesWithData = 0; - int size = 0; - - for (ChunkMeshData meshData : this.meshes.values()) { - size += meshData.getVertexDataSize(); - - for (Map.Entry entry : meshData.getSlices()) { - facesWithData |= 1 << entry.getKey().ordinal(); - } - } - - data.isEmpty = this.globalTileEntities.isEmpty() && this.tileEntities.isEmpty() && facesWithData == 0; - data.meshByteSize = size; - data.facesWithData = facesWithData; - return data; - } - - public static class Builder { - private final List globalTileEntities = new ArrayList<>(); - private final List tileEntities = new ArrayList<>(); - private final Set animatedSprites = new ObjectOpenHashSet<>(); - - private final EnumMap meshes = new EnumMap<>(BlockRenderPass.class); - - private ChunkOcclusionData occlusionData; - private ChunkRenderBounds bounds = ChunkRenderBounds.ALWAYS_FALSE; - - public Builder() { - for (BlockRenderPass pass : BlockRenderPass.VALUES) { - this.setMesh(pass, ChunkMeshData.EMPTY); - } - } - - public void setBounds(ChunkRenderBounds bounds) { - this.bounds = bounds; - } - - public void setOcclusionData(ChunkOcclusionData data) { - this.occlusionData = data; - } - - /** - * Adds a sprite to this data container for tracking. If the sprite is tickable, it will be ticked every frame - * before rendering as necessary. - * @param sprite The sprite - */ - public void addSprite(TextureAtlasSprite sprite) { - if (((ISpriteExt) sprite).isAnimation()) { - this.animatedSprites.add(sprite); - } - } - - public void setMesh(BlockRenderPass pass, ChunkMeshData data) { - this.meshes.put(pass, data); - } - - /** - * Adds a block entity to the data container. - * @param entity The block entity itself - * @param cull True if the block entity can be culled to this chunk render's volume, otherwise false - */ - public void addTileEntity(TileEntity entity, boolean cull) { - (cull ? this.tileEntities : this.globalTileEntities).add(entity); - } - - public ChunkRenderData build() { - ChunkRenderData data = new ChunkRenderData(); - data.globalTileEntities = new ObjectOpenHashSet<>(this.globalTileEntities); - data.tileEntities = this.tileEntities; - data.occlusionData = this.occlusionData; - data.meshes = this.meshes; - data.bounds = this.bounds; - data.animatedSprites = new ObjectArrayList<>(this.animatedSprites); - - int facesWithData = 0; - int size = 0; - - for (ChunkMeshData meshData : this.meshes.values()) { - size += meshData.getVertexDataSize(); - - for (Map.Entry entry : meshData.getSlices()) { - facesWithData |= 1 << entry.getKey().ordinal(); - } - } - - data.isEmpty = this.globalTileEntities.isEmpty() && this.tileEntities.isEmpty() && facesWithData == 0; - data.meshByteSize = size; - data.facesWithData = facesWithData; - - return data; - } - } - - private static ChunkRenderData createEmptyData() { - ChunkOcclusionData occlusionData = new ChunkOcclusionData(); - occlusionData.addOpenEdgeFaces(EnumSet.allOf(ForgeDirection.class)); - - Builder meshInfo = new Builder(); - meshInfo.setOcclusionData(occlusionData); - - return meshInfo.build(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/ChunkMeshAttribute.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/ChunkMeshAttribute.java deleted file mode 100644 index 1a4d572aa..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/ChunkMeshAttribute.java +++ /dev/null @@ -1,14 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.format; - -public enum ChunkMeshAttribute { - POSITION, - COLOR, - TEXTURE, - LIGHT, - // Iris - NORMAL, - TANGENT, - MID_TEX_COORD, - BLOCK_ID, - MID_BLOCK -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/ChunkModelOffset.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/ChunkModelOffset.java deleted file mode 100644 index 64b441a08..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/ChunkModelOffset.java +++ /dev/null @@ -1,11 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.format; - -public class ChunkModelOffset { - public float x, y, z; - - public void set(int x, int y, int z) { - this.x = x; - this.y = y; - this.z = z; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/DefaultModelVertexFormats.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/DefaultModelVertexFormats.java deleted file mode 100644 index 03e523dda..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/DefaultModelVertexFormats.java +++ /dev/null @@ -1,9 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.format; - -import me.jellysquid.mods.sodium.client.render.chunk.format.hfp.HFPModelVertexType; -import me.jellysquid.mods.sodium.client.render.chunk.format.sfp.SFPModelVertexType; - -public class DefaultModelVertexFormats { - public static final HFPModelVertexType MODEL_VERTEX_HFP = new HFPModelVertexType(); - public static final SFPModelVertexType MODEL_VERTEX_SFP = new SFPModelVertexType(); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/ModelVertexSink.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/ModelVertexSink.java deleted file mode 100644 index e75b87152..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/ModelVertexSink.java +++ /dev/null @@ -1,18 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.format; - -import me.jellysquid.mods.sodium.client.model.vertex.VertexSink; - -public interface ModelVertexSink extends VertexSink { - /** - * Writes a quad vertex to this sink. - * @param x The x-position of the vertex - * @param y The y-position of the vertex - * @param z The z-position of the vertex - * @param color The ABGR-packed color of the vertex - * @param u The u-texture of the vertex - * @param v The y-texture of the vertex - * @param light The packed light-map coordinates of the vertex - * @param shaderBlockId The blockId to be passed to the shader - */ - void writeQuad(float x, float y, float z, int color, float u, float v, int light, int shaderBlockId); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/ModelVertexUtil.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/ModelVertexUtil.java deleted file mode 100644 index 1d4eb4aae..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/ModelVertexUtil.java +++ /dev/null @@ -1,46 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.format; - -public class ModelVertexUtil { - /** - * Converts a floating point vertex position in range 0..32 to a de-normalized unsigned short. - * @param value The float in range 0..32 - * @return The resulting de-normalized unsigned short - */ - public static short denormalizeVertexPositionFloatAsShort(float value) { - // Since we're skipping the scaling formerly done in ChunkModelVertexTransformer to preserve precision, this - // method actually takes input unnormalized within the range 0..32, and expands that to 0..65536. - // TODO: Restructure things to be less arbitrary here - return (short) (value * 2048.0f); - } - - /** - * Converts a normalized floating point texture coordinate to a de-normalized unsigned short. - * @param value The normalized float - * @return The resulting de-normalized unsigned short - */ - public static short denormalizeVertexTextureFloatAsShort(float value) { - return (short) (Math.round(value * 32768.0F) & 0xFFFF); - } - - /** - * This moves some work out the shader code and simplifies things a bit. In vanilla, the game encodes light map - * texture coordinates as two un-normalized unsigned shorts in the range 0..255. Using the fixed-function pipeline, - * it then applies a matrix transformation which normalizes these coordinates and applies a centering offset. This - * operation has non-zero overhead and complicates shader code a bit. - * - * To work around the problem, this function instead normalizes these light map texture coordinates and applies the - * centering offset, allowing it to be baked into the vertex data itself. - * - * @param light The light map value - * @return The light map texture coordinates as two unsigned shorts with a center offset applied - */ - public static int encodeLightMapTexCoord(int light) { - int sl = (light >> 16) & 255; - sl = (sl << 8) + 2048; - - int bl = light & 255; - bl = (bl << 8) + 2048; - - return (sl << 16) | bl; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/hfp/HFPModelVertexBufferWriterNio.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/hfp/HFPModelVertexBufferWriterNio.java deleted file mode 100644 index 1f03b48f2..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/hfp/HFPModelVertexBufferWriterNio.java +++ /dev/null @@ -1,43 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.format.hfp; - -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferWriterNio; -import me.jellysquid.mods.sodium.client.render.chunk.format.DefaultModelVertexFormats; -import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexSink; -import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexUtil; - -import java.nio.ByteBuffer; - -public class HFPModelVertexBufferWriterNio extends VertexBufferWriterNio implements ModelVertexSink { - public HFPModelVertexBufferWriterNio(VertexBufferView backingBuffer) { - super(backingBuffer, DefaultModelVertexFormats.MODEL_VERTEX_HFP); - } - - @Override - public void writeQuad(float x, float y, float z, int color, float u, float v, int light, int shaderBlockId) { - this.writeQuadInternal( - ModelVertexUtil.denormalizeVertexPositionFloatAsShort(x), - ModelVertexUtil.denormalizeVertexPositionFloatAsShort(y), - ModelVertexUtil.denormalizeVertexPositionFloatAsShort(z), - color, - ModelVertexUtil.denormalizeVertexTextureFloatAsShort(u), - ModelVertexUtil.denormalizeVertexTextureFloatAsShort(v), - ModelVertexUtil.encodeLightMapTexCoord(light) - ); - } - - private void writeQuadInternal(short x, short y, short z, int color, short u, short v, int light) { - final int i = this.writeOffset; - - final ByteBuffer buffer = this.byteBuffer; - buffer.putShort(i, x); - buffer.putShort(i + 2, y); - buffer.putShort(i + 4, z); - buffer.putInt(i + 8, color); - buffer.putShort(i + 12, u); - buffer.putShort(i + 14, v); - buffer.putInt(i + 16, light); - - this.advance(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/hfp/HFPModelVertexBufferWriterUnsafe.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/hfp/HFPModelVertexBufferWriterUnsafe.java deleted file mode 100644 index 58da787d7..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/hfp/HFPModelVertexBufferWriterUnsafe.java +++ /dev/null @@ -1,43 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.format.hfp; - -import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*; - -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferWriterUnsafe; -import me.jellysquid.mods.sodium.client.render.chunk.format.DefaultModelVertexFormats; -import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexSink; -import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexUtil; - -public class HFPModelVertexBufferWriterUnsafe extends VertexBufferWriterUnsafe implements ModelVertexSink { - public HFPModelVertexBufferWriterUnsafe(VertexBufferView backingBuffer) { - super(backingBuffer, DefaultModelVertexFormats.MODEL_VERTEX_HFP); - } - - @Override - public void writeQuad(float x, float y, float z, int color, float u, float v, int light, int shaderBlockId) { - this.writeQuadInternal( - ModelVertexUtil.denormalizeVertexPositionFloatAsShort(x), - ModelVertexUtil.denormalizeVertexPositionFloatAsShort(y), - ModelVertexUtil.denormalizeVertexPositionFloatAsShort(z), - color, - ModelVertexUtil.denormalizeVertexTextureFloatAsShort(u), - ModelVertexUtil.denormalizeVertexTextureFloatAsShort(v), - ModelVertexUtil.encodeLightMapTexCoord(light) - ); - } - - private void writeQuadInternal(short x, short y, short z, int color, short u, short v, int light) { - long i = this.writePointer; - - memPutShort(i, x); - memPutShort(i + 2, y); - memPutShort(i + 4, z); - memPutInt(i + 8, color); - memPutShort(i + 12, u); - memPutShort(i + 14, v); - memPutInt(i + 16, light); - - this.advance(); - } - -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/hfp/HFPModelVertexType.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/hfp/HFPModelVertexType.java deleted file mode 100644 index 3437f85cc..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/hfp/HFPModelVertexType.java +++ /dev/null @@ -1,60 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.format.hfp; - -import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer; -import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexAttributeFormat; -import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexFormat; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; -import me.jellysquid.mods.sodium.client.model.vertex.type.BlittableVertexType; -import me.jellysquid.mods.sodium.client.model.vertex.type.ChunkVertexType; -import me.jellysquid.mods.sodium.client.render.chunk.format.ChunkMeshAttribute; -import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexSink; - -/** - * Uses half-precision floating point numbers to represent position coordinates and normalized unsigned shorts for - * texture coordinates. All texel positions in the block diffuse texture atlas can be exactly mapped (including - * their centering offset). - */ -public class HFPModelVertexType implements ChunkVertexType { - public static final int STRIDE = 20; - public static final GlVertexFormat VERTEX_FORMAT = - GlVertexFormat.builder(ChunkMeshAttribute.class, STRIDE) - .addElement(ChunkMeshAttribute.POSITION, 0, GlVertexAttributeFormat.UNSIGNED_SHORT, 3, false) - .addElement(ChunkMeshAttribute.COLOR, 8, GlVertexAttributeFormat.UNSIGNED_BYTE, 4, true) - .addElement(ChunkMeshAttribute.TEXTURE, 12, GlVertexAttributeFormat.UNSIGNED_SHORT, 2, false) - .addElement(ChunkMeshAttribute.LIGHT, 16, GlVertexAttributeFormat.UNSIGNED_SHORT, 2, true) - .build(); - - - public static final float MODEL_SCALE = (32.0f / 65536.0f); - public static final float TEXTURE_SCALE = (1.0f / 32768.0f); - - @Override - public ModelVertexSink createFallbackWriter(VertexConsumer consumer) { - throw new UnsupportedOperationException(); - } - - @Override - public ModelVertexSink createBufferWriter(VertexBufferView buffer, boolean direct) { - return direct ? new HFPModelVertexBufferWriterUnsafe(buffer) : new HFPModelVertexBufferWriterNio(buffer); - } - - @Override - public BlittableVertexType asBlittable() { - return this; - } - - @Override - public GlVertexFormat getCustomVertexFormat() { - return VERTEX_FORMAT; - } - - @Override - public float getModelScale() { - return MODEL_SCALE; - } - - @Override - public float getTextureScale() { - return TEXTURE_SCALE; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/sfp/SFPModelVertexBufferWriterNio.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/sfp/SFPModelVertexBufferWriterNio.java deleted file mode 100644 index 235d0fdfb..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/sfp/SFPModelVertexBufferWriterNio.java +++ /dev/null @@ -1,52 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.format.sfp; - -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferWriterNio; -import me.jellysquid.mods.sodium.client.render.chunk.format.DefaultModelVertexFormats; -import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexSink; - -import java.nio.ByteBuffer; - -public class SFPModelVertexBufferWriterNio extends VertexBufferWriterNio implements ModelVertexSink { - public SFPModelVertexBufferWriterNio(VertexBufferView backingBuffer) { - super(backingBuffer, DefaultModelVertexFormats.MODEL_VERTEX_SFP); - } - - @Override - public void writeQuad(float x, float y, float z, int color, float u, float v, int light, int shaderBlockId) { - int i = this.writeOffset; - - ByteBuffer buffer = this.byteBuffer; - buffer.putFloat(i, x); - buffer.putFloat(i + 4, y); - buffer.putFloat(i + 8, z); - buffer.putInt(i + 12, color); - buffer.putFloat(i + 16, u); - buffer.putFloat(i + 20, v); - buffer.putInt(i + 24, encodeLightMapTexCoord(light)); - - this.advance(); - } - - /** - * This moves some work out the shader code and simplifies things a bit. In vanilla, the game encodes light map - * texture coordinates as two un-normalized unsigned shorts in the range 0..255. Using the fixed-function pipeline, - * it then applies a matrix transformation which normalizes these coordinates and applies a centering offset. This - * operation has non-zero overhead and complicates shader code a bit. - * - * To work around the problem, this function instead normalizes these light map texture coordinates and applies the - * centering offset, allowing it to be baked into the vertex data itself. - * - * @param light The light map value - * @return The light map texture coordinates as two unsigned shorts with a center offset applied - */ - private static int encodeLightMapTexCoord(int light) { - int sl = (light >> 16) & 255; - sl = (sl << 8) + 2048; - - int bl = light & 255; - bl = (bl << 8) + 2048; - - return (sl << 16) | bl; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/sfp/SFPModelVertexBufferWriterUnsafe.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/sfp/SFPModelVertexBufferWriterUnsafe.java deleted file mode 100644 index 0443eafe9..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/sfp/SFPModelVertexBufferWriterUnsafe.java +++ /dev/null @@ -1,51 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.format.sfp; - -import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*; - -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferWriterUnsafe; -import me.jellysquid.mods.sodium.client.render.chunk.format.DefaultModelVertexFormats; -import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexSink; - -public class SFPModelVertexBufferWriterUnsafe extends VertexBufferWriterUnsafe implements ModelVertexSink { - public SFPModelVertexBufferWriterUnsafe(VertexBufferView backingBuffer) { - super(backingBuffer, DefaultModelVertexFormats.MODEL_VERTEX_SFP); - } - - @Override - public void writeQuad(float x, float y, float z, int color, float u, float v, int light, int shaderBlockId) { - long i = this.writePointer; - - memPutFloat(i, x); - memPutFloat(i + 4, y); - memPutFloat(i + 8, z); - memPutInt(i + 12, color); - memPutFloat(i + 16, u); - memPutFloat(i + 20, v); - memPutInt(i + 24, encodeLightMapTexCoord(light)); - - this.advance(); - } - - /** - * This moves some work out the shader code and simplifies things a bit. In vanilla, the game encodes light map - * texture coordinates as two un-normalized unsigned shorts in the range 0..255. Using the fixed-function pipeline, - * it then applies a matrix transformation which normalizes these coordinates and applies a centering offset. This - * operation has non-zero overhead and complicates shader code a bit. - * - * To work around the problem, this function instead normalizes these light map texture coordinates and applies the - * centering offset, allowing it to be baked into the vertex data itself. - * - * @param light The light map value - * @return The light map texture coordinates as two unsigned shorts with a center offset applied - */ - private static int encodeLightMapTexCoord(int light) { - int sl = (light >> 16) & 255; - sl = (sl << 8) + 2048; - - int bl = light & 255; - bl = (bl << 8) + 2048; - - return (sl << 16) | bl; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/sfp/SFPModelVertexType.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/sfp/SFPModelVertexType.java deleted file mode 100644 index 388a2c8a3..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/format/sfp/SFPModelVertexType.java +++ /dev/null @@ -1,57 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.format.sfp; - -import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer; -import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexAttributeFormat; -import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexFormat; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; -import me.jellysquid.mods.sodium.client.model.vertex.type.BlittableVertexType; -import me.jellysquid.mods.sodium.client.model.vertex.type.ChunkVertexType; -import me.jellysquid.mods.sodium.client.render.chunk.format.ChunkMeshAttribute; -import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexSink; - -/** - * Simple vertex format which uses single-precision floating point numbers to represent position and texture - * coordinates. - */ -public class SFPModelVertexType implements ChunkVertexType { - public static final GlVertexFormat VERTEX_FORMAT = - GlVertexFormat.builder(ChunkMeshAttribute.class, 32) - .addElement(ChunkMeshAttribute.POSITION, 0, GlVertexAttributeFormat.FLOAT, 3, false) - .addElement(ChunkMeshAttribute.COLOR, 12, GlVertexAttributeFormat.UNSIGNED_BYTE, 4, true) - .addElement(ChunkMeshAttribute.TEXTURE, 16, GlVertexAttributeFormat.FLOAT, 2, false) - .addElement(ChunkMeshAttribute.LIGHT, 24, GlVertexAttributeFormat.UNSIGNED_SHORT, 2, true) - .build(); - - public static final float MODEL_SCALE = 1.0f; - public static final float TEXTURE_SCALE = 1.0f; - - @Override - public ModelVertexSink createFallbackWriter(VertexConsumer consumer) { - throw new UnsupportedOperationException(); - } - - @Override - public ModelVertexSink createBufferWriter(VertexBufferView buffer, boolean direct) { - return direct ? new SFPModelVertexBufferWriterUnsafe(buffer) : new SFPModelVertexBufferWriterNio(buffer); - } - - @Override - public BlittableVertexType asBlittable() { - return this; - } - - @Override - public GlVertexFormat getCustomVertexFormat() { - return VERTEX_FORMAT; - } - - @Override - public float getModelScale() { - return MODEL_SCALE; - } - - @Override - public float getTextureScale() { - return TEXTURE_SCALE; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/lists/ChunkRenderList.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/lists/ChunkRenderList.java deleted file mode 100644 index bfdaa6f80..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/lists/ChunkRenderList.java +++ /dev/null @@ -1,118 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.lists; - -import it.unimi.dsi.fastutil.objects.ObjectArrayList; - -import java.util.Arrays; - -/** - * A simple extension over {@link ObjectArrayList} which provides iterator methods in either FIFO or LIFO ordering. - */ -public class ChunkRenderList { - private T[] stateArray; - private int[] cullArray; - private int size, capacity; - - public ChunkRenderList() { - this(1024); - } - - @SuppressWarnings("unchecked") - public ChunkRenderList(int capacity) { - this.size = 0; - this.capacity = capacity; - - this.stateArray = (T[]) new Object[capacity]; - this.cullArray = new int[capacity]; - } - - private void resize() { - this.capacity = this.capacity * 2; - - this.stateArray = Arrays.copyOf(this.stateArray, this.capacity); - this.cullArray = Arrays.copyOf(this.cullArray, this.capacity); - } - - public void add(T state, int cull) { - int idx = this.size++; - - if (idx >= this.capacity) { - this.resize(); - } - - this.stateArray[idx] = state; - this.cullArray[idx] = cull; - } - - public void reset() { - if (this.size == 0) { - return; - } - - for (int i = 0; i < this.size; i++) { - this.stateArray[i] = null; - } - - for (int i = 0; i < this.size; i++) { - this.cullArray[i] = 0; - } - - this.size = 0; - } - - /** - * @return An iterator which returns elements in FIFO order or LIFO order if {@param backwards} is set - */ - public ChunkRenderListIterator iterator(boolean backwards) { - if (backwards) { - return new ChunkRenderListIterator() { - private int pos = ChunkRenderList.this.size - 1; - - @Override - public T getGraphicsState() { - return ChunkRenderList.this.stateArray[this.pos]; - } - - @Override - public int getVisibleFaces() { - return ChunkRenderList.this.cullArray[this.pos]; - } - - @Override - public boolean hasNext() { - return this.pos >= 0; - } - - @Override - public void advance() { - this.pos--; - } - }; - } else { - return new ChunkRenderListIterator() { - private final int lim = ChunkRenderList.this.size; - - private int pos = 0; - - @Override - public T getGraphicsState() { - return ChunkRenderList.this.stateArray[this.pos]; - } - - @Override - public int getVisibleFaces() { - return ChunkRenderList.this.cullArray[this.pos]; - } - - @Override - public boolean hasNext() { - return this.pos < this.lim; - } - - @Override - public void advance() { - this.pos++; - } - }; - } - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/lists/ChunkRenderListIterator.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/lists/ChunkRenderListIterator.java deleted file mode 100644 index 9dc21f066..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/lists/ChunkRenderListIterator.java +++ /dev/null @@ -1,9 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.lists; - -public interface ChunkRenderListIterator { - T getGraphicsState(); - int getVisibleFaces(); - - boolean hasNext(); - void advance(); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/map/ChunkStatus.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/map/ChunkStatus.java deleted file mode 100644 index 648486cf3..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/map/ChunkStatus.java +++ /dev/null @@ -1,7 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.map; - -public class ChunkStatus { - public static final int FLAG_HAS_BLOCK_DATA = 1; - public static final int FLAG_HAS_LIGHT_DATA = 2; - public static final int FLAG_ALL = FLAG_HAS_BLOCK_DATA | FLAG_HAS_LIGHT_DATA; -} \ No newline at end of file diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/map/ChunkTracker.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/map/ChunkTracker.java deleted file mode 100644 index 167ac2739..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/map/ChunkTracker.java +++ /dev/null @@ -1,125 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.map; - -import it.unimi.dsi.fastutil.longs.Long2IntOpenHashMap; -import it.unimi.dsi.fastutil.longs.LongCollection; -import it.unimi.dsi.fastutil.longs.LongOpenHashSet; -import it.unimi.dsi.fastutil.longs.LongSet; -import it.unimi.dsi.fastutil.longs.LongSets; -import net.minecraft.world.ChunkCoordIntPair; - -public class ChunkTracker implements ClientChunkEventListener { - private final Long2IntOpenHashMap chunkStatus = new Long2IntOpenHashMap(); - private final LongOpenHashSet chunkReady = new LongOpenHashSet(); - - private final LongSet unloadQueue = new LongOpenHashSet(); - private final LongSet loadQueue = new LongOpenHashSet(); - - public ChunkTracker() { - - } - - @Override - public void updateMapCenter(int chunkX, int chunkZ) { - - } - - @Override - public void updateLoadDistance(int loadDistance) { - - } - - @Override - public void onChunkStatusAdded(int x, int z, int flags) { - var key = ChunkCoordIntPair.chunkXZ2Int(x, z); - - var prev = this.chunkStatus.get(key); - var cur = prev | flags; - - if (prev == cur) { - return; - } - - this.chunkStatus.put(key, cur); - - this.updateNeighbors(x, z); - } - - @Override - public void onChunkStatusRemoved(int x, int z, int flags) { - var key = ChunkCoordIntPair.chunkXZ2Int(x, z); - - var prev = this.chunkStatus.get(key); - int cur = prev & ~flags; - - if (prev == cur) { - return; - } - - if (cur == this.chunkStatus.defaultReturnValue()) { - this.chunkStatus.remove(key); - } else { - this.chunkStatus.put(key, cur); - } - - this.updateNeighbors(x, z); - } - - private void updateNeighbors(int x, int z) { - for (int ox = -1; ox <= 1; ox++) { - for (int oz = -1; oz <= 1; oz++) { - this.updateMerged(ox + x, oz + z); - } - } - } - - private void updateMerged(int x, int z) { - long key = ChunkCoordIntPair.chunkXZ2Int(x, z); - - int flags = this.chunkStatus.get(key); - - for (int ox = -1; ox <= 1; ox++) { - for (int oz = -1; oz <= 1; oz++) { - flags &= this.chunkStatus.get(ChunkCoordIntPair.chunkXZ2Int(ox + x, oz + z)); - } - } - - if (flags == ChunkStatus.FLAG_ALL) { - if (this.chunkReady.add(key) && !this.unloadQueue.remove(key)) { - this.loadQueue.add(key); - } - } else { - if (this.chunkReady.remove(key) && !this.loadQueue.remove(key)) { - this.unloadQueue.add(key); - } - } - } - - public LongCollection getReadyChunks() { - return LongSets.unmodifiable(this.chunkReady); - } - - public void forEachEvent(ChunkEventHandler loadEventHandler, ChunkEventHandler unloadEventHandler) { - forEachChunk(this.unloadQueue, unloadEventHandler); - this.unloadQueue.clear(); - - forEachChunk(this.loadQueue, loadEventHandler); - this.loadQueue.clear(); - } - - public static void forEachChunk(LongCollection queue, ChunkEventHandler handler) { - var iterator = queue.iterator(); - - while (iterator.hasNext()) { - var pos = iterator.nextLong(); - - var x = (int)(pos & 4294967295L); - var z = (int)((pos >> 32L) & 4294967295L); - - handler.apply(x, z); - } - } - - public interface ChunkEventHandler { - void apply(int x, int z); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/map/ChunkTrackerHolder.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/map/ChunkTrackerHolder.java deleted file mode 100644 index 4610a9533..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/map/ChunkTrackerHolder.java +++ /dev/null @@ -1,11 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.map; - -import net.minecraft.client.multiplayer.WorldClient; - -public interface ChunkTrackerHolder { - static ChunkTracker get(WorldClient world) { - return ((ChunkTrackerHolder) world).sodium$getTracker(); - } - - ChunkTracker sodium$getTracker(); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/map/ClientChunkEventListener.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/map/ClientChunkEventListener.java deleted file mode 100644 index 60e524426..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/map/ClientChunkEventListener.java +++ /dev/null @@ -1,10 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.map; - -public interface ClientChunkEventListener { - void updateMapCenter(int chunkX, int chunkZ); - - void updateLoadDistance(int loadDistance); - - void onChunkStatusAdded(int x, int z, int flags); - void onChunkStatusRemoved(int x, int z, int flags); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/passes/BlockRenderPass.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/passes/BlockRenderPass.java deleted file mode 100644 index 383ea37b8..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/passes/BlockRenderPass.java +++ /dev/null @@ -1,28 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.passes; - -/** - * The order of these enums must match the passes used by vanilla. - */ -public enum BlockRenderPass { - CUTOUT_MIPPED(false, 131072), - TRANSLUCENT(true, 262144); - - public static final BlockRenderPass[] VALUES = BlockRenderPass.values(); - public static final int COUNT = VALUES.length; - - private final boolean translucent; - private final int bufferSize; - - BlockRenderPass(boolean translucent, int bufferSize) { - this.translucent = translucent; - this.bufferSize = bufferSize; - } - - public boolean isTranslucent() { - return this.translucent; - } - - public int bufferSize() { - return this.bufferSize; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/region/ChunkRegion.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/region/ChunkRegion.java deleted file mode 100644 index 2bb973b10..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/region/ChunkRegion.java +++ /dev/null @@ -1,90 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.region; - -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing; -import it.unimi.dsi.fastutil.objects.ObjectArrayList; -import me.jellysquid.mods.sodium.client.gl.arena.GlBufferArena; -import me.jellysquid.mods.sodium.client.gl.device.CommandList; -import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; -import me.jellysquid.mods.sodium.client.gl.tessellation.GlTessellation; -import me.jellysquid.mods.sodium.client.render.chunk.ChunkGraphicsState; -import me.jellysquid.mods.sodium.client.render.chunk.backends.multidraw.ChunkDrawCallBatcher; -import me.jellysquid.mods.sodium.client.render.chunk.compile.ChunkBuildResult; - -public class ChunkRegion { - private static final int EXPECTED_CHUNK_SIZE = 4 * 1024; - - private final GlBufferArena arena; - private final ChunkDrawCallBatcher batch; - private final RenderDevice device; - - private final ObjectArrayList> uploadQueue; - - private GlTessellation tessellation; - - private final int x, y, z; - - public float camDistance; - - public ChunkRegion(RenderDevice device, int size, int x, int y, int z) { - int arenaSize = EXPECTED_CHUNK_SIZE * size; - - this.device = device; - this.arena = new GlBufferArena(device, arenaSize, arenaSize); - this.uploadQueue = new ObjectArrayList<>(); - - this.batch = ChunkDrawCallBatcher.create(size * ModelQuadFacing.COUNT); - - this.x = x; - this.y = y; - this.z = z; - } - - public int getCenterBlockX() { - return (this.x * ChunkRegionManager.BUFFER_WIDTH * 16) + (ChunkRegionManager.BUFFER_WIDTH / 2 * 16); - } - - public int getCenterBlockY() { - return (this.y * ChunkRegionManager.BUFFER_HEIGHT * 16) + (ChunkRegionManager.BUFFER_HEIGHT / 2 * 16); - } - - public int getCenterBlockZ() { - return (this.z * ChunkRegionManager.BUFFER_LENGTH * 16) + (ChunkRegionManager.BUFFER_LENGTH / 2 * 16); - } - - public GlBufferArena getBufferArena() { - return this.arena; - } - - public boolean isArenaEmpty() { - return this.arena.isEmpty(); - } - - public void deleteResources() { - if (this.tessellation != null) { - try (CommandList commands = this.device.createCommandList()) { - commands.deleteTessellation(this.tessellation); - } - - this.tessellation = null; - } - - this.arena.delete(); - this.batch.delete(); - } - - public ObjectArrayList> getUploadQueue() { - return this.uploadQueue; - } - - public ChunkDrawCallBatcher getDrawBatcher() { - return this.batch; - } - - public GlTessellation getTessellation() { - return this.tessellation; - } - - public void setTessellation(GlTessellation tessellation) { - this.tessellation = tessellation; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/region/ChunkRegionManager.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/region/ChunkRegionManager.java deleted file mode 100644 index f24860fd0..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/region/ChunkRegionManager.java +++ /dev/null @@ -1,78 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.region; - -import com.gtnewhorizons.angelica.compat.mojang.ChunkSectionPos; -import it.unimi.dsi.fastutil.longs.Long2ReferenceOpenHashMap; -import it.unimi.dsi.fastutil.objects.ObjectIterator; -import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; -import me.jellysquid.mods.sodium.client.render.chunk.ChunkGraphicsState; -import me.jellysquid.mods.sodium.client.util.MathUtil; -import org.apache.commons.lang3.Validate; - -public class ChunkRegionManager { - public static final int BUFFER_WIDTH = 8; - public static final int BUFFER_HEIGHT = 4; - public static final int BUFFER_LENGTH = 8; - - public static final int BUFFER_SIZE = BUFFER_WIDTH * BUFFER_HEIGHT * BUFFER_LENGTH; - - private static final int BUFFER_WIDTH_SH = Integer.bitCount(BUFFER_WIDTH - 1); - private static final int BUFFER_HEIGHT_SH = Integer.bitCount(BUFFER_HEIGHT - 1); - private static final int BUFFER_LENGTH_SH = Integer.bitCount(BUFFER_LENGTH - 1); - - static { - Validate.isTrue(MathUtil.isPowerOfTwo(BUFFER_WIDTH)); - Validate.isTrue(MathUtil.isPowerOfTwo(BUFFER_LENGTH)); - Validate.isTrue(MathUtil.isPowerOfTwo(BUFFER_HEIGHT)); - } - - private final Long2ReferenceOpenHashMap> regions = new Long2ReferenceOpenHashMap<>(); - private final RenderDevice device; - - public ChunkRegionManager(RenderDevice device) { - this.device = device; - } - - public ChunkRegion getRegion(int x, int y, int z) { - return this.regions.get(getRegionKey(x, y, z)); - } - - public ChunkRegion getOrCreateRegion(int x, int y, int z) { - long key = getRegionKey(x, y, z); - - ChunkRegion region = this.regions.get(key); - - if (region == null) { - this.regions.put(key, region = new ChunkRegion<>(this.device, BUFFER_SIZE, x >> BUFFER_WIDTH_SH, y >> BUFFER_HEIGHT_SH, z >> BUFFER_LENGTH_SH)); - } - - return region; - } - - public static long getRegionKey(int x, int y, int z) { - return ChunkSectionPos.asLong(x >> BUFFER_WIDTH_SH, y >> BUFFER_HEIGHT_SH, z >> BUFFER_LENGTH_SH); - } - - public void delete() { - for (ChunkRegion region : this.regions.values()) { - region.deleteResources(); - } - - this.regions.clear(); - } - - public void cleanup() { - for (ObjectIterator> iterator = this.regions.values().iterator(); iterator.hasNext(); ) { - ChunkRegion region = iterator.next(); - - if (region.isArenaEmpty()) { - region.deleteResources(); - - iterator.remove(); - } - } - } - - public int getAllocatedRegionCount() { - return this.regions.size(); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/shader/ChunkFogMode.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/shader/ChunkFogMode.java deleted file mode 100644 index 1e81e0444..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/shader/ChunkFogMode.java +++ /dev/null @@ -1,28 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.shader; - -import com.google.common.collect.ImmutableList; - -import java.util.List; -import java.util.function.Function; - -public enum ChunkFogMode { - NONE(ChunkShaderFogComponent.None::new, ImmutableList.of()), - LINEAR(ChunkShaderFogComponent.Linear::new, ImmutableList.of("USE_FOG", "USE_FOG_LINEAR")), - EXP2(ChunkShaderFogComponent.Exp2::new, ImmutableList.of("USE_FOG", "USE_FOG_EXP2")); - - private final Function factory; - private final List defines; - - ChunkFogMode(Function factory, List defines) { - this.factory = factory; - this.defines = defines; - } - - public Function getFactory() { - return this.factory; - } - - public List getDefines() { - return this.defines; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/shader/ChunkProgram.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/shader/ChunkProgram.java deleted file mode 100644 index ffe195a39..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/shader/ChunkProgram.java +++ /dev/null @@ -1,61 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.shader; - -import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryStack.*; - -import com.gtnewhorizon.gtnhlib.bytebuf.MemoryStack; -import com.gtnewhorizons.angelica.compat.toremove.MatrixStack; -import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; -import me.jellysquid.mods.sodium.client.gl.shader.GlProgram; -import me.jellysquid.mods.sodium.client.render.GameRendererContext; -import net.minecraft.client.renderer.OpenGlHelper; -import net.minecraft.util.ResourceLocation; -import org.lwjgl.opengl.GL13; -import org.lwjgl.opengl.GL20; - -import java.util.function.Function; - -/** - * A forward-rendering shader program for chunks. - */ -public class ChunkProgram extends GlProgram { - // Uniform variable binding indexes - private final int uModelViewProjectionMatrix; - private final int uModelScale; - private final int uTextureScale; - private final int uBlockTex; - private final int uLightTex; - - // The fog shader component used by this program in order to setup the appropriate GL state - private final ChunkShaderFogComponent fogShader; - - protected ChunkProgram(RenderDevice owner, ResourceLocation name, int handle, Function fogShaderFunction) { - super(owner, name, handle); - - this.uModelViewProjectionMatrix = this.getUniformLocation("u_ModelViewProjectionMatrix"); - - this.uBlockTex = this.getUniformLocation("u_BlockTex"); - this.uLightTex = this.getUniformLocation("u_LightTex"); - this.uModelScale = this.getUniformLocation("u_ModelScale"); - this.uTextureScale = this.getUniformLocation("u_TextureScale"); - - this.fogShader = fogShaderFunction.apply(this); - } - - public void setup(MatrixStack matrixStack, float modelScale, float textureScale) { - if(this.uBlockTex != -1) GL20.glUniform1i(this.uBlockTex, OpenGlHelper.defaultTexUnit - GL13.GL_TEXTURE0); - if(this.uLightTex != -1) GL20.glUniform1i(this.uLightTex, OpenGlHelper.lightmapTexUnit - GL13.GL_TEXTURE0); - - if(this.uModelScale != -1) GL20.glUniform3f(this.uModelScale, modelScale, modelScale, modelScale); - if(this.uTextureScale != -1) GL20.glUniform2f(this.uTextureScale, textureScale, textureScale); - - this.fogShader.setup(); - - if (this.uModelViewProjectionMatrix == -1) return; - try (MemoryStack stack = stackPush()) { - GL20.glUniformMatrix4( - this.uModelViewProjectionMatrix, - false, - GameRendererContext.getModelViewProjectionMatrix(matrixStack.peek(), stack)); - } - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/shader/ChunkRenderShaderBackend.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/shader/ChunkRenderShaderBackend.java deleted file mode 100644 index cb87bed0c..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/shader/ChunkRenderShaderBackend.java +++ /dev/null @@ -1,208 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.shader; - -import com.gtnewhorizons.angelica.compat.toremove.MatrixStack; -import com.gtnewhorizons.angelica.glsm.GLStateManager; -import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexFormat; -import me.jellysquid.mods.sodium.client.gl.compat.FogHelper; -import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; -import me.jellysquid.mods.sodium.client.gl.shader.GlProgram; -import me.jellysquid.mods.sodium.client.gl.shader.GlShader; -import me.jellysquid.mods.sodium.client.gl.shader.ShaderConstants; -import me.jellysquid.mods.sodium.client.gl.shader.ShaderLoader; -import me.jellysquid.mods.sodium.client.gl.shader.ShaderType; -import me.jellysquid.mods.sodium.client.model.vertex.type.ChunkVertexType; -import me.jellysquid.mods.sodium.client.render.chunk.ChunkGraphicsState; -import me.jellysquid.mods.sodium.client.render.chunk.ChunkRenderBackend; -import me.jellysquid.mods.sodium.client.render.chunk.format.ChunkMeshAttribute; -import me.jellysquid.mods.sodium.client.render.chunk.passes.BlockRenderPass; -import net.coderbot.iris.Iris; -import net.coderbot.iris.gl.program.ProgramSamplers; -import net.coderbot.iris.gl.program.ProgramUniforms; -import net.coderbot.iris.pipeline.SodiumTerrainPipeline; -import net.coderbot.iris.pipeline.WorldRenderingPipeline; -import net.coderbot.iris.shaderpack.transform.StringTransformations; -import net.coderbot.iris.shaderpack.transform.Transformations; -import net.coderbot.iris.shadows.ShadowRenderingState; -import net.coderbot.iris.sodium.shader_overrides.IrisChunkProgramOverrides; -import net.coderbot.iris.sodium.vertex_format.IrisModelVertexFormats; -import net.minecraft.util.ResourceLocation; -import org.apache.commons.io.IOUtils; - -import java.io.IOException; -import java.io.InputStream; -import java.nio.charset.StandardCharsets; -import java.util.EnumMap; -import java.util.List; - -public abstract class ChunkRenderShaderBackend implements ChunkRenderBackend { - - private final EnumMap programs = new EnumMap<>(ChunkFogMode.class); - - protected final ChunkVertexType vertexType; - protected final GlVertexFormat vertexFormat; - - protected ChunkProgram activeProgram; - - // Iris - private IrisChunkProgramOverrides irisChunkProgramOverrides; - - private RenderDevice device; - - private ChunkProgram override; - - public ChunkRenderShaderBackend(ChunkVertexType vertexType) { - if (Iris.enabled) { - irisChunkProgramOverrides = new IrisChunkProgramOverrides(); - } - - this.vertexType = vertexType; - this.vertexFormat = vertexType.getCustomVertexFormat(); - } - - public GlShader loadShaderRedirect(RenderDevice device, ShaderType type, ResourceLocation name, List constants) { - if (Iris.enabled && this.vertexType == IrisModelVertexFormats.MODEL_VERTEX_XHFP) { - String shader = getShaderSource(ShaderLoader.getShaderPath(name, type)); - shader = shader.replace("v_LightCoord = a_LightCoord", "v_LightCoord = (iris_LightmapTextureMatrix * vec4(a_LightCoord, 0, 1)).xy"); - - StringTransformations transformations = new StringTransformations(shader); - - transformations.injectLine( - Transformations.InjectionPoint.BEFORE_CODE, - "mat4 iris_LightmapTextureMatrix = mat4(vec4(0.00390625, 0.0, 0.0, 0.0), vec4(0.0, 0.00390625, 0.0, 0.0), vec4(0.0, 0.0, 0.00390625, 0.0), vec4(0.03125, 0.03125, 0.03125, 1.0));"); - - return new GlShader(device, type, name, transformations.toString(), ShaderConstants.fromStringList(constants)); - } else { - return ShaderLoader.loadShader(device, type, name, ShaderConstants.fromStringList(constants)); - } - } - - private ChunkProgram createShader(RenderDevice device, ChunkFogMode fogMode, GlVertexFormat vertexFormat) { - if(Iris.enabled) { - this.device = device; - WorldRenderingPipeline worldRenderingPipeline = Iris.getPipelineManager().getPipelineNullable(); - SodiumTerrainPipeline sodiumTerrainPipeline = null; - - if (worldRenderingPipeline != null) { - sodiumTerrainPipeline = worldRenderingPipeline.getSodiumTerrainPipeline(); - } - - irisChunkProgramOverrides.createShaders(sodiumTerrainPipeline, device); - } - - GlShader vertShader = loadShaderRedirect(device, ShaderType.VERTEX, new ResourceLocation("sodium", "chunk_gl20"), fogMode.getDefines()); - - GlShader fragShader = ShaderLoader.loadShader(device, ShaderType.FRAGMENT, new ResourceLocation("sodium", "chunk_gl20"), ShaderConstants.fromStringList(fogMode.getDefines())); - - try { - return GlProgram.builder(new ResourceLocation("sodium", "chunk_shader")) - .attachShader(vertShader) - .attachShader(fragShader) - .bindAttribute("a_Pos", ChunkShaderBindingPoints.POSITION) - .bindAttribute("a_Color", ChunkShaderBindingPoints.COLOR) - .bindAttribute("a_TexCoord", ChunkShaderBindingPoints.TEX_COORD) - .bindAttribute("a_LightCoord", ChunkShaderBindingPoints.LIGHT_COORD) - .bindAttribute("d_ModelOffset", ChunkShaderBindingPoints.MODEL_OFFSET) - .build((program, name) -> new ChunkProgram(device, program, name, fogMode.getFactory())); - } finally { - vertShader.delete(); - fragShader.delete(); - } - } - - - - private static String getShaderSource(String path) { - try { - InputStream in = ShaderLoader.class.getResourceAsStream(path); - Exception throwable = null; - - String res; - try { - if (in == null) { - throw new RuntimeException("Shader not found: " + path); - } - - res = IOUtils.toString(in, StandardCharsets.UTF_8); - } catch (Exception tr) { - throwable = tr; - throw tr; - } finally { - if (in != null) { - if (throwable != null) { - try { - in.close(); - } catch (Exception var12) { - throwable.addSuppressed(var12); - } - } else { - in.close(); - } - } - - } - - return res; - } catch (IOException e) { - throw new RuntimeException("Could not read shader sources", e); - } - } - - - @Override - public final void createShaders(RenderDevice device) { - this.programs.put(ChunkFogMode.NONE, this.createShader(device, ChunkFogMode.NONE, this.vertexFormat)); - this.programs.put(ChunkFogMode.LINEAR, this.createShader(device, ChunkFogMode.LINEAR, this.vertexFormat)); - this.programs.put(ChunkFogMode.EXP2, this.createShader(device, ChunkFogMode.EXP2, this.vertexFormat)); - } - - @Override - public void begin(MatrixStack matrixStack) { - this.activeProgram = this.programs.get(FogHelper.getFogMode()); - if (Iris.enabled && override != null) { - this.activeProgram = override; - } - this.activeProgram.bind(); - this.activeProgram.setup(matrixStack, this.vertexType.getModelScale(), this.vertexType.getTextureScale()); - } - - @Override - public void end(MatrixStack matrixStack) { - this.activeProgram.unbind(); - this.activeProgram = null; - if(Iris.enabled) { - ProgramUniforms.clearActiveUniforms(); - ProgramSamplers.clearActiveSamplers(); - Iris.getPipelineManager().getPipeline().ifPresent(WorldRenderingPipeline::endSodiumTerrainRendering); - } - } - - @Override - public void delete() { - if(Iris.enabled) { - irisChunkProgramOverrides.deleteShaders(); - } - for (ChunkProgram shader : this.programs.values()) { - shader.delete(); - } - } - - @Override - public ChunkVertexType getVertexType() { - return this.vertexType; - } - - // Iris - public void iris$begin(MatrixStack matrixStack, BlockRenderPass pass) { - if (ShadowRenderingState.areShadowsCurrentlyBeingRendered()) { - // No back face culling during the shadow pass - // TODO: Hopefully this won't be necessary in the future... - GLStateManager.disableCull(); - } - - this.override = irisChunkProgramOverrides.getProgramOverride(device, pass); - - Iris.getPipelineManager().getPipeline().ifPresent(WorldRenderingPipeline::beginSodiumTerrainRendering); - begin(matrixStack); - } - -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/shader/ChunkShaderBindingPoints.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/shader/ChunkShaderBindingPoints.java deleted file mode 100644 index 9b1b6d3d6..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/shader/ChunkShaderBindingPoints.java +++ /dev/null @@ -1,12 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.shader; - -import me.jellysquid.mods.sodium.client.gl.shader.ShaderBindingPoint; - -public class ChunkShaderBindingPoints { - public static final ShaderBindingPoint POSITION = new ShaderBindingPoint(0); - public static final ShaderBindingPoint COLOR = new ShaderBindingPoint(1); - public static final ShaderBindingPoint TEX_COORD = new ShaderBindingPoint(2); - public static final ShaderBindingPoint LIGHT_COORD = new ShaderBindingPoint(3); - - public static final ShaderBindingPoint MODEL_OFFSET = new ShaderBindingPoint(4); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/shader/ChunkShaderFogComponent.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/shader/ChunkShaderFogComponent.java deleted file mode 100644 index f32da240e..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/shader/ChunkShaderFogComponent.java +++ /dev/null @@ -1,70 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.shader; - -import me.jellysquid.mods.sodium.client.gl.compat.FogHelper; -import org.lwjgl.opengl.GL20; - -/** - * These shader implementations try to remain compatible with the deprecated fixed function pipeline by manually - * copying the state into each shader's uniforms. The shader code itself is a straight-forward implementation of the - * fog functions themselves from the fixed-function pipeline, except that they use the distance from the camera - * rather than the z-buffer to produce better looking fog that doesn't move with the player's view angle. - * - * Minecraft itself will actually try to enable distance-based fog by using the proprietary NV_fog_distance extension, - * but as the name implies, this only works on graphics cards produced by NVIDIA. The shader implementation however does - * not depend on any vendor-specific extensions and is written using very simple GLSL code. - */ -public abstract class ChunkShaderFogComponent { - public abstract void setup(); - - public static class None extends ChunkShaderFogComponent { - public None(ChunkProgram program) { - - } - - @Override - public void setup() { - - } - } - - public static class Exp2 extends ChunkShaderFogComponent { - private final int uFogColor; - private final int uFogDensity; - - public Exp2(ChunkProgram program) { - this.uFogColor = program.getUniformLocation("u_FogColor"); - this.uFogDensity = program.getUniformLocation("u_FogDensity"); - } - - @Override - public void setup() { - final float[] fc = FogHelper.getFogColor(); - GL20.glUniform4f(this.uFogColor, fc[0], fc[1], fc[2], fc[3]); - GL20.glUniform1f(this.uFogDensity, FogHelper.getFogDensity()); - } - } - - public static class Linear extends ChunkShaderFogComponent { - private final int uFogColor; - private final int uFogLength; - private final int uFogEnd; - - public Linear(ChunkProgram program) { - this.uFogColor = program.getUniformLocation("u_FogColor"); - this.uFogLength = program.getUniformLocation("u_FogLength"); - this.uFogEnd = program.getUniformLocation("u_FogEnd"); - } - - @Override - public void setup() { - float end = FogHelper.getFogEnd(); - float start = FogHelper.getFogStart(); - float[] color = FogHelper.getFogColor(); - - GL20.glUniform4f(this.uFogColor, color[0], color[1], color[2], color[3]); - GL20.glUniform1f(this.uFogLength, end - start); - GL20.glUniform1f(this.uFogEnd, end); - } - } - -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/tasks/ChunkRenderBuildTask.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/tasks/ChunkRenderBuildTask.java deleted file mode 100644 index 6f3378821..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/tasks/ChunkRenderBuildTask.java +++ /dev/null @@ -1,41 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.tasks; - -import me.jellysquid.mods.sodium.client.render.chunk.ChunkGraphicsState; -import me.jellysquid.mods.sodium.client.render.chunk.compile.ChunkBuildBuffers; -import me.jellysquid.mods.sodium.client.render.chunk.compile.ChunkBuildResult; -import me.jellysquid.mods.sodium.client.render.pipeline.context.ChunkRenderCacheLocal; -import me.jellysquid.mods.sodium.client.util.task.CancellationSource; - -/** - * Build tasks are immutable jobs (with optional prioritization) which contain all the necessary state to perform - * chunk mesh updates or quad sorting off the main thread. - * - * When a task is constructed on the main thread, it should copy all the state it requires in order to complete the task - * without further synchronization. The task will then be scheduled for async execution on a thread pool. - * - * After the task completes, it returns a "build result" which contains any computed data that needs to be handled - * on the main thread. - * - * @param The graphics state of the chunk render - */ -public abstract class ChunkRenderBuildTask { - /** - * Executes the given build task asynchronously from the calling thread. The implementation should be careful not - * to access or modify global mutable state. - * - * @param cache The render cache to use for building this chunk - * @param buffers The temporary scratch buffers for rendering block data - * @param cancellationSource The cancellation source which can be used to query if the task is cancelled - * @return The build result of this task, containing any data which needs to be uploaded on the main-thread, or null - * if the task was cancelled. - */ - public abstract ChunkBuildResult performBuild(ChunkRenderCacheLocal cache, ChunkBuildBuffers buffers, - CancellationSource cancellationSource); - - public boolean willRenderInMainThread(ChunkRenderCacheLocal cache) { return false; }; - /** - * Called on the main render thread when the task's execution returns. The implementation should release any - * resources it's still holding onto at this point. - */ - public abstract void releaseResources(); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/tasks/ChunkRenderRebuildTask.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/tasks/ChunkRenderRebuildTask.java deleted file mode 100644 index 145a089f2..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/tasks/ChunkRenderRebuildTask.java +++ /dev/null @@ -1,406 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.tasks; - -import com.gtnewhorizon.gtnhlib.blockpos.BlockPos; -import com.gtnewhorizons.angelica.compat.ModStatus; -import com.gtnewhorizons.angelica.compat.mojang.ChunkOcclusionDataBuilder; -import com.gtnewhorizons.angelica.compat.toremove.RenderLayer; -import com.gtnewhorizons.angelica.config.AngelicaConfig; -import com.gtnewhorizons.angelica.mixins.interfaces.ITexturesCache; -import net.coderbot.iris.Iris; -import com.gtnewhorizons.angelica.rendering.AngelicaBlockSafetyRegistry; -import com.gtnewhorizons.angelica.rendering.AngelicaRenderQueue; -import com.gtnewhorizons.angelica.utils.AnimationsRenderUtils; -import it.unimi.dsi.fastutil.longs.LongArrayFIFOQueue; -import java.util.Map; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.ExecutionException; -import me.jellysquid.mods.sodium.client.SodiumClientMod; -import me.jellysquid.mods.sodium.client.render.chunk.ChunkGraphicsState; -import me.jellysquid.mods.sodium.client.render.chunk.ChunkRenderContainer; -import me.jellysquid.mods.sodium.client.render.chunk.ChunkRenderManager; -import me.jellysquid.mods.sodium.client.render.chunk.compile.ChunkBuildBuffers; -import me.jellysquid.mods.sodium.client.render.chunk.compile.ChunkBuildResult; -import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkMeshData; -import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkRenderBounds; -import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkRenderData; -import me.jellysquid.mods.sodium.client.render.chunk.passes.BlockRenderPass; -import me.jellysquid.mods.sodium.client.render.pipeline.WorldUtil; -import me.jellysquid.mods.sodium.client.render.pipeline.context.ChunkRenderCacheLocal; -import me.jellysquid.mods.sodium.client.util.MathUtil; -import me.jellysquid.mods.sodium.client.util.task.CancellationSource; -import me.jellysquid.mods.sodium.client.world.WorldSlice; -import me.jellysquid.mods.sodium.client.world.cloned.ChunkRenderContext; -import net.coderbot.iris.block_rendering.BlockRenderingSettings; -import net.coderbot.iris.vertices.ExtendedDataHelper; -import net.minecraft.block.Block; -import net.minecraft.block.material.Material; -import net.minecraft.client.renderer.RenderBlocks; -import net.minecraft.client.renderer.texture.TextureAtlasSprite; -import net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher; -import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer; -import net.minecraft.tileentity.TileEntity; -import net.minecraft.util.AxisAlignedBB; -import net.minecraft.util.IIcon; -import net.minecraftforge.fluids.Fluid; -import org.joml.Vector3d; - -/** - * Rebuilds all the meshes of a chunk for each given render pass with non-occluded blocks. The result is then uploaded - * to graphics memory on the main thread. - * - * This task takes a slice of the world from the thread it is created on. Since these slices require rather large - * array allocations, they are pooled to ensure that the garbage collector doesn't become overloaded. - */ -public class ChunkRenderRebuildTask extends ChunkRenderBuildTask { - private final ChunkRenderContainer render; - - private final BlockPos offset; - - private final ChunkRenderContext context; - - private Vector3d camera; - - private final boolean translucencySorting; - - private boolean hasMainThreadBlocks = false; - private boolean hasMainThreadBlocksComputed = false; - - public ChunkRenderRebuildTask(ChunkRenderContainer render, ChunkRenderContext context, BlockPos offset) { - this.render = render; - this.offset = offset; - this.context = context; - this.camera = new Vector3d(); - this.translucencySorting = SodiumClientMod.options().advanced.translucencySorting; - } - - public ChunkRenderRebuildTask withCameraPosition(Vector3d camera) { - this.camera = camera; - return this; - } - - private boolean rendersOutsideBoundingBox(TileEntity entity, int baseX, int baseY, int baseZ) { - AxisAlignedBB box = entity.getRenderBoundingBox(); - - // Check if it's explictly infinite - if(box == TileEntity.INFINITE_EXTENT_AABB) - return true; - - // Check if it extends outside our minimums - if(box.minX < baseX || box.minY < baseY || box.minZ < baseZ) - return true; - - // Check if it extends outside our maximums - if(box.maxX > (baseX + 16) || box.maxY > (baseY + 16) || box.maxZ > (baseZ + 16)) - return true; - - // So it's within the chunk - return false; - } - - private boolean rendersOffThread(Block block) { - final int type = block.getRenderType(); - return (type < 42 && type != 22 && AngelicaBlockSafetyRegistry.canBlockRenderOffThread(block, false, false)) || AngelicaBlockSafetyRegistry.canBlockRenderOffThread(block, true, false); - } - - private void handleRenderBlocksTextures(RenderBlocks rb, ChunkRenderData.Builder builder) { - if(!AngelicaConfig.speedupAnimations || !(rb instanceof ITexturesCache)) return; - - for(IIcon texture : ((ITexturesCache)rb).getRenderedTextures()) { - if(texture instanceof TextureAtlasSprite textureAtlasSprite) { - builder.addSprite(textureAtlasSprite); - } - } - } - - private boolean canRenderInPass(Block block, BlockRenderPass pass) { - boolean canRender = block.canRenderInPass(pass.ordinal()); - Map blockTypeIds = BlockRenderingSettings.INSTANCE.getBlockTypeIds(); - RenderLayer renderLayer; - if (blockTypeIds != null && (renderLayer = blockTypeIds.get(block)) != null) { - canRender = switch (pass) { - case CUTOUT_MIPPED -> renderLayer == RenderLayer.cutout(); - case TRANSLUCENT -> renderLayer == RenderLayer.translucent(); - }; - } - return canRender; - } - - public boolean willRenderInMainThread(ChunkRenderCacheLocal cache) { - if (hasMainThreadBlocksComputed) - return hasMainThreadBlocks; - - final ChunkRenderData.Builder renderData = new ChunkRenderData.Builder(); - final ChunkOcclusionDataBuilder occluder = new ChunkOcclusionDataBuilder(); - final ChunkRenderBounds.Builder bounds = new ChunkRenderBounds.Builder(); - - cache.init(this.context); - - final WorldSlice slice = cache.getWorldSlice(); - - final int baseX = this.render.getOriginX(); - final int baseY = this.render.getOriginY(); - final int baseZ = this.render.getOriginZ(); - - final BlockPos pos = new BlockPos(); - - outer: - for (int relY = 0; relY < 16; relY++) { - for (int relZ = 0; relZ < 16; relZ++) { - for (int relX = 0; relX < 16; relX++) { - final Block block = slice.getBlockRelative(relX + 16, relY + 16, relZ + 16); - - // If the block is vanilla air, assume it renders nothing. Don't use isAir because mods - // can abuse it for all sorts of things - if (block.getMaterial() == Material.air) { - continue; - } - - if (!rendersOffThread(block)) { - hasMainThreadBlocks = true; - break outer; - } - } - } - } - - hasMainThreadBlocksComputed = true; - return hasMainThreadBlocks; - } - - @Override - public ChunkBuildResult performBuild(ChunkRenderCacheLocal cache, ChunkBuildBuffers buffers, CancellationSource cancellationSource) { - final ChunkRenderData.Builder renderData = new ChunkRenderData.Builder(); - final ChunkOcclusionDataBuilder occluder = new ChunkOcclusionDataBuilder(); - final ChunkRenderBounds.Builder bounds = new ChunkRenderBounds.Builder(); - - buffers.init(renderData); - - cache.init(this.context); - - final WorldSlice slice = cache.getWorldSlice(); - final RenderBlocks renderBlocks = new RenderBlocks(slice); - if(renderBlocks instanceof ITexturesCache textureCache) { - textureCache.enableTextureTracking(); - AnimationsRenderUtils.pushCache(textureCache); - } - - final int baseX = this.render.getOriginX(); - final int baseY = this.render.getOriginY(); - final int baseZ = this.render.getOriginZ(); - - final BlockPos pos = new BlockPos(); - final BlockPos renderOffset = this.offset; - - final LongArrayFIFOQueue mainThreadBlocks = new LongArrayFIFOQueue(); - - for (int relY = 0; relY < 16; relY++) { - if (cancellationSource.isCancelled()) { - return null; - } - - for (int relZ = 0; relZ < 16; relZ++) { - for (int relX = 0; relX < 16; relX++) { - Fluid fluid = null; - if (ModStatus.isFluidLoggedLoaded) { - fluid = slice.getFluidRelative(relX + 16, relY + 16, relZ + 16); - } - - final Block block = slice.getBlockRelative(relX + 16, relY + 16, relZ + 16); - - // If the block is vanilla air, assume it renders nothing. Don't use isAir because mods - // can abuse it for all sorts of things - if (block.getMaterial() == Material.air) { - continue; - } - - final int meta = slice.getBlockMetadataRelative(relX + 16, relY + 16, relZ + 16); - - pos.set(baseX + relX, baseY + relY, baseZ + relZ); - buffers.setRenderOffset(pos.x - renderOffset.getX(), pos.y - renderOffset.getY(), pos.z - renderOffset.getZ()); - - if(Iris.enabled) buffers.iris$setLocalPos(relX, relY, relZ); - - if (rendersOffThread(block)) { - // Do regular block rendering - final long seed = MathUtil.hashPos(pos.x, pos.y, pos.z); - for (BlockRenderPass pass : BlockRenderPass.VALUES) { - if (ModStatus.isFluidLoggedLoaded) { - if (fluid != null && canRenderInPass(fluid.getBlock(), pass)) { - ChunkRenderManager.setWorldRenderPass(pass); - if(Iris.enabled) buffers.iris$setMaterialId(fluid.getBlock(), ExtendedDataHelper.FLUID_RENDER_TYPE); - - cache.getBlockRenderer().renderFluidLogged(cache.getWorldSlice(), fluid, renderBlocks, pos, buffers.get(pass), seed); - } - } - if (canRenderInPass(block, pass) && !shouldUseSodiumFluidRendering(block)) { - ChunkRenderManager.setWorldRenderPass(pass); - if(Iris.enabled) buffers.iris$setMaterialId(block, ExtendedDataHelper.BLOCK_RENDER_TYPE); - - if (cache.getBlockRenderer().renderModel(cache.getWorldSlice(), renderBlocks, block, meta, pos, buffers.get(pass), true, seed)) { - bounds.addBlock(relX, relY, relZ); - } - } - } - - } else { - mainThreadBlocks.enqueue(pos.asLong()); - hasMainThreadBlocks = true; - } - - // Do fluid rendering without RenderBlocks - if (shouldUseSodiumFluidRendering(block)) { - for (BlockRenderPass pass : BlockRenderPass.VALUES) { - if (canRenderInPass(block, pass)) { - ChunkRenderManager.setWorldRenderPass(pass); - if(Iris.enabled) buffers.iris$setMaterialId(block, ExtendedDataHelper.FLUID_RENDER_TYPE); - - if (cache.getFluidRenderer().render(slice, cache.getWorldSlice(), block, pos, buffers.get(pass))) { - bounds.addBlock(relX, relY, relZ); - } - } - } - } - - if(Iris.enabled) buffers.iris$resetBlockContext(); - - if (block.hasTileEntity(meta)) { - final TileEntity entity = slice.getTileEntity(pos.x, pos.y, pos.z); - - final TileEntitySpecialRenderer renderer = TileEntityRendererDispatcher.instance.getSpecialRenderer(entity); - if (entity != null && renderer != null) { - renderData.addTileEntity(entity, !rendersOutsideBoundingBox(entity, baseX, baseY, baseZ)); - bounds.addBlock(relX, relY, relZ); - } - } - - if (block.isOpaqueCube()) { - occluder.markClosed(pos); - } - } - } - } - - if(renderBlocks instanceof ITexturesCache) { - AnimationsRenderUtils.popCache(); - } - - handleRenderBlocksTextures(renderBlocks, renderData); - - hasMainThreadBlocksComputed = true; - if(hasMainThreadBlocks) { - // Render the other blocks on the main thread - var future = CompletableFuture.runAsync(() -> this.performMainBuild(cache, buffers, cancellationSource, bounds, renderData, mainThreadBlocks), AngelicaRenderQueue.executor()); - while(!future.isDone() && !cancellationSource.isCancelled()) { - try { - future.get(); - } catch(InterruptedException e) { - // go around and check cancellation - } catch(ExecutionException e) { - throw new RuntimeException(e); - } - } - // Check if cancellation happened during that, so we don't render an incomplete chunk - if(cancellationSource.isCancelled()) return null; - } - - render.setRebuildForTranslucents(false); - for (BlockRenderPass pass : BlockRenderPass.VALUES) { - final ChunkMeshData mesh = buffers.createMesh(pass, (float)camera.x - offset.getX(), (float)camera.y - offset.getY(), (float)camera.z - offset.getZ(), this.translucencySorting); - - if (mesh != null) { - renderData.setMesh(pass, mesh); - if(this.translucencySorting && pass.isTranslucent()) - render.setRebuildForTranslucents(true); - } - } - - renderData.setOcclusionData(occluder.build()); - renderData.setBounds(bounds.build(this.render.getChunkPos())); - - return new ChunkBuildResult<>(this.render, renderData.build()); - } - - /** - * Render the blocks that should be rendered on the main thread. - */ - private void performMainBuild(ChunkRenderCacheLocal cache, ChunkBuildBuffers buffers, CancellationSource cancellationSource, ChunkRenderBounds.Builder bounds, ChunkRenderData.Builder renderData, LongArrayFIFOQueue mainThreadBlocks) { - final WorldSlice slice = cache.getWorldSlice(); - final BlockPos pos = new BlockPos(); - final int baseX = this.render.getOriginX(); - final int baseY = this.render.getOriginY(); - final int baseZ = this.render.getOriginZ(); - final BlockPos renderOffset = this.offset; - final RenderBlocks rb = new RenderBlocks(slice.getWorld()); - if(rb instanceof ITexturesCache textureCache) { - textureCache.enableTextureTracking(); - AnimationsRenderUtils.pushCache(textureCache); - } - while(!mainThreadBlocks.isEmpty()) { - final long longPos = mainThreadBlocks.dequeueLong(); - if (cancellationSource.isCancelled()) { - return; - } - pos.set(longPos); - final int relX = pos.getX() - baseX; - final int relY = pos.getY() - baseY; - final int relZ = pos.getZ() - baseZ; - final Block block = slice.getBlockRelative(relX + 16, relY + 16, relZ + 16); - - // Only render blocks that need main thread assistance - if (block.getMaterial() == Material.air || rendersOffThread(block)) { - continue; - } - - // TODO: Collect data on which render types are hitting this code path most often so mods can be updated slowly - - final int meta = slice.getBlockMetadataRelative(relX + 16, relY + 16, relZ + 16); - - buffers.setRenderOffset(pos.x - renderOffset.getX(), pos.y - renderOffset.getY(), pos.z - renderOffset.getZ()); - if(Iris.enabled) buffers.iris$setLocalPos(relX, relY, relZ); - - // Do regular block rendering - for (BlockRenderPass pass : BlockRenderPass.VALUES) { - if (canRenderInPass(block, pass) && !shouldUseSodiumFluidRendering(block)) { - ChunkRenderManager.setWorldRenderPass(pass); - final long seed = MathUtil.hashPos(pos.x, pos.y, pos.z); - if(Iris.enabled) buffers.iris$setMaterialId(block, ExtendedDataHelper.BLOCK_RENDER_TYPE); - - if (cache.getBlockRenderer().renderModel(slice.getWorld(), rb, block, meta, pos, buffers.get(pass), true, seed)) { - bounds.addBlock(relX, relY, relZ); - } - } - } - - if(Iris.enabled) buffers.iris$resetBlockContext(); - } - - if(rb instanceof ITexturesCache) { - AnimationsRenderUtils.popCache(); - } - - handleRenderBlocksTextures(rb, renderData); - } - - @Override - public void releaseResources() { - this.context.releaseResources(); - } - - @Override - public String toString() { - return "ChunkRenderRebuildTask{" - + "offset=" - + offset - + ", camera=" - + camera - + ", translucencySorting=" - + translucencySorting - + ", hasMainThreadBlocks=" - + hasMainThreadBlocks - + '}'; - } - - private static boolean shouldUseSodiumFluidRendering(Block block) { - return AngelicaConfig.enableSodiumFluidRendering && WorldUtil.isFluidBlock(block) && !ModStatus.isFluidLoggedLoaded; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/tasks/ChunkRenderTranslucencySortTask.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/tasks/ChunkRenderTranslucencySortTask.java deleted file mode 100644 index 5f2adb23f..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/tasks/ChunkRenderTranslucencySortTask.java +++ /dev/null @@ -1,100 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.chunk.tasks; - -import com.gtnewhorizon.gtnhlib.blockpos.BlockPos; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing; -import me.jellysquid.mods.sodium.client.gl.buffer.VertexData; -import me.jellysquid.mods.sodium.client.gl.util.BufferSlice; -import me.jellysquid.mods.sodium.client.render.chunk.ChunkGraphicsState; -import me.jellysquid.mods.sodium.client.render.chunk.ChunkRenderContainer; -import me.jellysquid.mods.sodium.client.render.chunk.compile.ChunkBufferSorter; -import me.jellysquid.mods.sodium.client.render.chunk.compile.ChunkBuildBuffers; -import me.jellysquid.mods.sodium.client.render.chunk.compile.ChunkBuildResult; -import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkMeshData; -import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkRenderData; -import me.jellysquid.mods.sodium.client.render.chunk.passes.BlockRenderPass; -import me.jellysquid.mods.sodium.client.render.pipeline.context.ChunkRenderCacheLocal; -import me.jellysquid.mods.sodium.client.util.task.CancellationSource; -import org.joml.Vector3d; -import org.lwjgl.BufferUtils; - -import java.nio.ByteBuffer; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; - -/** - * Handles sorting translucency data in built chunks. - */ -public class ChunkRenderTranslucencySortTask extends ChunkRenderBuildTask { - private static final BlockRenderPass[] TRANSLUCENT_PASSES = Arrays.stream(BlockRenderPass.VALUES).filter(BlockRenderPass::isTranslucent).toArray(BlockRenderPass[]::new); - - private static final BlockRenderPass[] NO_PASSES = new BlockRenderPass[0]; - - private final ChunkRenderContainer render; - private final BlockPos offset; - private final Vector3d camera; - - public ChunkRenderTranslucencySortTask(ChunkRenderContainer render, BlockPos offset, Vector3d camera) { - this.render = render; - this.offset = offset; - this.camera = camera; - - } - - - @Override - public ChunkBuildResult performBuild(ChunkRenderCacheLocal cache, ChunkBuildBuffers buffers, CancellationSource cancellationSource) { - final ChunkRenderData data = this.render.getData(); - final Map replacementMeshes; - - if(!data.isEmpty()) { - replacementMeshes = new HashMap<>(); - for(BlockRenderPass pass : TRANSLUCENT_PASSES) { - final ChunkGraphicsState state = this.render.getGraphicsState(pass); - if(state == null) - continue; - final ByteBuffer translucencyData = state.getTranslucencyData(); - if(translucencyData == null) - continue; - final ChunkMeshData translucentMesh = data.getMesh(pass); - if(translucentMesh == null) - continue; - - // Make a snapshot of the translucency data to sort - final ByteBuffer sortedData = BufferUtils.createByteBuffer(translucencyData.capacity()); - synchronized (translucencyData) { - sortedData.put(translucencyData); - translucencyData.position(0); - translucencyData.limit(translucencyData.capacity()); - } - - sortedData.flip(); - // Sort it and create the new mesh - ChunkBufferSorter.sortStandardFormat(buffers.getVertexType(), sortedData, sortedData.capacity(), (float) camera.x - offset.getX(), (float)camera.y - offset.getY(), (float)camera.z - offset.getZ()); - final ChunkMeshData newMesh = new ChunkMeshData(); - newMesh.setVertexData(new VertexData(sortedData, buffers.getVertexType().getCustomVertexFormat())); - for(Map.Entry entry : translucentMesh.getSlices()) { - newMesh.setModelSlice(entry.getKey(), entry.getValue()); - } - replacementMeshes.put(pass, newMesh); - } - } else { - replacementMeshes = Collections.emptyMap(); - } - - final ChunkBuildResult result = new ChunkBuildResult<>(this.render, data.copyAndReplaceMesh(replacementMeshes)); - result.passesToUpload = replacementMeshes.keySet().toArray(NO_PASSES); - return result; - } - - @Override - public void releaseResources() { - - } - - @Override - public String toString() { - return "ChunkRenderTranslucencySortTask{" + "offset=" + offset + ", camera=" + camera + '}'; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/entity/EntityLightSampler.java b/src/main/java/me/jellysquid/mods/sodium/client/render/entity/EntityLightSampler.java deleted file mode 100644 index f90a55dad..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/entity/EntityLightSampler.java +++ /dev/null @@ -1,10 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.entity; - -import com.gtnewhorizon.gtnhlib.blockpos.BlockPos; -import net.minecraft.entity.Entity; - -public interface EntityLightSampler { - int bridge$getBlockLight(T entity, BlockPos pos); - - int bridge$getSkyLight(T entity, BlockPos pos); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/occlusion/BlockOcclusionCache.java b/src/main/java/me/jellysquid/mods/sodium/client/render/occlusion/BlockOcclusionCache.java deleted file mode 100644 index 37a1d6f94..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/occlusion/BlockOcclusionCache.java +++ /dev/null @@ -1,70 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.occlusion; - -import com.gtnewhorizon.gtnhlib.blockpos.BlockPos; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing; -import it.unimi.dsi.fastutil.objects.Object2ByteLinkedOpenHashMap; -import net.minecraft.block.Block; -import net.minecraft.world.IBlockAccess; - -public class BlockOcclusionCache { - private static final byte UNCACHED_VALUE = (byte) 127; - - private final Object2ByteLinkedOpenHashMap map; - private final BlockPos cpos = new BlockPos(); - - public BlockOcclusionCache() { - this.map = new Object2ByteLinkedOpenHashMap<>(2048, 0.5F); - this.map.defaultReturnValue(UNCACHED_VALUE); - } - - /** - * @param block The block in the world - * @param meta The meta value of the block - * @param view The world view for this render context - * @param pos The position of the block - * @param facing The facing direction of the side to check - * @return True if the block side facing {@param dir} is not occluded, otherwise false - */ - public boolean shouldDrawSide(Block block, int meta, IBlockAccess view, BlockPos pos, ModelQuadFacing facing) { - if (facing == ModelQuadFacing.UNASSIGNED) - return true; - - final BlockPos adjPos = this.cpos; - adjPos.set(pos.getX() + facing.getStepX(), pos.getY() + facing.getStepY(), pos.getZ() + facing.getStepZ()); - - final Block adjState = view.getBlock(adjPos.x, adjPos.y, adjPos.z); - - return !adjState.isOpaqueCube(); - - // TODO: Use VoxelShape occlusion from modern - } - - private static final class CachedOcclusionShapeTest { - private Block a, b; - private int hashCode; - - private CachedOcclusionShapeTest() { - - } - - private CachedOcclusionShapeTest(Block a, Block b, int hashCode) { - this.a = a; - this.b = b; - this.hashCode = hashCode; - } - - @Override - public boolean equals(Object o) { - if (o instanceof CachedOcclusionShapeTest that) { - return this.a == that.a && this.b == that.b; - } - - return false; - } - - @Override - public int hashCode() { - return this.hashCode; - } - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/pipeline/BlockRenderer.java b/src/main/java/me/jellysquid/mods/sodium/client/render/pipeline/BlockRenderer.java deleted file mode 100644 index bcdd1d599..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/pipeline/BlockRenderer.java +++ /dev/null @@ -1,189 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.pipeline; - -import com.gtnewhorizon.gtnhlib.blockpos.BlockPos; -import com.gtnewhorizon.gtnhlib.client.renderer.CapturingTessellator; -import com.gtnewhorizon.gtnhlib.client.renderer.TessellatorManager; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.ColorMixer; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.ModelQuadView; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.ModelQuadViewMutable; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadOrientation; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.util.ModelQuadUtil; -import java.util.List; -import net.coderbot.iris.Iris; -import java.util.Random; -import me.jellysquid.mods.sodium.client.SodiumClientMod; -import me.jellysquid.mods.sodium.client.model.light.LightMode; -import me.jellysquid.mods.sodium.client.model.light.LightPipeline; -import me.jellysquid.mods.sodium.client.model.light.LightPipelineProvider; -import me.jellysquid.mods.sodium.client.model.light.data.QuadLightData; -import me.jellysquid.mods.sodium.client.render.chunk.compile.buffers.ChunkModelBuffers; -import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkRenderData; -import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexSink; -import me.jellysquid.mods.sodium.client.util.rand.XoRoShiRoRandom; -import net.coderbot.iris.block_rendering.BlockRenderingSettings; -import net.minecraft.block.Block; -import net.minecraft.client.Minecraft; -import net.minecraft.client.renderer.RenderBlocks; -import net.minecraft.client.renderer.texture.TextureAtlasSprite; -import net.minecraft.world.IBlockAccess; -import net.minecraftforge.fluids.Fluid; - -public class BlockRenderer { - private static final BlockPos POS_ZERO = new BlockPos(0, 0, 0); - - private final Random random = new XoRoShiRoRandom(); - - private final QuadLightData cachedQuadLightData = new QuadLightData(); - - private final boolean useAmbientOcclusion; - private final boolean useSodiumAO; - private boolean useSeparateAo; - - private final LightPipelineProvider lighters; - - - public BlockRenderer(LightPipelineProvider lighters) { - this.lighters = lighters; - // TODO: Sodium - AO Setting - this.useAmbientOcclusion = Minecraft.getMinecraft().gameSettings.ambientOcclusion > 0; - this.useSodiumAO = SodiumClientMod.options().quality.useSodiumAO; - } - - public boolean renderFluidLogged(IBlockAccess world, Fluid fluid, RenderBlocks renderBlocks, BlockPos pos, ChunkModelBuffers buffers, long seed) { - if (fluid == null) { - return false; - } - Block block = fluid.getBlock(); - if (block == null) { - return false; - } - - boolean rendered = false; - final int emitted = block.getLightValue(world, pos.x, pos.y, pos.z); - - try { - final LightMode mode = LightMode.SMOOTH; // TODO: this.getLightingMode(block); is what was previously used. The flat pipeline is busted and was only an optimization for very few blocks. - final LightPipeline lighter = this.lighters.getLighter(mode); - - final CapturingTessellator tess = TessellatorManager.startCapturingAndGet(); - tess.startDrawingQuads(); - // Use setTranslation rather than setOffset so that the float data written to the internal buffer - // is done in subchunk-relative coordinates - tess.setOffset(POS_ZERO); - tess.setTranslation(-pos.x, -pos.y, -pos.z); - renderBlocks.renderBlockByRenderType(block, pos.x, pos.y, pos.z); - final var quads = TessellatorManager.stopCapturingToPooledQuads(); - tess.resetOffset(); - - for (ModelQuadFacing facing : ModelQuadFacing.VALUES) { - this.random.setSeed(seed); - this.renderQuadList(pos, lighter, emitted, buffers, quads, facing, (this.useAmbientOcclusion && this.useSodiumAO)); - } - - if (!quads.isEmpty()) rendered = true; - } finally { - TessellatorManager.cleanup(); - } - - return rendered; - - } - - public boolean renderModel(IBlockAccess world, RenderBlocks renderBlocks, Block block, int meta, BlockPos pos, ChunkModelBuffers buffers, boolean cull, long seed) { - final LightMode mode = LightMode.SMOOTH; // TODO: this.getLightingMode(block); is what was previously used. The flat pipeline is busted and was only an optimization for very few blocks. - final LightPipeline lighter = this.lighters.getLighter(mode); - - boolean rendered = false; - - this.useSeparateAo = Iris.enabled && BlockRenderingSettings.INSTANCE.shouldUseSeparateAo(); - final int emitted = block.getLightValue(world, pos.x, pos.y, pos.z); - - try { - final CapturingTessellator tess = TessellatorManager.startCapturingAndGet(); - tess.startDrawingQuads(); - // Use setTranslation rather than setOffset so that the float data written to the internal buffer - // is done in subchunk-relative coordinates - tess.setOffset(POS_ZERO); - tess.setTranslation(-pos.x, -pos.y, -pos.z); - renderBlocks.renderBlockByRenderType(block, pos.x, pos.y, pos.z); - final var quads = TessellatorManager.stopCapturingToPooledQuads(); - tess.resetOffset(); - - for (ModelQuadFacing facing : ModelQuadFacing.VALUES) { - this.random.setSeed(seed); - this.renderQuadList(pos, lighter, emitted, buffers, quads, facing, (this.useAmbientOcclusion && this.useSodiumAO)); - } - - if (!quads.isEmpty()) rendered = true; - } finally { - TessellatorManager.cleanup(); - } - - return rendered; - } - - private void renderQuadList(BlockPos pos, LightPipeline lighter, int emitted, ChunkModelBuffers buffers, List quads, ModelQuadFacing facing, boolean useSodiumLight) { - final ModelVertexSink sink = buffers.getSink(facing); - sink.ensureCapacity(quads.size() * 4); - - final ChunkRenderData.Builder renderData = buffers.getRenderData(); - - // This is a very hot allocation, iterate over it manually - // noinspection ForLoopReplaceableByForEach - for (int i = 0, quadsSize = quads.size(); i < quadsSize; i++) { - final var quad = quads.get(i); - - final QuadLightData light = this.cachedQuadLightData; - - if (quad.getNormalFace() != facing) - continue; - - if (useSodiumLight || this.useSeparateAo) - lighter.calculate(quad, pos, light, facing, quad.getLightFace(), quad.hasAmbientOcclusion()); - - this.renderQuad(sink, quad, emitted, light, renderData, useSodiumLight); - } - - sink.flush(); - } - - private void renderQuad(ModelVertexSink sink, ModelQuadView quad, int emitted, QuadLightData light, ChunkRenderData.Builder renderData, boolean useSodiumLight) { - - final ModelQuadOrientation order = (useSodiumLight || this.useSeparateAo) ? ModelQuadOrientation.orientByBrightness(light.br, light.lm) : ModelQuadOrientation.NORMAL; - - int shaderBlockId = quad.getShaderBlockId(); - for (int dstIndex = 0; dstIndex < 4; dstIndex++) { - final int srcIndex = order.getVertexIndex(dstIndex); - - final float x = quad.getX(srcIndex); - final float y = quad.getY(srcIndex); - final float z = quad.getZ(srcIndex); - - int color = quad.getColor(srcIndex); - final float ao = light.br[srcIndex]; - if (useSeparateAo) { - color &= 0x00FFFFFF; - color |= ((int) (ao * 255.0f)) << 24; - } else { - - color = (useSodiumLight) ? ColorMixer.mulSingleWithoutAlpha(quad.getColor(srcIndex), (int)(light.br[srcIndex] * 255)) : quad.getColor(srcIndex); - } - - final float u = quad.getTexU(srcIndex); - final float v = quad.getTexV(srcIndex); - - final int lm = (useSeparateAo) ? ModelQuadUtil.mergeBakedLight(quad.getLight(srcIndex), emitted, light.lm[srcIndex]) : - (useSodiumLight) ? light.lm[srcIndex] : quad.getLight(srcIndex); - - sink.writeQuad(x, y, z, color, u, v, lm, shaderBlockId); - } - - final TextureAtlasSprite sprite = (TextureAtlasSprite) quad.celeritas$getSprite(); - - if (sprite != null) { - renderData.addSprite(sprite); - } - } - -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/pipeline/ChunkRenderCache.java b/src/main/java/me/jellysquid/mods/sodium/client/render/pipeline/ChunkRenderCache.java deleted file mode 100644 index feec0c4b8..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/pipeline/ChunkRenderCache.java +++ /dev/null @@ -1,5 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.pipeline; - -public class ChunkRenderCache { - -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/pipeline/FluidRenderer.java b/src/main/java/me/jellysquid/mods/sodium/client/render/pipeline/FluidRenderer.java deleted file mode 100644 index 2538b1bea..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/pipeline/FluidRenderer.java +++ /dev/null @@ -1,465 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.pipeline; - -import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.HORIZONTAL_DIRECTIONS; -import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.NEG_Y; -import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.POS_Y; -import static org.joml.Math.lerp; - -import com.gtnewhorizon.gtnhlib.blockpos.BlockPos; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.ColorARGB; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.ColorMixer; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.NormI8; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.ModelQuad; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.ModelQuadView; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.ModelQuadViewMutable; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFlags; -import java.util.Arrays; -import net.coderbot.iris.Iris; -import me.jellysquid.mods.sodium.client.model.light.LightMode; -import me.jellysquid.mods.sodium.client.model.light.LightPipeline; -import me.jellysquid.mods.sodium.client.model.light.LightPipelineProvider; -import me.jellysquid.mods.sodium.client.model.light.data.QuadLightData; -import me.jellysquid.mods.sodium.client.render.chunk.compile.buffers.ChunkModelBuffers; -import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexSink; -import me.jellysquid.mods.sodium.client.world.WorldSlice; -import net.coderbot.iris.block_rendering.BlockRenderingSettings; -import net.minecraft.block.Block; -import net.minecraft.client.Minecraft; -import net.minecraft.client.renderer.texture.TextureAtlasSprite; -import net.minecraft.util.MathHelper; -import net.minecraft.world.IBlockAccess; -import net.minecraftforge.common.util.ForgeDirection; -import net.minecraftforge.fluids.Fluid; -import org.joml.Vector3d; - -public class FluidRenderer { - private static final float EPSILON = 0.001f; - private final LightPipelineProvider lpp; - - private final BlockPos scratchPos = new BlockPos(); - - private final ModelQuadViewMutable quad = new ModelQuad(); - - private final QuadLightData quadLightData = new QuadLightData(); - private boolean useSeparateAo; - private final int[] quadColors = new int[4]; - private final int[] biomeColors = new int[4]; - private final TextureAtlasSprite missingTex = Minecraft.getMinecraft().getTextureMapBlocks().getAtlasSprite("minecraft:missing"); - - public FluidRenderer(LightPipelineProvider lpp) { - int normal = NormI8.pack(0.0f, 1.0f, 0.0f); - - for (int i = 0; i < 4; i++) { - this.quad.setForgeNormal(i, normal); - } - - this.lpp = lpp; - } - - private boolean isFluidOccluded(IBlockAccess world, int x, int y, int z, ForgeDirection d, Fluid fluid) { - Block block = world.getBlock(x, y, z); - boolean tmp = WorldUtil.getFluid(world.getBlock(x + d.offsetX, y + d.offsetY, z + d.offsetZ)) == fluid; - - if (block.getMaterial().isOpaque()) { - return tmp || block.isSideSolid(world, x, y, z, d); - // fluidlogged or next to water, occlude sides that are solid or the same liquid - // For a liquid block that's always - } - return tmp; - } - - private boolean isSideExposed(IBlockAccess world, int x, int y, int z, ModelQuadFacing dir, float height) { - BlockPos pos = this.scratchPos.set(x + dir.getStepX(), y + dir.getStepY(), z + dir.getStepZ()); - Block block = world.getBlock(pos.x, pos.y, pos.z); - - if (block.getMaterial().isOpaque()) { - final boolean renderAsFullCube = block.renderAsNormalBlock(); - - // Hoist these checks to avoid allocating the shape below - if (renderAsFullCube) { - // The top face always be inset, so if the shape above is a full cube it can't possibly occlude - return dir == POS_Y; - } else { - return true; - } - } - - return true; - } - - public boolean render(IBlockAccess world, WorldSlice slice, Block block, BlockPos pos, ChunkModelBuffers buffers) { - this.useSeparateAo = Iris.enabled && BlockRenderingSettings.INSTANCE.shouldUseSeparateAo(); - - int posX = pos.x; - int posY = pos.y; - int posZ = pos.z; - - - Fluid fluid = WorldUtil.getFluid(block); - if (fluid == null) return false; - - // Check for occluded sides; if everything is occluded, don't render - boolean sfUp = this.isFluidOccluded(world, posX, posY, posZ, ForgeDirection.UP, fluid); - boolean sfDown = this.isFluidOccluded(world, posX, posY, posZ, ForgeDirection.DOWN, fluid) || - !this.isSideExposed(world, posX, posY, posZ, NEG_Y, 0.8888889F); - boolean sfNorth = this.isFluidOccluded(world, posX, posY, posZ, ForgeDirection.NORTH, fluid); - boolean sfSouth = this.isFluidOccluded(world, posX, posY, posZ, ForgeDirection.SOUTH, fluid); - boolean sfWest = this.isFluidOccluded(world, posX, posY, posZ, ForgeDirection.WEST, fluid); - boolean sfEast = this.isFluidOccluded(world, posX, posY, posZ, ForgeDirection.EAST, fluid); - - if (sfUp && sfDown && sfEast && sfWest && sfNorth && sfSouth) { - return false; - } - - // sprites[0] should be the still frames, [1] the flowing, [2] the overlay - // Sides 0 and 1 (top and bottom) are still, 2+ flowing. Overlay is null because 1.7.10 probably doesn't use it. - TextureAtlasSprite[] sprites = new TextureAtlasSprite[]{ - (TextureAtlasSprite) fluid.getStillIcon(), - (TextureAtlasSprite) fluid.getFlowingIcon(), - null - }; - - // Because some mods are wack and return null textures here - sprites[0] = sprites[0] == null ? missingTex : sprites[0]; - sprites[1] = sprites[1] == null ? missingTex : sprites[1]; - - boolean hc = fluid.getColor() != 0xffffffff; - - boolean rendered = false; - - float h1 = this.getCornerHeight(world, posX, posY, posZ, fluid); - float h2 = this.getCornerHeight(world, posX, posY, posZ + 1, fluid); - float h3 = this.getCornerHeight(world, posX + 1, posY, posZ + 1, fluid); - float h4 = this.getCornerHeight(world, posX + 1, posY, posZ, fluid); - - float yOffset = sfDown ? 0.0F : EPSILON; - - final ModelQuadViewMutable quad = this.quad; - - LightMode mode = hc && Minecraft.isAmbientOcclusionEnabled() ? LightMode.SMOOTH : LightMode.FLAT; - LightPipeline lighter = this.lpp.getLighter(mode); - - quad.setFlags(0); - - if (!sfUp && this.isSideExposed(world, posX, posY, posZ, POS_Y, Math.min(Math.min(h1, h2), Math.min(h3, h4)))) { - h1 -= 0.001F; - h2 -= 0.001F; - h3 -= 0.001F; - h4 -= 0.001F; - - Vector3d velocity = WorldUtil.getVelocity(world, pos.x, pos.y, pos.z, block); - - TextureAtlasSprite sprite; - ModelQuadFacing facing; - float u1, u2, u3, u4; - float v1, v2, v3, v4; - - if (velocity.x == 0.0D && velocity.z == 0.0D) { - sprite = sprites[0]; - facing = ModelQuadFacing.POS_Y; - u1 = sprite.getInterpolatedU(0.0D); - v1 = sprite.getInterpolatedV(0.0D); - u2 = u1; - v2 = sprite.getInterpolatedV(16.0D); - u3 = sprite.getInterpolatedU(16.0D); - v3 = v2; - u4 = u3; - v4 = v1; - } else { - sprite = sprites[1]; - facing = ModelQuadFacing.UNASSIGNED; - float dir = (float) Math.atan2(velocity.z, velocity.x) - (((float)Math.PI / 2F)); - float sin = MathHelper.sin(dir) * 0.25F; - float cos = MathHelper.cos(dir) * 0.25F; - u1 = sprite.getInterpolatedU(8.0F + (-cos - sin) * 16.0F); - v1 = sprite.getInterpolatedV(8.0F + (-cos + sin) * 16.0F); - u2 = sprite.getInterpolatedU(8.0F + (-cos + sin) * 16.0F); - v2 = sprite.getInterpolatedV(8.0F + (cos + sin) * 16.0F); - u3 = sprite.getInterpolatedU(8.0F + (cos + sin) * 16.0F); - v3 = sprite.getInterpolatedV(8.0F + (cos - sin) * 16.0F); - u4 = sprite.getInterpolatedU(8.0F + (cos - sin) * 16.0F); - v4 = sprite.getInterpolatedV(8.0F + (-cos - sin) * 16.0F); - } - - float uAvg = (u1 + u2 + u3 + u4) / 4.0F; - float vAvg = (v1 + v2 + v3 + v4) / 4.0F; - float s1 = (float) sprites[0].getIconWidth() / (sprites[0].getMaxU() - sprites[0].getMinU()); - float s2 = (float) sprites[0].getIconHeight() / (sprites[0].getMaxV() - sprites[0].getMinV()); - float s3 = 4.0F / Math.max(s2, s1); - - u1 = lerp(u1, uAvg, s3); - u2 = lerp(u2, uAvg, s3); - u3 = lerp(u3, uAvg, s3); - u4 = lerp(u4, uAvg, s3); - v1 = lerp(v1, vAvg, s3); - v2 = lerp(v2, vAvg, s3); - v3 = lerp(v3, vAvg, s3); - v4 = lerp(v4, vAvg, s3); - - quad.setSprite(sprite); - - this.setVertex(quad, 0, 0.0f, h1, 0.0f, u1, v1); - this.setVertex(quad, 1, 0.0f, h2, 1.0F, u2, v2); - this.setVertex(quad, 2, 1.0F, h3, 1.0F, u3, v3); - this.setVertex(quad, 3, 1.0F, h4, 0.0f, u4, v4); - - this.calculateQuadColors(quad, pos, lighter, POS_Y, 1.0F, hc, slice); - this.flushQuad(buffers, quad, facing, false); - - if (WorldUtil.method_15756(slice, this.scratchPos.set(posX, posY + 1, posZ), fluid)) { - this.setVertex(quad, 3, 0.0f, h1, 0.0f, u1, v1); - this.setVertex(quad, 2, 0.0f, h2, 1.0F, u2, v2); - this.setVertex(quad, 1, 1.0F, h3, 1.0F, u3, v3); - this.setVertex(quad, 0, 1.0F, h4, 0.0f, u4, v4); - - this.flushQuad(buffers, quad, ModelQuadFacing.NEG_Y, true); - } - - rendered = true; - } - - if (!sfDown) { - TextureAtlasSprite sprite = sprites[0]; - - float minU = sprite.getMinU(); - float maxU = sprite.getMaxU(); - float minV = sprite.getMinV(); - float maxV = sprite.getMaxV(); - quad.setSprite(sprite); - - this.setVertex(quad, 0, 0.0f, yOffset, 1.0F, minU, maxV); - this.setVertex(quad, 1, 0.0f, yOffset, 0.0f, minU, minV); - this.setVertex(quad, 2, 1.0F, yOffset, 0.0f, maxU, minV); - this.setVertex(quad, 3, 1.0F, yOffset, 1.0F, maxU, maxV); - - this.calculateQuadColors(quad, pos, lighter, NEG_Y, 1.0F, hc, slice); - this.flushQuad(buffers, quad, ModelQuadFacing.NEG_Y, false); - - rendered = true; - } - - quad.setFlags(ModelQuadFlags.IS_ALIGNED); - - for (var facing : HORIZONTAL_DIRECTIONS) { - float c1; - float c2; - float x1; - float z1; - float x2; - float z2; - - switch (facing) { - case NEG_Z: - if (sfNorth) { - continue; - } - - c1 = h1; - c2 = h4; - x1 = 0.0f; - x2 = 1.0F; - z1 = 0.001f; - z2 = z1; - break; - case POS_Z: - if (sfSouth) { - continue; - } - - c1 = h3; - c2 = h2; - x1 = 1.0F; - x2 = 0.0f; - z1 = 0.999f; - z2 = z1; - break; - case NEG_X: - if (sfWest) { - continue; - } - - c1 = h2; - c2 = h1; - x1 = 0.001f; - x2 = x1; - z1 = 1.0F; - z2 = 0.0f; - break; - case POS_X: - if (sfEast) { - continue; - } - - c1 = h4; - c2 = h3; - x1 = 0.999f; - x2 = x1; - z1 = 0.0f; - z2 = 1.0F; - break; - default: - continue; - } - - if (this.isSideExposed(world, posX, posY, posZ, facing, Math.max(c1, c2))) { - int adjX = posX + facing.getStepX(); - int adjY = posY + facing.getStepY(); - int adjZ = posZ + facing.getStepZ(); - - TextureAtlasSprite sprite = sprites[1]; - TextureAtlasSprite oSprite = sprites[2]; - - if (oSprite != null) { - Block adjBlock = world.getBlock(adjX, adjY, adjZ); - - if (WorldUtil.shouldDisplayFluidOverlay(adjBlock)) { - // should ignore invisible blocks, barriers, light blocks - // use static water when adjacent block is ice, glass, stained glass, tinted glass - sprite = oSprite; - } - } - - float u1 = sprite.getInterpolatedU(0.0D); - float u2 = sprite.getInterpolatedU(8.0D); - float v1 = sprite.getInterpolatedV((1.0F - c1) * 16.0F * 0.5F); - float v2 = sprite.getInterpolatedV((1.0F - c2) * 16.0F * 0.5F); - float v3 = sprite.getInterpolatedV(8.0D); - - quad.setSprite(sprite); - - this.setVertex(quad, 0, x2, c2, z2, u2, v2); - this.setVertex(quad, 1, x2, yOffset, z2, u2, v3); - this.setVertex(quad, 2, x1, yOffset, z1, u1, v3); - this.setVertex(quad, 3, x1, c1, z1, u1, v1); - - float br = facing.getStepZ() != 0 ? 0.8F : 0.6F; - - this.calculateQuadColors(quad, pos, lighter, facing, br, hc, slice); - this.flushQuad(buffers, quad, facing, false); - - if (sprite != oSprite) { - this.setVertex(quad, 0, x1, c1, z1, u1, v1); - this.setVertex(quad, 1, x1, yOffset, z1, u1, v3); - this.setVertex(quad, 2, x2, yOffset, z2, u2, v3); - this.setVertex(quad, 3, x2, c2, z2, u2, v2); - - this.flushQuad(buffers, quad, facing.getOpposite(), true); - } - - rendered = true; - } - } - - return rendered; - } - - private void calculateQuadColors(ModelQuadView quad, BlockPos pos, LightPipeline lighter, ModelQuadFacing dir, float brightness, boolean colorized, WorldSlice slice) { - QuadLightData light = this.quadLightData; - lighter.calculate(quad, pos, light, null, dir, false); - - if (colorized) { - int color = slice.getBlock(pos.x,pos.y,pos.z).colorMultiplier(slice,pos.x,pos.y,pos.z); - Arrays.fill(this.biomeColors, ColorARGB.toABGR(color)); - } - - for (int i = 0; i < 4; i++) { - int color = colorized ? biomeColors[i] : 0xFFFFFFFF; - final float ao = light.br[i] * brightness; - if (useSeparateAo) { - color &= 0x00FFFFFF; - color |= ((int) (ao * 255.0f)) << 24; - } else { - color = ColorMixer.mulSingleWithoutAlpha(color, (int)(ao * 255)); - } - this.quadColors[i] = color; - } - } - - private void flushQuad(ChunkModelBuffers buffers, ModelQuadView quad, ModelQuadFacing facing, boolean flip) { - - int vertexIdx, lightOrder; - - if (flip) { - vertexIdx = 3; - lightOrder = -1; - } else { - vertexIdx = 0; - lightOrder = 1; - } - - ModelVertexSink sink = buffers.getSink(facing); - sink.ensureCapacity(4); - - for (int i = 0; i < 4; i++) { - float x = quad.getX(i); - float y = quad.getY(i); - float z = quad.getZ(i); - - int color = this.quadColors[vertexIdx]; - - float u = quad.getTexU(i); - float v = quad.getTexV(i); - - int light = this.quadLightData.lm[vertexIdx]; - - sink.writeQuad(x, y, z, color, u, v, light, -1); - - vertexIdx += lightOrder; - } - - TextureAtlasSprite sprite = (TextureAtlasSprite) quad.celeritas$getSprite(); - - if (sprite != null) { - buffers.getRenderData().addSprite(sprite); - } - - sink.flush(); - } - - private void setVertex(ModelQuadViewMutable quad, int i, float x, float y, float z, float u, float v) { - quad.setX(i, x); - quad.setY(i, y); - quad.setZ(i, z); - quad.setTexU(i, u); - quad.setTexV(i, v); - } - - private float getCornerHeight(IBlockAccess world, int x, int y, int z, Fluid fluid) { - int samples = 0; - float totalHeight = 0.0F; - - for (int i = 0; i < 4; ++i) { - int x2 = x - (i & 1); - int z2 = z - (i >> 1 & 1); - - Block block = world.getBlock(x2, y + 1, z2); - - if (WorldUtil.getFluid(block) == fluid) { - return 1.0F; - } - - BlockPos pos = this.scratchPos.set(x2, y, z2); - - block = world.getBlock(pos.x, pos.y, pos.z); - int meta = world.getBlockMetadata(pos.x, pos.y, pos.z); - Fluid fluid2 = WorldUtil.getFluid(block); - - if (fluid2 == fluid) { - float height = WorldUtil.getFluidHeight(fluid2, meta); - - if (height >= 0.8F) { - totalHeight += height * 10.0F; - samples += 10; - } else { - totalHeight += height; - ++samples; - } - } else if (!block.getMaterial().isSolid()) { - ++samples; - } - } - - return totalHeight / (float) samples; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/pipeline/WorldUtil.java b/src/main/java/me/jellysquid/mods/sodium/client/render/pipeline/WorldUtil.java deleted file mode 100644 index 14a11991f..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/pipeline/WorldUtil.java +++ /dev/null @@ -1,149 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.pipeline; - -import com.gtnewhorizon.gtnhlib.blockpos.BlockPos; -import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing; -import net.minecraft.block.Block; -import net.minecraft.block.BlockLiquid; -import net.minecraft.block.material.Material; -import net.minecraft.world.IBlockAccess; -import net.minecraftforge.common.util.ForgeDirection; -import net.minecraftforge.fluids.Fluid; -import net.minecraftforge.fluids.FluidRegistry; -import net.minecraftforge.fluids.IFluidBlock; -import org.joml.Vector3d; - -/** - * Contains methods stripped from BlockState or FluidState that didn't actually need to be there. Technically these - * could be a mixin to Block or Fluid, but that's annoying while not actually providing any benefit. - */ -public class WorldUtil { - - public static Vector3d getVelocity(IBlockAccess world, int x, int y, int z, Block thizz) { - - Vector3d velocity = new Vector3d(); - int decay = getEffectiveFlowDecay(world, x, y, z, thizz); - - for (var dire : ModelQuadFacing.HORIZONTAL_DIRECTIONS) { - - int adjX = x + dire.getStepX(); - int adjZ = z + dire.getStepZ(); - - int adjDecay = getEffectiveFlowDecay(world, adjX, y, adjZ, thizz); - - if (adjDecay < 0) { - - if (!world.getBlock(adjX, y, adjZ).getMaterial().blocksMovement()) { - - adjDecay = getEffectiveFlowDecay(world, adjX, y - 1, adjZ, thizz); - - if (adjDecay >= 0) { - - adjDecay -= (decay - 8); - velocity = velocity.add((adjX - x) * adjDecay, 0, (adjZ - z) * adjDecay); - } - } - } else { - - adjDecay -= decay; - velocity = velocity.add((adjX - x) * adjDecay, 0, (adjZ - z) * adjDecay); - } - } - - if (world.getBlockMetadata(x, y, z) >= 8) { - - if (thizz.isBlockSolid(world, x, y, z - 1, 2) || thizz.isBlockSolid(world, x, y, z + 1, 3) - || thizz.isBlockSolid(world, x - 1, y, z, 4) - || thizz.isBlockSolid(world, x + 1, y, z, 5) - || thizz.isBlockSolid(world, x, y + 1, z - 1, 2) - || thizz.isBlockSolid(world, x, y + 1, z + 1, 3) - || thizz.isBlockSolid(world, x - 1, y + 1, z, 4) - || thizz.isBlockSolid(world, x + 1, y + 1, z, 5)) { - velocity = velocity.normalize().add(0.0D, -6.0D, 0.0D); - } - } - - if (velocity.x == 0 && velocity.y == 0 && velocity.z == 0) return velocity.zero(); - return velocity.normalize(); - } - - /** - * Returns true if any block in a 3x3x3 cube is not the same fluid and not an opaque full cube. Equivalent to - * FluidState::method_15756 in modern. - */ - public static boolean method_15756(IBlockAccess world, BlockPos pos, Fluid fluid) { - for (int i = 0; i < 2; ++i) { - for (int j = 0; j < 2; ++j) { - Block block = world.getBlock(pos.x, pos.y, pos.z); - if (!block.isOpaqueCube() && getFluid(block) != fluid) { - return true; - } - } - } - - return false; - } - - /** - * Returns fluid height as a percentage of the block; 0 is none and 1 is full. - */ - public static float getFluidHeight(Fluid fluid, int meta) { - return fluid == null ? 0 : 1 - BlockLiquid.getLiquidHeightPercent(meta); - } - - /** - * Returns the flow decay but converts values indicating falling liquid (values >=8) to their effective source block - * value of zero - */ - public static int getEffectiveFlowDecay(IBlockAccess world, int x, int y, int z, Block thiz) { - - if (world.getBlock(x, y, z).getMaterial() != thiz.getMaterial()) { - - return -1; - } else { - - int decay = world.getBlockMetadata(x, y, z); - return decay >= 8 ? 0 : decay; - } - } - - // I believe forge mappings in modern say BreakableBlock, while yarn says TransparentBlock. - // I have a sneaking suspicion isOpaque is neither, but it works for now - public static boolean shouldDisplayFluidOverlay(Block block) { - return !block.getMaterial().isOpaque() || block.getMaterial() == Material.leaves; - } - - public static boolean isFluidBlock(Block block) { - return block instanceof IFluidBlock || block instanceof BlockLiquid; - } - - public static Fluid getFluid(Block b) { - if (b instanceof IFluidBlock fluidBlock) return fluidBlock.getFluid(); - if (b instanceof BlockLiquid) { - if (b.getMaterial() == Material.water) return FluidRegistry.WATER; - if (b.getMaterial() == Material.lava) return FluidRegistry.LAVA; - } - return null; - } - - /** - * Equivalent to method_15748 in 1.16.5 - */ - public static boolean isEmptyOrSame(Fluid fluid, Fluid otherFluid) { - return otherFluid == null || fluid == otherFluid; - } - - /** - * Equivalent to method_15749 in 1.16.5 - */ - public static boolean method_15749(IBlockAccess world, Fluid thiz, BlockPos pos, ForgeDirection dir) { - Block b = world.getBlock(pos.x, pos.y, pos.z); - Fluid f = getFluid(b); - if (f == thiz) { - return false; - } - if (dir == ForgeDirection.UP) { - return true; - } - return b.getMaterial() != Material.ice && b.isSideSolid(world, pos.x, pos.y, pos.z, dir); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/pipeline/context/ChunkRenderCacheLocal.java b/src/main/java/me/jellysquid/mods/sodium/client/render/pipeline/context/ChunkRenderCacheLocal.java deleted file mode 100644 index 1271dec7c..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/pipeline/context/ChunkRenderCacheLocal.java +++ /dev/null @@ -1,40 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.pipeline.context; - -import lombok.Getter; -import me.jellysquid.mods.sodium.client.model.light.LightPipelineProvider; -import me.jellysquid.mods.sodium.client.model.light.cache.ArrayLightDataCache; -import me.jellysquid.mods.sodium.client.render.pipeline.BlockRenderer; -import me.jellysquid.mods.sodium.client.render.pipeline.ChunkRenderCache; -import me.jellysquid.mods.sodium.client.render.pipeline.FluidRenderer; -import me.jellysquid.mods.sodium.client.world.WorldSlice; -import me.jellysquid.mods.sodium.client.world.cloned.ChunkRenderContext; -import net.minecraft.client.Minecraft; -import net.minecraft.client.multiplayer.WorldClient; - -public class ChunkRenderCacheLocal extends ChunkRenderCache { - private final ArrayLightDataCache lightDataCache; - - @Getter - private final BlockRenderer blockRenderer; - @Getter - private final FluidRenderer fluidRenderer; - @Getter - private final WorldSlice worldSlice; - - public ChunkRenderCacheLocal(Minecraft client, WorldClient world) { - this.worldSlice = new WorldSlice(world); - this.lightDataCache = new ArrayLightDataCache(this.worldSlice); - - final LightPipelineProvider lightPipelineProvider = new LightPipelineProvider(lightDataCache); - - this.blockRenderer = new BlockRenderer(lightPipelineProvider); - this.fluidRenderer = new FluidRenderer(lightPipelineProvider); - - } - - public void init(ChunkRenderContext context) { - this.lightDataCache.reset(context.getOrigin()); - this.worldSlice.copyData(context); - } - -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/pipeline/context/ChunkRenderCacheShared.java b/src/main/java/me/jellysquid/mods/sodium/client/render/pipeline/context/ChunkRenderCacheShared.java deleted file mode 100644 index 759b7bde4..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/pipeline/context/ChunkRenderCacheShared.java +++ /dev/null @@ -1,64 +0,0 @@ -package me.jellysquid.mods.sodium.client.render.pipeline.context; - -import it.unimi.dsi.fastutil.objects.Reference2ObjectOpenHashMap; -import me.jellysquid.mods.sodium.client.model.light.LightPipelineProvider; -import me.jellysquid.mods.sodium.client.model.light.cache.HashLightDataCache; -import me.jellysquid.mods.sodium.client.render.pipeline.BlockRenderer; -import me.jellysquid.mods.sodium.client.render.pipeline.ChunkRenderCache; -import me.jellysquid.mods.sodium.client.world.WorldSlice; -import net.minecraft.client.multiplayer.WorldClient; -import net.minecraft.world.World; - -import java.util.Map; - -public class ChunkRenderCacheShared extends ChunkRenderCache { - private static final Map INSTANCES = new Reference2ObjectOpenHashMap<>(); - - private final BlockRenderer blockRenderer; - private final HashLightDataCache lightCache; - - private ChunkRenderCacheShared(WorldSlice world) { - this.lightCache = new HashLightDataCache(world); - LightPipelineProvider lightPipelineProvider = new LightPipelineProvider(this.lightCache); - - this.blockRenderer = new BlockRenderer(lightPipelineProvider); - } - - public BlockRenderer getBlockRenderer() { - return this.blockRenderer; - } - - private void resetCache() { - this.lightCache.clearCache(); - } - - public static ChunkRenderCacheShared getInstance(WorldClient world) { - ChunkRenderCacheShared instance = INSTANCES.get(world); - - if (instance == null) { - throw new IllegalStateException("No global renderer exists"); - } - - return instance; - } - - public static void destroyRenderContext(WorldClient world) { - if (INSTANCES.remove(world) == null) { - throw new IllegalStateException("No render context exists for world: " + world); - } - } - - public static void createRenderContext(WorldClient world) { - if (INSTANCES.containsKey(world)) { - throw new IllegalStateException("Render context already exists for world: " + world); - } - - INSTANCES.put(world, new ChunkRenderCacheShared(new WorldSlice(world))); - } - - public static void resetCaches() { - for (ChunkRenderCacheShared context : INSTANCES.values()) { - context.resetCache(); - } - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/util/MathUtil.java b/src/main/java/me/jellysquid/mods/sodium/client/util/MathUtil.java deleted file mode 100644 index 460a0fee6..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/util/MathUtil.java +++ /dev/null @@ -1,27 +0,0 @@ -package me.jellysquid.mods.sodium.client.util; - -public class MathUtil { - /** - * @return True if the specified number is greater than zero and is a power of two, otherwise false - */ - public static boolean isPowerOfTwo(int n) { - return ((n & (n - 1)) == 0); - } - - /** - * @return Hash of the position, replaces a similar method from modern. It's almost certainly not exactly - * equivalent, but I'll be very concerned if it matters - */ - public static long hashPos(int x, int y, int z) { - return cantor(x, cantor(y, z)); - } - - /** - * Maps every positive a and b to a unique int, barring overflow - * Source on Stack Overflow - */ - private static long cantor(long a, long b) { - return (a + b + 1) * (a + b) / 2 + b; - } - -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/util/StateUtil.java b/src/main/java/me/jellysquid/mods/sodium/client/util/StateUtil.java deleted file mode 100644 index 8bb38c908..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/util/StateUtil.java +++ /dev/null @@ -1,24 +0,0 @@ -package me.jellysquid.mods.sodium.client.util; - -import net.minecraft.block.Block; - -public class StateUtil { - - public static boolean areBoundsFullCube(Block b) { - - if (b.getBlockBoundsMaxX() < 1) - return false; - if (b.getBlockBoundsMinX() > 0) - return false; - if (b.getBlockBoundsMaxY() < 1) - return false; - if (b.getBlockBoundsMinY() > 0) - return false; - if (b.getBlockBoundsMaxZ() < 1) - return false; - if (b.getBlockBoundsMinZ() > 1) - return false; - - return true; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/util/math/FrustumExtended.java b/src/main/java/me/jellysquid/mods/sodium/client/util/math/FrustumExtended.java deleted file mode 100644 index e78fd526c..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/util/math/FrustumExtended.java +++ /dev/null @@ -1,5 +0,0 @@ -package me.jellysquid.mods.sodium.client.util.math; - -public interface FrustumExtended { - boolean fastAabbTest(float minX, float minY, float minZ, float maxX, float maxY, float maxZ); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/util/math/Matrix3fExtended.java b/src/main/java/me/jellysquid/mods/sodium/client/util/math/Matrix3fExtended.java deleted file mode 100644 index d1480f766..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/util/math/Matrix3fExtended.java +++ /dev/null @@ -1,33 +0,0 @@ -package me.jellysquid.mods.sodium.client.util.math; - -import net.minecraftforge.common.util.ForgeDirection; -import org.joml.Vector3f; - -public interface Matrix3fExtended { - /** - * Applies the specified rotation to this matrix in-place. - * - * @param quaternion The quaternion to rotate this matrix by - */ -// void rotate(Quaternion quaternion); - - int computeNormal(ForgeDirection dir); - - float transformVecX(float x, float y, float z); - - float transformVecY(float x, float y, float z); - - float transformVecZ(float x, float y, float z); - - default float transformVecX(Vector3f dir) { - return this.transformVecX(dir.x, dir.y, dir.z); - } - - default float transformVecY(Vector3f dir) { - return this.transformVecY(dir.x, dir.y, dir.z); - } - - default float transformVecZ(Vector3f dir) { - return this.transformVecZ(dir.x, dir.y, dir.z); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/util/math/Matrix4fExtended.java b/src/main/java/me/jellysquid/mods/sodium/client/util/math/Matrix4fExtended.java deleted file mode 100644 index 861ffa86f..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/util/math/Matrix4fExtended.java +++ /dev/null @@ -1,50 +0,0 @@ -package me.jellysquid.mods.sodium.client.util.math; - - -public interface Matrix4fExtended { - /** - * Applies the specified rotation to this matrix in-place. - * - * @param quaternion The quaternion to rotate this matrix by - */ -// void rotate(Quaternion quaternion); - - /** - * Applies the specified translation to this matrix in-place. - * - * @param x The x-component of the translation - * @param y The y-component of the translation - * @param z The z-component of the translation - */ - void translate(float x, float y, float z); - - /** - * Applies this matrix transformation to the given input vector, returning the x-component. Avoids the lack of - * struct types in Java and allows for allocation-free return. - * @param x The x-component of the vector - * @param y The y-component of the vector - * @param z The z-component of the vector - * @return The x-component of the transformed input vector - */ - float transformVecX(float x, float y, float z); - - /** - * Applies this matrix transformation to the given input vector, returning the y-component. Avoids the lack of - * struct types in Java and allows for allocation-free return. - * @param x The x-component of the vector - * @param y The y-component of the vector - * @param z The z-component of the vector - * @return The y-component of the transformed input vector - */ - float transformVecY(float x, float y, float z); - - /** - * Applies this matrix transformation to the given input vector, returning the z-component. Avoids the lack of - * struct types in Java and allows for allocation-free return. - * @param x The x-component of the vector - * @param y The y-component of the vector - * @param z The z-component of the vector - * @return The z-component of the transformed input vector - */ - float transformVecZ(float x, float y, float z); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/util/math/MatrixUtil.java b/src/main/java/me/jellysquid/mods/sodium/client/util/math/MatrixUtil.java deleted file mode 100644 index 75386371f..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/util/math/MatrixUtil.java +++ /dev/null @@ -1,34 +0,0 @@ -package me.jellysquid.mods.sodium.client.util.math; - -import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.NormI8; -import net.minecraftforge.common.util.ForgeDirection; -import org.joml.Matrix3f; -import org.joml.Matrix4f; - -public class MatrixUtil { - public static int computeNormal(Matrix3f normalMatrix, ForgeDirection facing) { - return ((Matrix3fExtended) (Object) normalMatrix).computeNormal(facing); - } - - public static Matrix4fExtended getExtendedMatrix(Matrix4f matrix) { - return (Matrix4fExtended) (Object) matrix; - } - - public static Matrix3fExtended getExtendedMatrix(Matrix3f matrix) { - return (Matrix3fExtended) (Object) matrix; - } - - public static int transformPackedNormal(int norm, Matrix3f matrix) { - Matrix3fExtended mat = MatrixUtil.getExtendedMatrix(matrix); - - float normX1 = NormI8.unpackX(norm); - float normY1 = NormI8.unpackY(norm); - float normZ1 = NormI8.unpackZ(norm); - - float normX2 = mat.transformVecX(normX1, normY1, normZ1); - float normY2 = mat.transformVecY(normX1, normY1, normZ1); - float normZ2 = mat.transformVecZ(normX1, normY1, normZ1); - - return NormI8.pack(normX2, normY2, normZ2); - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/util/rand/SplitMixRandom.java b/src/main/java/me/jellysquid/mods/sodium/client/util/rand/SplitMixRandom.java deleted file mode 100644 index 5b79bfbb5..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/util/rand/SplitMixRandom.java +++ /dev/null @@ -1,99 +0,0 @@ -package me.jellysquid.mods.sodium.client.util.rand; - -import it.unimi.dsi.fastutil.HashCommon; - -// SplitMixRandom implementation from DSI Utilities, adopted in a minimal implementation to not -// import Apache Commons. -// -// http://xoshiro.di.unimi.it/ -public class SplitMixRandom { - private static final long PHI = 0x9E3779B97F4A7C15L; - - private long x; - - public SplitMixRandom() { - this(XoRoShiRoRandom.randomSeed()); - } - - public SplitMixRandom(final long seed) { - this.setSeed(seed); - } - - private static long staffordMix13(long z) { - z = (z ^ (z >>> 30)) * 0xBF58476D1CE4E5B9L; - z = (z ^ (z >>> 27)) * 0x94D049BB133111EBL; - - return z ^ (z >>> 31); - } - - private static int staffordMix4Upper32(long z) { - z = (z ^ (z >>> 33)) * 0x62A9D9ED799705F5L; - - return (int) (((z ^ (z >>> 28)) * 0xCB24D0A5C88C35B3L) >>> 32); - } - - public long nextLong() { - return staffordMix13(this.x += PHI); - } - - public int nextInt() { - return staffordMix4Upper32(this.x += PHI); - } - - public int nextInt(final int n) { - return (int) this.nextLong(n); - } - - public long nextLong(final long n) { - if (n <= 0) { - throw new IllegalArgumentException("illegal bound " + n + " (must be positive)"); - } - - long t = staffordMix13(this.x += PHI); - - final long nMinus1 = n - 1; - - if ((n & nMinus1) == 0) { - return t & nMinus1; - } - - long u = t >>> 1; - - while (u + nMinus1 - (t = u % n) < 0) { - u = staffordMix13(this.x += PHI) >>> 1; - } - - return t; - } - - public double nextDouble() { - return (staffordMix13(this.x += PHI) >>> 11) * 0x1.0p-53; - } - - public float nextFloat() { - return (staffordMix4Upper32(this.x += PHI) >>> 8) * 0x1.0p-24f; - } - - public boolean nextBoolean() { - return staffordMix4Upper32(this.x += PHI) < 0; - } - - public void nextBytes(final byte[] bytes) { - int i = bytes.length, n; - - while (i != 0) { - n = Math.min(i, 8); - for (long bits = staffordMix13(this.x += PHI); n-- != 0; bits >>= 8) { - bytes[--i] = (byte) bits; - } - } - } - - public void setSeed(final long seed) { - this.x = HashCommon.murmurHash3(seed); - } - - public void setState(final long state) { - this.x = state; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/util/rand/XoRoShiRoRandom.java b/src/main/java/me/jellysquid/mods/sodium/client/util/rand/XoRoShiRoRandom.java deleted file mode 100644 index c69707aa8..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/util/rand/XoRoShiRoRandom.java +++ /dev/null @@ -1,150 +0,0 @@ -package me.jellysquid.mods.sodium.client.util.rand; - -import java.util.Random; - -// XoRoShiRo128** implementation from DSI Utilities, adopted in a minimal implementation to not -// import Apache Commons. -// -// http://xoshiro.di.unimi.it/ -public class XoRoShiRoRandom extends Random { - private static final long serialVersionUID = 1L; - - private SplitMixRandom mixer; - private long seed = Long.MIN_VALUE; - private long p0, p1; // The initialization words for the current seed - private long s0, s1; // The current random words - private boolean hasSavedState; // True if we can be quickly reseed by using resetting the words - - private static final SplitMixRandom seedUniquifier = new SplitMixRandom(System.nanoTime()); - - public static long randomSeed() { - final long x; - - synchronized (XoRoShiRoRandom.seedUniquifier) { - x = XoRoShiRoRandom.seedUniquifier.nextLong(); - } - - return x ^ System.nanoTime(); - } - - public XoRoShiRoRandom() { - this(XoRoShiRoRandom.randomSeed()); - } - - public XoRoShiRoRandom(final long seed) { - this.setSeed(seed); - } - - @Override - public long nextLong() { - final long s0 = this.s0; - - long s1 = this.s1; - - final long result = s0 + s1; - - s1 ^= s0; - - this.s0 = Long.rotateLeft(s0, 24) ^ s1 ^ s1 << 16; - this.s1 = Long.rotateLeft(s1, 37); - - return result; - } - - @Override - public int nextInt() { - return (int) this.nextLong(); - } - - @Override - public int nextInt(final int n) { - return (int) this.nextLong(n); - } - - public long nextLong(final long n) { - if (n <= 0) { - throw new IllegalArgumentException("illegal bound " + n + " (must be positive)"); - } - - long t = this.nextLong(); - - final long nMinus1 = n - 1; - - // Shortcut for powers of two--high bits - if ((n & nMinus1) == 0) { - return (t >>> Long.numberOfLeadingZeros(nMinus1)) & nMinus1; - } - - // Rejection-based algorithm to get uniform integers in the general case - long u = t >>> 1; - - while (u + nMinus1 - (t = u % n) < 0) { - u = this.nextLong() >>> 1; - } - - return t; - - } - - @Override - public double nextDouble() { - return Double.longBitsToDouble(0x3FFL << 52 | this.nextLong() >>> 12) - 1.0; - } - - @Override - public float nextFloat() { - return (this.nextLong() >>> 40) * 0x1.0p-24f; - } - - @Override - public boolean nextBoolean() { - return this.nextLong() < 0; - } - - @Override - public void nextBytes(final byte[] bytes) { - int i = bytes.length, n; - - while (i != 0) { - n = Math.min(i, 8); - - for (long bits = this.nextLong(); n-- != 0; bits >>= 8) { - bytes[--i] = (byte) bits; - } - } - } - - @Override - public void setSeed(final long seed) { - // Restore the previous initial state if the seed hasn't changed - // Setting and mixing the seed is expensive, so this saves some CPU cycles - if (this.hasSavedState && this.seed == seed) { - this.s0 = this.p0; - this.s1 = this.p1; - } else { - SplitMixRandom mixer = this.mixer; - - // Avoid allocations of SplitMixRandom - if (mixer == null) { - mixer = this.mixer = new SplitMixRandom(seed); - } else { - mixer.setSeed(seed); - } - - this.s0 = mixer.nextLong(); - this.s1 = mixer.nextLong(); - - this.p0 = this.s0; - this.p1 = this.s1; - - this.seed = seed; - this.hasSavedState = true; - } - } - - public XoRoShiRoRandom setSeedAndReturn(final long seed) { - this.setSeed(seed); - - return this; - } -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/util/task/CancellationSource.java b/src/main/java/me/jellysquid/mods/sodium/client/util/task/CancellationSource.java deleted file mode 100644 index 00dff1481..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/util/task/CancellationSource.java +++ /dev/null @@ -1,5 +0,0 @@ -package me.jellysquid.mods.sodium.client.util.task; - -public interface CancellationSource { - boolean isCancelled(); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/world/ChunkStatusListener.java b/src/main/java/me/jellysquid/mods/sodium/client/world/ChunkStatusListener.java deleted file mode 100644 index 7cdbbc4c3..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/world/ChunkStatusListener.java +++ /dev/null @@ -1,20 +0,0 @@ -package me.jellysquid.mods.sodium.client.world; - -/** - * Defines a listener that can be attached to a world's chunk manager to receive chunk load and unload events. - */ -public interface ChunkStatusListener { - /** - * Called after a chunk is added to the world and loaded. - * @param x The x-coordinate of the loaded chunk - * @param z The z-coordinate of the loaded chunk - */ - void onChunkAdded(int x, int z); - - /** - * Called after a chunk is removed from the world and unloaded. - * @param x The x-coordiante of the unloaded chunk - * @param z The z-coordinate of the unloaded chunk - */ - void onChunkRemoved(int x, int z); -} diff --git a/src/main/java/me/jellysquid/mods/sodium/client/world/ClientWorldExtended.java b/src/main/java/me/jellysquid/mods/sodium/client/world/ClientWorldExtended.java deleted file mode 100644 index 47b7fd8af..000000000 --- a/src/main/java/me/jellysquid/mods/sodium/client/world/ClientWorldExtended.java +++ /dev/null @@ -1,8 +0,0 @@ -package me.jellysquid.mods.sodium.client.world; - -public interface ClientWorldExtended { - /** - * @return The world seed used for generating biome data on the client - */ - long getBiomeSeed(); -} diff --git a/src/main/java/net/coderbot/iris/Iris.java b/src/main/java/net/coderbot/iris/Iris.java index 0a51df094..673d0b317 100644 --- a/src/main/java/net/coderbot/iris/Iris.java +++ b/src/main/java/net/coderbot/iris/Iris.java @@ -12,6 +12,9 @@ import cpw.mods.fml.common.gameevent.InputEvent; import it.unimi.dsi.fastutil.objects.Object2IntMap; import lombok.Getter; import net.coderbot.iris.block_rendering.BlockRenderingSettings; +import com.gtnewhorizons.angelica.config.AngelicaConfig; +import net.coderbot.iris.celeritas.IrisCeleritasShaderProvider; +import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProviderHolder; import net.coderbot.iris.config.IrisConfig; import net.coderbot.iris.gl.shader.StandardMacros; import net.coderbot.iris.gui.screen.ShaderPackScreen; @@ -31,7 +34,7 @@ import net.coderbot.iris.shaderpack.option.OptionSet; import net.coderbot.iris.shaderpack.option.Profile; import net.coderbot.iris.shaderpack.option.values.MutableOptionValues; import net.coderbot.iris.shaderpack.option.values.OptionValues; -import net.coderbot.iris.sodium.block_context.BlockContextHolder; +import net.coderbot.iris.block_context.BlockContextHolder; import net.coderbot.iris.texture.pbr.PBRTextureManager; import net.minecraft.block.Block; import net.minecraft.client.Minecraft; @@ -378,6 +381,11 @@ public class Iris { return; } + // Register the Celeritas shader provider for Iris integration (only when Celeritas is enabled) + if (AngelicaConfig.enableCeleritas) { + IrisShaderProviderHolder.setProvider(new IrisCeleritasShaderProvider()); + } + // Warm up the threadpool so shader transformations are faster when we need them ShaderTransformExecutor.warmup(); @@ -402,6 +410,8 @@ public class Iris { // See: https://github.com/IrisShaders/Iris/issues/323 lastDimension = DimensionId.OVERWORLD; Iris.getPipelineManager().preparePipeline(DimensionId.OVERWORLD); + + BlockRenderingSettings.INSTANCE.reloadRendererIfRequired(); } public static void toggleShaders(Minecraft minecraft, boolean enabled) throws IOException { @@ -704,6 +714,8 @@ public class Iris { // https://github.com/IrisShaders/Iris/issues/1330 if (Minecraft.getMinecraft().theWorld != null) { Iris.getPipelineManager().preparePipeline(Iris.getCurrentDimension()); + + BlockRenderingSettings.INSTANCE.reloadRendererIfRequired(); } } diff --git a/src/main/java/net/coderbot/iris/block_context/BlockContextHolder.java b/src/main/java/net/coderbot/iris/block_context/BlockContextHolder.java new file mode 100644 index 000000000..5631a35b5 --- /dev/null +++ b/src/main/java/net/coderbot/iris/block_context/BlockContextHolder.java @@ -0,0 +1,19 @@ +package net.coderbot.iris.block_context; + +import it.unimi.dsi.fastutil.objects.Object2IntMap; +import net.minecraft.block.Block; + +public class BlockContextHolder { + private final Object2IntMap blockMatches; + public int blockId; + public short renderType; + + public BlockContextHolder(Object2IntMap blockMatches) { + this.blockMatches = blockMatches; + } + + public void set(Block block, short renderType) { + this.renderType = renderType; + this.blockId = blockMatches.getOrDefault(block, -1); + } +} diff --git a/src/main/java/net/coderbot/iris/block_rendering/BlockRenderingSettings.java b/src/main/java/net/coderbot/iris/block_rendering/BlockRenderingSettings.java index cbe345740..b7ab120f7 100644 --- a/src/main/java/net/coderbot/iris/block_rendering/BlockRenderingSettings.java +++ b/src/main/java/net/coderbot/iris/block_rendering/BlockRenderingSettings.java @@ -6,6 +6,7 @@ import it.unimi.dsi.fastutil.objects.Object2IntMap; import lombok.Getter; import net.coderbot.iris.shaderpack.materialmap.NamespacedId; import net.minecraft.block.Block; +import net.minecraft.client.Minecraft; import org.jetbrains.annotations.Nullable; import java.util.Map; @@ -37,6 +38,15 @@ public class BlockRenderingSettings { reloadRequired = false; } + public void reloadRendererIfRequired() { + if (isReloadRequired()) { + if (Minecraft.getMinecraft().renderGlobal != null) { + Minecraft.getMinecraft().renderGlobal.loadRenderers(); + } + clearReloadRequired(); + } + } + @Nullable public Object2IntMap getBlockMatches() { return blockMatches; diff --git a/src/main/java/net/coderbot/iris/celeritas/CeleritasTerrainPipeline.java b/src/main/java/net/coderbot/iris/celeritas/CeleritasTerrainPipeline.java new file mode 100644 index 000000000..afab95db2 --- /dev/null +++ b/src/main/java/net/coderbot/iris/celeritas/CeleritasTerrainPipeline.java @@ -0,0 +1,216 @@ +package net.coderbot.iris.celeritas; + +import com.google.common.collect.ImmutableSet; +import lombok.Getter; +import lombok.experimental.Accessors; +import net.coderbot.iris.Iris; +import net.coderbot.iris.gl.blending.BlendModeOverride; +import net.coderbot.iris.gl.framebuffer.GlFramebuffer; +import net.coderbot.iris.gl.program.ProgramImages; +import net.coderbot.iris.gl.program.ProgramSamplers; +import net.coderbot.iris.gl.program.ProgramUniforms; +import net.coderbot.iris.pipeline.PatchedShaderPrinter; +import net.coderbot.iris.pipeline.transform.PatchShaderType; +import net.coderbot.iris.rendertarget.RenderTargets; +import net.coderbot.iris.uniforms.CommonUniforms; +import net.coderbot.iris.uniforms.builtin.BuiltinReplacementUniforms; +import net.coderbot.iris.uniforms.custom.CustomUniforms; +import org.jetbrains.annotations.Nullable; + +import java.util.EnumMap; +import java.util.Map; +import java.util.Optional; +import java.util.concurrent.CompletableFuture; +import java.util.function.IntFunction; + +public class CeleritasTerrainPipeline { + private final EnumMap passInfoMap = new EnumMap<>(IrisTerrainPass.class); + + @Getter + private final CustomUniforms customUniforms; + + private final IntFunction createTerrainSamplers; + private final IntFunction createShadowSamplers; + + private final IntFunction createTerrainImages; + private final IntFunction createShadowImages; + + @Getter + @Accessors(fluent = true) + public static final class PassInfo { + private final EnumMap> sources = new EnumMap<>(PatchShaderType.class); + private GlFramebuffer framebuffer; + private BlendModeOverride blendModeOverride; + private float alphaReference; + + private PassInfo() { + for (PatchShaderType type : PatchShaderType.VALUES) { + sources.put(type, Optional.empty()); + } + } + + private void setSource(PatchShaderType type, @Nullable String source) { + sources.put(type, Optional.ofNullable(source)); + } + } + + public CeleritasTerrainPipeline( + IntFunction createTerrainSamplers, + IntFunction createShadowSamplers, + IntFunction createTerrainImages, + IntFunction createShadowImages, + CustomUniforms customUniforms, + String terrainSourceName, + String translucentSourceName, + String shadowSourceName, + CompletableFuture> terrainFuture, + CompletableFuture> translucentFuture, + CompletableFuture> shadowFuture, + RenderTargets renderTargets, + ImmutableSet flippedAfterPrepare, + ImmutableSet flippedAfterTranslucent, + @Nullable GlFramebuffer shadowFramebuffer, + int[] terrainDrawBuffers + ) { + this.customUniforms = customUniforms; + + // Initialize PassInfo for each pass + for (IrisTerrainPass pass : IrisTerrainPass.VALUES) { + passInfoMap.put(pass, new PassInfo()); + } + + // Process terrain shaders (used for GBUFFER_SOLID and GBUFFER_CUTOUT) + if (terrainFuture != null) { + try { + final Map result = terrainFuture.join(); + final PassInfo solidInfo = passInfoMap.get(IrisTerrainPass.GBUFFER_SOLID); + final PassInfo cutoutInfo = passInfoMap.get(IrisTerrainPass.GBUFFER_CUTOUT); + + solidInfo.setSource(PatchShaderType.VERTEX, result.get(PatchShaderType.VERTEX)); + solidInfo.setSource(PatchShaderType.GEOMETRY, result.get(PatchShaderType.GEOMETRY)); + solidInfo.setSource(PatchShaderType.FRAGMENT, result.get(PatchShaderType.FRAGMENT)); + + cutoutInfo.setSource(PatchShaderType.VERTEX, result.get(PatchShaderType.VERTEX)); + cutoutInfo.setSource(PatchShaderType.GEOMETRY, result.get(PatchShaderType.GEOMETRY)); + cutoutInfo.setSource(PatchShaderType.FRAGMENT, result.get(PatchShaderType.FRAGMENT)); + + PatchedShaderPrinter.debugPatchedShaders(terrainSourceName + "_celeritas", + result.get(PatchShaderType.VERTEX), result.get(PatchShaderType.GEOMETRY), result.get(PatchShaderType.FRAGMENT)); + } catch (Exception e) { + Iris.logger.error("Failed to transform terrain shader for Celeritas: {}", terrainSourceName, e); + throw new RuntimeException("Shader transformation failed for " + terrainSourceName, e); + } + } + + // Process translucent shaders (used for GBUFFER_TRANSLUCENT) + if (translucentFuture != null) { + try { + final Map result = translucentFuture.join(); + final PassInfo translucentInfo = passInfoMap.get(IrisTerrainPass.GBUFFER_TRANSLUCENT); + + translucentInfo.setSource(PatchShaderType.VERTEX, result.get(PatchShaderType.VERTEX)); + translucentInfo.setSource(PatchShaderType.GEOMETRY, result.get(PatchShaderType.GEOMETRY)); + translucentInfo.setSource(PatchShaderType.FRAGMENT, result.get(PatchShaderType.FRAGMENT)); + + PatchedShaderPrinter.debugPatchedShaders(translucentSourceName + "_celeritas", + result.get(PatchShaderType.VERTEX), result.get(PatchShaderType.GEOMETRY), result.get(PatchShaderType.FRAGMENT)); + } catch (Exception e) { + Iris.logger.error("Failed to transform translucent shader for Celeritas: {}", translucentSourceName, e); + throw new RuntimeException("Shader transformation failed for " + translucentSourceName, e); + } + } + + // Process shadow shaders (used for SHADOW and SHADOW_CUTOUT) + if (shadowFuture != null) { + try { + final Map result = shadowFuture.join(); + final PassInfo shadowInfo = passInfoMap.get(IrisTerrainPass.SHADOW); + final PassInfo shadowCutoutInfo = passInfoMap.get(IrisTerrainPass.SHADOW_CUTOUT); + + shadowInfo.setSource(PatchShaderType.VERTEX, result.get(PatchShaderType.VERTEX)); + shadowInfo.setSource(PatchShaderType.GEOMETRY, result.get(PatchShaderType.GEOMETRY)); + shadowInfo.setSource(PatchShaderType.FRAGMENT, result.get(PatchShaderType.FRAGMENT)); + + shadowCutoutInfo.setSource(PatchShaderType.VERTEX, result.get(PatchShaderType.VERTEX)); + shadowCutoutInfo.setSource(PatchShaderType.GEOMETRY, result.get(PatchShaderType.GEOMETRY)); + shadowCutoutInfo.setSource(PatchShaderType.FRAGMENT, result.get(PatchShaderType.FRAGMENT)); + + PatchedShaderPrinter.debugPatchedShaders(shadowSourceName + "_celeritas", + result.get(PatchShaderType.VERTEX), result.get(PatchShaderType.GEOMETRY), result.get(PatchShaderType.FRAGMENT)); + } catch (Exception e) { + Iris.logger.error("Failed to transform shadow shader for Celeritas: {}", shadowSourceName, e); + throw new RuntimeException("Shader transformation failed for " + shadowSourceName, e); + } + } + + // Set up framebuffers for each pass + // Shadow passes use the shadow framebuffer + if (shadowFramebuffer != null) { + passInfoMap.get(IrisTerrainPass.SHADOW).framebuffer = shadowFramebuffer; + passInfoMap.get(IrisTerrainPass.SHADOW_CUTOUT).framebuffer = shadowFramebuffer; + } + + // GBuffer passes use render target framebuffers + if (renderTargets != null && terrainDrawBuffers != null) { + final GlFramebuffer solidFb = renderTargets.createGbufferFramebuffer(flippedAfterPrepare, terrainDrawBuffers); + final GlFramebuffer translucentFb = renderTargets.createGbufferFramebuffer(flippedAfterTranslucent, terrainDrawBuffers); + + passInfoMap.get(IrisTerrainPass.GBUFFER_SOLID).framebuffer = solidFb; + passInfoMap.get(IrisTerrainPass.GBUFFER_CUTOUT).framebuffer = solidFb; + passInfoMap.get(IrisTerrainPass.GBUFFER_TRANSLUCENT).framebuffer = translucentFb; + } + + // Set blend mode overrides + passInfoMap.get(IrisTerrainPass.GBUFFER_SOLID).blendModeOverride = BlendModeOverride.OFF; + passInfoMap.get(IrisTerrainPass.GBUFFER_CUTOUT).blendModeOverride = BlendModeOverride.OFF; + passInfoMap.get(IrisTerrainPass.GBUFFER_TRANSLUCENT).blendModeOverride = null; // Default blending + passInfoMap.get(IrisTerrainPass.SHADOW).blendModeOverride = BlendModeOverride.OFF; + passInfoMap.get(IrisTerrainPass.SHADOW_CUTOUT).blendModeOverride = BlendModeOverride.OFF; + + // Set alpha references + passInfoMap.get(IrisTerrainPass.GBUFFER_SOLID).alphaReference = 0.0f; + passInfoMap.get(IrisTerrainPass.GBUFFER_CUTOUT).alphaReference = 0.1f; + passInfoMap.get(IrisTerrainPass.GBUFFER_TRANSLUCENT).alphaReference = 0.0f; + passInfoMap.get(IrisTerrainPass.SHADOW).alphaReference = 0.0f; + passInfoMap.get(IrisTerrainPass.SHADOW_CUTOUT).alphaReference = 0.1f; + + this.createTerrainSamplers = createTerrainSamplers; + this.createShadowSamplers = createShadowSamplers; + this.createTerrainImages = createTerrainImages; + this.createShadowImages = createShadowImages; + } + + public PassInfo getPassInfo(IrisTerrainPass pass) { + return passInfoMap.get(pass); + } + + public ProgramUniforms.Builder initUniforms(int programId) { + final ProgramUniforms.Builder uniforms = ProgramUniforms.builder("", programId); + + CommonUniforms.addDynamicUniforms(uniforms); + customUniforms.assignTo(uniforms); + + BuiltinReplacementUniforms.addBuiltinReplacementUniforms(uniforms); + return uniforms; + } + + public boolean hasShadowPass() { + return createShadowSamplers != null; + } + + public ProgramSamplers initTerrainSamplers(int programId) { + return createTerrainSamplers.apply(programId); + } + + public ProgramSamplers initShadowSamplers(int programId) { + return createShadowSamplers.apply(programId); + } + + public ProgramImages initTerrainImages(int programId) { + return createTerrainImages.apply(programId); + } + + public ProgramImages initShadowImages(int programId) { + return createShadowImages.apply(programId); + } +} diff --git a/src/main/java/net/coderbot/iris/celeritas/IrisCeleritasChunkProgramOverrides.java b/src/main/java/net/coderbot/iris/celeritas/IrisCeleritasChunkProgramOverrides.java new file mode 100644 index 000000000..a563c806d --- /dev/null +++ b/src/main/java/net/coderbot/iris/celeritas/IrisCeleritasChunkProgramOverrides.java @@ -0,0 +1,159 @@ +package net.coderbot.iris.celeritas; + +import net.coderbot.iris.Iris; +import net.coderbot.iris.gl.blending.BlendModeOverride; +import net.coderbot.iris.pipeline.WorldRenderingPipeline; +import net.coderbot.iris.pipeline.transform.PatchShaderType; +import net.coderbot.iris.shadows.ShadowRenderingState; +import org.embeddedt.embeddium.impl.gl.GlObject; +import org.embeddedt.embeddium.impl.gl.shader.GlProgram; +import org.embeddedt.embeddium.impl.gl.shader.GlShader; +import org.embeddedt.embeddium.impl.gl.shader.ShaderType; +import org.embeddedt.embeddium.impl.render.chunk.RenderPassConfiguration; +import org.embeddedt.embeddium.impl.render.chunk.shader.ChunkShaderInterface; +import org.embeddedt.embeddium.impl.render.chunk.terrain.TerrainRenderPass; +import org.jetbrains.annotations.Nullable; + +import java.util.EnumMap; +import java.util.Locale; +import java.util.Optional; + +public class IrisCeleritasChunkProgramOverrides { + private final EnumMap> programs = new EnumMap<>(IrisTerrainPass.class); + private boolean shadersCreated = false; + private int versionCounterForShaderReload = -1; + + @Nullable + private GlShader createVertexShader(IrisTerrainPass pass, CeleritasTerrainPipeline pipeline) { + final CeleritasTerrainPipeline.PassInfo info = pipeline.getPassInfo(pass); + final Optional source = info.sources().get(PatchShaderType.VERTEX); + + return source.map(s -> new GlShader(ShaderType.VERTEX, + "iris:celeritas-terrain-" + pass.toString().toLowerCase(Locale.ROOT) + ".vsh", s)) + .orElse(null); + } + + @Nullable + private GlShader createGeometryShader(IrisTerrainPass pass, CeleritasTerrainPipeline pipeline) { + final CeleritasTerrainPipeline.PassInfo info = pipeline.getPassInfo(pass); + final Optional source = info.sources().get(PatchShaderType.GEOMETRY); + + return source.map(s -> new GlShader(ShaderType.GEOM, + "iris:celeritas-terrain-" + pass.toString().toLowerCase(Locale.ROOT) + ".gsh", s)) + .orElse(null); + } + + @Nullable + private GlShader createFragmentShader(IrisTerrainPass pass, CeleritasTerrainPipeline pipeline) { + final CeleritasTerrainPipeline.PassInfo info = pipeline.getPassInfo(pass); + final Optional source = info.sources().get(PatchShaderType.FRAGMENT); + + return source.map(s -> new GlShader(ShaderType.FRAGMENT, + "iris:celeritas-terrain-" + pass.toString().toLowerCase(Locale.ROOT) + ".fsh", s)) + .orElse(null); + } + + @Nullable + private GlProgram createShader(IrisTerrainPass pass, CeleritasTerrainPipeline pipeline, RenderPassConfiguration configuration) { + final GlShader vertShader = createVertexShader(pass, pipeline); + final GlShader geomShader = createGeometryShader(pass, pipeline); + final GlShader fragShader = createFragmentShader(pass, pipeline); + + if (vertShader == null || fragShader == null) { + if (vertShader != null) vertShader.delete(); + if (geomShader != null) geomShader.delete(); + if (fragShader != null) fragShader.delete(); + return null; + } + + try { + final GlProgram.Builder builder = GlProgram.builder("iris:celeritas-chunk-" + pass.getName()); + + builder.attachShader(vertShader); + if (geomShader != null) { + builder.attachShader(geomShader); + } + builder.attachShader(fragShader); + + // Bind all attributes from the vertex format (includes base + Iris extended attributes) + final var vertexType =pass.toTerrainPass(configuration).vertexType(); + int attrIndex = 0; + for (var attr : vertexType.getVertexFormat().getAttributes()) { + builder.bindAttribute(attr.getName(), attrIndex++); + } + + // Get blend from PassInfo + final CeleritasTerrainPipeline.PassInfo passInfo = pipeline.getPassInfo(pass); + final BlendModeOverride blendOverride = passInfo.blendModeOverride(); + + return builder.link(context -> new IrisCeleritasChunkShaderInterface(((GlObject) context).handle(), context, pipeline, pass.isShadow(), blendOverride, pipeline.getCustomUniforms())); + } finally { + vertShader.delete(); + if (geomShader != null) geomShader.delete(); + fragShader.delete(); + } + } + + /** + * Create shaders for all Iris terrain passes. + */ + public void createShaders(CeleritasTerrainPipeline pipeline, RenderPassConfiguration configuration) { + if (pipeline != null) { + for (IrisTerrainPass pass : IrisTerrainPass.VALUES) { + if (pass.isShadow() && !pipeline.hasShadowPass()) { + this.programs.put(pass, null); + continue; + } + this.programs.put(pass, createShader(pass, pipeline, configuration)); + } + } else { + deleteShaders(); + } + shadersCreated = true; + } + + @Nullable + public GlProgram getProgramOverride(TerrainRenderPass pass, RenderPassConfiguration configuration) { + // Check for shader pack reload + if (versionCounterForShaderReload != Iris.getPipelineManager().getVersionCounterForSodiumShaderReload()) { + versionCounterForShaderReload = Iris.getPipelineManager().getVersionCounterForSodiumShaderReload(); + deleteShaders(); + } + + final WorldRenderingPipeline worldPipeline = Iris.getPipelineManager().getPipelineNullable(); + CeleritasTerrainPipeline celeritasPipeline = null; + if (worldPipeline != null) { + celeritasPipeline = worldPipeline.getCeleritasTerrainPipeline(); + } + + if (!shadersCreated) { + createShaders(celeritasPipeline, configuration); + } + + if (ShadowRenderingState.areShadowsCurrentlyBeingRendered()) { + if (celeritasPipeline != null && !celeritasPipeline.hasShadowPass()) { + throw new IllegalStateException("Shadow program requested, but shader pack has no shadow pass"); + } + return programs.get(pass.supportsFragmentDiscard() ? + IrisTerrainPass.SHADOW_CUTOUT : IrisTerrainPass.SHADOW); + } else { + if (pass.supportsFragmentDiscard()) { + return programs.get(IrisTerrainPass.GBUFFER_CUTOUT); + } else if (pass.isReverseOrder()) { + return programs.get(IrisTerrainPass.GBUFFER_TRANSLUCENT); + } else { + return programs.get(IrisTerrainPass.GBUFFER_SOLID); + } + } + } + + public void deleteShaders() { + for (GlProgram program : programs.values()) { + if (program != null) { + program.delete(); + } + } + programs.clear(); + shadersCreated = false; + } +} diff --git a/src/main/java/net/coderbot/iris/celeritas/IrisCeleritasChunkShaderInterface.java b/src/main/java/net/coderbot/iris/celeritas/IrisCeleritasChunkShaderInterface.java new file mode 100644 index 000000000..ec7596576 --- /dev/null +++ b/src/main/java/net/coderbot/iris/celeritas/IrisCeleritasChunkShaderInterface.java @@ -0,0 +1,199 @@ +package net.coderbot.iris.celeritas; + +import com.gtnewhorizons.angelica.glsm.GLStateManager; +import com.gtnewhorizons.angelica.mixins.interfaces.EntityRendererAccessor; +import net.coderbot.iris.Iris; +import net.coderbot.iris.gl.blending.BlendModeOverride; +import net.coderbot.iris.gl.framebuffer.GlFramebuffer; +import net.coderbot.iris.pipeline.WorldRenderingPipeline; +import net.coderbot.iris.samplers.IrisSamplers; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.texture.DynamicTexture; +import org.lwjgl.opengl.GL11; +import org.lwjgl.opengl.GL13; +import net.coderbot.iris.gl.program.ProgramImages; +import net.coderbot.iris.gl.program.ProgramSamplers; +import net.coderbot.iris.gl.program.ProgramUniforms; +import net.coderbot.iris.shadows.ShadowRenderingState; +import net.coderbot.iris.uniforms.custom.CustomUniforms; +import org.embeddedt.embeddium.impl.gl.shader.ShaderBindingContext; +import org.embeddedt.embeddium.impl.gl.shader.uniform.GlUniformFloat3v; +import org.embeddedt.embeddium.impl.gl.shader.uniform.GlUniformMatrix3f; +import org.embeddedt.embeddium.impl.gl.shader.uniform.GlUniformMatrix4f; +import org.embeddedt.embeddium.impl.gl.tessellation.GlPrimitiveType; +import org.embeddedt.embeddium.impl.render.chunk.shader.ChunkShaderInterface; +import org.embeddedt.embeddium.impl.render.chunk.shader.ChunkShaderTextureSlot; +import org.embeddedt.embeddium.impl.render.chunk.terrain.TerrainRenderPass; +import org.jetbrains.annotations.Nullable; +import org.joml.Matrix3f; +import org.joml.Matrix4f; +import org.joml.Matrix4fc; + +public class IrisCeleritasChunkShaderInterface implements ChunkShaderInterface { + @Nullable + private final GlUniformMatrix4f uniformModelViewMatrix; + @Nullable + private final GlUniformMatrix4f uniformModelViewMatrixInverse; + @Nullable + private final GlUniformMatrix4f uniformProjectionMatrix; + @Nullable + private final GlUniformMatrix4f uniformProjectionMatrixInverse; + @Nullable + private final GlUniformMatrix3f uniformNormalMatrix; + @Nullable + private final GlUniformFloat3v uniformRegionOffset; + + // Iris program state + private final ProgramUniforms irisProgramUniforms; + private final ProgramSamplers irisProgramSamplers; + private final ProgramImages irisProgramImages; + private final CustomUniforms customUniforms; + + // Rendering state + private final BlendModeOverride blendModeOverride; + + // Stored matrices for inverse and normal matrix computation + private final Matrix4f projectionMatrixInverse = new Matrix4f(); + private final Matrix4f modelViewMatrixInverse = new Matrix4f(); + private final Matrix3f normalMatrix = new Matrix3f(); + + public IrisCeleritasChunkShaderInterface(int handle, ShaderBindingContext context, CeleritasTerrainPipeline pipeline, boolean isShadowPass, BlendModeOverride blendModeOverride, CustomUniforms customUniforms) { + this.uniformModelViewMatrix = context.bindUniformIfPresent("iris_ModelViewMatrix", GlUniformMatrix4f::new); + this.uniformModelViewMatrixInverse = context.bindUniformIfPresent("iris_ModelViewMatrixInverse", GlUniformMatrix4f::new); + this.uniformProjectionMatrix = context.bindUniformIfPresent("iris_ProjectionMatrix", GlUniformMatrix4f::new); + this.uniformProjectionMatrixInverse = context.bindUniformIfPresent("iris_ProjectionMatrixInverse", GlUniformMatrix4f::new); + this.uniformNormalMatrix = context.bindUniformIfPresent("iris_NormalMatrix", GlUniformMatrix3f::new); + this.uniformRegionOffset = context.bindUniformIfPresent("u_RegionOffset", GlUniformFloat3v::new); + + this.blendModeOverride = blendModeOverride; + this.customUniforms = customUniforms; + + final ProgramUniforms.Builder builder = pipeline.initUniforms(handle); + customUniforms.mapholderToPass(builder, this); + this.irisProgramUniforms = builder.buildUniforms(); + this.irisProgramSamplers = isShadowPass ? pipeline.initShadowSamplers(handle) : pipeline.initTerrainSamplers(handle); + this.irisProgramImages = isShadowPass ? pipeline.initShadowImages(handle) : pipeline.initTerrainImages(handle); + } + + @Override + public void setupState(TerrainRenderPass pass) { + bindFramebuffer(pass); + + if (ShadowRenderingState.areShadowsCurrentlyBeingRendered()) { + GLStateManager.disableCull(); + } + + GLStateManager.glActiveTexture(GL13.GL_TEXTURE0 + IrisSamplers.ALBEDO_TEXTURE_UNIT); + GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, Minecraft.getMinecraft().getTextureMapBlocks().getGlTextureId()); + + GLStateManager.glActiveTexture(GL13.GL_TEXTURE0 + IrisSamplers.LIGHTMAP_TEXTURE_UNIT); + final DynamicTexture lightmapTexture = ((EntityRendererAccessor) Minecraft.getMinecraft().entityRenderer).getLightmapTexture(); + GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, lightmapTexture.getGlTextureId()); + + if (blendModeOverride != null) { + blendModeOverride.apply(); + } + + if (irisProgramUniforms != null) { + irisProgramUniforms.update(); + } + if (irisProgramSamplers != null) { + irisProgramSamplers.update(); + } + if (irisProgramImages != null) { + irisProgramImages.update(); + } + + customUniforms.push(this); + } + + @Override + public void restoreState() { + if (blendModeOverride != null) { + BlendModeOverride.restore(); + } + + ProgramUniforms.clearActiveUniforms(); + ProgramSamplers.clearActiveSamplers(); + } + + @Override + public GlPrimitiveType getPrimitiveType() { + return GlPrimitiveType.QUADS; + } + + @Override + public void setProjectionMatrix(Matrix4fc matrix) { + if (uniformProjectionMatrix != null) { + uniformProjectionMatrix.set(matrix); + } + + if (uniformProjectionMatrixInverse != null) { + projectionMatrixInverse.set(matrix); + projectionMatrixInverse.invert(); + uniformProjectionMatrixInverse.set(projectionMatrixInverse); + } + } + + @Override + public void setModelViewMatrix(Matrix4fc modelView) { + if (uniformModelViewMatrix != null) { + uniformModelViewMatrix.set(modelView); + } + + if (uniformModelViewMatrixInverse != null) { + modelViewMatrixInverse.set(modelView); + modelViewMatrixInverse.invert(); + uniformModelViewMatrixInverse.set(modelViewMatrixInverse); + } + + if (uniformNormalMatrix != null) { + normalMatrix.set(modelView); + normalMatrix.invert(); + normalMatrix.transpose(); + uniformNormalMatrix.set(normalMatrix); + } + } + + @Override + public void setRegionOffset(float x, float y, float z) { + if (uniformRegionOffset != null) { + uniformRegionOffset.set(x, y, z); + } + } + + @Override + public void setTextureSlot(ChunkShaderTextureSlot slot, int val) { + // No-op - Iris manages texture state internally + } + + private void bindFramebuffer(TerrainRenderPass pass) { + final CeleritasTerrainPipeline pipeline = getCeleritasTerrainPipeline(); + if (pipeline == null) { + return; + } + + final boolean isShadow = ShadowRenderingState.areShadowsCurrentlyBeingRendered(); + final IrisTerrainPass irisPass; + if (isShadow) { + irisPass = pass.supportsFragmentDiscard() ? IrisTerrainPass.SHADOW_CUTOUT : IrisTerrainPass.SHADOW; + } else if (pass.isReverseOrder()) { + irisPass = IrisTerrainPass.GBUFFER_TRANSLUCENT; + } else if (pass.supportsFragmentDiscard()) { + irisPass = IrisTerrainPass.GBUFFER_CUTOUT; + } else { + irisPass = IrisTerrainPass.GBUFFER_SOLID; + } + + final GlFramebuffer framebuffer = pipeline.getPassInfo(irisPass).framebuffer(); + if (framebuffer != null) { + framebuffer.bind(); + } + } + + @org.jetbrains.annotations.Nullable + private CeleritasTerrainPipeline getCeleritasTerrainPipeline() { + final WorldRenderingPipeline pipeline = Iris.getPipelineManager().getPipelineNullable(); + return pipeline != null ? pipeline.getCeleritasTerrainPipeline() : null; + } +} diff --git a/src/main/java/net/coderbot/iris/celeritas/IrisCeleritasShaderProvider.java b/src/main/java/net/coderbot/iris/celeritas/IrisCeleritasShaderProvider.java new file mode 100644 index 000000000..df8453111 --- /dev/null +++ b/src/main/java/net/coderbot/iris/celeritas/IrisCeleritasShaderProvider.java @@ -0,0 +1,82 @@ +package net.coderbot.iris.celeritas; + +import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProvider; +import com.gtnewhorizons.angelica.rendering.celeritas.iris.IrisExtendedChunkVertexType; +import it.unimi.dsi.fastutil.objects.Object2IntMap; +import net.coderbot.iris.Iris; +import net.coderbot.iris.block_rendering.BlockRenderingSettings; +import net.coderbot.iris.shadows.ShadowRenderingState; +import net.minecraft.block.Block; +import org.embeddedt.embeddium.impl.gl.shader.GlProgram; +import org.embeddedt.embeddium.impl.render.chunk.RenderPassConfiguration; +import org.embeddedt.embeddium.impl.render.chunk.shader.ChunkShaderInterface; +import org.embeddedt.embeddium.impl.render.chunk.terrain.TerrainRenderPass; +import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkVertexType; +import com.gtnewhorizons.angelica.compat.toremove.RenderLayer; +import org.jetbrains.annotations.Nullable; + +import java.util.Map; + +public class IrisCeleritasShaderProvider implements IrisShaderProvider { + private static final IrisExtendedChunkVertexType EXTENDED_VERTEX_TYPE = new IrisExtendedChunkVertexType(); + + private final IrisCeleritasChunkProgramOverrides overrides = new IrisCeleritasChunkProgramOverrides(); + private RenderPassConfiguration renderPassConfiguration; + + @Override + public boolean isShadersEnabled() { + return Iris.getCurrentPack().isPresent(); + } + + @Override + public boolean isShadowPass() { + return ShadowRenderingState.areShadowsCurrentlyBeingRendered(); + } + + @Override + public boolean shouldUseFaceCulling() { + return !ShadowRenderingState.areShadowsCurrentlyBeingRendered(); + } + + @Override + @Nullable + public GlProgram getShaderOverride(TerrainRenderPass pass) { + if (!isShadersEnabled() || renderPassConfiguration == null) { + return null; + } + return overrides.getProgramOverride(pass, renderPassConfiguration); + } + + @Override + public ChunkVertexType getVertexType(ChunkVertexType defaultType) { + if (isShadersEnabled() && BlockRenderingSettings.INSTANCE.shouldUseExtendedVertexFormat()) { + return EXTENDED_VERTEX_TYPE; + } + return defaultType; + } + + @Override + public void setRenderPassConfiguration(RenderPassConfiguration configuration) { + this.renderPassConfiguration = configuration; + } + + @Override + @Nullable + public Map getBlockTypeIds() { + return BlockRenderingSettings.INSTANCE.getBlockTypeIds(); + } + + @Override + @Nullable + public Object2IntMap getBlockMatches() { + return BlockRenderingSettings.INSTANCE.getBlockMatches(); + } + + public void deleteShaders() { + overrides.deleteShaders(); + } + + public IrisCeleritasChunkProgramOverrides getOverrides() { + return overrides; + } +} diff --git a/src/main/java/net/coderbot/iris/celeritas/IrisTerrainPass.java b/src/main/java/net/coderbot/iris/celeritas/IrisTerrainPass.java new file mode 100644 index 000000000..bd228eb6c --- /dev/null +++ b/src/main/java/net/coderbot/iris/celeritas/IrisTerrainPass.java @@ -0,0 +1,48 @@ +package net.coderbot.iris.celeritas; + +import org.embeddedt.embeddium.impl.render.chunk.RenderPassConfiguration; +import org.embeddedt.embeddium.impl.render.chunk.terrain.TerrainRenderPass; + +public enum IrisTerrainPass { + SHADOW("shadow"), + SHADOW_CUTOUT("shadow"), + GBUFFER_SOLID("gbuffers_terrain"), + GBUFFER_CUTOUT("gbuffers_terrain_cutout"), + GBUFFER_TRANSLUCENT("gbuffers_water"); + + public static final IrisTerrainPass[] VALUES = values(); + + private final String name; + + IrisTerrainPass(String name) { + this.name = name; + } + + public String getName() { + return name; + } + + public boolean isShadow() { + return this == SHADOW || this == SHADOW_CUTOUT; + } + + public TerrainRenderPass toTerrainPass(RenderPassConfiguration config) { + return switch (this) { + case SHADOW, GBUFFER_SOLID -> config.defaultSolidMaterial().pass; + case SHADOW_CUTOUT, GBUFFER_CUTOUT -> config.defaultCutoutMippedMaterial().pass; + case GBUFFER_TRANSLUCENT -> config.defaultTranslucentMaterial().pass; + }; + } + + public static IrisTerrainPass fromTerrainPass(TerrainRenderPass pass, boolean isShadow) { + if (isShadow) { + return pass.supportsFragmentDiscard() ? SHADOW_CUTOUT : SHADOW; + } else if (pass.supportsFragmentDiscard()) { + return GBUFFER_CUTOUT; + } else if (pass.isReverseOrder()) { + return GBUFFER_TRANSLUCENT; + } else { + return GBUFFER_SOLID; + } + } +} diff --git a/src/main/java/net/coderbot/iris/client/IrisDebugScreenHandler.java b/src/main/java/net/coderbot/iris/client/IrisDebugScreenHandler.java index 9c36d1bef..80284e3af 100644 --- a/src/main/java/net/coderbot/iris/client/IrisDebugScreenHandler.java +++ b/src/main/java/net/coderbot/iris/client/IrisDebugScreenHandler.java @@ -40,8 +40,6 @@ public class IrisDebugScreenHandler { if (mc.gameSettings.showDebugInfo) { event.right.add(Math.min(event.right.size(), 2), "Direct Buffers: +" + iris$humanReadableByteCountBin(iris$directPool.getMemoryUsed())); - event.right.add(""); - if (Iris.getIrisConfig().areShadersEnabled()) { event.right.add("[" + Iris.MODNAME + "] Shaderpack: " + Iris.getCurrentPackName() + (Iris.isFallback() ? " (fallback)" : "")); Iris.getCurrentPack().ifPresent(pack -> event.right.add("[" + Iris.MODNAME + "] " + pack.getProfileInfo())); diff --git a/src/main/java/net/coderbot/iris/features/FeatureFlags.java b/src/main/java/net/coderbot/iris/features/FeatureFlags.java index c0e501d20..a201c2549 100644 --- a/src/main/java/net/coderbot/iris/features/FeatureFlags.java +++ b/src/main/java/net/coderbot/iris/features/FeatureFlags.java @@ -12,6 +12,7 @@ public enum FeatureFlags { PER_BUFFER_BLENDING(() -> true, RenderSystem::supportsBufferBlending), COMPUTE_SHADERS(() -> true, RenderSystem::supportsCompute), ENTITY_TRANSLUCENT(() -> true, () -> true), + BLOCK_EMISSION_ATTRIBUTE(() -> true, () -> true), UNKNOWN(() -> false, () -> false); private final BooleanSupplier irisRequirement; diff --git a/src/main/java/net/coderbot/iris/gl/state/StateUpdateNotifiers.java b/src/main/java/net/coderbot/iris/gl/state/StateUpdateNotifiers.java index 7c1f535f3..ea8bbb9f6 100644 --- a/src/main/java/net/coderbot/iris/gl/state/StateUpdateNotifiers.java +++ b/src/main/java/net/coderbot/iris/gl/state/StateUpdateNotifiers.java @@ -1,18 +1,9 @@ package net.coderbot.iris.gl.state; /** - * Holds some standard update notifiers for various elements of GL state. Currently, this class has a few listeners for - * fog-related values. + * Holds update notifiers for PBR texture changes. */ public class StateUpdateNotifiers { - public static ValueUpdateNotifier fogToggleNotifier; - public static ValueUpdateNotifier fogModeNotifier; - public static ValueUpdateNotifier fogStartNotifier; - public static ValueUpdateNotifier fogEndNotifier; - public static ValueUpdateNotifier fogDensityNotifier; - public static ValueUpdateNotifier blendFuncNotifier; - public static ValueUpdateNotifier bindTextureNotifier; public static ValueUpdateNotifier normalTextureChangeNotifier; public static ValueUpdateNotifier specularTextureChangeNotifier; - public static ValueUpdateNotifier phaseChangeNotifier; } diff --git a/src/main/java/net/coderbot/iris/gl/state/ValueUpdateNotifier.java b/src/main/java/net/coderbot/iris/gl/state/ValueUpdateNotifier.java index 81774db5a..babdabd51 100644 --- a/src/main/java/net/coderbot/iris/gl/state/ValueUpdateNotifier.java +++ b/src/main/java/net/coderbot/iris/gl/state/ValueUpdateNotifier.java @@ -1,12 +1,14 @@ package net.coderbot.iris.gl.state; /** - * A + * A notifier that can trigger uniform updates when values change. */ public interface ValueUpdateNotifier { + /** No-op notifier for uniforms that are polled per-frame rather than push-notified */ + ValueUpdateNotifier NONE = listener -> {}; + /** - * Sets up a listener with this notifier. Whenever the underlying value of - * @param listener + * Sets up a listener with this notifier. */ void setListener(Runnable listener); } diff --git a/src/main/java/net/coderbot/iris/layer/GbufferPrograms.java b/src/main/java/net/coderbot/iris/layer/GbufferPrograms.java index 9b3671f8a..e481011fc 100644 --- a/src/main/java/net/coderbot/iris/layer/GbufferPrograms.java +++ b/src/main/java/net/coderbot/iris/layer/GbufferPrograms.java @@ -3,7 +3,6 @@ package net.coderbot.iris.layer; import net.coderbot.iris.Iris; import net.coderbot.iris.gbuffer_overrides.matching.SpecialCondition; import net.coderbot.iris.gl.shader.ProgramCreator; -import net.coderbot.iris.gl.state.StateUpdateNotifiers; import net.coderbot.iris.pipeline.WorldRenderingPhase; import net.coderbot.iris.pipeline.WorldRenderingPipeline; import org.lwjgl.opengl.GL20; @@ -12,7 +11,6 @@ public class GbufferPrograms { private static boolean entities; private static boolean blockEntities; private static boolean outline; - private static Runnable phaseChangeListener; private static void checkReentrancy() { if (entities || blockEntities || outline) { @@ -98,12 +96,6 @@ public class GbufferPrograms { } } - public static void runPhaseChangeNotifier() { - if (phaseChangeListener != null) { - phaseChangeListener.run(); - } - } - public static void setupSpecialRenderCondition(SpecialCondition override) { Iris.getPipelineManager().getPipeline().ifPresent(p -> p.setSpecialCondition(override)); } @@ -112,10 +104,6 @@ public class GbufferPrograms { Iris.getPipelineManager().getPipeline().ifPresent(p -> p.setSpecialCondition(null)); } - static { - StateUpdateNotifiers.phaseChangeNotifier = listener -> phaseChangeListener = listener; - } - public static void init() { // Empty initializer to run static } diff --git a/src/main/java/net/coderbot/iris/pipeline/DeferredWorldRenderingPipeline.java b/src/main/java/net/coderbot/iris/pipeline/DeferredWorldRenderingPipeline.java index 973dcae32..b45ef2909 100644 --- a/src/main/java/net/coderbot/iris/pipeline/DeferredWorldRenderingPipeline.java +++ b/src/main/java/net/coderbot/iris/pipeline/DeferredWorldRenderingPipeline.java @@ -9,6 +9,7 @@ import com.gtnewhorizons.angelica.glsm.texture.TextureInfoCache; import com.gtnewhorizons.angelica.rendering.RenderingState; import net.coderbot.iris.Iris; import net.coderbot.iris.block_rendering.BlockMaterialMapping; +import net.coderbot.iris.celeritas.CeleritasTerrainPipeline; import net.coderbot.iris.block_rendering.BlockRenderingSettings; import net.coderbot.iris.gbuffer_overrides.matching.InputAvailability; import net.coderbot.iris.gbuffer_overrides.matching.ProgramTable; @@ -128,7 +129,7 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R private final ImmutableSet flippedAfterPrepare; private final ImmutableSet flippedAfterTranslucent; - private final SodiumTerrainPipeline sodiumTerrainPipeline; + private final CeleritasTerrainPipeline celeritasTerrainPipeline; private final Map, Map> attributeTransforms; @@ -181,9 +182,10 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R final Optional translucentSource = first(programs.getGbuffersWater(), terrainSource); final Optional shadowSource = programs.getShadow(); - final CompletableFuture> sodiumTerrainFuture = terrainSource.map(DeferredWorldRenderingPipeline::submitSodiumTerrainTransform).orElse(null); - final CompletableFuture> sodiumTranslucentFuture = translucentSource.map(DeferredWorldRenderingPipeline::submitSodiumTerrainTransform).orElse(null); - final CompletableFuture> sodiumShadowFuture = shadowSource.map(DeferredWorldRenderingPipeline::submitSodiumTerrainTransform).orElse(null); + // Celeritas terrain transform futures + final CompletableFuture> celeritasTerrainFuture = terrainSource.map(DeferredWorldRenderingPipeline::submitCeleritasTerrainTransform).orElse(null); + final CompletableFuture> celeritasTranslucentFuture = translucentSource.map(DeferredWorldRenderingPipeline::submitCeleritasTerrainTransform).orElse(null); + final CompletableFuture> celeritasShadowFuture = shadowSource.map(DeferredWorldRenderingPipeline::submitCeleritasTerrainTransform).orElse(null); this.cloudSetting = programs.getPackDirectives().getCloudSetting(); this.shouldRenderUnderwaterOverlay = programs.getPackDirectives().underwaterOverlay(); @@ -392,7 +394,7 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R this.clearPassesFull = ClearPassCreator.createClearPasses(renderTargets, true, programs.getPackDirectives().getRenderTargetDirectives()); this.clearPasses = ClearPassCreator.createClearPasses(renderTargets, false, programs.getPackDirectives().getRenderTargetDirectives()); - // SodiumTerrainPipeline setup follows. + // Terrain pipeline sampler/image factory setup follows. Supplier> flipped = () -> isBeforeTranslucent ? flippedAfterPrepare : flippedAfterTranslucent; @@ -450,13 +452,22 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R return builder.build(); }; - this.sodiumTerrainPipeline = new SodiumTerrainPipeline(this, programs, createTerrainSamplers, + final GlFramebuffer celeritasShadowFb = (shadowRenderTargets != null && shadowRenderer != null) + ? shadowRenderTargets.createShadowFramebuffer(shadowRenderTargets.snapshot(), new int[] {0, 1}) + : null; + final int[] celeritasTerrainDrawBuffers = terrainSource + .map(source -> source.getDirectives().getDrawBuffers()) + .orElse(new int[] {0}); + + this.celeritasTerrainPipeline = new CeleritasTerrainPipeline(createTerrainSamplers, shadowRenderer == null ? null : createShadowTerrainSamplers, createTerrainImages, shadowRenderer == null ? null : createShadowTerrainImages, this.customUniforms, terrainSource.map(ProgramSource::getName).orElse(null), translucentSource.map(ProgramSource::getName).orElse(null), shadowSource.map(ProgramSource::getName).orElse(null), - sodiumTerrainFuture, sodiumTranslucentFuture, sodiumShadowFuture); + celeritasTerrainFuture, celeritasTranslucentFuture, celeritasShadowFuture, + renderTargets, flippedAfterPrepare, flippedAfterTranslucent, + celeritasShadowFb, celeritasTerrainDrawBuffers); } private RenderTargets getRenderTargets() { @@ -585,11 +596,6 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R return; } - if (sodiumTerrainRendering) { - beginPass(table.match(getCondition(getPhase()), new InputAvailability(true, true))); - return; - } - beginPass(table.match(getCondition(getPhase()), inputs)); } @@ -796,11 +802,11 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R GL11.glViewport(0, 0, main.framebufferWidth, main.framebufferHeight); } - if (program != null && !sodiumTerrainRendering) { + if (program != null) { program.use(); } - DeferredWorldRenderingPipeline.this.customUniforms.push(this); + DeferredWorldRenderingPipeline.this.customUniforms.push(this); if (alphaTestOverride != null) { alphaTestOverride.apply(); @@ -1094,6 +1100,7 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R if (shadowRenderer != null) { isRenderingShadow = true; + matchPass(); // Ensure shadow shader is bound for entity rendering shadowRenderer.renderShadows(levelRenderer, playerCamera); @@ -1208,8 +1215,8 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R } @Override - public SodiumTerrainPipeline getSodiumTerrainPipeline() { - return sodiumTerrainPipeline; + public CeleritasTerrainPipeline getCeleritasTerrainPipeline() { + return celeritasTerrainPipeline; } @Override @@ -1226,49 +1233,28 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R return phase; } - boolean sodiumTerrainRendering = false; - - @Override - public void syncProgram() { - matchPass(); - } - - @Override - public void beginSodiumTerrainRendering() { - sodiumTerrainRendering = true; - syncProgram(); - - } - - @Override - public void endSodiumTerrainRendering() { - sodiumTerrainRendering = false; - current = null; - syncProgram(); - } - @Override public void setOverridePhase(WorldRenderingPhase phase) { this.overridePhase = phase; - - GbufferPrograms.runPhaseChangeNotifier(); + matchPass(); } @Override public void setPhase(WorldRenderingPhase phase) { this.phase = phase; - - GbufferPrograms.runPhaseChangeNotifier(); + matchPass(); } @Override public void setInputs(InputAvailability availability) { this.inputs = availability; + matchPass(); } @Override public void setSpecialCondition(SpecialCondition special) { this.special = special; + matchPass(); } @Override @@ -1344,8 +1330,8 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R return futures; } - private static CompletableFuture> submitSodiumTerrainTransform(ProgramSource source) { - return Iris.ShaderTransformExecutor.submitTracked(() -> TransformPatcher.patchSodiumTerrain(source.getVertexSource().orElse(null), source.getGeometrySource().orElse(null), source.getFragmentSource().orElse(null))); + private static CompletableFuture> submitCeleritasTerrainTransform(ProgramSource source) { + return Iris.ShaderTransformExecutor.submitTracked(() -> TransformPatcher.patchCeleritasTerrain(source.getVertexSource().orElse(null), source.getGeometrySource().orElse(null), source.getFragmentSource().orElse(null))); } @SafeVarargs diff --git a/src/main/java/net/coderbot/iris/pipeline/FixedFunctionWorldRenderingPipeline.java b/src/main/java/net/coderbot/iris/pipeline/FixedFunctionWorldRenderingPipeline.java index efb429135..ca790e75b 100644 --- a/src/main/java/net/coderbot/iris/pipeline/FixedFunctionWorldRenderingPipeline.java +++ b/src/main/java/net/coderbot/iris/pipeline/FixedFunctionWorldRenderingPipeline.java @@ -2,6 +2,7 @@ package net.coderbot.iris.pipeline; import com.gtnewhorizons.angelica.compat.mojang.Camera; import net.coderbot.iris.block_rendering.BlockRenderingSettings; +import net.coderbot.iris.celeritas.CeleritasTerrainPipeline; import net.coderbot.iris.gbuffer_overrides.matching.InputAvailability; import net.coderbot.iris.gbuffer_overrides.matching.SpecialCondition; import net.coderbot.iris.gbuffer_overrides.state.RenderTargetStateListener; @@ -50,16 +51,6 @@ public class FixedFunctionWorldRenderingPipeline implements WorldRenderingPipeli return WorldRenderingPhase.NONE; } - @Override - public void beginSodiumTerrainRendering() { - - } - - @Override - public void endSodiumTerrainRendering() { - - } - @Override public void setOverridePhase(WorldRenderingPhase phase) { @@ -80,11 +71,6 @@ public class FixedFunctionWorldRenderingPipeline implements WorldRenderingPipeli } - @Override - public void syncProgram() { - - } - @Override public RenderTargetStateListener getRenderTargetStateListener() { return RenderTargetStateListener.NOP; @@ -126,7 +112,7 @@ public class FixedFunctionWorldRenderingPipeline implements WorldRenderingPipeli } @Override - public SodiumTerrainPipeline getSodiumTerrainPipeline() { + public CeleritasTerrainPipeline getCeleritasTerrainPipeline() { // no shaders to override return null; } diff --git a/src/main/java/net/coderbot/iris/pipeline/PipelineManager.java b/src/main/java/net/coderbot/iris/pipeline/PipelineManager.java index 148114574..1e3a68f94 100644 --- a/src/main/java/net/coderbot/iris/pipeline/PipelineManager.java +++ b/src/main/java/net/coderbot/iris/pipeline/PipelineManager.java @@ -3,10 +3,8 @@ package net.coderbot.iris.pipeline; import com.gtnewhorizons.angelica.glsm.GLStateManager; import lombok.Getter; import net.coderbot.iris.Iris; -import net.coderbot.iris.block_rendering.BlockRenderingSettings; import net.coderbot.iris.shaderpack.DimensionId; import net.coderbot.iris.uniforms.SystemTimeUniforms; -import net.minecraft.client.Minecraft; import org.jetbrains.annotations.Nullable; import org.lwjgl.opengl.GL11; import org.lwjgl.opengl.GL13; @@ -36,14 +34,6 @@ public class PipelineManager { Iris.logger.info("Creating pipeline for dimension {}", currentDimension); pipeline = pipelineFactory.apply(currentDimension); pipelinesPerDimension.put(currentDimension, pipeline); - - if (BlockRenderingSettings.INSTANCE.isReloadRequired()) { - if (Minecraft.getMinecraft().renderGlobal != null) { - Minecraft.getMinecraft().renderGlobal.loadRenderers(); - } - - BlockRenderingSettings.INSTANCE.clearReloadRequired(); - } } else { pipeline = pipelinesPerDimension.get(currentDimension); } diff --git a/src/main/java/net/coderbot/iris/pipeline/ShadowRenderer.java b/src/main/java/net/coderbot/iris/pipeline/ShadowRenderer.java index 4e5fe5ad6..ef2c1b3f7 100644 --- a/src/main/java/net/coderbot/iris/pipeline/ShadowRenderer.java +++ b/src/main/java/net/coderbot/iris/pipeline/ShadowRenderer.java @@ -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 visibleTileEntities; - public static List globalTileEntities; + public static final List visibleTileEntities = new ArrayList<>(); + public static final List globalTileEntities = new ArrayList<>(); public static boolean ACTIVE = false; + + private static final Comparator 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 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 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 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 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)); diff --git a/src/main/java/net/coderbot/iris/pipeline/SodiumTerrainPipeline.java b/src/main/java/net/coderbot/iris/pipeline/SodiumTerrainPipeline.java deleted file mode 100644 index 4b05ed43d..000000000 --- a/src/main/java/net/coderbot/iris/pipeline/SodiumTerrainPipeline.java +++ /dev/null @@ -1,189 +0,0 @@ -package net.coderbot.iris.pipeline; - -import lombok.Getter; -import net.coderbot.iris.gl.program.ProgramImages; -import net.coderbot.iris.gl.program.ProgramSamplers; -import net.coderbot.iris.gl.program.ProgramUniforms; -import net.coderbot.iris.pipeline.transform.PatchShaderType; -import net.coderbot.iris.shaderpack.ProgramSet; -import net.coderbot.iris.uniforms.CommonUniforms; -import net.coderbot.iris.uniforms.ExternallyManagedUniforms; -import net.coderbot.iris.uniforms.builtin.BuiltinReplacementUniforms; -import net.coderbot.iris.uniforms.custom.CustomUniforms; - -import java.util.Map; -import java.util.Objects; -import java.util.Optional; -import java.util.concurrent.CompletableFuture; -import java.util.function.IntFunction; - -import net.coderbot.iris.Iris; - -public class SodiumTerrainPipeline { - Optional terrainVertex = Optional.empty(); - Optional terrainGeometry = Optional.empty(); - Optional terrainFragment = Optional.empty(); - Optional translucentVertex = Optional.empty(); - Optional translucentGeometry = Optional.empty(); - Optional translucentFragment = Optional.empty(); - Optional shadowVertex = Optional.empty(); - Optional shadowGeometry = Optional.empty(); - Optional shadowFragment = Optional.empty(); - //GlFramebuffer framebuffer; - ProgramSet programSet; - - @Getter - private final CustomUniforms customUniforms; - - private final WorldRenderingPipeline parent; - - private final IntFunction createTerrainSamplers; - private final IntFunction createShadowSamplers; - - private final IntFunction createTerrainImages; - private final IntFunction createShadowImages; - - public SodiumTerrainPipeline(WorldRenderingPipeline parent, - ProgramSet programSet, IntFunction createTerrainSamplers, - IntFunction createShadowSamplers, - IntFunction createTerrainImages, - IntFunction createShadowImages, CustomUniforms customUniforms, - String terrainSourceName, - String translucentSourceName, - String shadowSourceName, - CompletableFuture> terrainFuture, - CompletableFuture> translucentFuture, - CompletableFuture> shadowFuture) { - this.parent = Objects.requireNonNull(parent); - - this.programSet = programSet; - - this.customUniforms = customUniforms; - - if (terrainFuture != null) { - try { - Map result = terrainFuture.join(); - terrainVertex = Optional.ofNullable(result.get(PatchShaderType.VERTEX)); - terrainGeometry = Optional.ofNullable(result.get(PatchShaderType.GEOMETRY)); - terrainFragment = Optional.ofNullable(result.get(PatchShaderType.FRAGMENT)); - - PatchedShaderPrinter.debugPatchedShaders(terrainSourceName + "_sodium", - terrainVertex.orElse(null), terrainGeometry.orElse(null), terrainFragment.orElse(null)); - } catch (Exception e) { - Iris.logger.error("Failed to transform terrain shader: {}", terrainSourceName, e); - throw new RuntimeException("Shader transformation failed for " + terrainSourceName, e); - } - } - - if (translucentFuture != null) { - try { - Map result = translucentFuture.join(); - translucentVertex = Optional.ofNullable(result.get(PatchShaderType.VERTEX)); - translucentGeometry = Optional.ofNullable(result.get(PatchShaderType.GEOMETRY)); - translucentFragment = Optional.ofNullable(result.get(PatchShaderType.FRAGMENT)); - - PatchedShaderPrinter.debugPatchedShaders(translucentSourceName + "_sodium", - translucentVertex.orElse(null), translucentGeometry.orElse(null), translucentFragment.orElse(null)); - } catch (Exception e) { - Iris.logger.error("Failed to transform translucent shader: {}", translucentSourceName, e); - throw new RuntimeException("Shader transformation failed for " + translucentSourceName, e); - } - } - - if (shadowFuture != null) { - try { - Map result = shadowFuture.join(); - shadowVertex = Optional.ofNullable(result.get(PatchShaderType.VERTEX)); - shadowGeometry = Optional.ofNullable(result.get(PatchShaderType.GEOMETRY)); - shadowFragment = Optional.ofNullable(result.get(PatchShaderType.FRAGMENT)); - - PatchedShaderPrinter.debugPatchedShaders(shadowSourceName + "_sodium", - shadowVertex.orElse(null), shadowGeometry.orElse(null), shadowFragment.orElse(null)); - } catch (Exception e) { - Iris.logger.error("Failed to transform shadow shader: {}", shadowSourceName, e); - throw new RuntimeException("Shader transformation failed for " + shadowSourceName, e); - } - } - - this.createTerrainSamplers = createTerrainSamplers; - this.createShadowSamplers = createShadowSamplers; - this.createTerrainImages = createTerrainImages; - this.createShadowImages = createShadowImages; - } - - public Optional getTerrainVertexShaderSource() { - return terrainVertex; - } - - public Optional getTerrainGeometryShaderSource() { - return terrainGeometry; - } - - public Optional getTerrainFragmentShaderSource() { - return terrainFragment; - } - - public Optional getTranslucentVertexShaderSource() { - return translucentVertex; - } - - public Optional getTranslucentGeometryShaderSource() { - return translucentGeometry; - } - - public Optional getTranslucentFragmentShaderSource() { - return translucentFragment; - } - - public Optional getShadowVertexShaderSource() { - return shadowVertex; - } - - public Optional getShadowGeometryShaderSource() { - return shadowGeometry; - } - - public Optional getShadowFragmentShaderSource() { - return shadowFragment; - } - - public ProgramUniforms.Builder initUniforms(int programId) { - ProgramUniforms.Builder uniforms = ProgramUniforms.builder("", programId); - - CommonUniforms.addDynamicUniforms(uniforms); - customUniforms.assignTo(uniforms); - - ExternallyManagedUniforms.addExternallyManagedUniforms116(uniforms); - - BuiltinReplacementUniforms.addBuiltinReplacementUniforms(uniforms); - return uniforms; - } - - public boolean hasShadowPass() { - return createShadowSamplers != null; - } - - public ProgramSamplers initTerrainSamplers(int programId) { - return createTerrainSamplers.apply(programId); - } - - public ProgramSamplers initShadowSamplers(int programId) { - return createShadowSamplers.apply(programId); - } - - public ProgramImages initTerrainImages(int programId) { - return createTerrainImages.apply(programId); - } - - public ProgramImages initShadowImages(int programId) { - return createShadowImages.apply(programId); - } - - /*public void bindFramebuffer() { - this.framebuffer.bind(); - } - - public void unbindFramebuffer() { - GlStateManager.bindFramebuffer(GL30.GL_FRAMEBUFFER, 0); - }*/ -} diff --git a/src/main/java/net/coderbot/iris/pipeline/WorldRenderingPipeline.java b/src/main/java/net/coderbot/iris/pipeline/WorldRenderingPipeline.java index 4dc2904f0..5f702e23d 100644 --- a/src/main/java/net/coderbot/iris/pipeline/WorldRenderingPipeline.java +++ b/src/main/java/net/coderbot/iris/pipeline/WorldRenderingPipeline.java @@ -4,6 +4,7 @@ import com.gtnewhorizons.angelica.compat.mojang.Camera; import net.coderbot.iris.gbuffer_overrides.matching.InputAvailability; import net.coderbot.iris.gbuffer_overrides.matching.SpecialCondition; import net.coderbot.iris.gbuffer_overrides.state.RenderTargetStateListener; +import net.coderbot.iris.celeritas.CeleritasTerrainPipeline; import net.coderbot.iris.shaderpack.CloudSetting; import net.coderbot.iris.uniforms.FrameUpdateNotifier; import net.minecraft.client.renderer.EntityRenderer; @@ -19,13 +20,10 @@ public interface WorldRenderingPipeline { WorldRenderingPhase getPhase(); - void beginSodiumTerrainRendering(); - void endSodiumTerrainRendering(); void setOverridePhase(WorldRenderingPhase phase); void setPhase(WorldRenderingPhase phase); void setInputs(InputAvailability availability); void setSpecialCondition(SpecialCondition special); - void syncProgram(); RenderTargetStateListener getRenderTargetStateListener(); int getCurrentNormalTexture(); @@ -39,7 +37,7 @@ public interface WorldRenderingPipeline { void finalizeLevelRendering(); void destroy(); - SodiumTerrainPipeline getSodiumTerrainPipeline(); + CeleritasTerrainPipeline getCeleritasTerrainPipeline(); FrameUpdateNotifier getFrameUpdateNotifier(); boolean shouldDisableVanillaEntityShadows(); diff --git a/src/main/java/net/coderbot/iris/pipeline/transform/CeleritasTransformer.java b/src/main/java/net/coderbot/iris/pipeline/transform/CeleritasTransformer.java new file mode 100644 index 000000000..26510bfca --- /dev/null +++ b/src/main/java/net/coderbot/iris/pipeline/transform/CeleritasTransformer.java @@ -0,0 +1,112 @@ +package net.coderbot.iris.pipeline.transform; + +import net.coderbot.iris.pipeline.transform.parameter.Parameters; +import org.taumc.glsl.Transformer; + +import java.util.HashMap; +import java.util.Map; + +import static net.coderbot.iris.pipeline.transform.PatchShaderType.FRAGMENT; +import static net.coderbot.iris.pipeline.transform.PatchShaderType.VERTEX; + +class CeleritasTransformer { + public static void transform(Transformer transformer, Parameters parameters) { + switch (parameters.type) { + // For Celeritas patching, treat fragment and geometry the same + case FRAGMENT: + case GEOMETRY: + transformFragment(transformer, parameters); + break; + case VERTEX: + transformVertex(transformer, parameters); + break; + default: + throw new IllegalStateException("Unexpected Celeritas terrain patching shader type: " + parameters.type); + } + } + + public static void transformVertex(Transformer transformer, Parameters parameters) { + transformer.injectVariable("uniform vec3 u_RegionOffset;"); // Per-region offset from setRegionOffset() + transformer.injectVariable("vec4 iris_LightTexCoord;"); + transformer.injectFunction("vec4 iris_ftransform() { return gl_ModelViewProjectionMatrix * _celeritas_getVertexPosition(); }"); + transformer.injectFunction( + "vec4 _celeritas_getVertexPosition() { " + + "return vec4(_vert_position + u_RegionOffset + _get_draw_translation(_draw_id), 1.0); }"); + transformer.injectFunction( + "void _celeritas_init() { " + + "_vert_init(); " + + "iris_LightTexCoord = vec4(vec2(_vert_tex_light_coord), 0.0, 1.0); }"); + transformer.prependMain("_celeritas_init();"); + transformShared(transformer, parameters); + + final Map vertexReplacements = new HashMap<>(); + vertexReplacements.put("gl_Vertex", "_celeritas_getVertexPosition()"); + vertexReplacements.put("gl_MultiTexCoord0", "vec4(_vert_tex_diffuse_coord, 0.0, 1.0)"); + vertexReplacements.put("gl_MultiTexCoord1", "iris_LightTexCoord"); + vertexReplacements.put("gl_MultiTexCoord2", "iris_LightTexCoord"); + vertexReplacements.forEach(transformer::replaceExpression); + + final Map vertexRenames = new HashMap<>(); + vertexRenames.put("gl_Color", "_vert_color"); + vertexRenames.put("ftransform", "iris_ftransform"); + vertexRenames.put("gl_Normal", "iris_Normal"); + vertexRenames.put("chunkOffset", "u_RegionOffset"); + transformer.rename(vertexRenames); + + transformer.injectVariable("in vec3 iris_Normal;"); + } + + public static void transformFragment(Transformer transformer, Parameters parameters) { + // interestingly there is nothing that isn't shared + transformShared(transformer, parameters); + } + + private static void transformShared(Transformer transformer, Parameters parameters) { + transformer.injectVariable("uniform mat4 iris_ModelViewMatrix;"); + transformer.injectVariable("uniform mat4 iris_ModelViewMatrixInverse;"); + transformer.injectVariable("uniform mat4 iris_ProjectionMatrix;"); + transformer.injectVariable("uniform mat4 iris_ProjectionMatrixInverse;"); + transformer.injectVariable("uniform mat3 iris_NormalMatrix;"); + transformer.injectVariable("uniform mat4 iris_LightmapTextureMatrix;"); + + final Map renames = new HashMap<>(); + renames.put("gl_ModelViewMatrix", "iris_ModelViewMatrix"); + renames.put("gl_ModelViewMatrixInverse", "iris_ModelViewMatrixInverse"); + renames.put("gl_ProjectionMatrix", "iris_ProjectionMatrix"); + renames.put("gl_ProjectionMatrixInverse", "iris_ProjectionMatrixInverse"); + renames.put("gl_NormalMatrix", "iris_NormalMatrix"); + transformer.rename(renames); + + final Map sharedReplacements = new HashMap<>(); + sharedReplacements.put("gl_TextureMatrix[0]", "mat4(1.0)"); + sharedReplacements.put("gl_TextureMatrix[1]", "iris_LightmapTextureMatrix"); + sharedReplacements.put("gl_ModelViewProjectionMatrix", "(iris_ProjectionMatrix * iris_ModelViewMatrix)"); + sharedReplacements.forEach(transformer::replaceExpression); + + transformFog(transformer, parameters); + } + + private static void transformFog(Transformer transformer, Parameters parameters) { + transformer.injectVariable("uniform float iris_FogDensity;"); + transformer.injectVariable("uniform float iris_FogStart;"); + transformer.injectVariable("uniform float iris_FogEnd;"); + transformer.injectVariable("uniform vec4 iris_FogColor;"); + + transformer.injectFunction("struct iris_FogParameters { vec4 color; float density; float start; float end; float scale; };"); + transformer.injectFunction( + "iris_FogParameters iris_Fog = iris_FogParameters(iris_FogColor, iris_FogDensity, " + + "iris_FogStart, iris_FogEnd, 1.0 / (iris_FogEnd - iris_FogStart));"); + + final Map fogRenames = new HashMap<>(); + fogRenames.put("gl_Fog", "iris_Fog"); + fogRenames.put("gl_FogFragCoord", "iris_FogFragCoord"); + transformer.rename(fogRenames); + + if (parameters.type == VERTEX) { + transformer.injectVariable("out float iris_FogFragCoord;"); + transformer.prependMain("iris_FogFragCoord = 0.0;"); + } else if (parameters.type == FRAGMENT) { + transformer.injectVariable("in float iris_FogFragCoord;"); + } + } +} diff --git a/src/main/java/net/coderbot/iris/pipeline/transform/Patch.java b/src/main/java/net/coderbot/iris/pipeline/transform/Patch.java index 285345aa3..9bf29037a 100644 --- a/src/main/java/net/coderbot/iris/pipeline/transform/Patch.java +++ b/src/main/java/net/coderbot/iris/pipeline/transform/Patch.java @@ -2,6 +2,6 @@ package net.coderbot.iris.pipeline.transform; public enum Patch { ATTRIBUTES, - SODIUM_TERRAIN, + CELERITAS_TERRAIN, COMPOSITE } diff --git a/src/main/java/net/coderbot/iris/pipeline/transform/PatchShaderType.java b/src/main/java/net/coderbot/iris/pipeline/transform/PatchShaderType.java index d11797dba..729f18188 100644 --- a/src/main/java/net/coderbot/iris/pipeline/transform/PatchShaderType.java +++ b/src/main/java/net/coderbot/iris/pipeline/transform/PatchShaderType.java @@ -7,6 +7,8 @@ public enum PatchShaderType { GEOMETRY(ShaderType.GEOMETRY), FRAGMENT(ShaderType.FRAGMENT); + public static final PatchShaderType[] VALUES = values(); + public final ShaderType glShaderType; private PatchShaderType(ShaderType glShaderType) { diff --git a/src/main/java/net/coderbot/iris/pipeline/transform/ShaderTransformer.java b/src/main/java/net/coderbot/iris/pipeline/transform/ShaderTransformer.java index 7ca9699b9..d8710f5fd 100644 --- a/src/main/java/net/coderbot/iris/pipeline/transform/ShaderTransformer.java +++ b/src/main/java/net/coderbot/iris/pipeline/transform/ShaderTransformer.java @@ -1,6 +1,7 @@ package net.coderbot.iris.pipeline.transform; import com.google.common.base.Stopwatch; +import com.gtnewhorizons.angelica.rendering.celeritas.iris.IrisExtendedChunkVertexType; import it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap; import net.coderbot.iris.Iris; import net.coderbot.iris.gl.shader.ShaderType; @@ -8,6 +9,8 @@ import net.coderbot.iris.pipeline.transform.parameter.Parameters; import net.coderbot.iris.pipeline.transform.parameter.AttributeParameters; import org.antlr.v4.runtime.tree.ParseTree; import org.antlr.v4.runtime.tree.TerminalNode; +import org.embeddedt.embeddium.impl.gl.shader.ShaderConstants; +import org.embeddedt.embeddium.impl.render.shader.ShaderLoader; import org.taumc.glsl.ShaderParser; import org.taumc.glsl.Transformer; import org.taumc.glsl.grammar.GLSLLexer; @@ -139,7 +142,7 @@ public class ShaderTransformer { Stopwatch watch = Stopwatch.createStarted(); - for (PatchShaderType type : PatchShaderType.values()) { + for (PatchShaderType type : PatchShaderType.VALUES) { parameters.type = type; if (inputs.get(type) == null) { continue; @@ -205,11 +208,18 @@ public class ShaderTransformer { CompatibilityTransformer.transformGrouped(types, parameters); for (var entry : types.entrySet()) { final Transformer transformer = entry.getValue(); - final String header = prepatched.get(entry.getKey()); + String header = prepatched.get(entry.getKey()); + + // For Celeritas terrain vertex shaders, inject chunk_vertex.glsl header + if (patchType == Patch.CELERITAS_TERRAIN && entry.getKey() == PatchShaderType.VERTEX) { + header += computeCeleritasHeader(); + } + + final String finalHeader = header; final StringBuilder formattedShaderBuilder = new StringBuilder(); transformer.mutateTree(tree -> { - formattedShaderBuilder.append(getFormattedShader(tree, header)); + formattedShaderBuilder.append(getFormattedShader(tree, finalHeader)); }); String formattedShader = formattedShaderBuilder.toString(); @@ -250,8 +260,12 @@ public class ShaderTransformer { private static void doTransform(Transformer transformer, Patch patchType, Parameters parameters, String profile, int versionInt) { switch (patchType) { - case SODIUM_TERRAIN: - SodiumTransformer.transform(transformer, parameters); + case CELERITAS_TERRAIN: + CeleritasTransformer.transform(transformer, parameters); + // Handle mc_midTexCoord for Celeritas + patchMultiTexCoord3(transformer, parameters); + replaceMidTexCoord(transformer, IrisExtendedChunkVertexType.MID_TEX_SCALE); + applyIntelHd4000Workaround(transformer); break; case COMPOSITE: CompositeDepthTransformer.transform(transformer); @@ -326,6 +340,21 @@ public class ShaderTransformer { } } + private static String computeCeleritasHeader() { + final ShaderConstants constants = ShaderConstants.builder() + .add("VERT_POS_SCALE", "1.0") + .add("VERT_POS_OFFSET", "0.0") + .add("VERT_TEX_SCALE", "1.0") + .build(); + + final String chunkVertexHeader = org.embeddedt.embeddium.impl.gl.shader.ShaderParser.parseShader( + ShaderLoader.getShaderSource("sodium:include/chunk_vertex.glsl"), + ShaderLoader::getShaderSource, + constants); + + return "\n\n" + chunkVertexHeader + "\n\n"; + } + public static String getFormattedShader(ParseTree tree, String string) { StringBuilder sb = new StringBuilder(string + "\n"); String[] tabHolder = {""}; diff --git a/src/main/java/net/coderbot/iris/pipeline/transform/SodiumTransformer.java b/src/main/java/net/coderbot/iris/pipeline/transform/SodiumTransformer.java deleted file mode 100644 index 2194565ee..000000000 --- a/src/main/java/net/coderbot/iris/pipeline/transform/SodiumTransformer.java +++ /dev/null @@ -1,86 +0,0 @@ -package net.coderbot.iris.pipeline.transform; - -import net.coderbot.iris.pipeline.transform.parameter.Parameters; -import org.taumc.glsl.Transformer; - -import java.util.HashMap; -import java.util.Map; - -class SodiumTransformer { - public static void transform(Transformer transformer, Parameters parameters) { - switch (parameters.type) { - // For Sodium patching, treat fragment and geometry the same - case FRAGMENT: - case GEOMETRY: - transformFragment(transformer, parameters); - break; - case VERTEX: - transformVertex(transformer, parameters); - break; - default: - throw new IllegalStateException("Unexpected Sodium terrain patching shader type: " + parameters.type); - } - } - - /** - * Transforms vertex shaders. - */ - public static void transformVertex(Transformer transformer, Parameters parameters) { - transformer.injectVariable("attribute vec3 iris_Pos;"); - transformer.injectVariable("attribute vec4 iris_Color;"); - transformer.injectVariable("attribute vec2 iris_TexCoord;"); - transformer.injectVariable("attribute vec2 iris_LightCoord;"); - transformer.injectVariable("attribute vec3 iris_Normal;"); - transformer.injectVariable("uniform vec3 u_ModelScale;"); - transformer.injectVariable("uniform vec2 u_TextureScale;"); - transformer.injectVariable("attribute vec4 iris_ModelOffset;"); - - transformer.injectFunction("vec4 iris_LightTexCoord = vec4(iris_LightCoord, 0, 1);"); - transformer.injectFunction("vec4 ftransform() { return gl_ModelViewProjectionMatrix * gl_Vertex; }"); - - transformShared(transformer, parameters); - - Map vertexReplacements = new HashMap<>(); - vertexReplacements.put("gl_Vertex", "vec4((iris_Pos * u_ModelScale) + iris_ModelOffset.xyz, 1.0)"); - vertexReplacements.put("gl_MultiTexCoord0", "vec4(iris_TexCoord * u_TextureScale, 0.0, 1.0)"); - vertexReplacements.put("gl_MultiTexCoord1", "iris_LightTexCoord"); - vertexReplacements.put("gl_MultiTexCoord2", "iris_LightTexCoord"); - vertexReplacements.forEach(transformer::replaceExpression); - - Map vertexRenames = new HashMap<>(); - vertexRenames.put("gl_Color", "iris_Color"); - vertexRenames.put("gl_Normal", "iris_Normal"); - vertexRenames.put("ftransform", "iris_ftransform"); - transformer.rename(vertexRenames); - } - - /** - * Transforms fragment shaders. The fragment shader does only the shared things - * from the vertex shader. - */ - public static void transformFragment(Transformer transformer, Parameters parameters) { - // interestingly there is nothing that isn't shared - transformShared(transformer, parameters); - } - - /** - * Does the things that transformVertex and transformFragment have in common. - */ - private static void transformShared(Transformer transformer, Parameters parameters) { - transformer.injectVariable("uniform mat4 iris_ModelViewMatrix;"); - transformer.injectVariable("uniform mat4 u_ModelViewProjectionMatrix;"); - transformer.injectVariable("uniform mat4 iris_NormalMatrix;"); - transformer.injectVariable("uniform mat4 iris_LightmapTextureMatrix;"); - - Map renames = new HashMap<>(); - renames.put("gl_ModelViewMatrix", "iris_ModelViewMatrix"); - renames.put("gl_ModelViewProjectionMatrix", "u_ModelViewProjectionMatrix"); - transformer.rename(renames); - - Map sharedReplacements = new HashMap<>(); - sharedReplacements.put("gl_NormalMatrix", "mat3(iris_NormalMatrix)"); - sharedReplacements.put("gl_TextureMatrix[0]", "mat4(1.0)"); - sharedReplacements.put("gl_TextureMatrix[1]", "iris_LightmapTextureMatrix"); - sharedReplacements.forEach(transformer::replaceExpression); - } -} diff --git a/src/main/java/net/coderbot/iris/pipeline/transform/TransformPatcher.java b/src/main/java/net/coderbot/iris/pipeline/transform/TransformPatcher.java index e2259fd25..55fa3a38f 100644 --- a/src/main/java/net/coderbot/iris/pipeline/transform/TransformPatcher.java +++ b/src/main/java/net/coderbot/iris/pipeline/transform/TransformPatcher.java @@ -113,8 +113,8 @@ public class TransformPatcher { return transform(vertex, geometry, fragment, new AttributeParameters(Patch.ATTRIBUTES, geometry != null, inputs)); } - public static Map patchSodiumTerrain(String vertex, String geometry, String fragment) { - return transform(vertex, geometry, fragment, new Parameters(Patch.SODIUM_TERRAIN)); + public static Map patchCeleritasTerrain(String vertex, String geometry, String fragment) { + return transform(vertex, geometry, fragment, new Parameters(Patch.CELERITAS_TERRAIN)); } public static Map patchComposite(String vertex, String geometry, String fragment) { diff --git a/src/main/java/net/coderbot/iris/shadows/frustum/BoxCuller.java b/src/main/java/net/coderbot/iris/shadows/frustum/BoxCuller.java index 48a6614f6..208eceda5 100644 --- a/src/main/java/net/coderbot/iris/shadows/frustum/BoxCuller.java +++ b/src/main/java/net/coderbot/iris/shadows/frustum/BoxCuller.java @@ -3,7 +3,7 @@ package net.coderbot.iris.shadows.frustum; import net.minecraft.util.AxisAlignedBB; public class BoxCuller { - private final double maxDistance; + private double maxDistance; private double minAllowedX; private double maxAllowedX; @@ -16,6 +16,10 @@ public class BoxCuller { this.maxDistance = maxDistance; } + public void setMaxDistance(double maxDistance) { + this.maxDistance = maxDistance; + } + public void setPosition(double cameraX, double cameraY, double cameraZ) { this.minAllowedX = cameraX - maxDistance; this.maxAllowedX = cameraX + maxDistance; @@ -39,10 +43,19 @@ public class BoxCuller { return true; } - if (maxZ < this.minAllowedZ || minZ > this.maxAllowedZ) { + return maxZ < this.minAllowedZ || minZ > this.maxAllowedZ; + } + + // View-relative coordinates version + public boolean isCulledViewRelative(float minX, float minY, float minZ, float maxX, float maxY, float maxZ) { + if (maxX < -this.maxDistance || minX > this.maxDistance) { return true; } - return false; + if (maxY < -this.maxDistance || minY > this.maxDistance) { + return true; + } + + return maxZ < -this.maxDistance || minZ > this.maxDistance; } } diff --git a/src/main/java/net/coderbot/iris/shadows/frustum/CullEverythingFrustum.java b/src/main/java/net/coderbot/iris/shadows/frustum/CullEverythingFrustum.java index 8cbef5a5c..c9507e541 100644 --- a/src/main/java/net/coderbot/iris/shadows/frustum/CullEverythingFrustum.java +++ b/src/main/java/net/coderbot/iris/shadows/frustum/CullEverythingFrustum.java @@ -2,22 +2,26 @@ package net.coderbot.iris.shadows.frustum; import net.minecraft.client.renderer.culling.Frustrum; import net.minecraft.util.AxisAlignedBB; +import org.embeddedt.embeddium.impl.render.viewport.Viewport; +import org.embeddedt.embeddium.impl.render.viewport.ViewportProvider; +import org.embeddedt.embeddium.impl.render.viewport.frustum.Frustum; +import org.joml.Vector3d; -public class CullEverythingFrustum extends Frustrum { - - // for Sodium - public boolean fastAabbTest(float minX, float minY, float minZ, float maxX, float maxY, float maxZ) { - return false; - } - - // For Immersive Portals - // We return false here since isVisible is going to return false anyways. - public boolean canDetermineInvisible(double minX, double minY, double minZ, double maxX, double maxY, double maxZ) { - return false; - } +public class CullEverythingFrustum extends Frustrum implements ViewportProvider, Frustum { + private final Vector3d position = new Vector3d(); @Override public boolean isBoundingBoxInFrustum(AxisAlignedBB aabb) { return false; } + + @Override + public boolean testAab(float minX, float minY, float minZ, float maxX, float maxY, float maxZ) { + return false; + } + + @Override + public Viewport sodium$createViewport() { + return new Viewport(this, position.set(xPosition, yPosition, zPosition)); + } } diff --git a/src/main/java/net/coderbot/iris/shadows/frustum/advanced/AdvancedShadowCullingFrustum.java b/src/main/java/net/coderbot/iris/shadows/frustum/advanced/AdvancedShadowCullingFrustum.java index 180f7d77a..47344100a 100644 --- a/src/main/java/net/coderbot/iris/shadows/frustum/advanced/AdvancedShadowCullingFrustum.java +++ b/src/main/java/net/coderbot/iris/shadows/frustum/advanced/AdvancedShadowCullingFrustum.java @@ -3,8 +3,12 @@ package net.coderbot.iris.shadows.frustum.advanced; import net.coderbot.iris.shadows.frustum.BoxCuller; import net.minecraft.client.renderer.culling.Frustrum; import net.minecraft.util.AxisAlignedBB; +import org.embeddedt.embeddium.impl.render.viewport.Viewport; +import org.embeddedt.embeddium.impl.render.viewport.ViewportProvider; +import org.embeddedt.embeddium.impl.render.viewport.frustum.Frustum; import org.joml.Math; import org.joml.Matrix4f; +import org.joml.Vector3d; import org.joml.Vector3f; import org.joml.Vector4f; @@ -28,7 +32,7 @@ import org.joml.Vector4f; * are not sensitive to the specific internal ordering of planes and corners, in order to avoid potential bugs at the * cost of slightly more computations.

*/ -public class AdvancedShadowCullingFrustum extends Frustrum { +public class AdvancedShadowCullingFrustum extends Frustrum implements ViewportProvider, Frustum { private static final int MAX_CLIPPING_PLANES = 13; /** @@ -59,30 +63,47 @@ public class AdvancedShadowCullingFrustum extends Frustrum { * *

*/ + private static final Vector3f scratch3a = new Vector3f(); + private static final Vector3f scratch3b = new Vector3f(); + private static final Vector3f scratch3c = new Vector3f(); + private static final Vector3f scratch3d = new Vector3f(); + private static final Vector3f scratch3e = new Vector3f(); + private static final Vector3f scratch3f = new Vector3f(); + private final Vector4f[] planes = new Vector4f[MAX_CLIPPING_PLANES]; private int planeCount = 0; - // The center coordinates of this frustum. - private double x; - private double y; - private double z; + private final Vector3f shadowLightVectorFromOrigin = new Vector3f(); + private BoxCuller boxCuller; + private final Vector3d position = new Vector3d(); - private final Vector3f shadowLightVectorFromOrigin; - private final BoxCuller boxCuller; + private final BaseClippingPlanes baseClippingPlanes = new BaseClippingPlanes(); + private final boolean[] isBackArray = new boolean[6]; - public AdvancedShadowCullingFrustum(Matrix4f playerView, Matrix4f playerProjection, Vector3f shadowLightVectorFromOrigin, - BoxCuller boxCuller) { - this.shadowLightVectorFromOrigin = shadowLightVectorFromOrigin; - BaseClippingPlanes baseClippingPlanes = new BaseClippingPlanes(playerView, playerProjection); - - boolean[] isBack = addBackPlanes(baseClippingPlanes); - addEdgePlanes(baseClippingPlanes, isBack); + public AdvancedShadowCullingFrustum() { + for (int i = 0; i < MAX_CLIPPING_PLANES; i++) { + planes[i] = new Vector4f(); + } + } + public void init(Matrix4f playerView, Matrix4f playerProjection, Vector3f shadowLightVector, BoxCuller boxCuller) { + this.shadowLightVectorFromOrigin.set(shadowLightVector); this.boxCuller = boxCuller; + this.planeCount = 0; + + baseClippingPlanes.init(playerView, playerProjection); + + addBackPlanes(baseClippingPlanes, isBackArray); + addEdgePlanes(baseClippingPlanes, isBackArray); } private void addPlane(Vector4f plane) { - planes[planeCount] = plane; + planes[planeCount].set(plane); + planeCount += 1; + } + + private void addPlane(float x, float y, float z, float w) { + planes[planeCount].set(x, y, z, w); planeCount += 1; } @@ -91,24 +112,23 @@ public class AdvancedShadowCullingFrustum extends Frustrum { * This can eliminate many chunks, especially if the player is staring at the shadow light * (sun / moon). */ - private boolean[] addBackPlanes(BaseClippingPlanes baseClippingPlanes) { - Vector4f[] planes = baseClippingPlanes.getPlanes(); - boolean[] isBack = new boolean[planes.length]; + private void addBackPlanes(BaseClippingPlanes baseClippingPlanes, boolean[] isBack) { + final Vector4f[] basePlanes = baseClippingPlanes.getPlanes(); - for (int planeIndex = 0; planeIndex < planes.length; planeIndex++) { - Vector4f plane = planes[planeIndex]; - Vector3f planeNormal = truncate(plane); + for (int planeIndex = 0; planeIndex < basePlanes.length; planeIndex++) { + final Vector4f plane = basePlanes[planeIndex]; + truncate(plane, scratch3a); // Find back planes by looking for planes with a normal vector that points // in the same general direction as the vector pointing from the origin to the shadow light - // + // That is, the angle between those two vectors is less than or equal to 90 degrees, // meaning that the dot product is positive or zero. - float dot = planeNormal.dot(shadowLightVectorFromOrigin); + final float dot = scratch3a.dot(shadowLightVectorFromOrigin); - boolean back = dot > 0.0; - boolean edge = dot == 0.0; + final boolean back = dot > 0.0; + final boolean edge = dot == 0.0; // TODO: audit behavior when the dot product is zero isBack[planeIndex] = back; @@ -117,21 +137,18 @@ public class AdvancedShadowCullingFrustum extends Frustrum { addPlane(plane); } } - - return isBack; } private void addEdgePlanes(BaseClippingPlanes baseClippingPlanes, boolean[] isBack) { - Vector4f[] planes = baseClippingPlanes.getPlanes(); + final Vector4f[] planes = baseClippingPlanes.getPlanes(); for (int planeIndex = 0; planeIndex < planes.length; planeIndex++) { if (!isBack[planeIndex]) { continue; } - Vector4f plane = planes[planeIndex]; - - NeighboringPlaneSet neighbors = NeighboringPlaneSet.forPlane(planeIndex); + final Vector4f plane = planes[planeIndex]; + final NeighboringPlaneSet neighbors = NeighboringPlaneSet.forPlane(planeIndex); if (!isBack[neighbors.getPlane0()]) { addEdgePlane(plane, planes[neighbors.getPlane0()]); @@ -151,40 +168,33 @@ public class AdvancedShadowCullingFrustum extends Frustrum { } } - private Vector3f truncate(Vector4f base) { - return new Vector3f(base.x(), base.y(), base.z()); - } - - private Vector4f extend(Vector3f base, float w) { - return new Vector4f(base.x(), base.y(), base.z(), w); + private Vector3f truncate(Vector4f base, Vector3f dest) { + return dest.set(base.x(), base.y(), base.z()); } private float lengthSquared(Vector3f v) { - float x = v.x(); - float y = v.y(); - float z = v.z(); + final float x = v.x(); + final float y = v.y(); + final float z = v.z(); return x * x + y * y + z * z; } - private Vector3f cross(Vector3f first, Vector3f second) { - Vector3f result = new Vector3f(first.x(), first.y(), first.z()); - result.cross(second); - - return result; + private Vector3f cross(Vector3f first, Vector3f second, Vector3f dest) { + return dest.set(first).cross(second); } private void addEdgePlane(Vector4f backPlane4, Vector4f frontPlane4) { - Vector3f backPlaneNormal = truncate(backPlane4); - Vector3f frontPlaneNormal = truncate(frontPlane4); + final Vector3f backPlaneNormal = truncate(backPlane4, scratch3a); + final Vector3f frontPlaneNormal = truncate(frontPlane4, scratch3b); // vector along the intersection of the two planes - Vector3f intersection = cross(backPlaneNormal, frontPlaneNormal); + final Vector3f intersection = cross(backPlaneNormal, frontPlaneNormal, scratch3c); // compute edge plane normal, we want the normal vector of the edge plane // to always be perpendicular to the shadow light vector (since that's // what makes it an edge plane!) - Vector3f edgePlaneNormal = cross(intersection, shadowLightVectorFromOrigin); + final Vector3f edgePlaneNormal = cross(intersection, shadowLightVectorFromOrigin, scratch3d); // At this point, we have a normal vector for our new edge plane, but we don't // have a value for distance (d). We can solve for it with a little algebra, @@ -204,16 +214,15 @@ public class AdvancedShadowCullingFrustum extends Frustrum { // Fortunately, we can compute that point. If we create a plane passing through the origin // with a normal vector parallel to the intersection line, then the intersection // of all 3 planes will be a point on the line of intersection between the two planes we care about. - Vector3f point; - + final Vector3f point; { // "Line of intersection between two planes" // https://stackoverflow.com/a/32410473 by ideasman42, CC BY-SA 3.0 // (a modified version of "Intersection of 2-planes" from Graphics Gems 1, page 305 // NB: We can assume that the intersection vector has a non-zero length. - Vector3f ixb = cross(intersection, backPlaneNormal); - Vector3f fxi = cross(frontPlaneNormal, intersection); + final Vector3f ixb = cross(intersection, backPlaneNormal, scratch3e); + final Vector3f fxi = cross(frontPlaneNormal, intersection, scratch3f); ixb.mul(-frontPlane4.w()); fxi.mul(-backPlane4.w()); @@ -225,54 +234,23 @@ public class AdvancedShadowCullingFrustum extends Frustrum { } // Now that we have a point and a normal vector, we can make a plane. + // dot(normal, (x, y, z) - point) = 0 + // a(x - point.x) + b(y - point.y) + c(z - point.z) = 0 + // d = a * point.x + b * point.y + c * point.z = dot(normal, point) + // w = -d - Vector4f plane; - - { - // dot(normal, (x, y, z) - point) = 0 - // a(x - point.x) + b(y - point.y) + c(z - point.z) = 0 - // d = a * point.x + b * point.y + c * point.z = dot(normal, point) - // w = -d - - float d = edgePlaneNormal.dot(point); - float w = -d; - - plane = extend(edgePlaneNormal, w); - } - - // Check and make sure our point is actually on all 3 planes. - // This can be removed in production but it's good to check for now while we're still testing. - /*{ - float dp0 = plane.dotProduct(extend(point, 1.0F)); - float dp1 = frontPlane4.dotProduct(extend(point, 1.0F)); - float dp2 = backPlane4.dotProduct(extend(point, 1.0F)); - - if (Math.abs(dp0) > 0.0005) { - throw new IllegalStateException("dp0 should be zero, but was " + dp0); - } - - if (Math.abs(dp1) > 0.0005) { - throw new IllegalStateException("dp1 should be zero, but was " + dp1); - } - - if (Math.abs(dp2) > 0.0005) { - throw new IllegalStateException("dp2 should be zero, but was " + dp2); - } - }*/ - - addPlane(plane); + final float d = edgePlaneNormal.dot(point); + addPlane(edgePlaneNormal.x(), edgePlaneNormal.y(), edgePlaneNormal.z(), -d); } // Note: These functions are copied & modified from the vanilla Frustum class. @Override public void setPosition(double cameraX, double cameraY, double cameraZ) { + super.setPosition(cameraX, cameraY, cameraZ); + if (this.boxCuller != null) { boxCuller.setPosition(cameraX, cameraY, cameraZ); } - - this.x = cameraX; - this.y = cameraY; - this.z = cameraZ; } @Override @@ -284,77 +262,40 @@ public class AdvancedShadowCullingFrustum extends Frustrum { return this.isVisible(aabb.minX, aabb.minY, aabb.minZ, aabb.maxX, aabb.maxY, aabb.maxZ); } - // For Sodium - // TODO: change this to respect intersections on 1.18+! - public boolean fastAabbTest(float minX, float minY, float minZ, float maxX, float maxY, float maxZ) { - if (boxCuller != null && boxCuller.isCulled(minX, minY, minZ, maxX, maxY, maxZ)) { + // Embeddium Frustum interface - receives view-relative coords + @Override + public boolean testAab(float minX, float minY, float minZ, float maxX, float maxY, float maxZ) { + if (boxCuller != null && boxCuller.isCulledViewRelative(minX, minY, minZ, maxX, maxY, maxZ)) { return false; } - return isVisible(minX, minY, minZ, maxX, maxY, maxZ); + return checkCornerVisibility(minX, minY, minZ, maxX, maxY, maxZ); } - // For Immersive Portals - // TODO: Figure out if IP culling can somehow be compatible with Iris culling. - public boolean canDetermineInvisible(double minX, double minY, double minZ, double maxX, double maxY, double maxZ) { - return false; + @Override + public Viewport sodium$createViewport() { + return new Viewport(this, position.set(xPosition, yPosition, zPosition)); } private boolean isVisible(double minX, double minY, double minZ, double maxX, double maxY, double maxZ) { - float f = (float)(minX - this.x); - float g = (float)(minY - this.y); - float h = (float)(minZ - this.z); - float i = (float)(maxX - this.x); - float j = (float)(maxY - this.y); - float k = (float)(maxZ - this.z); - return this.checkCornerVisibility(f, g, h, i, j, k) != 0; + return this.checkCornerVisibility((float)(minX - xPosition), (float)(minY - yPosition), (float)(minZ - zPosition), + (float)(maxX - xPosition), (float)(maxY - yPosition), (float)(maxZ - zPosition)); } - - /** - * Checks corner visibility. - * @param minX Minimum X value of the AABB. - * @param minY Minimum Y value of the AABB. - * @param minZ Minimum Z value of the AABB. - * @param maxX Maximum X value of the AABB. - * @param maxY Maximum Y value of the AABB. - * @param maxZ Maximum Z value of the AABB. - * @return 0 if nothing is visible, 1 if everything is visible, 2 if only some corners are visible. - */ - private int checkCornerVisibility(float minX, float minY, float minZ, float maxX, float maxY, float maxZ) { - float outsideBoundX; - float outsideBoundY; - float outsideBoundZ; - + // view-relative coordinates. + private boolean checkCornerVisibility(float minX, float minY, float minZ, float maxX, float maxY, float maxZ) { for (int i = 0; i < planeCount; ++i) { - Vector4f plane = this.planes[i]; + final Vector4f plane = this.planes[i]; - // Check if plane is inside or intersecting. - // This is ported from JOML's FrustumIntersection. - - if (plane.x() < 0) { - outsideBoundX = minX; - } else { - outsideBoundX = maxX; - } - - if (plane.y() < 0) { - outsideBoundY = minY; - } else { - outsideBoundY = maxY; - } - - if (plane.z() < 0) { - outsideBoundZ = minZ; - } else { - outsideBoundZ = maxZ; - } + final float outsideBoundX = plane.x() < 0 ? minX : maxX; + final float outsideBoundY = plane.y() < 0 ? minY : maxY; + final float outsideBoundZ = plane.z() < 0 ? minZ : maxZ; if (Math.fma(plane.x(), outsideBoundX, Math.fma(plane.y(), outsideBoundY, plane.z() * outsideBoundZ)) < -plane.w()) { - return 0; + return false; } } - return 2; + return true; } } diff --git a/src/main/java/net/coderbot/iris/shadows/frustum/advanced/BaseClippingPlanes.java b/src/main/java/net/coderbot/iris/shadows/frustum/advanced/BaseClippingPlanes.java index c4d155350..b5b3bcf6c 100644 --- a/src/main/java/net/coderbot/iris/shadows/frustum/advanced/BaseClippingPlanes.java +++ b/src/main/java/net/coderbot/iris/shadows/frustum/advanced/BaseClippingPlanes.java @@ -5,34 +5,34 @@ import org.joml.Vector4f; public class BaseClippingPlanes { private final Vector4f[] planes = new Vector4f[6]; + private final Matrix4f transformScratch = new Matrix4f(); - public BaseClippingPlanes(Matrix4f playerView, Matrix4f playerProjection) { - this.init(playerView, playerProjection); + public BaseClippingPlanes() { + for (int i = 0; i < planes.length; i++) { + planes[i] = new Vector4f(); + } } - private void init(Matrix4f view, Matrix4f projection) { + public void init(Matrix4f view, Matrix4f projection) { // Transform = Transpose(Projection x View) + transformScratch.set(projection); + transformScratch.mul(view); + transformScratch.transpose(); - Matrix4f transform = new Matrix4f(projection); - transform.mul(view); - transform.transpose(); - - planes[0] = transform(transform, -1, 0, 0); - planes[1] = transform(transform, 1, 0, 0); - planes[2] = transform(transform, 0, -1, 0); - planes[3] = transform(transform, 0, 1, 0); + transform(transformScratch, -1, 0, 0, planes[0]); + transform(transformScratch, 1, 0, 0, planes[1]); + transform(transformScratch, 0, -1, 0, planes[2]); + transform(transformScratch, 0, 1, 0, planes[3]); // FAR clipping plane - planes[4] = transform(transform, 0, 0, -1); + transform(transformScratch, 0, 0, -1, planes[4]); // NEAR clipping plane - planes[5] = transform(transform, 0, 0, 1); + transform(transformScratch, 0, 0, 1, planes[5]); } - private static Vector4f transform(Matrix4f transform, float x, float y, float z) { - Vector4f vector4f = new Vector4f(x, y, z, 1.0F); - vector4f.mul(transform); - vector4f.normalize(); - - return vector4f; + private static void transform(Matrix4f transform, float x, float y, float z, Vector4f dest) { + dest.set(x, y, z, 1.0F); + dest.mul(transform); + dest.normalize(); } public Vector4f[] getPlanes() { diff --git a/src/main/java/net/coderbot/iris/shadows/frustum/fallback/BoxCullingFrustum.java b/src/main/java/net/coderbot/iris/shadows/frustum/fallback/BoxCullingFrustum.java index 233dfece7..bec8f8e6f 100644 --- a/src/main/java/net/coderbot/iris/shadows/frustum/fallback/BoxCullingFrustum.java +++ b/src/main/java/net/coderbot/iris/shadows/frustum/fallback/BoxCullingFrustum.java @@ -3,9 +3,14 @@ package net.coderbot.iris.shadows.frustum.fallback; import net.coderbot.iris.shadows.frustum.BoxCuller; import net.minecraft.client.renderer.culling.Frustrum; import net.minecraft.util.AxisAlignedBB; +import org.embeddedt.embeddium.impl.render.viewport.Viewport; +import org.embeddedt.embeddium.impl.render.viewport.ViewportProvider; +import org.embeddedt.embeddium.impl.render.viewport.frustum.Frustum; +import org.joml.Vector3d; -public class BoxCullingFrustum extends Frustrum { +public class BoxCullingFrustum extends Frustrum implements ViewportProvider, Frustum { private final BoxCuller boxCuller; + private final Vector3d position = new Vector3d(); public BoxCullingFrustum(BoxCuller boxCuller) { this.boxCuller = boxCuller; @@ -13,25 +18,22 @@ public class BoxCullingFrustum extends Frustrum { @Override public void setPosition(double cameraX, double cameraY, double cameraZ) { + super.setPosition(cameraX, cameraY, cameraZ); boxCuller.setPosition(cameraX, cameraY, cameraZ); } - // for Sodium - // TODO: Better way to do this... Maybe we shouldn't be using a frustum for the box culling in the first place! - public boolean fastAabbTest(float minX, float minY, float minZ, float maxX, float maxY, float maxZ) { - return !boxCuller.isCulled(minX, minY, minZ, maxX, maxY, maxZ); - } - - // For Immersive Portals - // NB: The shadow culling in Immersive Portals must be disabled, because when Advanced Shadow Frustum Culling - // is not active, we are at a point where we can make no assumptions how the shader pack uses the shadow - // pass beyond what it already tells us. So we cannot use any extra fancy culling methods. - public boolean canDetermineInvisible(double minX, double minY, double minZ, double maxX, double maxY, double maxZ) { - return false; - } - @Override public boolean isBoundingBoxInFrustum(AxisAlignedBB aabb) { return !boxCuller.isCulled(aabb); } + + @Override + public boolean testAab(float minX, float minY, float minZ, float maxX, float maxY, float maxZ) { + return !boxCuller.isCulledViewRelative(minX, minY, minZ, maxX, maxY, maxZ); + } + + @Override + public Viewport sodium$createViewport() { + return new Viewport(this, position.set(xPosition, yPosition, zPosition)); + } } diff --git a/src/main/java/net/coderbot/iris/shadows/frustum/fallback/NonCullingFrustum.java b/src/main/java/net/coderbot/iris/shadows/frustum/fallback/NonCullingFrustum.java index 284debfa6..76f078ec8 100644 --- a/src/main/java/net/coderbot/iris/shadows/frustum/fallback/NonCullingFrustum.java +++ b/src/main/java/net/coderbot/iris/shadows/frustum/fallback/NonCullingFrustum.java @@ -2,25 +2,26 @@ package net.coderbot.iris.shadows.frustum.fallback; import net.minecraft.client.renderer.culling.Frustrum; import net.minecraft.util.AxisAlignedBB; +import org.embeddedt.embeddium.impl.render.viewport.Viewport; +import org.embeddedt.embeddium.impl.render.viewport.ViewportProvider; +import org.embeddedt.embeddium.impl.render.viewport.frustum.Frustum; +import org.joml.Vector3d; - -public class NonCullingFrustum extends Frustrum { - - // for Sodium - public boolean fastAabbTest(float minX, float minY, float minZ, float maxX, float maxY, float maxZ) { - return true; - } - - // For Immersive Portals - // NB: The shadow culling in Immersive Portals must be disabled, because when Advanced Shadow Frustum Culling - // is not active, we are at a point where we can make no assumptions how the shader pack uses the shadow - // pass beyond what it already tells us. So we cannot use any extra fancy culling methods. - public boolean canDetermineInvisible(double minX, double minY, double minZ, double maxX, double maxY, double maxZ) { - return false; - } +public class NonCullingFrustum extends Frustrum implements ViewportProvider, Frustum { + private final Vector3d position = new Vector3d(); @Override public boolean isBoundingBoxInFrustum(AxisAlignedBB aabb) { return true; } + + @Override + public boolean testAab(float minX, float minY, float minZ, float maxX, float maxY, float maxZ) { + return true; + } + + @Override + public Viewport sodium$createViewport() { + return new Viewport(this, position.set(xPosition, yPosition, zPosition)); + } } diff --git a/src/main/java/net/coderbot/iris/sodium/IrisChunkShaderBindingPoints.java b/src/main/java/net/coderbot/iris/sodium/IrisChunkShaderBindingPoints.java deleted file mode 100644 index ad470fbfe..000000000 --- a/src/main/java/net/coderbot/iris/sodium/IrisChunkShaderBindingPoints.java +++ /dev/null @@ -1,16 +0,0 @@ -package net.coderbot.iris.sodium; - -import me.jellysquid.mods.sodium.client.gl.shader.ShaderBindingPoint; - -/** - * Defines Iris-specific chunk shader binding points. - * - * NB: Make sure this doesn't collide with anything in {@link me.jellysquid.mods.sodium.client.render.chunk.shader.ChunkShaderBindingPoints} - */ -public class IrisChunkShaderBindingPoints { - public static final ShaderBindingPoint NORMAL = new ShaderBindingPoint(5); - public static final ShaderBindingPoint TANGENT = new ShaderBindingPoint(6); - public static final ShaderBindingPoint MID_TEX_COORD = new ShaderBindingPoint(7); - public static final ShaderBindingPoint BLOCK_ID = new ShaderBindingPoint(8); - public static final ShaderBindingPoint MID_BLOCK = new ShaderBindingPoint(9); -} diff --git a/src/main/java/net/coderbot/iris/sodium/Mixins.txt b/src/main/java/net/coderbot/iris/sodium/Mixins.txt deleted file mode 100644 index 0dc133c82..000000000 --- a/src/main/java/net/coderbot/iris/sodium/Mixins.txt +++ /dev/null @@ -1,39 +0,0 @@ -Y directional_shading - Y MixinSmoothLightPipeline.java - Y MixinFlatLightPipeline.java -* shader_overrides - * ShaderTypeAccessor.java - Y MixinChunkRenderShaderBackend.java - Y MixinShaderType.java - Y MixinChunkProgram.java - Y MixinChunkRenderManager.java -* shadow_map - Y MixinSodiumWorldRenderer.java - Y MixinGameRendererContext.java - Y MixinChunkRenderManager.java -* block_id - Y MixinChunkRenderRebuildTask.java - Y MixinChunkBuildBuffers.java -* pbr_animation - * MixinTextureAtlasSprite.java -* vertex_format - * entity - * MixinBufferBuilder_ExtendedVertexFormatCompat.java // Unclear - Y MixinSodiumWorldRenderer.java - Y MixinChunkOneshotGraphicsState.java - N GlVertexAttributeFormatAccessor.java - Y MixinMultidrawChunkRenderBackend.java - Y MixinChunkMeshAttribute.java - Y MixinGlVertexFormatBuilder.java - N ChunkMeshAttributeAccessor.java -* separate_ao - * MixinBlockRenderer.java - * MixinFluidRenderer.java - * MixinBufferBuilder_IntrinsicSeparateAo.java -* options - X MixinSodiumGameOptionPages.java - X MixinOptionImpl.java - X MixinSodiumGameOptions.java - X MixinSodiumOptionsGUI.java - X MixinChunkRenderManager.java -* IrisSodiumCompatMixinPlugin.java diff --git a/src/main/java/net/coderbot/iris/sodium/block_context/BlockContextHolder.java b/src/main/java/net/coderbot/iris/sodium/block_context/BlockContextHolder.java deleted file mode 100644 index 6f7e601ff..000000000 --- a/src/main/java/net/coderbot/iris/sodium/block_context/BlockContextHolder.java +++ /dev/null @@ -1,47 +0,0 @@ -package net.coderbot.iris.sodium.block_context; - -import it.unimi.dsi.fastutil.objects.Object2IntMap; -import it.unimi.dsi.fastutil.objects.Object2IntMaps; -import net.minecraft.block.Block; - -public class BlockContextHolder { - private final Object2IntMap blockMatches; - - public int localPosX; - public int localPosY; - public int localPosZ; - - public short blockId; - public short renderType; - - public BlockContextHolder() { - this.blockMatches = Object2IntMaps.emptyMap(); - this.blockId = -1; - this.renderType = -1; - } - - public BlockContextHolder(Object2IntMap idMap) { - this.blockMatches = idMap; - this.blockId = -1; - this.renderType = -1; - } - - public void setLocalPos(int localPosX, int localPosY, int localPosZ) { - this.localPosX = localPosX; - this.localPosY = localPosY; - this.localPosZ = localPosZ; - } - - public void set(Block block, short renderType) { - this.blockId = (short) this.blockMatches.getOrDefault(block, -1); - this.renderType = renderType; - } - - public void reset() { - this.blockId = -1; - this.renderType = -1; - this.localPosX = 0; - this.localPosY = 0; - this.localPosZ = 0; - } -} diff --git a/src/main/java/net/coderbot/iris/sodium/block_context/ChunkBuildBuffersExt.java b/src/main/java/net/coderbot/iris/sodium/block_context/ChunkBuildBuffersExt.java deleted file mode 100644 index 407b3cde7..000000000 --- a/src/main/java/net/coderbot/iris/sodium/block_context/ChunkBuildBuffersExt.java +++ /dev/null @@ -1,11 +0,0 @@ -package net.coderbot.iris.sodium.block_context; - -import net.minecraft.block.Block; - -public interface ChunkBuildBuffersExt { - void iris$setLocalPos(int localPosX, int localPosY, int localPosZ); - - void iris$setMaterialId(Block block, short renderType); - - void iris$resetBlockContext(); -} diff --git a/src/main/java/net/coderbot/iris/sodium/block_context/ContextAwareVertexWriter.java b/src/main/java/net/coderbot/iris/sodium/block_context/ContextAwareVertexWriter.java deleted file mode 100644 index b0ba32679..000000000 --- a/src/main/java/net/coderbot/iris/sodium/block_context/ContextAwareVertexWriter.java +++ /dev/null @@ -1,5 +0,0 @@ -package net.coderbot.iris.sodium.block_context; - -public interface ContextAwareVertexWriter { - void iris$setContextHolder(BlockContextHolder holder); -} diff --git a/src/main/java/net/coderbot/iris/sodium/shader_overrides/ChunkRenderBackendExt.java b/src/main/java/net/coderbot/iris/sodium/shader_overrides/ChunkRenderBackendExt.java deleted file mode 100644 index 311632a70..000000000 --- a/src/main/java/net/coderbot/iris/sodium/shader_overrides/ChunkRenderBackendExt.java +++ /dev/null @@ -1,8 +0,0 @@ -package net.coderbot.iris.sodium.shader_overrides; - -import com.gtnewhorizons.angelica.compat.toremove.MatrixStack; -import me.jellysquid.mods.sodium.client.render.chunk.passes.BlockRenderPass; - -public interface ChunkRenderBackendExt { - void iris$begin(MatrixStack matrixStack, BlockRenderPass pass); -} diff --git a/src/main/java/net/coderbot/iris/sodium/shader_overrides/IrisChunkProgram.java b/src/main/java/net/coderbot/iris/sodium/shader_overrides/IrisChunkProgram.java deleted file mode 100644 index 4a935bb52..000000000 --- a/src/main/java/net/coderbot/iris/sodium/shader_overrides/IrisChunkProgram.java +++ /dev/null @@ -1,109 +0,0 @@ -package net.coderbot.iris.sodium.shader_overrides; - -import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryStack.*; - -import com.gtnewhorizon.gtnhlib.bytebuf.MemoryStack; -import com.gtnewhorizons.angelica.compat.toremove.MatrixStack; -import com.gtnewhorizons.angelica.glsm.RenderSystem; -import java.nio.FloatBuffer; -import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; -import me.jellysquid.mods.sodium.client.render.chunk.shader.ChunkProgram; -import me.jellysquid.mods.sodium.client.render.chunk.shader.ChunkShaderFogComponent; -import net.coderbot.iris.gl.program.ProgramImages; -import net.coderbot.iris.gl.program.ProgramSamplers; -import net.coderbot.iris.gl.program.ProgramUniforms; -import net.coderbot.iris.pipeline.SodiumTerrainPipeline; -import net.coderbot.iris.uniforms.custom.CustomUniforms; -import net.minecraft.util.ResourceLocation; -import org.jetbrains.annotations.Nullable; -import org.joml.Matrix4f; - -public class IrisChunkProgram extends ChunkProgram { - // Uniform variable binding indexes - private final int uModelViewMatrix; - private final int uNormalMatrix; - - @Nullable - private final ProgramUniforms irisProgramUniforms; - - @Nullable - private final ProgramSamplers irisProgramSamplers; - - @Nullable - private final ProgramImages irisProgramImages; - - private CustomUniforms customUniforms; - - public IrisChunkProgram(RenderDevice owner, ResourceLocation name, int handle, boolean isShadowPass, SodiumTerrainPipeline pipeline, CustomUniforms customUniforms) { - super(owner, name, handle, ChunkShaderFogComponent.None::new); - this.uModelViewMatrix = this.getUniformLocation("iris_ModelViewMatrix"); - this.uNormalMatrix = this.getUniformLocation("iris_NormalMatrix"); - this.customUniforms = customUniforms; - - ProgramUniforms.Builder builder = pipeline.initUniforms(handle); - customUniforms.mapholderToPass(builder, this); - this.irisProgramUniforms = builder.buildUniforms(); - this.irisProgramSamplers - = isShadowPass? pipeline.initShadowSamplers(handle) : pipeline.initTerrainSamplers(handle); - this.irisProgramImages = isShadowPass ? pipeline.initShadowImages(handle) : pipeline.initTerrainImages(handle); - } - - @Override - public void setup(MatrixStack matrixStack, float modelScale, float textureScale) { - super.setup(matrixStack, modelScale, textureScale); - - if (irisProgramUniforms != null) { - irisProgramUniforms.update(); - } - - if (irisProgramSamplers != null) { - irisProgramSamplers.update(); - } - - if (irisProgramImages != null) { - irisProgramImages.update(); - } - - Matrix4f modelViewMatrix = matrixStack.peek().getModel(); - Matrix4f normalMatrix = new Matrix4f(matrixStack.peek().getModel()); - normalMatrix.invert(); - normalMatrix.transpose(); - - uniformMatrix(uModelViewMatrix, modelViewMatrix); - uniformMatrix(uNormalMatrix, normalMatrix); - - customUniforms.push(this); - } - - @Override - public int getUniformLocation(String name) { - // NB: We pass through calls involving u_ModelViewProjectionMatrix, u_ModelScale, and u_TextureScale, since - // currently patched Iris shader programs use those. - - if ("iris_BlockTex".equals(name) || "iris_LightTex".equals(name)) { - // Not relevant for Iris shader programs - return -1; - } - - try { - return super.getUniformLocation(name); - } catch (NullPointerException e) { - // Suppress getUniformLocation - return -1; - } - } - - private void uniformMatrix(int location, Matrix4f matrix) { - if (location == -1) { - return; - } - - try (MemoryStack stack = stackPush()) { - FloatBuffer buffer = stack.mallocFloat(16); - - matrix.get(buffer); - - RenderSystem.uniformMatrix4fv(location, false, buffer); - } - } -} diff --git a/src/main/java/net/coderbot/iris/sodium/shader_overrides/IrisChunkProgramOverrides.java b/src/main/java/net/coderbot/iris/sodium/shader_overrides/IrisChunkProgramOverrides.java deleted file mode 100644 index d099c56da..000000000 --- a/src/main/java/net/coderbot/iris/sodium/shader_overrides/IrisChunkProgramOverrides.java +++ /dev/null @@ -1,205 +0,0 @@ -package net.coderbot.iris.sodium.shader_overrides; - -import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; -import me.jellysquid.mods.sodium.client.gl.shader.GlProgram; -import me.jellysquid.mods.sodium.client.gl.shader.GlShader; -import me.jellysquid.mods.sodium.client.gl.shader.ShaderConstants; -import me.jellysquid.mods.sodium.client.gl.shader.ShaderType; -import me.jellysquid.mods.sodium.client.render.chunk.passes.BlockRenderPass; -import me.jellysquid.mods.sodium.client.render.chunk.shader.ChunkProgram; -import me.jellysquid.mods.sodium.client.render.chunk.shader.ChunkShaderBindingPoints; -import net.coderbot.iris.Iris; -import net.coderbot.iris.gl.program.ProgramImages; -import net.coderbot.iris.gl.program.ProgramSamplers; -import net.coderbot.iris.gl.program.ProgramUniforms; -import net.coderbot.iris.pipeline.SodiumTerrainPipeline; -import net.coderbot.iris.pipeline.WorldRenderingPipeline; -import net.coderbot.iris.shadows.ShadowRenderingState; -import net.coderbot.iris.sodium.IrisChunkShaderBindingPoints; -import net.minecraft.util.ResourceLocation; -import org.jetbrains.annotations.Nullable; - -import java.util.EnumMap; -import java.util.Locale; -import java.util.Optional; - -public class IrisChunkProgramOverrides { - private static final ShaderConstants EMPTY_CONSTANTS = ShaderConstants.builder().build(); - - private final EnumMap programs = new EnumMap<>(IrisTerrainPass.class); - - private int versionCounterForSodiumShaderReload = -1; - - private GlShader createVertexShader(RenderDevice device, IrisTerrainPass pass, SodiumTerrainPipeline pipeline) { - Optional irisVertexShader; - - if (pass == IrisTerrainPass.SHADOW) { - irisVertexShader = pipeline.getShadowVertexShaderSource(); - } else if (pass == IrisTerrainPass.GBUFFER_SOLID) { - irisVertexShader = pipeline.getTerrainVertexShaderSource(); - } else if (pass == IrisTerrainPass.GBUFFER_TRANSLUCENT) { - irisVertexShader = pipeline.getTranslucentVertexShaderSource(); - } else { - throw new IllegalArgumentException("Unknown pass type " + pass); - } - - String source = irisVertexShader.orElse(null); - - if (source == null) { - return null; - } - - return new GlShader(device, ShaderType.VERTEX, new ResourceLocation("iris", - "sodium-terrain-" + pass.toString().toLowerCase(Locale.ROOT) + ".vsh"), source, EMPTY_CONSTANTS); - } - - private GlShader createGeometryShader(RenderDevice device, IrisTerrainPass pass, SodiumTerrainPipeline pipeline) { - Optional irisGeometryShader; - - if (pass == IrisTerrainPass.SHADOW) { - irisGeometryShader = pipeline.getShadowGeometryShaderSource(); - } else if (pass == IrisTerrainPass.GBUFFER_SOLID) { - irisGeometryShader = pipeline.getTerrainGeometryShaderSource(); - } else if (pass == IrisTerrainPass.GBUFFER_TRANSLUCENT) { - irisGeometryShader = pipeline.getTranslucentGeometryShaderSource(); - } else { - throw new IllegalArgumentException("Unknown pass type " + pass); - } - - String source = irisGeometryShader.orElse(null); - - if (source == null) { - return null; - } - - return new GlShader(device, IrisShaderTypes.GEOMETRY, new ResourceLocation("iris", - "sodium-terrain-" + pass.toString().toLowerCase(Locale.ROOT) + ".gsh"), source, EMPTY_CONSTANTS); - } - - private GlShader createFragmentShader(RenderDevice device, IrisTerrainPass pass, SodiumTerrainPipeline pipeline) { - Optional irisFragmentShader; - - if (pass == IrisTerrainPass.SHADOW) { - irisFragmentShader = pipeline.getShadowFragmentShaderSource(); - } else if (pass == IrisTerrainPass.GBUFFER_SOLID) { - irisFragmentShader = pipeline.getTerrainFragmentShaderSource(); - } else if (pass == IrisTerrainPass.GBUFFER_TRANSLUCENT) { - irisFragmentShader = pipeline.getTranslucentFragmentShaderSource(); - } else { - throw new IllegalArgumentException("Unknown pass type " + pass); - } - - String source = irisFragmentShader.orElse(null); - - if (source == null) { - return null; - } - - return new GlShader(device, ShaderType.FRAGMENT, new ResourceLocation("iris", - "sodium-terrain-" + pass.toString().toLowerCase(Locale.ROOT) + ".fsh"), source, EMPTY_CONSTANTS); - } - - @Nullable - private ChunkProgram createShader(RenderDevice device, IrisTerrainPass pass, SodiumTerrainPipeline pipeline) { - GlShader vertShader = createVertexShader(device, pass, pipeline); - GlShader geomShader = createGeometryShader(device, pass, pipeline); - GlShader fragShader = createFragmentShader(device, pass, pipeline); - - if (vertShader == null || fragShader == null) { - if (vertShader != null) { - vertShader.delete(); - } - - if (geomShader != null) { - geomShader.delete(); - } - - if (fragShader != null) { - fragShader.delete(); - } - - // TODO: Partial shader programs? - return null; - } - - try { - GlProgram.Builder builder = GlProgram.builder(new ResourceLocation("sodium", "chunk_shader_for_" - + pass.getName())); - - if (geomShader != null) { - builder.attachShader(geomShader); - } - - return builder.attachShader(vertShader) - .attachShader(fragShader) - .bindAttribute("iris_Pos", ChunkShaderBindingPoints.POSITION) - .bindAttribute("iris_Color", ChunkShaderBindingPoints.COLOR) - .bindAttribute("iris_TexCoord", ChunkShaderBindingPoints.TEX_COORD) - .bindAttribute("iris_LightCoord", ChunkShaderBindingPoints.LIGHT_COORD) - .bindAttribute("iris_Normal", IrisChunkShaderBindingPoints.NORMAL) - .bindAttribute("at_tangent", IrisChunkShaderBindingPoints.TANGENT) - .bindAttribute("mc_midTexCoord", IrisChunkShaderBindingPoints.MID_TEX_COORD) - .bindAttribute("mc_Entity", IrisChunkShaderBindingPoints.BLOCK_ID) - .bindAttribute("at_midBlock", IrisChunkShaderBindingPoints.MID_BLOCK) - .bindAttribute("iris_ModelOffset", ChunkShaderBindingPoints.MODEL_OFFSET) - .build((program, name) -> new IrisChunkProgram(device, program, name, pass == IrisTerrainPass.SHADOW, pipeline, pipeline.getCustomUniforms())); - } finally { - vertShader.delete(); - if (geomShader != null) { - geomShader.delete(); - } - fragShader.delete(); - } - } - - public void createShaders(SodiumTerrainPipeline sodiumTerrainPipeline, RenderDevice device) { - if (sodiumTerrainPipeline != null) { - for (IrisTerrainPass pass : IrisTerrainPass.values()) { - if (pass == IrisTerrainPass.SHADOW && !sodiumTerrainPipeline.hasShadowPass()) { - this.programs.put(pass, null); - continue; - } - - this.programs.put(pass, createShader(device, pass, sodiumTerrainPipeline)); - } - } else { - this.programs.clear(); - } - } - - @Nullable - public ChunkProgram getProgramOverride(RenderDevice device, BlockRenderPass pass) { - WorldRenderingPipeline worldRenderingPipeline = Iris.getPipelineManager().getPipelineNullable(); - SodiumTerrainPipeline sodiumTerrainPipeline = null; - - if (worldRenderingPipeline != null) { - sodiumTerrainPipeline = worldRenderingPipeline.getSodiumTerrainPipeline(); - } - - if (versionCounterForSodiumShaderReload != Iris.getPipelineManager().getVersionCounterForSodiumShaderReload()) { - versionCounterForSodiumShaderReload = Iris.getPipelineManager().getVersionCounterForSodiumShaderReload(); - deleteShaders(); - createShaders(sodiumTerrainPipeline, device); - } - - if (ShadowRenderingState.areShadowsCurrentlyBeingRendered()) { - if (sodiumTerrainPipeline != null && !sodiumTerrainPipeline.hasShadowPass()) { - throw new IllegalStateException("Shadow program requested, but the pack does not have a shadow pass?"); - } - - return this.programs.get(IrisTerrainPass.SHADOW); - } else { - return this.programs.get(pass.isTranslucent() ? IrisTerrainPass.GBUFFER_TRANSLUCENT : IrisTerrainPass.GBUFFER_SOLID); - } - } - - public void deleteShaders() { - for (ChunkProgram program : this.programs.values()) { - if (program != null) { - program.delete(); - } - } - - this.programs.clear(); - } -} diff --git a/src/main/java/net/coderbot/iris/sodium/shader_overrides/IrisShaderTypes.java b/src/main/java/net/coderbot/iris/sodium/shader_overrides/IrisShaderTypes.java deleted file mode 100644 index 6e7cefd4f..000000000 --- a/src/main/java/net/coderbot/iris/sodium/shader_overrides/IrisShaderTypes.java +++ /dev/null @@ -1,7 +0,0 @@ -package net.coderbot.iris.sodium.shader_overrides; - -import me.jellysquid.mods.sodium.client.gl.shader.ShaderType; - -public class IrisShaderTypes { - public static ShaderType GEOMETRY = ShaderType.GEOMETRY; -} diff --git a/src/main/java/net/coderbot/iris/sodium/shader_overrides/IrisTerrainPass.java b/src/main/java/net/coderbot/iris/sodium/shader_overrides/IrisTerrainPass.java deleted file mode 100644 index 1c0d6a2a8..000000000 --- a/src/main/java/net/coderbot/iris/sodium/shader_overrides/IrisTerrainPass.java +++ /dev/null @@ -1,17 +0,0 @@ -package net.coderbot.iris.sodium.shader_overrides; - -public enum IrisTerrainPass { - SHADOW("shadow"), - GBUFFER_SOLID("gbuffers_terrain"), - GBUFFER_TRANSLUCENT("gbuffers_water"); - - private final String name; - - IrisTerrainPass(String name) { - this.name = name; - } - - public String getName() { - return name; - } -} diff --git a/src/main/java/net/coderbot/iris/sodium/shadow_map/SwappableChunkRenderManager.java b/src/main/java/net/coderbot/iris/sodium/shadow_map/SwappableChunkRenderManager.java deleted file mode 100644 index 1692cf79c..000000000 --- a/src/main/java/net/coderbot/iris/sodium/shadow_map/SwappableChunkRenderManager.java +++ /dev/null @@ -1,5 +0,0 @@ -package net.coderbot.iris.sodium.shadow_map; - -public interface SwappableChunkRenderManager { - void iris$swapVisibilityState(); -} diff --git a/src/main/java/net/coderbot/iris/sodium/vertex_format/IrisGlVertexAttributeFormat.java b/src/main/java/net/coderbot/iris/sodium/vertex_format/IrisGlVertexAttributeFormat.java deleted file mode 100644 index b2736642c..000000000 --- a/src/main/java/net/coderbot/iris/sodium/vertex_format/IrisGlVertexAttributeFormat.java +++ /dev/null @@ -1,9 +0,0 @@ -package net.coderbot.iris.sodium.vertex_format; - -import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexAttributeFormat; -import org.lwjgl.opengl.GL11; - -public class IrisGlVertexAttributeFormat { - public static final GlVertexAttributeFormat BYTE = new GlVertexAttributeFormat(GL11.GL_BYTE, 1); - public static final GlVertexAttributeFormat SHORT = new GlVertexAttributeFormat(GL11.GL_SHORT, 2); -} diff --git a/src/main/java/net/coderbot/iris/sodium/vertex_format/IrisModelVertexFormats.java b/src/main/java/net/coderbot/iris/sodium/vertex_format/IrisModelVertexFormats.java deleted file mode 100644 index b8c963997..000000000 --- a/src/main/java/net/coderbot/iris/sodium/vertex_format/IrisModelVertexFormats.java +++ /dev/null @@ -1,7 +0,0 @@ -package net.coderbot.iris.sodium.vertex_format; - -import net.coderbot.iris.sodium.vertex_format.terrain_xhfp.XHFPModelVertexType; - -public class IrisModelVertexFormats { - public static final XHFPModelVertexType MODEL_VERTEX_XHFP = new XHFPModelVertexType(); -} diff --git a/src/main/java/net/coderbot/iris/sodium/vertex_format/entity_xhfp/QuadViewEntity.java b/src/main/java/net/coderbot/iris/sodium/vertex_format/entity_xhfp/QuadViewEntity.java deleted file mode 100644 index 2ee3f6670..000000000 --- a/src/main/java/net/coderbot/iris/sodium/vertex_format/entity_xhfp/QuadViewEntity.java +++ /dev/null @@ -1,66 +0,0 @@ -package net.coderbot.iris.sodium.vertex_format.entity_xhfp; - -import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*; - -import net.coderbot.iris.vertices.IrisQuadView; - -import java.nio.ByteBuffer; - -public abstract class QuadViewEntity implements IrisQuadView { - long writePointer; - int stride; - - @Override - public float x(int index) { - return getFloat(writePointer - stride * (3L - index)); - } - - @Override - public float y(int index) { - return getFloat(writePointer + 4 - stride * (3L - index)); - } - - @Override - public float z(int index) { - return getFloat(writePointer + 8 - stride * (3L - index)); - } - - @Override - public float u(int index) { - return getFloat(writePointer + 16 - stride * (3L - index)); - } - - @Override - public float v(int index) { - return getFloat(writePointer + 20 - stride * (3L - index)); - } - - abstract float getFloat(long writePointer); - - public static class QuadViewEntityUnsafe extends QuadViewEntity { - public void setup(long writePointer, int stride) { - this.writePointer = writePointer; - this.stride = stride; - } - - @Override - float getFloat(long writePointer) { - return memGetFloat(writePointer); - } - } - - public static class QuadViewEntityNio extends QuadViewEntity { - private ByteBuffer buffer; - - public void setup(ByteBuffer buffer, int writePointer, int stride) { - this.buffer = buffer; - this.writePointer = writePointer; - this.stride = stride; - } - - @Override - float getFloat(long writePointer) { - return buffer.getFloat((int) writePointer); - } - } -} diff --git a/src/main/java/net/coderbot/iris/sodium/vertex_format/terrain_xhfp/QuadViewTerrain.java b/src/main/java/net/coderbot/iris/sodium/vertex_format/terrain_xhfp/QuadViewTerrain.java deleted file mode 100644 index c6c485c18..000000000 --- a/src/main/java/net/coderbot/iris/sodium/vertex_format/terrain_xhfp/QuadViewTerrain.java +++ /dev/null @@ -1,74 +0,0 @@ -package net.coderbot.iris.sodium.vertex_format.terrain_xhfp; - -import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*; - -import net.coderbot.iris.vertices.IrisQuadView; - -import java.nio.ByteBuffer; - -public abstract class QuadViewTerrain implements IrisQuadView { - long writePointer; - int stride; - - @Override - public float x(int index) { - return normalizeVertexPositionShortAsFloat(getShort(writePointer - stride * (3L - index))); - } - - @Override - public float y(int index) { - return normalizeVertexPositionShortAsFloat(getShort(writePointer + 2 - stride * (3L - index))); - } - - @Override - public float z(int index) { - return normalizeVertexPositionShortAsFloat(getShort(writePointer + 4 - stride * (3L - index))); - } - - @Override - public float u(int index) { - return normalizeVertexTextureShortAsFloat(getShort(writePointer + 12 - stride * (3L - index))); - } - - @Override - public float v(int index) { - return normalizeVertexTextureShortAsFloat(getShort(writePointer + 14 - stride * (3L - index))); - } - - private static float normalizeVertexTextureShortAsFloat(short value) { - return (value & 0xFFFF) * (1.0f / 32768.0f); - } - - private static float normalizeVertexPositionShortAsFloat(short value) { - return (value & 0xFFFF) * (1.0f / 65535.0f); - } - - abstract short getShort(long writePointer); - - public static class QuadViewTerrainUnsafe extends QuadViewTerrain { - public void setup(long writePointer, int stride) { - this.writePointer = writePointer; - this.stride = stride; - } - - @Override - short getShort(long writePointer) { - return memGetShort(writePointer); - } - } - - public static class QuadViewTerrainNio extends QuadViewTerrain { - private ByteBuffer buffer; - - public void setup(ByteBuffer buffer, int writePointer, int stride) { - this.buffer = buffer; - this.writePointer = writePointer; - this.stride = stride; - } - - @Override - short getShort(long writePointer) { - return buffer.getShort((int) writePointer); - } - } -} diff --git a/src/main/java/net/coderbot/iris/sodium/vertex_format/terrain_xhfp/XHFPModelVertexBufferWriterNio.java b/src/main/java/net/coderbot/iris/sodium/vertex_format/terrain_xhfp/XHFPModelVertexBufferWriterNio.java deleted file mode 100644 index 17ecdef72..000000000 --- a/src/main/java/net/coderbot/iris/sodium/vertex_format/terrain_xhfp/XHFPModelVertexBufferWriterNio.java +++ /dev/null @@ -1,149 +0,0 @@ -package net.coderbot.iris.sodium.vertex_format.terrain_xhfp; - -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferWriterNio; -import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexSink; -import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexUtil; -import net.coderbot.iris.sodium.block_context.BlockContextHolder; -import net.coderbot.iris.sodium.block_context.ContextAwareVertexWriter; -import net.coderbot.iris.sodium.vertex_format.IrisModelVertexFormats; -import net.coderbot.iris.vertices.ExtendedDataHelper; -import net.coderbot.iris.vertices.NormalHelper; -import org.joml.Vector3f; - -import java.nio.ByteBuffer; - -import static net.coderbot.iris.sodium.vertex_format.terrain_xhfp.XHFPModelVertexType.STRIDE; - -public class XHFPModelVertexBufferWriterNio extends VertexBufferWriterNio implements ModelVertexSink, ContextAwareVertexWriter { - private final QuadViewTerrain.QuadViewTerrainNio quad = new QuadViewTerrain.QuadViewTerrainNio(); - private final Vector3f normal = new Vector3f(); - - private BlockContextHolder contextHolder; - - private int vertexCount; - private float uSum; - private float vSum; - - public XHFPModelVertexBufferWriterNio(VertexBufferView backingBuffer) { - super(backingBuffer, IrisModelVertexFormats.MODEL_VERTEX_XHFP); - } - - @Override - public void writeQuad(float x, float y, float z, int color, float u, float v, int light, int shaderBlockId) { - uSum += u; - vSum += v; - - this.writeQuadInternal( - ModelVertexUtil.denormalizeVertexPositionFloatAsShort(x), - ModelVertexUtil.denormalizeVertexPositionFloatAsShort(y), - ModelVertexUtil.denormalizeVertexPositionFloatAsShort(z), - color, - ModelVertexUtil.denormalizeVertexTextureFloatAsShort(u), - ModelVertexUtil.denormalizeVertexTextureFloatAsShort(v), - light, - shaderBlockId != -1 ? (short)shaderBlockId : contextHolder.blockId, - contextHolder.renderType, - ExtendedDataHelper.computeMidBlock(x, y, z, contextHolder.localPosX, contextHolder.localPosY, contextHolder.localPosZ) - ); - } - - private void writeQuadInternal(short x, short y, short z, int color, short u, short v, int light, short materialId, - short renderType, int packedMidBlock) { - int i = this.writeOffset; - - vertexCount++; - // NB: uSum and vSum must already be incremented outside of this function. - - ByteBuffer buffer = this.byteBuffer; - buffer.putShort(i, x); - buffer.putShort(i + 2, y); - buffer.putShort(i + 4, z); - buffer.putInt(i + 8, color); - buffer.putShort(i + 12, u); - buffer.putShort(i + 14, v); - buffer.putShort(i + 16, (short) (light & 0xFFFF)); - buffer.putShort(i + 18, (short) (light >> 16 & 0xFFFF)); - // NB: We don't set midTexCoord, normal, and tangent here, they will be filled in later. - // block ID: We only set the first 2 values, any legacy shaders using z or w will get filled in based on the GLSL spec - // https://www.khronos.org/opengl/wiki/Vertex_Specification#Vertex_format - // TODO: can we pack this into one short? - buffer.putShort(i + 36, materialId); - buffer.putShort(i + 38, renderType); - buffer.putInt(i + 40, packedMidBlock); - - if (vertexCount == 4) { - vertexCount = 0; - - // FIXME - // The following logic is incorrect because OpenGL denormalizes shorts by dividing by 65535. The atlas is - // based on power-of-two values and so a normalization factor that is not a power of two causes the values - // used in the shader to be off by enough to cause visual errors. These are most noticeable on 1.18 with POM - // on block edges. - // - // The only reliable way that this can be fixed is to apply the same shader transformations to midTexCoord - // as Sodium does to the regular texture coordinates - dividing them by the correct power-of-two value inside - // of the shader instead of letting OpenGL value normalization do the division. However, this requires - // fragile patching that is not yet possible. - // - // As a temporary solution, the normalized shorts have been replaced with regular floats, but this takes up - // an extra 4 bytes per vertex. - - // NB: Be careful with the math here! A previous bug was caused by midU going negative as a short, which - // was sign-extended into midTexCoord, causing midV to have garbage (likely NaN data). If you're touching - // this code, be aware of that, and don't introduce those kinds of bugs! - // - // Also note that OpenGL takes shorts in the range of [0, 65535] and transforms them linearly to [0.0, 1.0], - // so multiply by 65535, not 65536. - // - // TODO: Does this introduce precision issues? Do we need to fall back to floats here? This might break - // with high resolution texture packs. -// int midU = (int)(65535.0F * Math.min(uSum * 0.25f, 1.0f)) & 0xFFFF; -// int midV = (int)(65535.0F * Math.min(vSum * 0.25f, 1.0f)) & 0xFFFF; -// int midTexCoord = (midV << 16) | midU; - - uSum *= 0.25f; - vSum *= 0.25f; - - buffer.putFloat(i + 20, uSum); - buffer.putFloat(i + 20 - STRIDE, uSum); - buffer.putFloat(i + 20 - STRIDE * 2, uSum); - buffer.putFloat(i + 20 - STRIDE * 3, uSum); - - buffer.putFloat(i + 24, vSum); - buffer.putFloat(i + 24 - STRIDE, vSum); - buffer.putFloat(i + 24 - STRIDE * 2, vSum); - buffer.putFloat(i + 24 - STRIDE * 3, vSum); - - uSum = 0; - vSum = 0; - - // normal computation - // Implementation based on the algorithm found here: - // https://github.com/IrisShaders/ShaderDoc/blob/master/vertex-format-extensions.md#surface-normal-vector - - quad.setup(buffer, i, STRIDE); - NormalHelper.computeFaceNormal(normal, quad); - int packedNormal = NormalHelper.packNormal(normal, 0.0f); - - buffer.putInt(i + 32, packedNormal); - buffer.putInt(i + 32 - STRIDE, packedNormal); - buffer.putInt(i + 32 - STRIDE * 2, packedNormal); - buffer.putInt(i + 32 - STRIDE * 3, packedNormal); - - int tangent = NormalHelper.computeTangent(normal.x, normal.y, normal.z, quad); - - buffer.putInt(i + 28, tangent); - buffer.putInt(i + 28 - STRIDE, tangent); - buffer.putInt(i + 28 - STRIDE * 2, tangent); - buffer.putInt(i + 28 - STRIDE * 3, tangent); - } - - this.advance(); - } - - @Override - public void iris$setContextHolder(BlockContextHolder holder) { - this.contextHolder = holder; - } -} diff --git a/src/main/java/net/coderbot/iris/sodium/vertex_format/terrain_xhfp/XHFPModelVertexBufferWriterUnsafe.java b/src/main/java/net/coderbot/iris/sodium/vertex_format/terrain_xhfp/XHFPModelVertexBufferWriterUnsafe.java deleted file mode 100644 index 0c1f210e5..000000000 --- a/src/main/java/net/coderbot/iris/sodium/vertex_format/terrain_xhfp/XHFPModelVertexBufferWriterUnsafe.java +++ /dev/null @@ -1,148 +0,0 @@ -package net.coderbot.iris.sodium.vertex_format.terrain_xhfp; - -import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*; - -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferWriterUnsafe; -import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexSink; -import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexUtil; -import net.coderbot.iris.sodium.block_context.BlockContextHolder; -import net.coderbot.iris.sodium.block_context.ContextAwareVertexWriter; -import net.coderbot.iris.sodium.vertex_format.IrisModelVertexFormats; -import net.coderbot.iris.vertices.ExtendedDataHelper; -import net.coderbot.iris.vertices.NormalHelper; -import org.joml.Vector3f; - -import static net.coderbot.iris.sodium.vertex_format.terrain_xhfp.XHFPModelVertexType.STRIDE; - -public class XHFPModelVertexBufferWriterUnsafe extends VertexBufferWriterUnsafe implements ModelVertexSink, ContextAwareVertexWriter { - private final QuadViewTerrain.QuadViewTerrainUnsafe quad = new QuadViewTerrain.QuadViewTerrainUnsafe(); - private final Vector3f normal = new Vector3f(); - - private BlockContextHolder contextHolder; - - private int vertexCount; - private float uSum; - private float vSum; - - public XHFPModelVertexBufferWriterUnsafe(VertexBufferView backingBuffer) { - super(backingBuffer, IrisModelVertexFormats.MODEL_VERTEX_XHFP); - } - - @Override - public void writeQuad(float x, float y, float z, int color, float u, float v, int light, int shaderBlockId) { - uSum += u; - vSum += v; - - this.writeQuadInternal( - ModelVertexUtil.denormalizeVertexPositionFloatAsShort(x), - ModelVertexUtil.denormalizeVertexPositionFloatAsShort(y), - ModelVertexUtil.denormalizeVertexPositionFloatAsShort(z), - color, - ModelVertexUtil.denormalizeVertexTextureFloatAsShort(u), - ModelVertexUtil.denormalizeVertexTextureFloatAsShort(v), - light, - shaderBlockId != -1 ? (short)shaderBlockId : contextHolder.blockId, - contextHolder.renderType, - ExtendedDataHelper.computeMidBlock(x, y, z, contextHolder.localPosX, contextHolder.localPosY, contextHolder.localPosZ) - ); - } - - private void writeQuadInternal(short x, short y, short z, int color, short u, short v, int light, short materialId, - short renderType, int packedMidBlock) { - long i = this.writePointer; - - vertexCount++; - // NB: uSum and vSum must already be incremented outside of this function. - - memPutShort(i, x); - memPutShort(i + 2, y); - memPutShort(i + 4, z); - memPutInt(i + 8, color); - memPutShort(i + 12, u); - memPutShort(i + 14, v); - memPutShort(i + 16, (short) (light & 0xFFFF)); - memPutShort(i + 18, (short) (light >> 16 & 0xFFFF)); - // NB: We don't set midTexCoord, normal, and tangent here, they will be filled in later. - // block ID: We only set the first 2 values, any legacy shaders using z or w will get filled in based on the GLSL spec - // https://www.khronos.org/opengl/wiki/Vertex_Specification#Vertex_format - // TODO: can we pack this into one short? - memPutShort(i + 36, materialId); - memPutShort(i + 38, renderType); - memPutInt(i + 40, packedMidBlock); - - if (vertexCount == 4) { - vertexCount = 0; - - // FIXME - // The following logic is incorrect because OpenGL denormalizes shorts by dividing by 65535. The atlas is - // based on power-of-two values and so a normalization factor that is not a power of two causes the values - // used in the shader to be off by enough to cause visual errors. These are most noticeable on 1.18 with POM - // on block edges. - // - // The only reliable way that this can be fixed is to apply the same shader transformations to midTexCoord - // as Sodium does to the regular texture coordinates - dividing them by the correct power-of-two value inside - // of the shader instead of letting OpenGL value normalization do the division. However, this requires - // fragile patching that is not yet possible. - // - // As a temporary solution, the normalized shorts have been replaced with regular floats, but this takes up - // an extra 4 bytes per vertex. - - // NB: Be careful with the math here! A previous bug was caused by midU going negative as a short, which - // was sign-extended into midTexCoord, causing midV to have garbage (likely NaN data). If you're touching - // this code, be aware of that, and don't introduce those kinds of bugs! - // - // Also note that OpenGL takes shorts in the range of [0, 65535] and transforms them linearly to [0.0, 1.0], - // so multiply by 65535, not 65536. - // - // TODO: Does this introduce precision issues? Do we need to fall back to floats here? This might break - // with high resolution texture packs. -// int midU = (int)(65535.0F * Math.min(uSum * 0.25f, 1.0f)) & 0xFFFF; -// int midV = (int)(65535.0F * Math.min(vSum * 0.25f, 1.0f)) & 0xFFFF; -// int midTexCoord = (midV << 16) | midU; - - uSum *= 0.25f; - vSum *= 0.25f; - - memPutFloat(i + 20, uSum); - memPutFloat(i + 20 - STRIDE, uSum); - memPutFloat(i + 20 - STRIDE * 2, uSum); - memPutFloat(i + 20 - STRIDE * 3, uSum); - - memPutFloat(i + 24, vSum); - memPutFloat(i + 24 - STRIDE, vSum); - memPutFloat(i + 24 - STRIDE * 2, vSum); - memPutFloat(i + 24 - STRIDE * 3, vSum); - - uSum = 0; - vSum = 0; - - // normal computation - // Implementation based on the algorithm found here: - // https://github.com/IrisShaders/ShaderDoc/blob/master/vertex-format-extensions.md#surface-normal-vector - - quad.setup(i, STRIDE); - NormalHelper.computeFaceNormal(normal, quad); - int packedNormal = NormalHelper.packNormal(normal, 0.0f); - - memPutInt(i + 32, packedNormal); - memPutInt(i + 32 - STRIDE, packedNormal); - memPutInt(i + 32 - STRIDE * 2, packedNormal); - memPutInt(i + 32 - STRIDE * 3, packedNormal); - - int tangent = NormalHelper.computeTangent(normal.x, normal.y, normal.z, quad); - - memPutInt(i + 28, tangent); - memPutInt(i + 28 - STRIDE, tangent); - memPutInt(i + 28 - STRIDE * 2, tangent); - memPutInt(i + 28 - STRIDE * 3, tangent); - } - - this.advance(); - } - - @Override - public void iris$setContextHolder(BlockContextHolder holder) { - this.contextHolder = holder; - } -} diff --git a/src/main/java/net/coderbot/iris/sodium/vertex_format/terrain_xhfp/XHFPModelVertexType.java b/src/main/java/net/coderbot/iris/sodium/vertex_format/terrain_xhfp/XHFPModelVertexType.java deleted file mode 100644 index 70e8fd6f3..000000000 --- a/src/main/java/net/coderbot/iris/sodium/vertex_format/terrain_xhfp/XHFPModelVertexType.java +++ /dev/null @@ -1,62 +0,0 @@ -package net.coderbot.iris.sodium.vertex_format.terrain_xhfp; - -import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer; -import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexAttributeFormat; -import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexFormat; -import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView; -import me.jellysquid.mods.sodium.client.model.vertex.type.BlittableVertexType; -import me.jellysquid.mods.sodium.client.model.vertex.type.ChunkVertexType; -import me.jellysquid.mods.sodium.client.render.chunk.format.ChunkMeshAttribute; -import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexSink; -import net.coderbot.iris.sodium.vertex_format.IrisGlVertexAttributeFormat; - -/** - * Like HFPModelVertexType, but extended to support Iris. The extensions aren't particularly efficient right now. - */ -public class XHFPModelVertexType implements ChunkVertexType { - public static final int STRIDE = 44; - public static final GlVertexFormat VERTEX_FORMAT = GlVertexFormat.builder(ChunkMeshAttribute.class, STRIDE) - .addElement(ChunkMeshAttribute.POSITION, 0, GlVertexAttributeFormat.UNSIGNED_SHORT, 3, false) - .addElement(ChunkMeshAttribute.COLOR, 8, GlVertexAttributeFormat.UNSIGNED_BYTE, 4, true) - .addElement(ChunkMeshAttribute.TEXTURE, 12, GlVertexAttributeFormat.UNSIGNED_SHORT, 2, false) - .addElement(ChunkMeshAttribute.LIGHT, 16, GlVertexAttributeFormat.UNSIGNED_SHORT, 2, false) - .addElement(ChunkMeshAttribute.MID_TEX_COORD, 20, GlVertexAttributeFormat.FLOAT, 2, false) - .addElement(ChunkMeshAttribute.TANGENT, 28, IrisGlVertexAttributeFormat.BYTE, 4, true) - .addElement(ChunkMeshAttribute.NORMAL, 32, IrisGlVertexAttributeFormat.BYTE, 3, true) - .addElement(ChunkMeshAttribute.BLOCK_ID, 36, IrisGlVertexAttributeFormat.SHORT, 2, false) - .addElement(ChunkMeshAttribute.MID_BLOCK, 40, IrisGlVertexAttributeFormat.BYTE, 3, false) - .build(); - - public static final float MODEL_SCALE = (32.0f / 65536.0f); - public static final float TEXTURE_SCALE = (1.0f / 32768.0f); - - @Override - public ModelVertexSink createFallbackWriter(VertexConsumer consumer) { - throw new UnsupportedOperationException(); - } - - @Override - public ModelVertexSink createBufferWriter(VertexBufferView buffer, boolean direct) { - return direct ? new XHFPModelVertexBufferWriterUnsafe(buffer) : new XHFPModelVertexBufferWriterNio(buffer); - } - - @Override - public BlittableVertexType asBlittable() { - return this; - } - - @Override - public GlVertexFormat getCustomVertexFormat() { - return VERTEX_FORMAT; - } - - @Override - public float getModelScale() { - return MODEL_SCALE; - } - - @Override - public float getTextureScale() { - return TEXTURE_SCALE; - } -} diff --git a/src/main/java/net/coderbot/iris/uniforms/CelestialUniforms.java b/src/main/java/net/coderbot/iris/uniforms/CelestialUniforms.java index a51bcb79a..d35bdd2d3 100644 --- a/src/main/java/net/coderbot/iris/uniforms/CelestialUniforms.java +++ b/src/main/java/net/coderbot/iris/uniforms/CelestialUniforms.java @@ -16,7 +16,11 @@ import static net.coderbot.iris.gl.uniform.UniformUpdateFrequency.PER_FRAME; * @see Uniforms: Celestial bodies */ public final class CelestialUniforms { + private static final Vector4f upPositionCache = new Vector4f(); + private static final Matrix4f upMatrixCache = new Matrix4f(); + private final Vector4f positionCache = new Vector4f(); + private final Matrix4f celestialMatrixCache = new Matrix4f(); private final float sunPathRotation; public CelestialUniforms(float sunPathRotation) { @@ -70,56 +74,55 @@ public final class CelestialUniforms { } private Vector4f getCelestialPositionInWorldSpace(float y) { - final Vector4f position = new Vector4f(0.0F, y, 0.0F, 0.0F); + positionCache.set(0.0F, y, 0.0F, 0.0F); // TODO: Deduplicate / remove this function. - final Matrix4f celestial = new Matrix4f().identity(); + celestialMatrixCache.identity(); // This is the same transformation applied by renderSky, however, it's been moved to here. // This is because we need the result of it before it's actually performed in vanilla. - celestial.rotateY(-90.F * Constants.DEGREES_TO_RADIANS); - celestial.rotateZ(sunPathRotation * Constants.DEGREES_TO_RADIANS); - celestial.rotateX(getSkyAngle() * 360.0F * Constants.DEGREES_TO_RADIANS); + celestialMatrixCache.rotateY(-90.F * Constants.DEGREES_TO_RADIANS); + celestialMatrixCache.rotateZ(sunPathRotation * Constants.DEGREES_TO_RADIANS); + celestialMatrixCache.rotateX(getSkyAngle() * 360.0F * Constants.DEGREES_TO_RADIANS); - celestial.transform(position); + celestialMatrixCache.transform(positionCache); - return position; + return positionCache; } private Vector4f getCelestialPosition(float y) { - Vector4f position = new Vector4f(0.0F, y, 0.0F, 0.0F); + positionCache.set(0.0F, y, 0.0F, 0.0F); - final Matrix4f celestial = new Matrix4f(RenderingState.INSTANCE.getModelViewMatrix()); + celestialMatrixCache.set(RenderingState.INSTANCE.getModelViewMatrix()); // This is the same transformation applied by renderSky, however, it's been moved to here. // This is because we need the result of it before it's actually performed in vanilla. - celestial.rotateY(-90.F * Constants.DEGREES_TO_RADIANS); - celestial.rotateZ(sunPathRotation * Constants.DEGREES_TO_RADIANS); - celestial.rotateX(getSkyAngle() * 360.0F * Constants.DEGREES_TO_RADIANS); + celestialMatrixCache.rotateY(-90.F * Constants.DEGREES_TO_RADIANS); + celestialMatrixCache.rotateZ(sunPathRotation * Constants.DEGREES_TO_RADIANS); + celestialMatrixCache.rotateX(getSkyAngle() * 360.0F * Constants.DEGREES_TO_RADIANS); - position = celestial.transform(position); + celestialMatrixCache.transform(positionCache); - return position; + return positionCache; } private static Vector4f getUpPosition() { - Vector4f upVector = new Vector4f(0.0F, 100.0F, 0.0F, 0.0F); + upPositionCache.set(0.0F, 100.0F, 0.0F, 0.0F); // Get the current model view matrix, since that is the basis of the celestial model view matrix - final Matrix4f preCelestial = new Matrix4f(RenderingState.INSTANCE.getModelViewMatrix()); + upMatrixCache.set(RenderingState.INSTANCE.getModelViewMatrix()); // Apply the fixed -90.0F degrees rotation to mirror the same transformation in renderSky. // But, notably, skip the rotation by the skyAngle. - preCelestial.rotateY(-90.F * Constants.DEGREES_TO_RADIANS); + upMatrixCache.rotateY(-90.F * Constants.DEGREES_TO_RADIANS); // Use this matrix to transform the vector. - upVector = preCelestial.transform(upVector); + upMatrixCache.transform(upPositionCache); - return upVector; + return upPositionCache; } public static boolean isDay() { // Determine whether it is day or night based on the sky angle. - // // World#isDay appears to do some nontrivial calculations that appear to not entirely work for us here. return getSunAngle() <= 0.5; } diff --git a/src/main/java/net/coderbot/iris/uniforms/CommonUniforms.java b/src/main/java/net/coderbot/iris/uniforms/CommonUniforms.java index 0333931bc..e3324fa5f 100644 --- a/src/main/java/net/coderbot/iris/uniforms/CommonUniforms.java +++ b/src/main/java/net/coderbot/iris/uniforms/CommonUniforms.java @@ -7,7 +7,7 @@ import com.gtnewhorizons.angelica.glsm.texture.TextureInfo; import com.gtnewhorizons.angelica.glsm.texture.TextureInfoCache; import com.gtnewhorizons.angelica.glsm.texture.TextureTracker; import com.gtnewhorizons.angelica.mixins.interfaces.EntityRendererAccessor; -import net.coderbot.iris.gl.state.StateUpdateNotifiers; +import net.coderbot.iris.gl.state.ValueUpdateNotifier; import net.coderbot.iris.gl.uniform.DynamicUniformHolder; import net.coderbot.iris.gl.uniform.UniformHolder; import net.coderbot.iris.layer.GbufferPrograms; @@ -68,11 +68,10 @@ public final class CommonUniforms { ExternallyManagedUniforms.addExternallyManagedUniforms116(uniforms); IdMapUniforms.addEntityIdMapUniforms(uniforms); FogUniforms.addFogUniforms(uniforms); + IrisInternalUniforms.addFogUniforms(uniforms); - // TODO: OptiFine doesn't think that atlasSize is a "dynamic" uniform, - // but we do. How will custom uniforms depending on atlasSize work? uniforms.uniform2i("atlasSize", () -> { - final int glId = GLStateManager.getBoundTextureForServerState(); + final int glId = GLStateManager.getBoundTextureForServerState(0); final AbstractTexture texture = TextureTracker.INSTANCE.getTexture(glId); if (texture instanceof TextureMap) { @@ -81,15 +80,15 @@ public final class CommonUniforms { } return ZERO_VECTOR_2i; - }, StateUpdateNotifiers.bindTextureNotifier); + }, ValueUpdateNotifier.NONE); uniforms.uniform2i("gtextureSize", () -> { - final int glId = GLStateManager.getBoundTextureForServerState(); + final int glId = GLStateManager.getBoundTextureForServerState(0); final TextureInfo info = TextureInfoCache.INSTANCE.getInfo(glId); return new Vector2i(info.getWidth(), info.getHeight()); - }, StateUpdateNotifiers.bindTextureNotifier); + }, ValueUpdateNotifier.NONE); uniforms.uniform4i("blendFunc", () -> { if(GLStateManager.getBlendMode().isEnabled()) { @@ -97,9 +96,9 @@ public final class CommonUniforms { return new Vector4i(blend.getSrcRgb(), blend.getDstRgb(), blend.getSrcAlpha(), blend.getDstAlpha()); } return ZERO_VECTOR_4i; - }, StateUpdateNotifiers.blendFuncNotifier); + }, ValueUpdateNotifier.NONE); - uniforms.uniform1i("renderStage", () -> GbufferPrograms.getCurrentPhase().ordinal(), StateUpdateNotifiers.phaseChangeNotifier); + uniforms.uniform1i("renderStage", () -> GbufferPrograms.getCurrentPhase().ordinal(), ValueUpdateNotifier.NONE); uniforms.uniform4f("entityColor", CapturedRenderingState.INSTANCE::getCurrentEntityColor, CapturedRenderingState.INSTANCE.getEntityColorNotifier()); diff --git a/src/main/java/net/coderbot/iris/uniforms/ExternallyManagedUniforms.java b/src/main/java/net/coderbot/iris/uniforms/ExternallyManagedUniforms.java index 1a860d7a9..1a9b6e0ca 100644 --- a/src/main/java/net/coderbot/iris/uniforms/ExternallyManagedUniforms.java +++ b/src/main/java/net/coderbot/iris/uniforms/ExternallyManagedUniforms.java @@ -12,8 +12,6 @@ public class ExternallyManagedUniforms { addMat4(uniformHolder, "iris_ModelViewMatrix"); addMat4(uniformHolder, "u_ModelViewProjectionMatrix"); addMat4(uniformHolder, "iris_NormalMatrix"); - - // 1.21.6+ uniformHolder.externallyManagedUniform("heavyFog", UniformType.BOOL); } @@ -24,42 +22,7 @@ public class ExternallyManagedUniforms { uniformHolder.externallyManagedUniform("u_TextureScale", UniformType.VEC2); } - public static void addExternallyManagedUniforms117(UniformHolder uniformHolder) { - addExternallyManagedUniforms(uniformHolder); - - // Sodium - addFloat(uniformHolder, "iris_FogStart"); - addFloat(uniformHolder, "iris_FogEnd"); - addVec4(uniformHolder, "iris_FogColor"); - addMat4(uniformHolder, "iris_ProjectionMatrix"); - addFloat(uniformHolder, "u_TextureScale"); - addFloat(uniformHolder, "u_ModelScale"); - addFloat(uniformHolder, "iris_ModelOffset"); - uniformHolder.externallyManagedUniform("iris_CameraTranslation", UniformType.VEC3); - - // Vanilla - uniformHolder.externallyManagedUniform("iris_TextureMat", UniformType.MAT4); - uniformHolder.externallyManagedUniform("iris_ModelViewMat", UniformType.MAT4); - uniformHolder.externallyManagedUniform("iris_ProjMat", UniformType.MAT4); - uniformHolder.externallyManagedUniform("iris_ChunkOffset", UniformType.VEC3); - uniformHolder.externallyManagedUniform("iris_ColorModulator", UniformType.VEC4); - uniformHolder.externallyManagedUniform("iris_FogStart", UniformType.FLOAT); - uniformHolder.externallyManagedUniform("iris_FogEnd", UniformType.FLOAT); - uniformHolder.externallyManagedUniform("iris_FogDensity", UniformType.FLOAT); - uniformHolder.externallyManagedUniform("iris_LineWidth", UniformType.FLOAT); - uniformHolder.externallyManagedUniform("iris_ScreenSize", UniformType.VEC2); - uniformHolder.externallyManagedUniform("iris_FogColor", UniformType.VEC4); - } - private static void addMat4(UniformHolder uniformHolder, String name) { uniformHolder.externallyManagedUniform(name, UniformType.MAT4); } - - private static void addVec4(UniformHolder uniformHolder, String name) { - uniformHolder.externallyManagedUniform(name, UniformType.VEC4); - } - - private static void addFloat(UniformHolder uniformHolder, String name) { - uniformHolder.externallyManagedUniform(name, UniformType.FLOAT); - } } diff --git a/src/main/java/net/coderbot/iris/uniforms/FogUniforms.java b/src/main/java/net/coderbot/iris/uniforms/FogUniforms.java index a970d52b9..f7033a256 100644 --- a/src/main/java/net/coderbot/iris/uniforms/FogUniforms.java +++ b/src/main/java/net/coderbot/iris/uniforms/FogUniforms.java @@ -1,7 +1,7 @@ package net.coderbot.iris.uniforms; import com.gtnewhorizons.angelica.glsm.GLStateManager; -import net.coderbot.iris.gl.state.StateUpdateNotifiers; +import net.coderbot.iris.gl.state.ValueUpdateNotifier; import net.coderbot.iris.gl.uniform.DynamicUniformHolder; public class FogUniforms { @@ -14,24 +14,12 @@ public class FogUniforms { if(!GLStateManager.getFogMode().isEnabled()) return 0; return GLStateManager.getFogState().getFogMode(); - }, listener -> { - StateUpdateNotifiers.fogToggleNotifier.setListener(listener); - StateUpdateNotifiers.fogModeNotifier.setListener(listener); - }); + }, ValueUpdateNotifier.NONE); - uniforms.uniform1f("fogDensity", () -> GLStateManager.getFogState().getDensity(), listener -> { - StateUpdateNotifiers.fogToggleNotifier.setListener(listener); - StateUpdateNotifiers.fogDensityNotifier.setListener(listener); - }); + uniforms.uniform1f("fogDensity", () -> GLStateManager.getFogState().getDensity(), ValueUpdateNotifier.NONE); - uniforms.uniform1f("fogStart", () -> GLStateManager.getFogState().getStart(), listener -> { - StateUpdateNotifiers.fogToggleNotifier.setListener(listener); - StateUpdateNotifiers.fogStartNotifier.setListener(listener); - }); + uniforms.uniform1f("fogStart", () -> GLStateManager.getFogState().getStart(), ValueUpdateNotifier.NONE); - uniforms.uniform1f("fogEnd", () -> GLStateManager.getFogState().getEnd(), listener -> { - StateUpdateNotifiers.fogToggleNotifier.setListener(listener); - StateUpdateNotifiers.fogEndNotifier.setListener(listener); - }); + uniforms.uniform1f("fogEnd", () -> GLStateManager.getFogState().getEnd(), ValueUpdateNotifier.NONE); } } diff --git a/src/main/java/net/coderbot/iris/uniforms/IrisInternalUniforms.java b/src/main/java/net/coderbot/iris/uniforms/IrisInternalUniforms.java new file mode 100644 index 000000000..7a2b396ce --- /dev/null +++ b/src/main/java/net/coderbot/iris/uniforms/IrisInternalUniforms.java @@ -0,0 +1,31 @@ +package net.coderbot.iris.uniforms; + +import com.gtnewhorizons.angelica.glsm.GLStateManager; +import net.coderbot.iris.gl.uniform.DynamicUniformHolder; +import org.joml.Vector3d; +import org.joml.Vector4f; + +import static net.coderbot.iris.gl.uniform.UniformUpdateFrequency.PER_FRAME; + +public class IrisInternalUniforms { + private static final Vector4f FOG_COLOR = new Vector4f(); + + private IrisInternalUniforms() { + } + + public static void addFogUniforms(DynamicUniformHolder uniforms) { + uniforms.uniform4f(PER_FRAME, "iris_FogColor", () -> { + final Vector3d color = GLStateManager.getFogState().getFogColor(); + return FOG_COLOR.set((float) color.x, (float) color.y, (float) color.z, GLStateManager.getFogState().getFogAlpha()); + }); + + uniforms + .uniform1f(PER_FRAME, "iris_FogStart", () -> GLStateManager.getFogState().getStart()) + .uniform1f(PER_FRAME, "iris_FogEnd", () -> GLStateManager.getFogState().getEnd()) + .uniform1f(PER_FRAME, "iris_FogDensity", () -> Math.max(0.0F, GLStateManager.getFogState().getDensity())); + + uniforms + .uniform1f(PER_FRAME, "iris_currentAlphaTest", () -> GLStateManager.getAlphaState().getReference()) + .uniform1f(PER_FRAME, "alphaTestRef", () -> GLStateManager.getAlphaState().getReference()); + } +} diff --git a/src/main/java/net/coderbot/iris/vertices/NormalHelper.java b/src/main/java/net/coderbot/iris/vertices/NormalHelper.java index 05a30ca19..619603538 100644 --- a/src/main/java/net/coderbot/iris/vertices/NormalHelper.java +++ b/src/main/java/net/coderbot/iris/vertices/NormalHelper.java @@ -44,14 +44,6 @@ public abstract class NormalHelper { * Expects convex quads with all points co-planar. */ public static void computeFaceNormal(@NotNull Vector3f saveTo, IrisQuadView q) { -// final Direction nominalFace = q.nominalFace(); -// -// if (GeometryHelper.isQuadParallelToFace(nominalFace, q)) { -// Vec3i vec = nominalFace.getVector(); -// saveTo.set(vec.getX(), vec.getY(), vec.getZ()); -// return; -// } - final float x0 = q.x(0); final float y0 = q.y(0); final float z0 = q.z(0); @@ -76,7 +68,7 @@ public abstract class NormalHelper { float normY = dz0 * dx1 - dx0 * dz1; float normZ = dx0 * dy1 - dy0 * dx1; - float l = (float) Math.sqrt(normX * normX + normY * normY + normZ * normZ); + final float l = (float) Math.sqrt(normX * normX + normY * normY + normZ * normZ); if (l != 0) { normX /= l; @@ -93,14 +85,6 @@ public abstract class NormalHelper { *

Assumes counter-clockwise winding order, which is the norm. */ public static void computeFaceNormalTri(@NotNull Vector3f saveTo, TriView t) { -// final Direction nominalFace = q.nominalFace(); -// -// if (GeometryHelper.isQuadParallelToFace(nominalFace, q)) { -// Vec3i vec = nominalFace.getVector(); -// saveTo.set(vec.getX(), vec.getY(), vec.getZ()); -// return; -// } - final float x0 = t.x(0); final float y0 = t.y(0); final float z0 = t.z(0); @@ -155,9 +139,9 @@ public abstract class NormalHelper { // project v onto normal // offset v by the projection to get the point on the plane // project x0, y0, z0 onto normal - float d0 = x0 * normalX + y0 * normalY + z0 * normalZ; - float d1 = x1 * normalX + y1 * normalY + z1 * normalZ; - float d2 = x2 * normalX + y2 * normalY + z2 * normalZ; + final float d0 = x0 * normalX + y0 * normalY + z0 * normalZ; + final float d1 = x1 * normalX + y1 * normalY + z1 * normalZ; + final float d2 = x2 * normalX + y2 * normalY + z2 * normalZ; // offset x, y, z by the projection to get the projected point on the normal plane x0 -= d0 * normalX; @@ -173,30 +157,30 @@ public abstract class NormalHelper { z2 -= d2 * normalZ; - float edge1x = x1 - x0; - float edge1y = y1 - y0; - float edge1z = z1 - z0; + final float edge1x = x1 - x0; + final float edge1y = y1 - y0; + final float edge1z = z1 - z0; - float edge2x = x2 - x0; - float edge2y = y2 - y0; - float edge2z = z2 - z0; + final float edge2x = x2 - x0; + final float edge2y = y2 - y0; + final float edge2z = z2 - z0; - float u0 = t.u(0); - float v0 = t.v(0); + final float u0 = t.u(0); + final float v0 = t.v(0); - float u1 = t.u(1); - float v1 = t.v(1); + final float u1 = t.u(1); + final float v1 = t.v(1); - float u2 = t.u(2); - float v2 = t.v(2); + final float u2 = t.u(2); + final float v2 = t.v(2); - float deltaU1 = u1 - u0; - float deltaV1 = v1 - v0; - float deltaU2 = u2 - u0; - float deltaV2 = v2 - v0; + final float deltaU1 = u1 - u0; + final float deltaV1 = v1 - v0; + final float deltaU2 = u2 - u0; + final float deltaV2 = v2 - v0; - float fdenom = deltaU1 * deltaV2 - deltaU2 * deltaV1; - float f; + final float fdenom = deltaU1 * deltaV2 - deltaU2 * deltaV1; + final float f; if (fdenom == 0.0) { f = 1.0f; @@ -207,7 +191,7 @@ public abstract class NormalHelper { float tangentx = f * (deltaV2 * edge1x - deltaV1 * edge2x); float tangenty = f * (deltaV2 * edge1y - deltaV1 * edge2y); float tangentz = f * (deltaV2 * edge1z - deltaV1 * edge2z); - float tcoeff = rsqrt(tangentx * tangentx + tangenty * tangenty + tangentz * tangentz); + final float tcoeff = rsqrt(tangentx * tangentx + tangenty * tangenty + tangentz * tangentz); tangentx *= tcoeff; tangenty *= tcoeff; tangentz *= tcoeff; @@ -215,7 +199,7 @@ public abstract class NormalHelper { float bitangentx = f * (-deltaU2 * edge1x + deltaU1 * edge2x); float bitangenty = f * (-deltaU2 * edge1y + deltaU1 * edge2y); float bitangentz = f * (-deltaU2 * edge1z + deltaU1 * edge2z); - float bitcoeff = rsqrt(bitangentx * bitangentx + bitangenty * bitangenty + bitangentz * bitangentz); + final float bitcoeff = rsqrt(bitangentx * bitangentx + bitangenty * bitangenty + bitangentz * bitangentz); bitangentx *= bitcoeff; bitangenty *= bitcoeff; bitangentz *= bitcoeff; @@ -230,12 +214,12 @@ public abstract class NormalHelper { // such as vector cross products! The calculation for pbitangentz // used to be broken because it multiplied values in the wrong order. - float pbitangentx = tangenty * normalZ - tangentz * normalY; - float pbitangenty = tangentz * normalX - tangentx * normalZ; - float pbitangentz = tangentx * normalY - tangenty * normalX; + final float pbitangentx = tangenty * normalZ - tangentz * normalY; + final float pbitangenty = tangentz * normalX - tangentx * normalZ; + final float pbitangentz = tangentx * normalY - tangenty * normalX; - float dot = (bitangentx * pbitangentx) + (bitangenty * pbitangenty) + (bitangentz * pbitangentz); - float tangentW; + final float dot = (bitangentx * pbitangentx) + (bitangenty * pbitangenty) + (bitangentz * pbitangentz); + final float tangentW; if (dot < 0) { tangentW = -1.0F; @@ -248,42 +232,42 @@ public abstract class NormalHelper { public static int computeTangent(float normalX, float normalY, float normalZ, TriView t) { // Capture all of the relevant vertex positions - float x0 = t.x(0); - float y0 = t.y(0); - float z0 = t.z(0); + final float x0 = t.x(0); + final float y0 = t.y(0); + final float z0 = t.z(0); - float x1 = t.x(1); - float y1 = t.y(1); - float z1 = t.z(1); + final float x1 = t.x(1); + final float y1 = t.y(1); + final float z1 = t.z(1); - float x2 = t.x(2); - float y2 = t.y(2); - float z2 = t.z(2); + final float x2 = t.x(2); + final float y2 = t.y(2); + final float z2 = t.z(2); - float edge1x = x1 - x0; - float edge1y = y1 - y0; - float edge1z = z1 - z0; + final float edge1x = x1 - x0; + final float edge1y = y1 - y0; + final float edge1z = z1 - z0; - float edge2x = x2 - x0; - float edge2y = y2 - y0; - float edge2z = z2 - z0; + final float edge2x = x2 - x0; + final float edge2y = y2 - y0; + final float edge2z = z2 - z0; - float u0 = t.u(0); - float v0 = t.v(0); + final float u0 = t.u(0); + final float v0 = t.v(0); - float u1 = t.u(1); - float v1 = t.v(1); + final float u1 = t.u(1); + final float v1 = t.v(1); - float u2 = t.u(2); - float v2 = t.v(2); + final float u2 = t.u(2); + final float v2 = t.v(2); - float deltaU1 = u1 - u0; - float deltaV1 = v1 - v0; - float deltaU2 = u2 - u0; - float deltaV2 = v2 - v0; + final float deltaU1 = u1 - u0; + final float deltaV1 = v1 - v0; + final float deltaU2 = u2 - u0; + final float deltaV2 = v2 - v0; - float fdenom = deltaU1 * deltaV2 - deltaU2 * deltaV1; - float f; + final float fdenom = deltaU1 * deltaV2 - deltaU2 * deltaV1; + final float f; if (fdenom == 0.0) { f = 1.0f; @@ -294,7 +278,7 @@ public abstract class NormalHelper { float tangentx = f * (deltaV2 * edge1x - deltaV1 * edge2x); float tangenty = f * (deltaV2 * edge1y - deltaV1 * edge2y); float tangentz = f * (deltaV2 * edge1z - deltaV1 * edge2z); - float tcoeff = rsqrt(tangentx * tangentx + tangenty * tangenty + tangentz * tangentz); + final float tcoeff = rsqrt(tangentx * tangentx + tangenty * tangenty + tangentz * tangentz); tangentx *= tcoeff; tangenty *= tcoeff; tangentz *= tcoeff; @@ -302,7 +286,7 @@ public abstract class NormalHelper { float bitangentx = f * (-deltaU2 * edge1x + deltaU1 * edge2x); float bitangenty = f * (-deltaU2 * edge1y + deltaU1 * edge2y); float bitangentz = f * (-deltaU2 * edge1z + deltaU1 * edge2z); - float bitcoeff = rsqrt(bitangentx * bitangentx + bitangenty * bitangenty + bitangentz * bitangentz); + final float bitcoeff = rsqrt(bitangentx * bitangentx + bitangenty * bitangenty + bitangentz * bitangentz); bitangentx *= bitcoeff; bitangenty *= bitcoeff; bitangentz *= bitcoeff; @@ -317,12 +301,12 @@ public abstract class NormalHelper { // such as vector cross products! The calculation for pbitangentz // used to be broken because it multiplied values in the wrong order. - float pbitangentx = tangenty * normalZ - tangentz * normalY; - float pbitangenty = tangentz * normalX - tangentx * normalZ; - float pbitangentz = tangentx * normalY - tangenty * normalX; + final float pbitangentx = tangenty * normalZ - tangentz * normalY; + final float pbitangenty = tangentz * normalX - tangentx * normalZ; + final float pbitangentz = tangentx * normalY - tangenty * normalX; - float dot = (bitangentx * pbitangentx) + (bitangenty * pbitangenty) + (bitangentz * pbitangentz); - float tangentW; + final float dot = (bitangentx * pbitangentx) + (bitangenty * pbitangenty) + (bitangentz * pbitangentz); + final float tangentW; if (dot < 0) { tangentW = -1.0F; diff --git a/src/main/resources/META-INF/angelica_at.cfg b/src/main/resources/META-INF/angelica_at.cfg index 003c55e3f..f648f0be2 100644 --- a/src/main/resources/META-INF/angelica_at.cfg +++ b/src/main/resources/META-INF/angelica_at.cfg @@ -53,6 +53,7 @@ public net.minecraft.client.renderer.texture.TextureMap field_110575_b # locatio public net.minecraft.client.renderer.texture.TextureMap field_147636_j # mipmapLevels public net.minecraft.client.renderer.texture.TextureMap field_147637_k # anisotropicFiltering public net.minecraft.client.renderer.texture.TextureMap func_147634_a(Lnet/minecraft/util/ResourceLocation;I)Lnet/minecraft/util/ResourceLocation; # ResourceLocation completeResourceLocation(ResourceLocation, int) +public net.minecraft.client.renderer.texture.TextureMap field_110574_e # mapRegisteredSprites public net.minecraft.client.gui.GuiVideoSettings field_146498_f # parentGuiScreen public net.minecraft.entity.Entity field_70151_c # fire @@ -87,3 +88,10 @@ public net.minecraft.block.material.Material field_76240_I # isTranslucent public net.minecraft.world.biome.BiomeGenBase field_76765_S # enableRain public net.minecraft.world.biome.BiomeGenBase field_76766_R # enableSnow public net.minecraft.world.biome.BiomeGenMutated field_150611_aD # baseBiome + +public net.minecraftforge.client.ForgeHooksClient renderPass # renderPass +public net.minecraftforge.client.ForgeHooksClient worldRenderPass # worldRenderPass + +public net.minecraft.client.renderer.culling.Frustrum field_78550_b # xPosition +public net.minecraft.client.renderer.culling.Frustrum field_78551_c # yPosition +public net.minecraft.client.renderer.culling.Frustrum field_78549_d # zPosition diff --git a/src/main/resources/META-INF/services/com.mitchej123.glsm.GLStateManagerService b/src/main/resources/META-INF/services/com.mitchej123.glsm.GLStateManagerService new file mode 100644 index 000000000..4826e3e81 --- /dev/null +++ b/src/main/resources/META-INF/services/com.mitchej123.glsm.GLStateManagerService @@ -0,0 +1 @@ +com.gtnewhorizons.angelica.glsm.AngelicaGLStateManagerService diff --git a/src/main/resources/META-INF/services/com.mitchej123.glsm.RenderSystemService b/src/main/resources/META-INF/services/com.mitchej123.glsm.RenderSystemService new file mode 100644 index 000000000..6d1337470 --- /dev/null +++ b/src/main/resources/META-INF/services/com.mitchej123.glsm.RenderSystemService @@ -0,0 +1 @@ +com.gtnewhorizons.angelica.glsm.AngelicaRenderSystemService diff --git a/src/main/resources/META-INF/services/com.mitchej123.lwjgl.LWJGLService b/src/main/resources/META-INF/services/com.mitchej123.lwjgl.LWJGLService new file mode 100644 index 000000000..33a5970b6 --- /dev/null +++ b/src/main/resources/META-INF/services/com.mitchej123.lwjgl.LWJGLService @@ -0,0 +1,3 @@ +com.mitchej123.lwjgl.lwjgl3.LWJGL3Service +com.mitchej123.lwjgl.lwjgl2.LWJGL2Service + diff --git a/src/main/resources/META-INF/services/org.embeddedt.embeddium.impl.render.chunk.fog.FogService b/src/main/resources/META-INF/services/org.embeddedt.embeddium.impl.render.chunk.fog.FogService new file mode 100644 index 000000000..f70a0435c --- /dev/null +++ b/src/main/resources/META-INF/services/org.embeddedt.embeddium.impl.render.chunk.fog.FogService @@ -0,0 +1 @@ +com.gtnewhorizons.angelica.glsm.AngelicaFogService diff --git a/src/main/resources/assets/angelica/lang/en_US.lang b/src/main/resources/assets/angelica/lang/en_US.lang index 7ad511e49..2bffbee93 100644 --- a/src/main/resources/assets/angelica/lang/en_US.lang +++ b/src/main/resources/assets/angelica/lang/en_US.lang @@ -178,6 +178,8 @@ options.angelica.itemdisplaylistcount=Item Renderer Cache Limit options.angelica.itemdisplaylistcount.tooltip=The upper limit of VBO's to cache in the optimized item renderer. Higher values will significantly increase performance, but may result in increased VRAM usage. options.angelica.sleepbeforeswap=Alternate FPS Limiter options.angelica.sleepbeforeswap.tooltip=Switches to an alternate FPS limiter that gives more stable frametimes, in exchange for slightly more latency. Will never introduce more than one frame of latency, and has a lower impact at higher framerates. +options.angelica.threadedChunkBuilding=Threaded Chunk Building +options.angelica.threadedChunkBuilding.tooltip=If enabled, chunk meshing will be performed on multiple threads in parallel, significantly improving chunk build speed. Disable if you experience rendering issues with mods that have custom block renderers. Requires renderer reload to take effect. pack.iris.select.title=Select pack.iris.configure.title=Configure label.iris.true=On diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/MixinEntityRenderer.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/MixinEntityRenderer.java index 0009659d3..4681daff7 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/MixinEntityRenderer.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/MixinEntityRenderer.java @@ -5,9 +5,11 @@ import com.gtnewhorizons.angelica.mixins.interfaces.EntityRendererAccessor; import com.gtnewhorizons.angelica.rendering.RenderingState; import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.EntityRenderer; +import net.minecraft.client.renderer.texture.DynamicTexture; import net.minecraft.entity.EntityLivingBase; import net.minecraft.entity.player.EntityPlayer; import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.gen.Accessor; import org.spongepowered.asm.mixin.gen.Invoker; import org.spongepowered.asm.mixin.injection.At; import org.spongepowered.asm.mixin.injection.Inject; @@ -20,6 +22,9 @@ public abstract class MixinEntityRenderer implements EntityRendererAccessor { @Invoker public abstract float invokeGetNightVisionBrightness(EntityPlayer entityPlayer, float partialTicks); + @Accessor("lightmapTexture") + public abstract DynamicTexture getLightmapTexture(); + @Inject(method = "renderWorld", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/ActiveRenderInfo;updateRenderInfo(Lnet/minecraft/entity/player/EntityPlayer;Z)V", shift = At.Shift.AFTER)) private void angelica$captureCameraMatrix(float partialTicks, long finishTimeNano, CallbackInfo ci) { final Minecraft mc = Minecraft.getMinecraft(); diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/animation/MixinBlockFire.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/animation/MixinBlockFire.java deleted file mode 100644 index 147051ef0..000000000 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/animation/MixinBlockFire.java +++ /dev/null @@ -1,22 +0,0 @@ -package com.gtnewhorizons.angelica.mixins.early.angelica.animation; - -import com.gtnewhorizons.angelica.utils.AnimationsRenderUtils; -import net.minecraft.block.BlockFire; -import net.minecraft.util.IIcon; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.Shadow; -import org.spongepowered.asm.mixin.injection.At; -import org.spongepowered.asm.mixin.injection.Inject; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; - -@Mixin(BlockFire.class) -public class MixinBlockFire { - - @Shadow - private IIcon[] field_149850_M; - - @Inject(method = "getFireIcon", at = @At("HEAD")) - private void angelica$markFireAnimationForUpdate(int p_149840_1_, CallbackInfoReturnable cir) { - AnimationsRenderUtils.markBlockTextureForUpdate(field_149850_M[p_149840_1_]); - } -} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/animation/MixinMinecraftForgeClient.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/animation/MixinMinecraftForgeClient.java deleted file mode 100644 index ce4721824..000000000 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/animation/MixinMinecraftForgeClient.java +++ /dev/null @@ -1,44 +0,0 @@ -package com.gtnewhorizons.angelica.mixins.early.angelica.animation; - -import com.gtnewhorizons.angelica.mixins.interfaces.IPatchedTextureAtlasSprite; -import net.minecraft.client.Minecraft; -import net.minecraft.client.renderer.texture.TextureAtlasSprite; -import net.minecraft.item.Item; -import net.minecraft.item.ItemStack; -import net.minecraft.util.IIcon; -import net.minecraftforge.client.IItemRenderer; -import net.minecraftforge.client.MinecraftForgeClient; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.injection.At; -import org.spongepowered.asm.mixin.injection.Inject; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; - -@Mixin(MinecraftForgeClient.class) -public class MixinMinecraftForgeClient { - - /** - * @author laetansky We can just mark any item texture that gets rendered for an update - */ - @Inject(method = "getItemRenderer", at = @At("HEAD"), remap = false) - private static void angelica$beforeRenderItem(ItemStack itemStack, IItemRenderer.ItemRenderType type, - CallbackInfoReturnable cir) { - // Don't animate items if a world is not present (e.g. during loading) - if (Minecraft.getMinecraft().theWorld == null) { - return; - } - final Item item = itemStack.getItem(); - if (item.requiresMultipleRenderPasses()) { - for (int i = 0; i < item.getRenderPasses(itemStack.getItemDamage()); i++) { - IIcon icon = item.getIcon(itemStack, i); - if (icon instanceof TextureAtlasSprite) { - ((IPatchedTextureAtlasSprite) icon).markNeedsAnimationUpdate(); - } - } - } else { - final IIcon icon = itemStack.getIconIndex(); - if (icon instanceof TextureAtlasSprite) { - ((IPatchedTextureAtlasSprite) icon).markNeedsAnimationUpdate(); - } - } - } -} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/animation/MixinRenderBlockFluid.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/animation/MixinRenderBlockFluid.java deleted file mode 100644 index a90d8dcf5..000000000 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/animation/MixinRenderBlockFluid.java +++ /dev/null @@ -1,23 +0,0 @@ -package com.gtnewhorizons.angelica.mixins.early.angelica.animation; - -import com.gtnewhorizons.angelica.utils.AnimationsRenderUtils; -import net.minecraft.client.Minecraft; -import net.minecraft.util.IIcon; -import net.minecraftforge.fluids.RenderBlockFluid; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.injection.At; -import org.spongepowered.asm.mixin.injection.Inject; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; - -@Mixin(value = RenderBlockFluid.class, remap = false) -public abstract class MixinRenderBlockFluid { - - /** - * @author laetansky - * @reason mark texture for update - */ - @Inject(method = "getIcon", at = @At(value = "RETURN", ordinal = 0)) - private void angelica$updateTexture(IIcon icon, CallbackInfoReturnable cir) { - AnimationsRenderUtils.markBlockTextureForUpdate(icon, Minecraft.getMinecraft().theWorld); - } -} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/animation/MixinRenderItem.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/animation/MixinRenderItem.java deleted file mode 100644 index 723506380..000000000 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/animation/MixinRenderItem.java +++ /dev/null @@ -1,25 +0,0 @@ -package com.gtnewhorizons.angelica.mixins.early.angelica.animation; - -import com.gtnewhorizons.angelica.mixins.interfaces.IPatchedTextureAtlasSprite; -import net.minecraft.client.renderer.entity.RenderItem; -import net.minecraft.client.renderer.texture.TextureAtlasSprite; -import net.minecraft.util.IIcon; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.injection.At; -import org.spongepowered.asm.mixin.injection.Inject; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; - -@Mixin(RenderItem.class) -public class MixinRenderItem { - - /** - * Some mods may call it to render their internally stored icons, so we make sure we mark those for an update - */ - @Inject(method = "renderIcon", at = @At("HEAD")) - private void angelica$beforeRenderIcon(int p_94149_1_, int p_94149_2_, IIcon icon, int p_94149_4_, int p_94149_5_, - CallbackInfo ci) { - if (icon instanceof TextureAtlasSprite) { - ((IPatchedTextureAtlasSprite) icon).markNeedsAnimationUpdate(); - } - } -} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/animation/MixinTextureAtlasSprite.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/animation/MixinTextureAtlasSprite.java index 562b6e250..60632f3ae 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/animation/MixinTextureAtlasSprite.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/animation/MixinTextureAtlasSprite.java @@ -1,54 +1,46 @@ package com.gtnewhorizons.angelica.mixins.early.angelica.animation; import com.gtnewhorizons.angelica.mixins.interfaces.IPatchedTextureAtlasSprite; -import com.gtnewhorizons.angelica.mixins.interfaces.ISpriteExt; -import com.gtnewhorizons.angelica.utils.AnimationsRenderUtils; -import com.llamalad7.mixinextras.injector.ModifyReturnValue; - import net.minecraft.client.renderer.texture.TextureAtlasSprite; import net.minecraft.client.resources.data.AnimationMetadataSection; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.Shadow; import org.spongepowered.asm.mixin.Unique; -import org.spongepowered.asm.mixin.injection.At; import java.util.List; +/** Provides animation active-state tracking and dry-run updates. */ @Mixin(TextureAtlasSprite.class) public abstract class MixinTextureAtlasSprite implements IPatchedTextureAtlasSprite { - @Unique - private boolean needsAnimationUpdate = false; + @Shadow protected int tickCounter; + @Shadow protected int frameCounter; + @Shadow private AnimationMetadataSection animationMetadata; + @Shadow protected List framesTextureData; - @Shadow - protected int tickCounter; - @Shadow - protected int frameCounter; - - @Shadow - private AnimationMetadataSection animationMetadata; - - @Shadow - protected List framesTextureData; + @Unique private boolean angelica$isActive = false; @Override public void markNeedsAnimationUpdate() { - needsAnimationUpdate = true; + this.angelica$isActive = true; } @Override public boolean needsAnimationUpdate() { - return needsAnimationUpdate; + if (this.angelica$isActive) { + this.angelica$isActive = false; + return true; + } + return false; } @Override public void unmarkNeedsAnimationUpdate() { - needsAnimationUpdate = false; + this.angelica$isActive = false; } @Override public void updateAnimationsDryRun() { - // account for weird subclass that doesn't use the stock mechanisms for animation if (animationMetadata == null || framesTextureData == null) return; tickCounter++; @@ -59,13 +51,4 @@ public abstract class MixinTextureAtlasSprite implements IPatchedTextureAtlasSpr this.tickCounter = 0; } } - - @ModifyReturnValue(method = "getMinU", at = @At("RETURN")) - private float angelica$onUVAccessed(float value) { - if (((ISpriteExt)this).isAnimation()) { - AnimationsRenderUtils.onSpriteUsed(this); - needsAnimationUpdate = true; - } - return value; - } } diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/animation/MixinTextureMap.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/animation/MixinTextureMap.java index e75b58bc1..647cab559 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/animation/MixinTextureMap.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/animation/MixinTextureMap.java @@ -28,31 +28,28 @@ public abstract class MixinTextureMap extends AbstractTexture { private static final Minecraft mc = Minecraft.getMinecraft(); /** - * @author laetansky - * @reason only update animations for textures that are being currently drawn By default minecraft handles any - * animations that present in listAnimatedSprites no matter if you see it or not which can lead to a huge - * performance decrease + * @author laetansky, jss2a98aj + * @reason Only update visible animations; use UV auto-marking via IPatchedTextureAtlasSprite */ @Overwrite public void updateAnimations() { - final boolean renderAllAnimations = AngelicaMod.animationsMode.is(AnimationMode.ALL); - final boolean renderVisibleAnimations = AngelicaMod.animationsMode.is(AnimationMode.VISIBLE_ONLY); + final boolean renderAll = AngelicaMod.animationsMode.is(AnimationMode.ALL); + final boolean renderVisible = AngelicaMod.animationsMode.is(AnimationMode.VISIBLE_ONLY); mc.mcProfiler.startSection("updateAnimations"); GL11.glBindTexture(GL11.GL_TEXTURE_2D, this.getGlTextureId()); - // C Style loop should be faster + final int size = listAnimatedSprites.size(); for (int i = 0; i < size; i++) { - final TextureAtlasSprite textureAtlasSprite = listAnimatedSprites.get(i); - final IPatchedTextureAtlasSprite patchedTextureAtlasSprite = ((IPatchedTextureAtlasSprite) textureAtlasSprite); + final TextureAtlasSprite sprite = listAnimatedSprites.get(i); + final IPatchedTextureAtlasSprite patched = (IPatchedTextureAtlasSprite) sprite; - if (renderAllAnimations || (renderVisibleAnimations && patchedTextureAtlasSprite.needsAnimationUpdate())) { - mc.mcProfiler.startSection(textureAtlasSprite.getIconName()); - textureAtlasSprite.updateAnimation(); - patchedTextureAtlasSprite.unmarkNeedsAnimationUpdate(); - mc.mcProfiler.endSection(); + // needsAnimationUpdate() is one-shot: returns true if marked, then auto-resets + if (renderAll || (renderVisible && patched.needsAnimationUpdate())) { + sprite.updateAnimation(); } else { - patchedTextureAtlasSprite.updateAnimationsDryRun(); + // Keep frame counters in sync for sprites not being updated + patched.updateAnimationsDryRun(); } } mc.mcProfiler.endSection(); diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/animation/MixinWorldRenderer.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/animation/MixinWorldRenderer.java deleted file mode 100644 index bbf65bb9a..000000000 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/animation/MixinWorldRenderer.java +++ /dev/null @@ -1,57 +0,0 @@ -package com.gtnewhorizons.angelica.mixins.early.angelica.animation; - -import com.gtnewhorizons.angelica.mixins.interfaces.IPatchedTextureAtlasSprite; -import com.gtnewhorizons.angelica.mixins.interfaces.ITexturesCache; -import net.minecraft.client.renderer.WorldRenderer; -import net.minecraft.util.IIcon; -import net.minecraft.world.IBlockAccess; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.Shadow; -import org.spongepowered.asm.mixin.Unique; -import org.spongepowered.asm.mixin.injection.At; -import org.spongepowered.asm.mixin.injection.Inject; -import org.spongepowered.asm.mixin.injection.ModifyArg; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; - -import java.util.Set; - -@Mixin(WorldRenderer.class) -public class MixinWorldRenderer implements ITexturesCache { - - @Shadow - public boolean isInFrustum; - - @Unique - private Set renderedIcons; - - @ModifyArg(method = "updateRenderer", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/RenderBlocks;(Lnet/minecraft/world/IBlockAccess;)V")) - private IBlockAccess angelica$onUpdateRenderer(IBlockAccess chunkCache) { - ((ITexturesCache) chunkCache).enableTextureTracking(); - renderedIcons = ((ITexturesCache) chunkCache).getRenderedTextures(); - return chunkCache; - } - - @Inject(method = "getGLCallListForPass", at = @At("HEAD")) - private void angelica$getGLCallListForPass(int pass, CallbackInfoReturnable cir) { - if (isInFrustum && pass == 0 && renderedIcons != null) { - for (IIcon icon : renderedIcons) { - ((IPatchedTextureAtlasSprite) icon).markNeedsAnimationUpdate(); - } - } - } - - @Override - public Set getRenderedTextures() { - return renderedIcons; - } - - @Override - public void enableTextureTracking() { - - } - - @Override - public void track(IPatchedTextureAtlasSprite sprite) { - - } -} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/dynamiclights/MixinEntity.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/dynamiclights/MixinEntity.java index e77e12371..200623e7a 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/dynamiclights/MixinEntity.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/dynamiclights/MixinEntity.java @@ -4,8 +4,8 @@ import com.gtnewhorizon.gtnhlib.blockpos.BlockPos; import com.gtnewhorizon.gtnhlib.blockpos.IBlockPos; import com.gtnewhorizons.angelica.dynamiclights.DynamicLights; import com.gtnewhorizons.angelica.dynamiclights.IDynamicLightSource; +import com.gtnewhorizons.angelica.dynamiclights.IDynamicLightWorldRenderer; import it.unimi.dsi.fastutil.longs.LongOpenHashSet; -import me.jellysquid.mods.sodium.client.render.SodiumWorldRenderer; import net.minecraft.entity.Entity; import net.minecraft.util.MathHelper; import net.minecraft.world.World; @@ -97,7 +97,7 @@ public abstract class MixinEntity implements IDynamicLightSource { } @Override - public boolean angelica$updateDynamicLight(@NotNull SodiumWorldRenderer renderer) { + public boolean angelica$updateDynamicLight(@NotNull IDynamicLightWorldRenderer renderer) { double deltaX = this.posX - this.angelica$prevX; double deltaY = this.posY - this.angelica$prevY; double deltaZ = this.posZ - this.angelica$prevZ; @@ -148,7 +148,7 @@ public abstract class MixinEntity implements IDynamicLightSource { } @Override - public void angelica$scheduleTrackedChunksRebuild(@NotNull SodiumWorldRenderer renderer) { + public void angelica$scheduleTrackedChunksRebuild(@NotNull IDynamicLightWorldRenderer renderer) { for (long pos : this.angelica$trackedLitChunkPos) { DynamicLights.scheduleChunkRebuild(renderer, pos); } diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/dynamiclights/MixinEntityRenderer.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/dynamiclights/MixinEntityRenderer.java index 3bda03c60..1919720af 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/dynamiclights/MixinEntityRenderer.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/dynamiclights/MixinEntityRenderer.java @@ -1,7 +1,7 @@ package com.gtnewhorizons.angelica.mixins.early.angelica.dynamiclights; import com.gtnewhorizons.angelica.dynamiclights.DynamicLights; -import me.jellysquid.mods.sodium.client.render.SodiumWorldRenderer; +import com.gtnewhorizons.angelica.dynamiclights.IDynamicLightWorldRenderer; import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.EntityRenderer; import org.spongepowered.asm.mixin.Mixin; @@ -16,8 +16,11 @@ public class MixinEntityRenderer { private Minecraft mc; @Inject(method = "renderWorld", at = @At("HEAD")) - private void updateDynamicLights(float p_78471_1_, long p_78471_2_, CallbackInfo ci){ - mc.mcProfiler.endStartSection("angelica_dynamic_lighting"); - DynamicLights.get().updateAll(SodiumWorldRenderer.getInstance()); + private void updateDynamicLights(float p_78471_1_, long p_78471_2_, CallbackInfo ci) { + IDynamicLightWorldRenderer renderer = DynamicLights.getActiveRenderer(); + if (renderer != null && renderer.isActive()) { + mc.mcProfiler.endStartSection("angelica_dynamic_lighting"); + DynamicLights.get().updateAll(renderer); + } } } diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/biome_blending/MixinBlockGrass.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/biome_blending/MixinBlockGrass.java new file mode 100644 index 000000000..8651d66d3 --- /dev/null +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/biome_blending/MixinBlockGrass.java @@ -0,0 +1,25 @@ +package com.gtnewhorizons.angelica.mixins.early.celeritas.biome_blending; + +import com.gtnewhorizons.angelica.rendering.celeritas.SmoothBiomeColorCache; +import com.gtnewhorizons.angelica.rendering.celeritas.WorldClientExtension; +import com.llamalad7.mixinextras.injector.wrapmethod.WrapMethod; +import com.llamalad7.mixinextras.injector.wrapoperation.Operation; +import net.minecraft.block.BlockGrass; +import net.minecraft.world.IBlockAccess; +import org.spongepowered.asm.mixin.Mixin; + +@Mixin(BlockGrass.class) +public class MixinBlockGrass { + @WrapMethod(method = "colorMultiplier") + private int celeritas$smoothBlendColor(IBlockAccess access, int x, int y, int z, Operation original) { + // Check ThreadLocal first (for worker threads), then fall back to world cache + SmoothBiomeColorCache cache = SmoothBiomeColorCache.getActiveCache(); + if (cache != null) { + return cache.getColor(SmoothBiomeColorCache.ColorType.GRASS, x, y, z); + } else if (access instanceof WorldClientExtension ext) { + return ext.celeritas$getSmoothBiomeColorCache().getColor(SmoothBiomeColorCache.ColorType.GRASS, x, y, z); + } else { + return original.call(access, x, y, z); + } + } +} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/biome_blending/MixinBlockLeaves.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/biome_blending/MixinBlockLeaves.java new file mode 100644 index 000000000..9e2d7aed1 --- /dev/null +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/biome_blending/MixinBlockLeaves.java @@ -0,0 +1,25 @@ +package com.gtnewhorizons.angelica.mixins.early.celeritas.biome_blending; + +import com.gtnewhorizons.angelica.rendering.celeritas.SmoothBiomeColorCache; +import com.gtnewhorizons.angelica.rendering.celeritas.WorldClientExtension; +import com.llamalad7.mixinextras.injector.wrapmethod.WrapMethod; +import com.llamalad7.mixinextras.injector.wrapoperation.Operation; +import net.minecraft.block.BlockLeaves; +import net.minecraft.world.IBlockAccess; +import org.spongepowered.asm.mixin.Mixin; + +@Mixin(BlockLeaves.class) +public class MixinBlockLeaves { + @WrapMethod(method = "colorMultiplier") + private int celeritas$smoothBlendColor(IBlockAccess access, int x, int y, int z, Operation original) { + // Check ThreadLocal first (for worker threads), then fall back to world cache + SmoothBiomeColorCache cache = SmoothBiomeColorCache.getActiveCache(); + if (cache != null) { + return cache.getColor(SmoothBiomeColorCache.ColorType.FOLIAGE, x, y, z); + } else if (access instanceof WorldClientExtension ext) { + return ext.celeritas$getSmoothBiomeColorCache().getColor(SmoothBiomeColorCache.ColorType.FOLIAGE, x, y, z); + } else { + return original.call(access, x, y, z); + } + } +} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/biome_blending/MixinBlockLiquid.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/biome_blending/MixinBlockLiquid.java new file mode 100644 index 000000000..0cdb0668b --- /dev/null +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/biome_blending/MixinBlockLiquid.java @@ -0,0 +1,34 @@ +package com.gtnewhorizons.angelica.mixins.early.celeritas.biome_blending; + +import com.gtnewhorizons.angelica.rendering.celeritas.SmoothBiomeColorCache; +import com.gtnewhorizons.angelica.rendering.celeritas.WorldClientExtension; +import com.llamalad7.mixinextras.injector.wrapmethod.WrapMethod; +import com.llamalad7.mixinextras.injector.wrapoperation.Operation; +import net.minecraft.block.Block; +import net.minecraft.block.BlockLiquid; +import net.minecraft.block.material.Material; +import net.minecraft.world.IBlockAccess; +import org.spongepowered.asm.mixin.Mixin; + +@Mixin(BlockLiquid.class) +public abstract class MixinBlockLiquid extends Block { + protected MixinBlockLiquid(Material material) { + super(material); + } + + @WrapMethod(method = "colorMultiplier") + private int celeritas$smoothBlendColor(IBlockAccess access, int x, int y, int z, Operation original) { + if (this.blockMaterial != Material.water) { + return original.call(access, x, y, z); + } + // Check ThreadLocal first (for worker threads), then fall back to world cache + SmoothBiomeColorCache cache = SmoothBiomeColorCache.getActiveCache(); + if (cache != null) { + return cache.getColor(SmoothBiomeColorCache.ColorType.WATER, x, y, z); + } else if (access instanceof WorldClientExtension ext) { + return ext.celeritas$getSmoothBiomeColorCache().getColor(SmoothBiomeColorCache.ColorType.WATER, x, y, z); + } else { + return original.call(access, x, y, z); + } + } +} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinEffectRenderer.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/features/culling/MixinEffectRenderer.java similarity index 52% rename from src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinEffectRenderer.java rename to src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/features/culling/MixinEffectRenderer.java index b1bcc3c51..ffb7500aa 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinEffectRenderer.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/features/culling/MixinEffectRenderer.java @@ -1,13 +1,12 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; +package com.gtnewhorizons.angelica.mixins.early.celeritas.features.culling; -import me.jellysquid.mods.sodium.client.SodiumClientMod; -import me.jellysquid.mods.sodium.client.render.SodiumWorldRenderer; +import com.gtnewhorizons.angelica.rendering.celeritas.CeleritasWorldRenderer; import net.minecraft.client.particle.EffectRenderer; import net.minecraft.client.particle.EntityFX; import net.minecraft.client.renderer.Tessellator; -import net.minecraft.client.renderer.culling.Frustrum; import net.minecraft.entity.Entity; import net.minecraft.tileentity.TileEntity; +import org.embeddedt.embeddium.impl.render.viewport.Viewport; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.Unique; import org.spongepowered.asm.mixin.injection.At; @@ -15,46 +14,51 @@ import org.spongepowered.asm.mixin.injection.Inject; import org.spongepowered.asm.mixin.injection.Redirect; import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; +/** + * EffectRenderer mixin for celeritas particle culling. + * Culls particles that are outside the view frustum. + */ @Mixin(EffectRenderer.class) public class MixinEffectRenderer { @Unique - private Frustrum cullingFrustum; + private Viewport cullingViewport; @Unique - private void setupCullingFrustum() { - Frustrum frustum = SodiumWorldRenderer.getInstance().getFrustum(); - boolean useCulling = SodiumClientMod.options().advanced.useParticleCulling; - // Setup the frustum state before rendering particles - if (useCulling && frustum != null) { - this.cullingFrustum = frustum; + private void setupCullingViewport() { + final boolean useCulling = true;// TODO: boolean useCulling = SodiumClientMod.options().advanced.useParticleCulling; + if(useCulling) { + this.cullingViewport = CeleritasWorldRenderer.getInstance().getLastViewport(); } else { - this.cullingFrustum = null; + this.cullingViewport = null; } } @Inject(method = "renderParticles", at = @At("HEAD")) - private void setupFrustum$standart(Entity player, float partialTickTime, CallbackInfo ci) { - setupCullingFrustum(); + private void setupViewport$standard(Entity player, float partialTickTime, CallbackInfo ci) { + setupCullingViewport(); } @Redirect(method = "renderParticles", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/particle/EntityFX;renderParticle(Lnet/minecraft/client/renderer/Tessellator;FFFFFF)V")) private void renderParticles(EntityFX particle, Tessellator tessellator, float partialTicks, float rotationX, float rotationZ, float rotationYZ, float rotationXY, float rotationXZ) { - if(cullingFrustum == null || particle.boundingBox == TileEntity.INFINITE_EXTENT_AABB || cullingFrustum.isBoundingBoxInFrustum(particle.boundingBox)) { + if (cullingViewport == null || particle.boundingBox == TileEntity.INFINITE_EXTENT_AABB || + cullingViewport.isBoxVisible(particle.boundingBox.minX, particle.boundingBox.minY, particle.boundingBox.minZ, + particle.boundingBox.maxX, particle.boundingBox.maxY, particle.boundingBox.maxZ)) { particle.renderParticle(tessellator, partialTicks, rotationX, rotationZ, rotationYZ, rotationXY, rotationXZ); } } @Inject(method = "renderLitParticles", at = @At("HEAD")) - private void setupFrustum$lit(Entity player, float partialTickTime, CallbackInfo ci) { - setupCullingFrustum(); + private void setupViewport$lit(Entity player, float partialTickTime, CallbackInfo ci) { + setupCullingViewport(); } @Redirect(method = "renderLitParticles", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/particle/EntityFX;renderParticle(Lnet/minecraft/client/renderer/Tessellator;FFFFFF)V")) private void renderLitParticles(EntityFX particle, Tessellator tessellator, float partialTicks, float rotationX, float rotationZ, float rotationYZ, float rotationXY, float rotationXZ) { - if(cullingFrustum == null || particle.boundingBox == TileEntity.INFINITE_EXTENT_AABB || cullingFrustum.isBoundingBoxInFrustum(particle.boundingBox)) { + if (cullingViewport == null || particle.boundingBox == TileEntity.INFINITE_EXTENT_AABB || + cullingViewport.isBoxVisible(particle.boundingBox.minX, particle.boundingBox.minY, particle.boundingBox.minZ, + particle.boundingBox.maxX, particle.boundingBox.maxY, particle.boundingBox.maxZ)) { particle.renderParticle(tessellator, partialTicks, rotationX, rotationZ, rotationYZ, rotationXY, rotationXZ); } } - } diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/features/mipmaps/MixinTextureAtlasSprite.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/features/mipmaps/MixinTextureAtlasSprite.java new file mode 100644 index 000000000..673b35978 --- /dev/null +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/features/mipmaps/MixinTextureAtlasSprite.java @@ -0,0 +1,89 @@ +package com.gtnewhorizons.angelica.mixins.early.celeritas.features.mipmaps; + +import com.gtnewhorizons.angelica.rendering.celeritas.SpriteExtension; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import org.embeddedt.embeddium.api.util.ColorABGR; +import org.embeddedt.embeddium.impl.render.chunk.sprite.SpriteTransparencyLevel; +import org.embeddedt.embeddium.impl.util.color.ColorSRGB; +import org.spongepowered.asm.mixin.Final; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.Unique; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; + +import java.util.List; + +/** Calculates sprite transparency level during mipmap generation. */ +@Mixin(TextureAtlasSprite.class) +public abstract class MixinTextureAtlasSprite implements SpriteExtension { + + @Shadow protected List framesTextureData; + @Shadow @Final private String iconName; + + @Unique private SpriteTransparencyLevel celeritas$transparencyLevel = SpriteTransparencyLevel.TRANSLUCENT; + + @Inject(method = "generateMipmaps", at = @At("HEAD")) + private void celeritas$processSprite(int level, CallbackInfo ci) { + if (this.framesTextureData.isEmpty() || this.framesTextureData.get(0) == null) { + return; + } + celeritas$processTransparentImages(this.framesTextureData.get(0)[0], level > 0 && !iconName.contains("leaves")); + } + + @Unique + private void celeritas$processTransparentImages(int[] nativeImage, boolean shouldRewriteColors) { + float r = 0.0f, g = 0.0f, b = 0.0f; + float totalWeight = 0.0f; + SpriteTransparencyLevel level = SpriteTransparencyLevel.OPAQUE; + + for (int y = 0; y < nativeImage.length; y++) { + int color = nativeImage[y]; + int alpha = ColorABGR.unpackAlpha(color); + + if (alpha > 0) { + if (alpha < 255) { + level = level.chooseNextLevel(SpriteTransparencyLevel.TRANSLUCENT); + } else { + level = level.chooseNextLevel(SpriteTransparencyLevel.OPAQUE); + } + + if (shouldRewriteColors) { + float weight = (float) alpha; + r += ColorSRGB.srgbToLinear(ColorABGR.unpackRed(color)) * weight; + g += ColorSRGB.srgbToLinear(ColorABGR.unpackGreen(color)) * weight; + b += ColorSRGB.srgbToLinear(ColorABGR.unpackBlue(color)) * weight; + totalWeight += weight; + } + } else { + level = level.chooseNextLevel(SpriteTransparencyLevel.TRANSPARENT); + } + } + + this.celeritas$transparencyLevel = level; + + if (!shouldRewriteColors || totalWeight == 0.0f) { + return; + } + + r /= totalWeight; + g /= totalWeight; + b /= totalWeight; + + int averageColor = ColorSRGB.linearToSrgb(r, g, b, 0); + + for (int y = 0; y < nativeImage.length; y++) { + int color = nativeImage[y]; + int alpha = ColorABGR.unpackAlpha(color); + if (alpha == 0) { + nativeImage[y] = averageColor; + } + } + } + + @Override + public SpriteTransparencyLevel celeritas$getTransparencyLevel() { + return this.celeritas$transparencyLevel; + } +} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/features/mipmaps/MixinTextureUtil.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/features/mipmaps/MixinTextureUtil.java new file mode 100644 index 000000000..79041e8af --- /dev/null +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/features/mipmaps/MixinTextureUtil.java @@ -0,0 +1,21 @@ +package com.gtnewhorizons.angelica.mixins.early.celeritas.features.mipmaps; + +import net.minecraft.client.renderer.texture.TextureUtil; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Overwrite; + +import static org.embeddedt.embeddium.impl.texture.MipmapHelper.weightedAverageColor; + +@Mixin(TextureUtil.class) +public class MixinTextureUtil { + /** + * @author coderbot + * @reason replace the vanilla blending function with our improved function + */ + @Overwrite + private static int func_147943_a(int one, int two, int three, int four, boolean checkAlpha) { + // First blend horizontally, then blend vertically. + // This works well for the case where our change is the most impactful (grass side overlays) + return weightedAverageColor(weightedAverageColor(one, two), weightedAverageColor(three, four)); + } +} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/features/textures/MixinTextureAtlasSprite.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/features/textures/MixinTextureAtlasSprite.java new file mode 100644 index 000000000..4c8742abd --- /dev/null +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/features/textures/MixinTextureAtlasSprite.java @@ -0,0 +1,29 @@ +package com.gtnewhorizons.angelica.mixins.early.celeritas.features.textures; + +import com.gtnewhorizons.angelica.mixins.interfaces.IPatchedTextureAtlasSprite; +import com.gtnewhorizons.angelica.rendering.celeritas.SpriteExtension; +import com.llamalad7.mixinextras.injector.ModifyReturnValue; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.injection.At; + +/** UV auto-marking for animation updates. Delegates to IPatchedTextureAtlasSprite. */ +@Mixin(TextureAtlasSprite.class) +public abstract class MixinTextureAtlasSprite implements SpriteExtension { + + @Override + public void celeritas$markActive() { + ((IPatchedTextureAtlasSprite) this).markNeedsAnimationUpdate(); + } + + @Override + public boolean celeritas$shouldUpdate() { + return ((IPatchedTextureAtlasSprite) this).needsAnimationUpdate(); + } + + @ModifyReturnValue(method = {"getMinU", "getInterpolatedU"}, at = @At("RETURN")) + private float celeritas$markActiveOnUVAccess(float original) { + ((IPatchedTextureAtlasSprite) this).markNeedsAnimationUpdate(); + return original; + } +} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/features/textures/MixinTextureMap.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/features/textures/MixinTextureMap.java new file mode 100644 index 000000000..6b69d2356 --- /dev/null +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/features/textures/MixinTextureMap.java @@ -0,0 +1,45 @@ +package com.gtnewhorizons.angelica.mixins.early.celeritas.features.textures; + +import com.gtnewhorizons.angelica.rendering.celeritas.TextureMapExtension; +import com.llamalad7.mixinextras.sugar.Local; +import net.minecraft.client.renderer.texture.Stitcher; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.client.renderer.texture.TextureMap; +import org.embeddedt.embeddium.impl.util.collections.quadtree.QuadTree; +import org.embeddedt.embeddium.impl.util.collections.quadtree.Rect2i; +import org.spongepowered.asm.mixin.Final; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.Unique; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; + +import java.util.Map; + +/** QuadTree for sprite UV lookup. */ +@Mixin(TextureMap.class) +public class MixinTextureMap implements TextureMapExtension { + + @Shadow @Final private Map mapUploadedSprites; + + @Unique private QuadTree celeritas$quadTree; + @Unique private int celeritas$width; + @Unique private int celeritas$height; + + @Inject(method = "loadTextureAtlas", at = @At("RETURN")) + private void celeritas$generateQuadTree(CallbackInfo ci, @Local(ordinal = 0) Stitcher stitcher) { + this.celeritas$width = stitcher.getCurrentWidth(); + this.celeritas$height = stitcher.getCurrentHeight(); + + final Rect2i treeRect = new Rect2i(0, 0, celeritas$width, celeritas$height); + final int minSize = this.mapUploadedSprites.values().stream().mapToInt(sprite -> Math.max(sprite.getIconWidth(), sprite.getIconHeight())).min().orElse(0); + this.celeritas$quadTree = new QuadTree<>(treeRect, minSize, this.mapUploadedSprites.values(), sprite -> new Rect2i(sprite.getOriginX(), sprite.getOriginY(), sprite.getIconWidth(), sprite.getIconHeight())); + } + + @Override + public TextureAtlasSprite celeritas$findFromUV(float u, float v) { + if (celeritas$quadTree == null) return null; + return this.celeritas$quadTree.find(Math.round(u * this.celeritas$width), Math.round(v * this.celeritas$height)); + } +} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/frustum/MixinFrustrum.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/frustum/MixinFrustrum.java new file mode 100644 index 000000000..ef7d71334 --- /dev/null +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/frustum/MixinFrustrum.java @@ -0,0 +1,26 @@ +package com.gtnewhorizons.angelica.mixins.early.celeritas.frustum; + +import net.minecraft.client.renderer.culling.ClippingHelper; +import net.minecraft.client.renderer.culling.Frustrum; +import org.embeddedt.embeddium.impl.render.viewport.Viewport; +import org.embeddedt.embeddium.impl.render.viewport.ViewportProvider; +import org.joml.Vector3d; +import org.spongepowered.asm.mixin.Final; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; + +@Mixin(Frustrum.class) +public abstract class MixinFrustrum implements ViewportProvider { + @Shadow @Final private ClippingHelper clippingHelper; + @Shadow private double xPosition, yPosition, zPosition; + + @Override + public Viewport sodium$createViewport() { + // Shadow frustum subclasses override this via their own ViewportProvider impl. + // This default handles vanilla Frustrum only. + return new Viewport( + this.clippingHelper::isBoxInFrustum, + new Vector3d(this.xPosition, this.yPosition, this.zPosition) + ); + } +} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/terrain/MixinChunkProviderClient.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/terrain/MixinChunkProviderClient.java new file mode 100644 index 000000000..7193d2828 --- /dev/null +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/terrain/MixinChunkProviderClient.java @@ -0,0 +1,29 @@ +package com.gtnewhorizons.angelica.mixins.early.celeritas.terrain; + +import net.minecraft.client.multiplayer.ChunkProviderClient; +import net.minecraft.world.World; +import net.minecraft.world.chunk.Chunk; +import org.embeddedt.embeddium.impl.render.chunk.map.ChunkStatus; +import org.embeddedt.embeddium.impl.render.chunk.map.ChunkTrackerHolder; +import org.spongepowered.asm.mixin.Final; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; + +@Mixin(ChunkProviderClient.class) +public abstract class MixinChunkProviderClient { + @Shadow @Final private World worldObj; + + @Inject(method = "loadChunk", at = @At("RETURN")) + private void celeritas$afterLoadChunk(int x, int z, CallbackInfoReturnable cir) { + ChunkTrackerHolder.get(this.worldObj).onChunkStatusAdded(x, z, ChunkStatus.FLAG_ALL); + } + + @Inject(method = "unloadChunk", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/chunk/Chunk;onChunkUnload()V", shift = At.Shift.AFTER)) + private void celeritas$afterUnloadChunk(int x, int z, CallbackInfo ci) { + ChunkTrackerHolder.get(this.worldObj).onChunkStatusRemoved(x, z, ChunkStatus.FLAG_ALL); + } +} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/terrain/MixinMinecraft_ChunkUpdates.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/terrain/MixinMinecraft_ChunkUpdates.java new file mode 100644 index 000000000..c15ecee0a --- /dev/null +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/terrain/MixinMinecraft_ChunkUpdates.java @@ -0,0 +1,17 @@ +package com.gtnewhorizons.angelica.mixins.early.celeritas.terrain; + +import com.gtnewhorizons.angelica.rendering.celeritas.CeleritasDebug; +import net.minecraft.client.Minecraft; +import org.objectweb.asm.Opcodes; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Redirect; + +@Mixin(Minecraft.class) +public abstract class MixinMinecraft_ChunkUpdates { + @Redirect(method = "runGameLoop", at = @At(opcode = Opcodes.GETSTATIC, value = "FIELD", + target = "Lnet/minecraft/client/renderer/WorldRenderer;chunksUpdated:I", ordinal = 0)) + private int celeritas$properChunkUpdateCounter() { + return CeleritasDebug.readAndResetChunkUpdateCounter(); + } +} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/terrain/MixinRenderGlobal.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/terrain/MixinRenderGlobal.java new file mode 100644 index 000000000..6d77108c8 --- /dev/null +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/terrain/MixinRenderGlobal.java @@ -0,0 +1,289 @@ +package com.gtnewhorizons.angelica.mixins.early.celeritas.terrain; + +import com.gtnewhorizons.angelica.compat.mojang.Camera; +import com.gtnewhorizons.angelica.compat.mojang.GameModeUtil; +import com.gtnewhorizons.angelica.glsm.GLStateManager; +import com.gtnewhorizons.angelica.mixins.interfaces.IRenderGlobalExt; +import com.gtnewhorizons.angelica.rendering.AngelicaRenderQueue; +import com.gtnewhorizons.angelica.rendering.celeritas.BlockRenderLayer; +import com.gtnewhorizons.angelica.rendering.celeritas.CeleritasWorldRenderer; +import net.coderbot.iris.Iris; +import net.coderbot.iris.layer.GbufferPrograms; +import net.coderbot.iris.pipeline.HandRenderer; +import net.coderbot.iris.pipeline.WorldRenderingPhase; +import net.coderbot.iris.pipeline.WorldRenderingPipeline; +import net.coderbot.iris.shadows.ShadowRenderingState; +import net.minecraft.client.Minecraft; +import net.minecraft.client.multiplayer.WorldClient; +import net.minecraft.client.renderer.OpenGlHelper; +import net.minecraft.client.renderer.RenderGlobal; +import net.minecraft.client.renderer.RenderHelper; +import net.minecraft.client.renderer.culling.ICamera; +import net.minecraft.client.renderer.texture.TextureManager; +import net.minecraft.client.renderer.texture.TextureMap; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import org.embeddedt.embeddium.impl.gl.device.RenderDevice; +import org.embeddedt.embeddium.impl.render.chunk.shader.ChunkShaderFogComponent; +import org.embeddedt.embeddium.impl.render.terrain.SimpleWorldRenderer; +import org.embeddedt.embeddium.impl.render.viewport.ViewportProvider; +import org.lwjgl.opengl.GL11; +import org.objectweb.asm.Opcodes; +import org.spongepowered.asm.mixin.Final; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Overwrite; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.Unique; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Constant; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.ModifyConstant; +import org.spongepowered.asm.mixin.injection.Redirect; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; + +import static org.joml.Math.lerp; + +/** + * RenderGlobal mixin for celeritas integration. + * Redirects chunk rendering to CeleritasWorldRenderer/AngelicaRenderSectionManager. + */ +@Mixin(value = RenderGlobal.class, priority = 900) +public class MixinRenderGlobal implements IRenderGlobalExt { + @Shadow public Minecraft mc; + @Shadow @Final private TextureManager renderEngine; + + @Unique private CeleritasWorldRenderer celeritas$renderer; + @Unique private int celeritas$frame; + + @Unique + private boolean angelica$isSpectatorMode() { + return GameModeUtil.isSpectator(); + } + + @Redirect(method = "(Lnet/minecraft/client/Minecraft;)V", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/GLAllocation;generateDisplayLists(I)I", ordinal = 0)) + private int celeritas$skipDisplayListAllocation(int count) { + // Skip allocation - celeritas replaces WorldRenderer with its own rendering system + return 0; + } + + @Redirect(method = "loadRenderers", at = @At(value = "FIELD", target = "Lnet/minecraft/client/renderer/RenderGlobal;renderDistanceChunks:I", opcode = Opcodes.GETFIELD, ordinal = 0)) + private int celeritas$nullifyBuiltChunkStorage(RenderGlobal self) { + // Minimize resource allocation + return 0; + } + + @ModifyConstant(method = "loadRenderers", constant = @Constant(intValue = 16, ordinal = 0), require = 1) + private int celeritas$nullifyBuiltChunkStorage2(int constant) { + // Minimize resource allocation + return 1; + } + + @Inject(method = "", at = @At("RETURN")) + private void celeritas$initRenderer(Minecraft mc, CallbackInfo ci) { + this.celeritas$renderer = CeleritasWorldRenderer.create(mc); + } + + @Inject(method = "Lnet/minecraft/client/renderer/RenderGlobal;setWorldAndLoadRenderers(Lnet/minecraft/client/multiplayer/WorldClient;)V", at = @At("RETURN")) + private void celeritas$setWorldAndLoadRenderers(WorldClient world, CallbackInfo ci) { + RenderDevice.enterManagedCode(); + try { + this.celeritas$renderer.setWorld(world); + } finally { + RenderDevice.exitManagedCode(); + } + + if (world != null && mc.renderViewEntity != null) { + final Entity e = mc.renderViewEntity; + Camera.INSTANCE.getPos().set(e.posX, e.posY + e.getEyeHeight(), e.posZ); + e.lastTickPosX = e.posX; + e.lastTickPosY = e.posY; + e.lastTickPosZ = e.posZ; + } + } + + @Inject(method = "onStaticEntitiesChanged", at = @At("RETURN")) + private void onTerrainUpdateScheduled(CallbackInfo ci) { + this.celeritas$renderer.scheduleTerrainUpdate(); + } + + @Unique + private static boolean sortAndRenderLogged = false; + + /** + * @author celeritas + * @reason Redirect to our renderer with Iris phase support + */ + @Overwrite + public int sortAndRender(EntityLivingBase entity, int pass, double partialTicks) { + if (!sortAndRenderLogged && ShadowRenderingState.areShadowsCurrentlyBeingRendered()) { + Iris.logger.info("[SHADOW DEBUG] sortAndRender called! pass={}", pass); + sortAndRenderLogged = true; + } + + final WorldRenderingPipeline pipeline; + if (!Iris.enabled) { + pipeline = null; + } else { + pipeline = Iris.getPipelineManager().getPipelineNullable(); + if (pass == 0) { + pipeline.setPhase(WorldRenderingPhase.TERRAIN_CUTOUT); + } else if (pass == 1) { + if (!ShadowRenderingState.areShadowsCurrentlyBeingRendered()) { + iris$beginTranslucents(pipeline, Camera.INSTANCE); + } + pipeline.setPhase(WorldRenderingPhase.TERRAIN_TRANSLUCENT); + this.renderEngine.bindTexture(TextureMap.locationBlocksTexture); + } + } + + RenderDevice.enterManagedCode(); + + RenderHelper.disableStandardItemLighting(); + + GLStateManager.glActiveTexture(OpenGlHelper.defaultTexUnit); + GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, this.mc.getTextureMapBlocks().getGlTextureId()); + GLStateManager.glEnable(GL11.GL_TEXTURE_2D); + + GLStateManager.glEnable(GL11.GL_ALPHA_TEST); + GLStateManager.glEnable(GL11.GL_FOG); + + this.mc.entityRenderer.enableLightmap(partialTicks); + + final double camX = lerp(entity.lastTickPosX, entity.posX, partialTicks); + final double camY = lerp(entity.lastTickPosY, entity.posY, partialTicks); + final double camZ = lerp(entity.lastTickPosZ, entity.posZ, partialTicks); + + try { + mc.mcProfiler.endStartSection("draw_chunk_layer_" + pass); + this.celeritas$renderer.drawChunkLayer(BlockRenderLayer.fromVanillaPass(pass), camX, camY, camZ); + } finally { + RenderDevice.exitManagedCode(); + } + + this.mc.entityRenderer.disableLightmap(partialTicks); + + if (pipeline != null) pipeline.setPhase(WorldRenderingPhase.NONE); + + return 0; + } + + /** + * @author celeritas + * @reason Redirect terrain setup to our renderer + */ + @Overwrite + public void clipRenderersByFrustum(ICamera camera, float partialTicks) { + RenderDevice.enterManagedCode(); + + try { + final Entity viewEntity = this.mc.renderViewEntity; + final float fogDistance = ChunkShaderFogComponent.FOG_SERVICE.getFogCutoff(); + + final double camX = viewEntity.posX; + final double camY = viewEntity.posY + viewEntity.getEyeHeight(); + final double camZ = viewEntity.posZ; + + final SimpleWorldRenderer.CameraState cameraState = new SimpleWorldRenderer.CameraState( + camX, camY, camZ, + viewEntity.rotationPitch, viewEntity.rotationYaw, fogDistance + ); + this.celeritas$renderer.setupTerrain(((ViewportProvider)camera).sodium$createViewport(), cameraState, this.celeritas$frame++, angelica$isSpectatorMode(), false); + } finally { + RenderDevice.exitManagedCode(); + } + } + + /** + * @author celeritas + * @reason Redirect to our renderer + */ + @Overwrite + public void markBlocksForUpdate(int minX, int minY, int minZ, int maxX, int maxY, int maxZ) { + this.celeritas$renderer.scheduleRebuildForBlockArea(minX, minY, minZ, maxX, maxY, maxZ, false); + } + + @Unique + public void angelica$reload() { + RenderDevice.enterManagedCode(); + try { + this.celeritas$renderer.reload(); + } finally { + RenderDevice.exitManagedCode(); + } + } + + @Inject(method = "loadRenderers", at = @At("RETURN")) + private void onReload(CallbackInfo ci) { + angelica$reload(); + } + + + + @Inject(method = "renderEntities", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/RenderHelper;enableStandardItemLighting()V", shift = At.Shift.AFTER, ordinal = 0), cancellable = true) + public void celeritas$renderTileEntities(EntityLivingBase entity, ICamera camera, float partialTicks, CallbackInfo ci) { + if (Iris.enabled) { + GbufferPrograms.beginBlockEntities(); + GbufferPrograms.setBlockEntityDefaults(); + } + this.celeritas$renderer.renderBlockEntities(partialTicks); + if (Iris.enabled) { + GbufferPrograms.endBlockEntities(); + } + this.mc.entityRenderer.disableLightmap(partialTicks); + this.mc.mcProfiler.endSection(); + ci.cancel(); + } + + /** + * @author celeritas + * @reason Redirect to our renderer + */ + @Overwrite + public String getDebugInfoRenders() { + return this.celeritas$renderer.getChunksDebugString(); + } + + + + + + /** + * @author celeritas + * @reason Process render queue with 5ms budget, track metrics + */ + @Overwrite + public boolean updateRenderers(EntityLivingBase e, boolean b) { + final int BUDGET_NS = 5 * 1000 * 1000; + final long startTime = System.nanoTime(); + int tasksRan = 0; + + while (System.nanoTime() - startTime < BUDGET_NS) { + if (AngelicaRenderQueue.processTasks(1) == 0) + break; + tasksRan++; + } + + AngelicaRenderQueue.recordFrameStats(tasksRan, System.nanoTime() - startTime); + return true; + } + + @Unique + private void iris$beginTranslucents(WorldRenderingPipeline pipeline, Camera camera) { + pipeline.beginHand(); + HandRenderer.INSTANCE.renderSolid(camera.getPartialTicks(), camera, mc.renderGlobal, pipeline); + mc.mcProfiler.endStartSection("iris_pre_translucent"); + pipeline.beginTranslucents(); + } + + @Redirect(method = "renderEntities", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/Entity;isInRangeToRender3d(DDD)Z")) + private boolean isInRange(Entity e, double x, double y, double z) { + return e.isInRangeToRender3d(x, y, z) && celeritas$renderer.isEntityVisible(e); + } + + + @Override + public void angelica$scheduleTerrainUpdate() { + this.celeritas$renderer.scheduleTerrainUpdate(); + } + +} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/terrain/MixinRenderSectionManager.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/terrain/MixinRenderSectionManager.java new file mode 100644 index 000000000..6c8ffa87c --- /dev/null +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/terrain/MixinRenderSectionManager.java @@ -0,0 +1,22 @@ +package com.gtnewhorizons.angelica.mixins.early.celeritas.terrain; + +import com.gtnewhorizons.angelica.mixins.interfaces.RenderSectionManagerAccessor; +import it.unimi.dsi.fastutil.longs.Long2ReferenceMap; +import org.embeddedt.embeddium.impl.render.chunk.RenderSection; +import org.embeddedt.embeddium.impl.render.chunk.RenderSectionManager; +import org.spongepowered.asm.mixin.Final; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; + +@Mixin(value = RenderSectionManager.class, remap = false) +public class MixinRenderSectionManager implements RenderSectionManagerAccessor { + + @Shadow + @Final + private Long2ReferenceMap sectionByPosition; + + @Override + public Long2ReferenceMap angelica$getSectionByPosition() { + return sectionByPosition; + } +} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/terrain/MixinWorldClient.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/terrain/MixinWorldClient.java new file mode 100644 index 000000000..2651dde71 --- /dev/null +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/terrain/MixinWorldClient.java @@ -0,0 +1,27 @@ +package com.gtnewhorizons.angelica.mixins.early.celeritas.terrain; + +import com.gtnewhorizons.angelica.rendering.celeritas.SmoothBiomeColorCache; +import com.gtnewhorizons.angelica.rendering.celeritas.WorldClientExtension; +import net.minecraft.client.multiplayer.WorldClient; +import net.minecraft.world.IBlockAccess; +import org.embeddedt.embeddium.impl.render.chunk.map.ChunkTracker; +import org.embeddedt.embeddium.impl.render.chunk.map.ChunkTrackerHolder; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Unique; + + +@Mixin(WorldClient.class) +public class MixinWorldClient implements ChunkTrackerHolder, WorldClientExtension { + @Unique private final ChunkTracker celeritas$tracker = new ChunkTracker(); + @Unique private final SmoothBiomeColorCache celeritas$smoothBiomeColorCache = new SmoothBiomeColorCache((IBlockAccess) this); + + @Override + public ChunkTracker sodium$getTracker() { + return this.celeritas$tracker; + } + + @Override + public SmoothBiomeColorCache celeritas$getSmoothBiomeColorCache() { + return this.celeritas$smoothBiomeColorCache; + } +} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/threading/MixinForgeHooksClient.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/threading/MixinForgeHooksClient.java new file mode 100644 index 000000000..18f56d772 --- /dev/null +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/threading/MixinForgeHooksClient.java @@ -0,0 +1,21 @@ +package com.gtnewhorizons.angelica.mixins.early.celeritas.threading; + +import com.gtnewhorizons.angelica.rendering.celeritas.threading.RenderPassHelper; +import net.minecraftforge.client.ForgeHooksClient; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Overwrite; + +/** + * Makes ForgeHooksClient.getWorldRenderPass() thread-safe by delegating to RenderPassHelper. + */ +@Mixin(value = ForgeHooksClient.class, remap = false) +public abstract class MixinForgeHooksClient { + /** + * @author Angelica + * @reason Thread-safe worldRenderPass for multi-threaded chunk building + */ + @Overwrite + public static int getWorldRenderPass() { + return RenderPassHelper.getWorldRenderPass(); + } +} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/AccessorBiomeColorEvent.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/AccessorBiomeColorEvent.java similarity index 86% rename from src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/AccessorBiomeColorEvent.java rename to src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/AccessorBiomeColorEvent.java index df00f91fb..ca7d73a73 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/AccessorBiomeColorEvent.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/AccessorBiomeColorEvent.java @@ -1,4 +1,4 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; +package com.gtnewhorizons.angelica.mixins.early.rendering; import net.minecraftforge.event.terraingen.BiomeEvent; import org.spongepowered.asm.mixin.Mixin; diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinBiomeGenBase.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinBiomeGenBase.java similarity index 97% rename from src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinBiomeGenBase.java rename to src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinBiomeGenBase.java index 7a67220c3..e871faf93 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinBiomeGenBase.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinBiomeGenBase.java @@ -1,4 +1,4 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; +package com.gtnewhorizons.angelica.mixins.early.rendering; import com.gtnewhorizons.angelica.compat.iris.BiomeCategoryCache; import com.gtnewhorizons.angelica.utils.EventUtils; diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinBlock.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinBlock.java similarity index 95% rename from src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinBlock.java rename to src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinBlock.java index a0929c288..fd95de07b 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinBlock.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinBlock.java @@ -1,4 +1,4 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; +package com.gtnewhorizons.angelica.mixins.early.rendering; import com.gtnewhorizons.angelica.glsm.ThreadedBlockData; import net.minecraft.block.Block; diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinBlockFluidBase.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinBlockFluidBase.java similarity index 93% rename from src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinBlockFluidBase.java rename to src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinBlockFluidBase.java index 91a32a850..c881d5137 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinBlockFluidBase.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinBlockFluidBase.java @@ -1,4 +1,4 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; +package com.gtnewhorizons.angelica.mixins.early.rendering; import com.llamalad7.mixinextras.injector.wrapoperation.Operation; import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation; diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinChunk.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinChunk.java similarity index 97% rename from src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinChunk.java rename to src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinChunk.java index 3fc996d5a..bf269b3ac 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinChunk.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinChunk.java @@ -1,4 +1,4 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; +package com.gtnewhorizons.angelica.mixins.early.rendering; import net.minecraft.client.Minecraft; import net.minecraft.world.World; diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinChunkProviderServer.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinChunkProviderServer.java similarity index 95% rename from src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinChunkProviderServer.java rename to src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinChunkProviderServer.java index 235c177f2..a0f29410c 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinChunkProviderServer.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinChunkProviderServer.java @@ -1,4 +1,4 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; +package com.gtnewhorizons.angelica.mixins.early.rendering; import net.minecraft.world.biome.WorldChunkManager; import net.minecraft.world.chunk.Chunk; diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinClientRegistry.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinClientRegistry.java similarity index 94% rename from src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinClientRegistry.java rename to src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinClientRegistry.java index 95c035538..c36716361 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinClientRegistry.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinClientRegistry.java @@ -1,4 +1,4 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; +package com.gtnewhorizons.angelica.mixins.early.rendering; import cpw.mods.fml.client.registry.ClientRegistry; import org.spongepowered.asm.mixin.Mixin; diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinEntityItem_RenderDist.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinEntityItem_RenderDist.java similarity index 92% rename from src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinEntityItem_RenderDist.java rename to src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinEntityItem_RenderDist.java index 479f5fcdb..c35f6ccfc 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinEntityItem_RenderDist.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinEntityItem_RenderDist.java @@ -1,4 +1,4 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; +package com.gtnewhorizons.angelica.mixins.early.rendering; import net.minecraft.entity.Entity; import net.minecraft.entity.item.EntityItem; diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinEntityRenderer.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinEntityRenderer.java similarity index 85% rename from src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinEntityRenderer.java rename to src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinEntityRenderer.java index c660f6486..3264ed045 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinEntityRenderer.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinEntityRenderer.java @@ -1,6 +1,6 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; +package com.gtnewhorizons.angelica.mixins.early.rendering; -import me.jellysquid.mods.sodium.client.gl.compat.FogHelper; +import com.gtnewhorizons.angelica.glsm.compat.FogHelper; import net.minecraft.client.renderer.EntityRenderer; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.Shadow; diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinEntity_RenderDist.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinEntity_RenderDist.java similarity index 91% rename from src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinEntity_RenderDist.java rename to src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinEntity_RenderDist.java index c20171b94..7c455e3fe 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinEntity_RenderDist.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinEntity_RenderDist.java @@ -1,4 +1,4 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; +package com.gtnewhorizons.angelica.mixins.early.rendering; import me.jellysquid.mods.sodium.client.gui.SodiumGameOptions; import net.minecraft.entity.Entity; diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinFMLClientHandler.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinFMLClientHandler.java similarity index 90% rename from src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinFMLClientHandler.java rename to src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinFMLClientHandler.java index 3abf6ad7f..9c5c47c8f 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinFMLClientHandler.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinFMLClientHandler.java @@ -1,4 +1,4 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; +package com.gtnewhorizons.angelica.mixins.early.rendering; import com.gtnewhorizons.angelica.Tags; import cpw.mods.fml.client.FMLClientHandler; diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinGameSettings.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinGameSettings.java similarity index 81% rename from src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinGameSettings.java rename to src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinGameSettings.java index c948017e4..9f27e26b6 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinGameSettings.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinGameSettings.java @@ -1,4 +1,4 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; +package com.gtnewhorizons.angelica.mixins.early.rendering; import net.minecraft.client.settings.GameSettings; import org.spongepowered.asm.mixin.Mixin; @@ -9,7 +9,7 @@ import org.spongepowered.asm.mixin.injection.ModifyConstant; public class MixinGameSettings { /** * @author embeddedt - * @reason Sodium Renderer supports up to 32 chunks + * @reason Angelica's Renderers supports up to 32 chunks */ @ModifyConstant(method = "(Lnet/minecraft/client/Minecraft;Ljava/io/File;)V", constant = @Constant(floatValue = 16.0f)) private float increaseMaxDistance(float old) { diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinLongHashMap.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinLongHashMap.java similarity index 88% rename from src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinLongHashMap.java rename to src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinLongHashMap.java index 136bd27ff..b49dfa633 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinLongHashMap.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinLongHashMap.java @@ -1,4 +1,4 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; +package com.gtnewhorizons.angelica.mixins.early.rendering; import net.minecraft.util.LongHashMap; import org.spongepowered.asm.mixin.Mixin; diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinMinecraft.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinMinecraft.java new file mode 100644 index 000000000..cd9249c8b --- /dev/null +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinMinecraft.java @@ -0,0 +1,23 @@ +package com.gtnewhorizons.angelica.mixins.early.rendering; + +import com.gtnewhorizons.angelica.mixins.interfaces.IRenderGlobalExt; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.RenderGlobal; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; + +@Mixin(Minecraft.class) +public class MixinMinecraft { + @Shadow + public RenderGlobal renderGlobal; + + @Inject(method = "resize", at = @At("TAIL")) + private void celeritas$resize(int width, int height, CallbackInfo ci) { + if (this.renderGlobal != null) { + ((IRenderGlobalExt) this.renderGlobal).angelica$scheduleTerrainUpdate(); + } + } +} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinPlayerManager.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinPlayerManager.java similarity index 90% rename from src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinPlayerManager.java rename to src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinPlayerManager.java index 292add0f3..75da0732d 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinPlayerManager.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinPlayerManager.java @@ -1,4 +1,4 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; +package com.gtnewhorizons.angelica.mixins.early.rendering; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.injection.At; diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinRenderBlocks.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinRenderBlocks.java similarity index 99% rename from src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinRenderBlocks.java rename to src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinRenderBlocks.java index b84c0cb8c..190a2e106 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinRenderBlocks.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinRenderBlocks.java @@ -1,4 +1,4 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; +package com.gtnewhorizons.angelica.mixins.early.rendering; import com.gtnewhorizons.angelica.AngelicaMod; import com.gtnewhorizons.angelica.common.BlockError; diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinRenderingRegistry.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinRenderingRegistry.java similarity index 98% rename from src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinRenderingRegistry.java rename to src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinRenderingRegistry.java index b93fa1bdb..d12d4a716 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinRenderingRegistry.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinRenderingRegistry.java @@ -1,4 +1,4 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; +package com.gtnewhorizons.angelica.mixins.early.rendering; import com.gtnewhorizons.angelica.api.ThreadSafeISBRH; import com.gtnewhorizons.angelica.api.ThreadSafeISBRHFactory; diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinTileEntity.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinTileEntity.java similarity index 95% rename from src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinTileEntity.java rename to src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinTileEntity.java index b5faabf4c..11a185f77 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinTileEntity.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinTileEntity.java @@ -1,4 +1,4 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; +package com.gtnewhorizons.angelica.mixins.early.rendering; import net.minecraft.block.Block; import net.minecraft.tileentity.TileEntity; diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinTileEntityMobSpawner.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinTileEntityMobSpawner.java similarity index 88% rename from src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinTileEntityMobSpawner.java rename to src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinTileEntityMobSpawner.java index 5f2c5cea7..4bfaf2d20 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinTileEntityMobSpawner.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinTileEntityMobSpawner.java @@ -1,4 +1,4 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; +package com.gtnewhorizons.angelica.mixins.early.rendering; import com.gtnewhorizons.angelica.config.AngelicaConfig; import net.minecraft.tileentity.TileEntity; diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinTileEntityRendererDispatcher.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinTileEntityRendererDispatcher.java similarity index 96% rename from src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinTileEntityRendererDispatcher.java rename to src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinTileEntityRendererDispatcher.java index 0327b99ac..debdb068f 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinTileEntityRendererDispatcher.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinTileEntityRendererDispatcher.java @@ -1,4 +1,4 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; +package com.gtnewhorizons.angelica.mixins.early.rendering; import net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher; import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer; diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/shaders/MixinEntityRenderer.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/shaders/MixinEntityRenderer.java index d1ea5686e..b2435c136 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/shaders/MixinEntityRenderer.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/shaders/MixinEntityRenderer.java @@ -64,8 +64,8 @@ public abstract class MixinEntityRenderer implements IResourceManagerReloadListe } } - @Inject(at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/RenderGlobal;clipRenderersByFrustum(Lnet/minecraft/client/renderer/culling/ICamera;F)V", shift = At.Shift.AFTER), method = "renderWorld(FJ)V") - private void iris$beginEntities(float partialTicks, long startTime, CallbackInfo ci, @Share("pipeline") LocalRef pipeline) { + @Inject(at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/RenderGlobal;clipRenderersByFrustum(Lnet/minecraft/client/renderer/culling/ICamera;F)V"), method = "renderWorld(FJ)V") + private void iris$renderShadows(float partialTicks, long startTime, CallbackInfo ci, @Share("pipeline") LocalRef pipeline) { pipeline.get().renderShadows((EntityRenderer) (Object) this, Camera.INSTANCE); } diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinForgeHooksClient.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinForgeHooksClient.java deleted file mode 100644 index 3a9ca6674..000000000 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinForgeHooksClient.java +++ /dev/null @@ -1,19 +0,0 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; - -import me.jellysquid.mods.sodium.client.render.chunk.ChunkRenderManager; -import net.minecraftforge.client.ForgeHooksClient; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.Overwrite; - -@Mixin(value = ForgeHooksClient.class, remap = false) -public class MixinForgeHooksClient { - /** - * @author mitchej123 - * @reason thread safe world render pass - */ - @Overwrite - public static int getWorldRenderPass() { - return ChunkRenderManager.getWorldRenderPass(); - } - -} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinFrustrum.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinFrustrum.java deleted file mode 100644 index fc4bdf3c3..000000000 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinFrustrum.java +++ /dev/null @@ -1,17 +0,0 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; - -import me.jellysquid.mods.sodium.client.util.math.FrustumExtended; -import net.minecraft.client.renderer.culling.Frustrum; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.Shadow; - -@Mixin(Frustrum.class) -public abstract class MixinFrustrum implements FrustumExtended { - @Shadow - public abstract boolean isBoxInFrustum(double p_78548_1_, double p_78548_3_, double p_78548_5_, double p_78548_7_, double p_78548_9_, double p_78548_11_); - - @Override - public boolean fastAabbTest(float minX, float minY, float minZ, float maxX, float maxY, float maxZ) { - return isBoxInFrustum(minX, minY, minZ, maxX, maxY, maxZ); - } -} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinMinecraft.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinMinecraft.java deleted file mode 100644 index f286ba43b..000000000 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinMinecraft.java +++ /dev/null @@ -1,37 +0,0 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; - -import com.gtnewhorizons.angelica.mixins.interfaces.IRenderGlobalExt; -import me.jellysquid.mods.sodium.client.SodiumClientMod; -import net.minecraft.client.Minecraft; -import net.minecraft.client.renderer.RenderGlobal; -import net.minecraft.client.settings.GameSettings; -import org.lwjgl.opengl.GL11; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.Shadow; -import org.spongepowered.asm.mixin.injection.At; -import org.spongepowered.asm.mixin.injection.Inject; -import org.spongepowered.asm.mixin.injection.Redirect; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; - -@Mixin(Minecraft.class) -public class MixinMinecraft { - @Shadow - public RenderGlobal renderGlobal; - - @Inject(method="resize", at=@At("TAIL")) - private void sodium$resize(int width, int height, CallbackInfo ci) { - if(this.renderGlobal != null) { - ((IRenderGlobalExt)this.renderGlobal).scheduleTerrainUpdate(); - } - } - - @Redirect(method = "runGameLoop", at = @At(value = "FIELD", target = "Lnet/minecraft/client/settings/GameSettings;fancyGraphics:Z")) - private boolean sodium$overrideFancyGrass(GameSettings gameSettings) { - return SodiumClientMod.options().quality.grassQuality.isFancy(); - } - - @Redirect(method = "checkGLError", at = @At(value = "INVOKE", target = "Lorg/lwjgl/opengl/GL11;glGetError()I", remap = false)) - private int sodium$checkGLError() { - return SodiumClientMod.options().performance.useNoErrorGLContext ? 0 : GL11.glGetError(); - } -} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinRenderGlobal.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinRenderGlobal.java deleted file mode 100644 index 36ef3b1ee..000000000 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinRenderGlobal.java +++ /dev/null @@ -1,329 +0,0 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; - -import com.gtnewhorizons.angelica.compat.mojang.Camera; -import com.gtnewhorizons.angelica.compat.mojang.GameModeUtil; -import com.gtnewhorizons.angelica.compat.toremove.MatrixStack; -import com.gtnewhorizons.angelica.mixins.interfaces.IRenderGlobalExt; -import com.gtnewhorizons.angelica.rendering.AngelicaRenderQueue; -import com.gtnewhorizons.angelica.rendering.RenderingState; -import lombok.Getter; -import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; -import me.jellysquid.mods.sodium.client.render.SodiumWorldRenderer; -import me.jellysquid.mods.sodium.client.render.chunk.passes.BlockRenderPass; -import net.coderbot.iris.Iris; -import net.coderbot.iris.pipeline.HandRenderer; -import net.coderbot.iris.pipeline.ShadowRenderer; -import net.coderbot.iris.pipeline.WorldRenderingPhase; -import net.coderbot.iris.pipeline.WorldRenderingPipeline; -import net.minecraft.client.Minecraft; -import net.minecraft.client.multiplayer.WorldClient; -import net.minecraft.client.renderer.RenderGlobal; -import net.minecraft.client.renderer.RenderHelper; -import net.minecraft.client.renderer.WorldRenderer; -import net.minecraft.client.renderer.culling.Frustrum; -import net.minecraft.client.renderer.culling.ICamera; -import net.minecraft.client.renderer.texture.TextureManager; -import net.minecraft.client.renderer.texture.TextureMap; -import net.minecraft.entity.Entity; -import net.minecraft.entity.EntityLivingBase; -import net.minecraft.init.Blocks; -import org.lwjgl.opengl.GL11; -import org.spongepowered.asm.mixin.Final; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.Overwrite; -import org.spongepowered.asm.mixin.Shadow; -import org.spongepowered.asm.mixin.Unique; -import org.spongepowered.asm.mixin.injection.At; -import org.spongepowered.asm.mixin.injection.Inject; -import org.spongepowered.asm.mixin.injection.Redirect; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; - -import static org.joml.Math.lerp; - -// Let other mixins apply, and then overwrite them -@Mixin(value = RenderGlobal.class, priority = 2000) -public class MixinRenderGlobal implements IRenderGlobalExt { - @Shadow public int renderChunksWide; - @Shadow public int renderChunksTall; - @Shadow public int renderChunksDeep; - @Shadow public WorldClient theWorld; - @Shadow public Minecraft mc; - @Shadow public int renderDistanceChunks; - @Shadow public WorldRenderer[] worldRenderers; - @Shadow public WorldRenderer[] sortedWorldRenderers; - @Shadow @Final private TextureManager renderEngine; - - - @Getter - @Unique private SodiumWorldRenderer renderer; - - private int sodium$frame; - - @Override - public void scheduleTerrainUpdate() { - this.renderer.scheduleTerrainUpdate(); - } - - @Redirect( - method = "(Lnet/minecraft/client/Minecraft;)V", - at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/GLAllocation;generateDisplayLists(I)I", ordinal = 0)) - private int sodium$skipDisplayListAllocation(int count) { - // Skip allocation when Sodium is enabled - Sodium completely replaces WorldRenderer - // with its own chunk rendering system, so these display lists are never used. - return 0; - } - - @Inject(method="", at=@At("RETURN")) - private void sodium$initRenderer(Minecraft mc, CallbackInfo ci) { - this.renderer = SodiumWorldRenderer.create(mc); - } - - @Inject(method="Lnet/minecraft/client/renderer/RenderGlobal;setWorldAndLoadRenderers(Lnet/minecraft/client/multiplayer/WorldClient;)V", at=@At("RETURN")) - private void sodium$setWorldAndLoadRenderers(WorldClient world, CallbackInfo ci) { - RenderDevice.enterManagedCode(); - try { - this.renderer.setWorld(world); - } finally { - RenderDevice.exitManagedCode(); - } - } - - /** - * @author mitchej123, sodium - * @reason Redirect to our renderer - */ - @Overwrite - public String getDebugInfoRenders() { - return this.renderer.getChunksDebugString(); - } - - /** - * @author Sodium - * @reason Redirect to our renderer - */ - @Overwrite - public int renderSortedRenderers(int x, int z, int pass, double partialTicks) { - // Do nothing - return 0; - } - /** - * @author Sodium - * @reason Redirect to our renderer - */ - @Overwrite - public void renderAllRenderLists(int pass, double partialTicks) { - // Do nothing - } - - /** - * @author Sodium - * @reason Redirect to our renderer - */ - @Overwrite - private void checkOcclusionQueryResult(int x, int z) { - // Do nothing - } - - /** - * @author Sodium - * @reason Redirect to our renderer - */ - @Overwrite - public void markRenderersForNewPosition(int p_72722_1_, int p_72722_2_, int p_72722_3_) { - // Do nothing - } - - /** - * @author Sodium - * @reason Redirect to our renderer - */ - @Overwrite - public boolean updateRenderers(EntityLivingBase e, boolean b){ - final int BUDGET_NS = 5 * 1000 * 1000; - long startTime = System.nanoTime(); - for (;;) { - int tasksRan = AngelicaRenderQueue.processTasks(1); - if (tasksRan == 0) - break; - long elapsedTime = System.nanoTime() - startTime; - if (elapsedTime > BUDGET_NS) - break; - } - return true; - } - - @Unique - private void iris$beginTranslucents(WorldRenderingPipeline pipeline, Camera camera) { - pipeline.beginHand(); - HandRenderer.INSTANCE.renderSolid(camera.getPartialTicks(), camera, mc.renderGlobal, pipeline); - mc.mcProfiler.endStartSection("iris_pre_translucent"); - pipeline.beginTranslucents(); - } - - /** - * @author Sodium - * @reason Redirect to our renderer - */ - @Overwrite - public int sortAndRender(EntityLivingBase entity, int pass, double partialTicks) { - final WorldRenderingPipeline pipeline; - if(!Iris.enabled) { - pipeline = null; - } else { - pipeline = Iris.getPipelineManager().getPipelineNullable(); - if(pass == 0) { - pipeline.setPhase(WorldRenderingPhase.TERRAIN_CUTOUT); - } else if(pass == 1) { - if (!ShadowRenderer.ACTIVE) { - iris$beginTranslucents(pipeline, Camera.INSTANCE); - } - - pipeline.setPhase(WorldRenderingPhase.TERRAIN_TRANSLUCENT); - this.renderEngine.bindTexture(TextureMap.locationBlocksTexture); - } - } - // Handle view distance change - if(this.renderDistanceChunks != this.mc.gameSettings.renderDistanceChunks) { - this.loadRenderers(); - } - - RenderHelper.disableStandardItemLighting(); - GL11.glEnable(GL11.GL_TEXTURE_2D); - GL11.glEnable(GL11.GL_ALPHA_TEST); - GL11.glEnable(GL11.GL_FOG); - this.mc.entityRenderer.enableLightmap(partialTicks); - // Roughly equivalent to `renderLayer` - RenderDevice.enterManagedCode(); - - final double x = lerp(entity.lastTickPosX, entity.posX, partialTicks); - final double y = lerp(entity.lastTickPosY, entity.posY, partialTicks); - final double z = lerp(entity.lastTickPosZ, entity.posZ, partialTicks); - - try { - final MatrixStack matrixStack = new MatrixStack(ShadowRenderer.ACTIVE ? ShadowRenderer.MODELVIEW : RenderingState.INSTANCE.getModelViewMatrix()); - mc.mcProfiler.endStartSection("draw_chunk_layer_" + pass); - this.renderer.drawChunkLayer(BlockRenderPass.VALUES[pass], matrixStack, x, y, z); - } finally { - RenderDevice.exitManagedCode(); - this.mc.entityRenderer.disableLightmap(partialTicks); - } - - if(pipeline != null) pipeline.setPhase(WorldRenderingPhase.NONE); - - return 0; - } - - private boolean isSpectatorMode() { - return GameModeUtil.isSpectator(); - } - - /** - * @author Sodium - * @reason Redirect to our renderer - */ - @Overwrite - public void clipRenderersByFrustum(ICamera frustrum, float partialTicks) { - // Roughly equivalent to setupTerrain - RenderDevice.enterManagedCode(); - - final Frustrum frustum = (Frustrum) frustrum; - boolean hasForcedFrustum = false; - boolean spectator = isSpectatorMode(); - frustum.setPosition(Camera.INSTANCE.getPos().x, Camera.INSTANCE.getPos().y, Camera.INSTANCE.getPos().z); - - try { - this.renderer.updateChunks(Camera.INSTANCE, frustum, hasForcedFrustum, sodium$frame++, spectator); - } finally { - RenderDevice.exitManagedCode(); - } - } - - /** - * @author Sodium - * @reason Redirect to our renderer - */ - @Overwrite - public void markBlocksForUpdate(int minX, int minY, int minZ, int maxX, int maxY, int maxZ) { - // scheduleBlockRenders - this.renderer.scheduleRebuildForBlockArea(minX, minY, minZ, maxX, maxY, maxZ, false); - } - - - /** - * @author Sodium - * @reason Redirect to our renderer - */ - @Overwrite - public void markBlockForUpdate(int x, int y, int z) { - this.renderer.scheduleRebuildForBlockArea(x - 1, y - 1, z - 1, x + 1, y + 1, z + 1, false); - } - - /** - * @author Sodium - * @reason Redirect to our renderer - */ - @Overwrite - public void markBlockForRenderUpdate(int x, int y, int z) { - // scheduleBlockRenders - this.renderer.scheduleRebuildForBlockArea(x - 1, y - 1, z - 1, x + 1, y + 1, z + 1, false); - } - - - /** - * @author Sodium - * @reason Redirect to our renderer - */ - @Overwrite - public void markBlockRangeForRenderUpdate(int minX, int minY, int minZ, int maxX, int maxY, int maxZ) { - // scheduleBlockRenders - this.renderer.scheduleRebuildForBlockArea(minX, minY, minZ, maxX, maxY, maxZ, false); - } - - @Inject(method = "loadRenderers", at = @At("RETURN")) - private void onReload(CallbackInfo ci) { - reload(); - } - - public void reload() { - RenderDevice.enterManagedCode(); - - try { - this.renderer.reload(); - } finally { - RenderDevice.exitManagedCode(); - } - } - - /** - * @author Sodium - * @reason Redirect to our renderer - */ - @Overwrite - public void loadRenderers() { - if (this.theWorld == null) return; - Blocks.leaves.setGraphicsLevel(this.mc.gameSettings.fancyGraphics); - Blocks.leaves2.setGraphicsLevel(this.mc.gameSettings.fancyGraphics); - this.renderDistanceChunks = this.mc.gameSettings.renderDistanceChunks; - this.worldRenderers = null; - this.sortedWorldRenderers = null; - - this.renderChunksWide = 0; - this.renderChunksTall = 0; - this.renderChunksDeep = 0; - } - - - - - @Inject(method="renderEntities", at=@At(value="INVOKE", target="Lnet/minecraft/client/renderer/RenderHelper;enableStandardItemLighting()V", shift = At.Shift.AFTER)) - public void sodium$renderTileEntities(EntityLivingBase entity, ICamera camera, float partialTicks, CallbackInfo ci) { - this.renderer.renderTileEntities(entity, camera, partialTicks); - } - - @Redirect(method="renderEntities", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/Entity;isInRangeToRender3d(DDD)Z")) - private boolean isInRange(Entity e, double x, double y, double z) { - // TODO: this check is done slightly earlier than Sodium does it, make sure it doesn't cull too much - return e.isInRangeToRender3d(x, y, z) && SodiumWorldRenderer.getInstance().isEntityVisible(e); - } - -} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinRenderManager.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinRenderManager.java deleted file mode 100644 index ddb5e6c5b..000000000 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinRenderManager.java +++ /dev/null @@ -1,37 +0,0 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; - -import com.gtnewhorizons.angelica.dynamiclights.DynamicLights; -import me.jellysquid.mods.sodium.client.gui.options.named.LightingQuality; -import me.jellysquid.mods.sodium.client.model.light.EntityLighter; -import net.minecraft.client.Minecraft; -import net.minecraft.client.renderer.entity.RenderManager; -import net.minecraft.entity.Entity; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.injection.At; -import org.spongepowered.asm.mixin.injection.Redirect; - -@Mixin(RenderManager.class) -public class MixinRenderManager { - - /** - * Sodium: Use Sodium smooth entity light if enabled. - */ - @Redirect(method = "renderEntityStatic", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/Entity;getBrightnessForRender(F)I")) - private int sodium$getBrightnessForRender(Entity self, float partialTicks) { - int lightmap; - if (Minecraft.getMinecraft().gameSettings.ambientOcclusion == LightingQuality.HIGH.getVanilla()) { - lightmap = EntityLighter.getBlendedLight(self, partialTicks); - }else { - lightmap = self.getBrightnessForRender(partialTicks); - } - - if (DynamicLights.isEnabled()){ - int dynamicLightLevel = (int) DynamicLights.get().getDynamicLightLevel((int)self.posX, (int)self.posY, (int)self.posZ); - if (dynamicLightLevel > 0) { - lightmap = DynamicLights.get().getLightmapWithDynamicLight(dynamicLightLevel, lightmap); - } - } - - return lightmap; - } -} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinWorldClient.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinWorldClient.java deleted file mode 100644 index 654b7adf3..000000000 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinWorldClient.java +++ /dev/null @@ -1,29 +0,0 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; - -import me.jellysquid.mods.sodium.client.render.chunk.map.ChunkStatus; -import me.jellysquid.mods.sodium.client.render.chunk.map.ChunkTracker; -import me.jellysquid.mods.sodium.client.render.chunk.map.ChunkTrackerHolder; -import net.minecraft.client.multiplayer.WorldClient; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.injection.At; -import org.spongepowered.asm.mixin.injection.Inject; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; - -@Mixin(WorldClient.class) -public class MixinWorldClient implements ChunkTrackerHolder { - private final ChunkTracker angelica$tracker = new ChunkTracker(); - - @Inject(method = "doPreChunk", at = @At("TAIL")) - private void sodium$loadChunk(int x, int z, boolean load, CallbackInfo ci) { - if(load) { - this.angelica$tracker.onChunkStatusAdded(x, z, ChunkStatus.FLAG_ALL); - } else { - this.angelica$tracker.onChunkStatusRemoved(x, z, ChunkStatus.FLAG_ALL); - } - } - - @Override - public ChunkTracker sodium$getTracker() { - return this.angelica$tracker; - } -} diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinWorldRenderer.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinWorldRenderer.java deleted file mode 100644 index fa5a18453..000000000 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/sodium/MixinWorldRenderer.java +++ /dev/null @@ -1,30 +0,0 @@ -package com.gtnewhorizons.angelica.mixins.early.sodium; - -import net.minecraft.client.renderer.WorldRenderer; -import net.minecraft.entity.EntityLivingBase; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.Overwrite; - -// Let other mixins apply, and then overwrite them -@Mixin(value=WorldRenderer.class, priority = 2000) -public class MixinWorldRenderer { - /** - * @author Sodium - * @reason Redirect to our renderer - */ - @Overwrite - public void updateRenderer(EntityLivingBase e){ - // Do nothing - } - - /** - * @author Sodium - * @reason Redirect to our renderer - */ - @Overwrite - public void updateRendererSort(EntityLivingBase e){ - // Do nothing - } - - -} diff --git a/src/test/java/com/gtnewhorizons/angelica/glsm/recording/RecordingDataStructuresTest.java b/src/test/java/com/gtnewhorizons/angelica/glsm/recording/RecordingDataStructuresTest.java index 3e9e4282b..2447604dd 100644 --- a/src/test/java/com/gtnewhorizons/angelica/glsm/recording/RecordingDataStructuresTest.java +++ b/src/test/java/com/gtnewhorizons/angelica/glsm/recording/RecordingDataStructuresTest.java @@ -41,20 +41,6 @@ class RecordingDataStructuresTest { assertEquals(GL11.GL_QUADS, cmd.primitiveType()); } - @Test - void testRecordedGeometryCreation() { - ByteBuffer buffer = ByteBuffer.allocate(16); - DrawCommand cmd1 = new DrawCommand(0, 4, GL11.GL_QUADS); - DrawCommand cmd2 = new DrawCommand(4, 3, GL11.GL_TRIANGLES); - List commands = Arrays.asList(cmd1, cmd2); - - RecordedGeometry geom = new RecordedGeometry(buffer, null, commands, 7); - assertEquals(buffer, geom.buffer()); - assertEquals(commands, geom.drawCommands()); - assertEquals(7, geom.totalVertexCount()); - assertEquals(16, geom.getByteSize()); - } - @Test void testCompiledDisplayListCreation() { // Create a display list with PushMatrix, Scale, PopMatrix