Make shader based clouds work with iris shaderpacks, and port optimizations from #1685 (#1793)

* Make shader based clouds work with iris shaderpacks, and port optimizations from #1685

Co-Authored-By: Eclipse-Sol <[email protected]>

* Yeet GL_QUADS

* Optimize a little more

---------

Co-authored-by: Eclipse-Sol <[email protected]>
Co-authored-by: Logan Phillips <[email protected]>
This commit is contained in:
authored and GitHub committed 2026-05-28 10:31:17 -04:00
1 parent 5dc4f1fab8
commit dcc8d8deed
19 files changed
+1008 -357

No files matched your search

@@ -26,6 +26,7 @@ public class IrisGLSMBridge {
private static Runnable fogStartListener = null;
private static Runnable fogEndListener = null;
private static Runnable fogDensityListener = null;
private static Runnable colorModulatorListener = null;
static {
StateUpdateNotifiers.alphaFuncNotifier = listener -> alphaFuncListener = listener;
@@ -35,6 +36,7 @@ public class IrisGLSMBridge {
StateUpdateNotifiers.fogStartNotifier = listener -> fogStartListener = listener;
StateUpdateNotifiers.fogEndNotifier = listener -> fogEndListener = listener;
StateUpdateNotifiers.fogDensityNotifier = listener -> fogDensityListener = listener;
StateUpdateNotifiers.colorModulatorNotifier = listener -> colorModulatorListener = listener;
}
public static void register() {
@@ -108,6 +110,10 @@ public class IrisGLSMBridge {
}
});
GLSMHooks.SHADER_COLOR_CHANGE.addListener(event -> {
if (Iris.enabled && colorModulatorListener != null) colorModulatorListener.run();
});
GLSMHooks.FOG_STATE_CHANGE.addListener(event -> {
if (Iris.enabled) {
if (fogModeListener != null) fogModeListener.run();
@@ -157,17 +163,17 @@ public class IrisGLSMBridge {
GLSMHooks.PROGRAM_CHANGE.addListener(event -> {
if (!Iris.enabled) return;
if (event.postBind) return;
final WorldRenderingPipeline pipeline = Iris.getPipelineManager().getPipelineNullable();
if (!(pipeline instanceof DeferredWorldRenderingPipeline drp)) return;
if (!drp.shouldOverrideShaders()) return;
if (drp.getActivePassProgramId() == -1) return;
if (DepthColorStorage.isOwnedProgram(event.newProgram)) {
DepthColorStorage.unlockDepthColor();
}
});
GLSMHooks.PROGRAM_CHANGE.addListener(event -> {
if (!Iris.enabled) return;
if (!event.postBind) return;
@@ -0,0 +1,75 @@
package com.gtnewhorizons.angelica.render;
import java.nio.ByteBuffer;
final class CloudEdges {
private static final int CELL_EMPTY_THRESHOLD = 10;
final int width, height;
private final int wMask, hMask;
private final boolean whPow2;
private final long[] opaqueBits;
final int opaqueCount;
CloudEdges(int width, int height, ByteBuffer rgba) {
this.width = width;
this.height = height;
this.wMask = width - 1;
this.hMask = height - 1;
this.whPow2 = (width & wMask) == 0 && (height & hMask) == 0;
final int total = width * height;
final long[] bits = new long[(total + 63) >>> 6];
int op = 0;
for (int i = 0; i < total; i++) {
if ((rgba.get(i * 4 + 3) & 0xFF) >= CELL_EMPTY_THRESHOLD) {
bits[i >>> 6] |= 1L << (i & 63);
op++;
}
}
this.opaqueBits = bits;
this.opaqueCount = op;
}
boolean cellOpaque(int x, int z) {
final int xw, zh;
if (whPow2) {
xw = x & wMask;
zh = z & hMask;
} else {
xw = Math.floorMod(x, width);
zh = Math.floorMod(z, height);
}
final int idx = xw + zh * width;
return ((opaqueBits[idx >>> 6] >>> (idx & 63)) & 1L) != 0L;
}
long readOpaqueRowBits(int x0, int z) {
final int zMod, x0Mod;
if (whPow2) {
zMod = z & hMask;
x0Mod = x0 & wMask;
} else {
zMod = Math.floorMod(z, height);
x0Mod = Math.floorMod(x0, width);
}
if (x0Mod + 10 <= width) {
return readContigBits(opaqueBits, (long) zMod * width + x0Mod, 10);
}
final int colsBeforeWrap = width - x0Mod;
final long firstPart = readContigBits(opaqueBits, (long) zMod * width + x0Mod, colsBeforeWrap);
final long secondPart = readContigBits(opaqueBits, (long) zMod * width, 10 - colsBeforeWrap);
return firstPart | (secondPart << colsBeforeWrap);
}
private static long readContigBits(long[] bits, long startBitIdx, int count) {
final int wordIdx = (int) (startBitIdx >>> 6);
final int bitOff = (int) (startBitIdx & 63);
final long mask = count == 64 ? -1L : (1L << count) - 1L;
final long w0 = bits[wordIdx];
if (bitOff + count <= 64) {
return (w0 >>> bitOff) & mask;
}
final long w1 = bits[wordIdx + 1];
return ((w0 >>> bitOff) | (w1 << (64 - bitOff))) & mask;
}
}
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,78 @@
package com.gtnewhorizons.angelica.render;
import org.embeddedt.embeddium.impl.gl.shader.ShaderBindingContext;
import org.embeddedt.embeddium.impl.gl.shader.uniform.GlUniformFloat4v;
import org.embeddedt.embeddium.impl.gl.shader.uniform.GlUniformInt;
import org.embeddedt.embeddium.impl.gl.shader.uniform.GlUniformMatrix4f;
final class CloudUniforms {
static final float ALPHA = 0.8f;
final GlUniformMatrix4f mvp;
final GlUniformFloat4v colorMult;
final GlUniformFloat4v fogParams;
final GlUniformFloat4v fogColor;
final GlUniformInt fogEnabled;
final GlUniformInt tex;
private int lastFogEnabled = -1;
private float lastFogR = Float.NaN, lastFogG = Float.NaN, lastFogB = Float.NaN;
private float lastColorR = Float.NaN, lastColorG = Float.NaN, lastColorB = Float.NaN;
private float lastFogParamX = Float.NaN, lastFogParamY = Float.NaN;
private final float[] uploadBuf = new float[4];
CloudUniforms(ShaderBindingContext ctx) {
mvp = ctx.bindUniform("u_MVPMatrix", GlUniformMatrix4f::new);
colorMult = ctx.bindUniform("u_ColorMult", GlUniformFloat4v::new);
fogParams = ctx.bindUniform("u_FogParams", GlUniformFloat4v::new);
fogColor = ctx.bindUniform("u_FogColor", GlUniformFloat4v::new);
fogEnabled = ctx.bindUniform("u_FogEnabled", GlUniformInt::new);
tex = ctx.bindUniform("u_Tex", GlUniformInt::new);
}
void setFogEnabled(boolean enabled) {
final int val = enabled ? 1 : 0;
if (val != lastFogEnabled) {
lastFogEnabled = val;
fogEnabled.setInt(val);
}
}
void setFogColor(float r, float g, float b) {
if (r != lastFogR || g != lastFogG || b != lastFogB) {
lastFogR = r;
lastFogG = g;
lastFogB = b;
uploadBuf[0] = r;
uploadBuf[1] = g;
uploadBuf[2] = b;
uploadBuf[3] = 1.0f;
fogColor.set(uploadBuf);
}
}
void setFogParams(float x, float y) {
if (x != lastFogParamX || y != lastFogParamY) {
lastFogParamX = x;
lastFogParamY = y;
uploadBuf[0] = x;
uploadBuf[1] = y;
uploadBuf[2] = 0f;
uploadBuf[3] = 0f;
fogParams.set(uploadBuf);
}
}
void setColorMult(float r, float g, float b) {
if (r != lastColorR || g != lastColorG || b != lastColorB) {
lastColorR = r;
lastColorG = g;
lastColorB = b;
uploadBuf[0] = r;
uploadBuf[1] = g;
uploadBuf[2] = b;
uploadBuf[3] = ALPHA;
colorMult.set(uploadBuf);
}
}
}
@@ -11,6 +11,7 @@ public class StateUpdateNotifiers {
public static ValueUpdateNotifier alphaFuncNotifier;
public static ValueUpdateNotifier alphaTestNotifier;
public static ValueUpdateNotifier blendFuncNotifier;
public static ValueUpdateNotifier colorModulatorNotifier;
public static ValueUpdateNotifier bindTextureNotifier;
public static ValueUpdateNotifier normalTextureChangeNotifier;
public static ValueUpdateNotifier specularTextureChangeNotifier;
@@ -34,7 +34,7 @@ class AttributeTransformer {
transformer.injectVariable("layout(location = 4) in vec3 iris_Normal;");
transformer.rename("gl_Vertex", "iris_Vertex");
transformer.rename("gl_Color", "iris_Color");
transformer.replaceExpression("gl_Color", "(iris_Color * iris_ColorModulator)");
transformer.rename("gl_Normal", "iris_Normal");
// ftransform() = gl_ModelViewProjectionMatrix * gl_Vertex
@@ -34,6 +34,7 @@ class CeleritasTransformer {
transformer.injectFunction(
"void _celeritas_init() { " +
"_vert_init(); " +
"_vert_color = _vert_color * iris_ColorModulator; " +
"iris_LightTexCoord = vec4(vec2(_vert_tex_light_coord), 0.0, 1.0); }");
transformer.prependMain("_celeritas_init();");
transformShared(transformer, parameters);
@@ -20,9 +20,10 @@ public class CommonTransformer {
}
if (parameters.type == ShaderType.VERTEX) {
root.injectVariable("uniform vec4 iris_ColorModulator;");
root.injectVariable("out vec4 iris_FrontColor;");
root.rename("gl_FrontColor", "iris_FrontColor");
root.prependMain("iris_FrontColor = vec4(1.0);");
root.prependMain("iris_FrontColor = iris_ColorModulator;");
} else if (parameters.type == ShaderType.FRAGMENT) {
root.injectVariable("in vec4 iris_FrontColor;");
root.rename("gl_Color", "iris_FrontColor");
@@ -94,7 +94,7 @@ public class DHGenericTransformer {
+ " float skyLight = (float(uSkyLight) + 0.5) / 16.0;"
+ " _vert_tex_light_coord = vec2(blockLight, skyLight);"
+ " dhMaterialId = aMaterial;"
+ " _vert_color = iris_color;"
+ " _vert_color = iris_color * iris_ColorModulator;"
+ " }"
);
transformer.prependMain("_vert_init();");
@@ -86,7 +86,7 @@ public class DHTerrainTransformer {
+ " _vert_normal = irisNormals[int(irisExtra.y)];"
+ " dhMaterialId = int(irisExtra.x);"
+ " _vert_tex_light_coord = vec2((float(lights / 16u) + 0.5) / 16.0, (mod(float(lights), 16.0) + 0.5) / 16.0);"
+ " _vert_color = iris_color;"
+ " _vert_color = iris_color * iris_ColorModulator;"
+ " }"
);
transformer.prependMain("_vert_init();");
@@ -23,7 +23,7 @@ public enum ProgramId {
TexturedLit(ProgramGroup.Gbuffers, "textured_lit", Textured),
SkyBasic(ProgramGroup.Gbuffers, "skybasic", Basic),
SkyTextured(ProgramGroup.Gbuffers, "skytextured", Textured),
Clouds(ProgramGroup.Gbuffers, "clouds", Textured),
Clouds(ProgramGroup.Gbuffers, "clouds", Textured, null, new AlphaTestOverride(new AlphaTest(AlphaTestFunction.GREATER, 0.1F))),
Terrain(ProgramGroup.Gbuffers, "terrain", TexturedLit),
TerrainSolid(ProgramGroup.Gbuffers, "terrain_solid", Terrain),
@@ -2,6 +2,7 @@ package net.coderbot.iris.uniforms;
import com.gtnewhorizons.angelica.compat.mojang.Camera;
import com.gtnewhorizons.angelica.compat.mojang.GameModeUtil;
import com.gtnewhorizons.angelica.render.CloudRenderer;
import net.coderbot.iris.gl.uniform.UniformHolder;
import net.coderbot.iris.gl.uniform.UniformUpdateFrequency;
import net.minecraft.client.Minecraft;
@@ -40,6 +41,16 @@ public class IrisExclusiveUniforms {
uniforms.uniform3d(UniformUpdateFrequency.PER_FRAME, "eyePosition", IrisExclusiveUniforms::getEyePosition);
uniforms.uniform3d(UniformUpdateFrequency.PER_FRAME, "relativeEyePosition", IrisExclusiveUniforms::getRelativeEyePosition);
uniforms.uniform4f(UniformUpdateFrequency.PER_TICK, "lightningBoltPosition", IrisExclusiveUniforms::getLightningBoltPosition);
uniforms.uniform1f(UniformUpdateFrequency.PER_FRAME, "cloudTime", IrisExclusiveUniforms::getCloudTime);
}
private static float getCloudTime() {
final WorldClient level = Minecraft.getMinecraft().theWorld;
if (level == null) return 0f;
final long cycle = (long) CloudRenderer.getCloudTextureWidth() * 400L * CloudRenderer.getScaleMult();
final long t = level.getTotalWorldTime() % cycle;
final float partial = Minecraft.getMinecraft().timer.renderPartialTicks;
return (t + partial) * 0.03F;
}
private static float getThunderStrength() {
@@ -12,10 +12,19 @@ import static net.coderbot.iris.gl.uniform.UniformUpdateFrequency.PER_FRAME;
public class IrisInternalUniforms {
private static final Vector4f FOG_COLOR = new Vector4f();
private static final Vector4f COLOR_MODULATOR = new Vector4f(1f, 1f, 1f, 1f);
private IrisInternalUniforms() {
}
private static Vector4f getColorModulator() {
return COLOR_MODULATOR.set(
GLStateManager.getShaderColorR(),
GLStateManager.getShaderColorG(),
GLStateManager.getShaderColorB(),
GLStateManager.getShaderColorA());
}
private static float getEffectiveAlphaRef() {
if (!GLStateManager.getAlphaTest().isEnabled() || GLStateManager.getAlphaState().getFunction() == GL11.GL_ALWAYS) {
return -1.0f;
@@ -44,5 +53,7 @@ public class IrisInternalUniforms {
.uniform1f("iris_currentAlphaTest", IrisInternalUniforms::getEffectiveAlphaRef, StateUpdateNotifiers.alphaTestNotifier)
.uniform1f("alphaTestRef", IrisInternalUniforms::getEffectiveAlphaRef, StateUpdateNotifiers.alphaTestNotifier)
.uniform1i("iris_currentAlphaFunc", IrisInternalUniforms::getEffectiveAlphaFunc, StateUpdateNotifiers.alphaFuncNotifier);
uniforms.uniform4f("iris_ColorModulator", IrisInternalUniforms::getColorModulator, StateUpdateNotifiers.colorModulatorNotifier);
}
}