From fdb470b5b388a6f225a0edff1bb0b7968b0aa641 Mon Sep 17 00:00:00 2001 From: coolGi Date: Wed, 19 Jul 2023 22:19:01 +0930 Subject: [PATCH 1/2] Save commit for fog fix --- .../core/render/renderer/LodRenderer.java | 10 +- .../shaders/AbstractShaderRenderer.java | 10 +- .../render/renderer/shaders/DarkShader.java | 11 + .../render/renderer/shaders/FogShader.java | 92 ++++++++ .../render/renderer/shaders/SSAORenderer.java | 196 ++++++++++++++++++ .../render/renderer/shaders/SSAOShader.java | 4 +- core/src/main/resources/shaders/fog/fog.frag | 47 +++-- .../main/resources/shaders/noise/noise.frag | 14 +- .../shaders/{ssao/ao.vert => normal.vert} | 2 + core/src/main/resources/shaders/ssao/ao.frag | 5 + .../resources/shaders/ssao/apply-frag.frag | 2 +- .../src/main/resources/shaders/test/dark.frag | 9 + 12 files changed, 378 insertions(+), 24 deletions(-) create mode 100644 core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/DarkShader.java create mode 100644 core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/FogShader.java create mode 100644 core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/SSAORenderer.java rename core/src/main/resources/shaders/{ssao/ao.vert => normal.vert} (67%) create mode 100644 core/src/main/resources/shaders/test/dark.frag diff --git a/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/LodRenderer.java b/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/LodRenderer.java index 92cf2fb42..45262125a 100644 --- a/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/LodRenderer.java +++ b/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/LodRenderer.java @@ -30,6 +30,9 @@ import com.seibel.distanthorizons.core.render.glObject.GLProxy; import com.seibel.distanthorizons.core.render.glObject.GLState; import com.seibel.distanthorizons.core.render.glObject.buffer.GLVertexBuffer; import com.seibel.distanthorizons.core.render.glObject.buffer.QuadElementBuffer; +import com.seibel.distanthorizons.core.render.renderer.shaders.DarkShader; +import com.seibel.distanthorizons.core.render.renderer.shaders.FogShader; +import com.seibel.distanthorizons.core.render.renderer.shaders.SSAORenderer; import com.seibel.distanthorizons.core.render.renderer.shaders.SSAOShader; import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.util.RenderUtil; @@ -244,7 +247,12 @@ public class LodRenderer bufferHandler.renderOpaque(this); if (Config.Client.Advanced.Graphics.Quality.ssao.get()) { - SSAOShader.INSTANCE.render(partialTicks); +// SSAOShader.INSTANCE.render(partialTicks); + SSAORenderer.INSTANCE.render(partialTicks); + } + { +// FogShader.INSTANCE.render(partialTicks); +// DarkShader.INSTANCE.render(partialTicks); } //======================// diff --git a/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/AbstractShaderRenderer.java b/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/AbstractShaderRenderer.java index 623841f3e..43b6a1704 100644 --- a/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/AbstractShaderRenderer.java +++ b/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/AbstractShaderRenderer.java @@ -6,6 +6,7 @@ import com.seibel.distanthorizons.core.render.glObject.GLState; import com.seibel.distanthorizons.core.render.glObject.buffer.GLVertexBuffer; import com.seibel.distanthorizons.core.render.glObject.shader.ShaderProgram; import com.seibel.distanthorizons.core.render.glObject.vertexAttribute.VertexAttribute; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import org.lwjgl.opengl.GL11; import org.lwjgl.opengl.GL32; @@ -14,6 +15,7 @@ import java.nio.ByteBuffer; import java.nio.ByteOrder; public abstract class AbstractShaderRenderer { + protected static final IMinecraftClientWrapper MC = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class); protected static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); private static final float[] box_vertices = { @@ -106,7 +108,7 @@ public abstract class AbstractShaderRenderer { this.setApplyShaderUniforms(partialTicks); } GL32.glEnable(GL11.GL_BLEND); - GL32.glBlendFunc(GL32.GL_ZERO, GL32.GL_SRC_ALPHA); + GL32.glBlendFunc(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA); GL32.glBindFramebuffer(GL32.GL_FRAMEBUFFER, MC_RENDER.getTargetFrameBuffer()); GL32.glActiveTexture(GL32.GL_TEXTURE0); GL32.glBindTexture(GL32.GL_TEXTURE_2D, shaderTexture); @@ -149,4 +151,10 @@ public abstract class AbstractShaderRenderer { boxBuffer.bind(); boxBuffer.uploadBuffer(buffer, box_vertices.length, EGpuUploadMethod.DATA, box_vertices.length * Float.BYTES); } + + public void free() { + this.shader.free(); + if (this.applyShader != null) + this.applyShader.free(); + } } diff --git a/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/DarkShader.java b/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/DarkShader.java new file mode 100644 index 000000000..f9d825b8e --- /dev/null +++ b/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/DarkShader.java @@ -0,0 +1,11 @@ +package com.seibel.distanthorizons.core.render.renderer.shaders; + +import com.seibel.distanthorizons.core.render.glObject.shader.ShaderProgram; + +public class DarkShader extends AbstractShaderRenderer { + public static DarkShader INSTANCE = new DarkShader(); + + protected DarkShader() { + super(new ShaderProgram("shaders/normal.vert", "shaders/test/dark.frag", "fragColor", new String[] { "vPosition", "color" })); + } +} diff --git a/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/FogShader.java b/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/FogShader.java new file mode 100644 index 000000000..4f978a080 --- /dev/null +++ b/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/FogShader.java @@ -0,0 +1,92 @@ +package com.seibel.distanthorizons.core.render.renderer.shaders; + +import com.seibel.distanthorizons.api.enums.rendering.EFogColorMode; +import com.seibel.distanthorizons.core.config.Config; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.render.fog.LodFogConfig; +import com.seibel.distanthorizons.core.render.glObject.shader.Shader; +import com.seibel.distanthorizons.core.render.glObject.shader.ShaderProgram; +import com.seibel.distanthorizons.core.util.LodUtil; +import com.seibel.distanthorizons.core.util.RenderUtil; +import com.seibel.distanthorizons.core.wrapperInterfaces.IVersionConstants; +import com.seibel.distanthorizons.coreapi.util.math.Mat4f; +import org.lwjgl.opengl.GL32; + +import java.awt.*; + +public class FogShader extends AbstractShaderRenderer { + public static FogShader INSTANCE = new FogShader(LodFogConfig.generateFogConfig()); + private static final IVersionConstants VERSION_CONSTANTS = SingletonInjector.INSTANCE.get(IVersionConstants.class); + + // Fog Uniforms + public final int fogColorUniform; + public final int fogScaleUniform; + public final int fogVerticalScaleUniform; + public final int nearFogStartUniform; + public final int nearFogLengthUniform;; + public final int fullFogModeUniform; + + public FogShader(LodFogConfig fogConfig) { + // TODO & Note: This code is a bit jank, so try to update it later (preferably not using something to process the shader) + super(new ShaderProgram( + () -> Shader.loadFile("shaders/normal.vert", false, new StringBuilder()).toString(), + () -> fogConfig.loadAndProcessFragShader("shaders/fog/fog.frag", false).toString(), + "fragColor", new String[] { "vPos", "vPosition", "color" } + )); + + // Fog uniforms + fogColorUniform = this.shader.getUniformLocation("fogColor"); + fullFogModeUniform = this.shader.getUniformLocation("fullFogMode"); + fogScaleUniform = this.shader.tryGetUniformLocation("fogScale"); + fogVerticalScaleUniform = this.shader.tryGetUniformLocation("fogVerticalScale"); + // near + nearFogStartUniform = this.shader.tryGetUniformLocation("nearFogStart"); + nearFogLengthUniform = this.shader.tryGetUniformLocation("nearFogLength"); + } + + + @Override + void setShaderUniforms(float partialTicks) { + int lodDrawDistance = RenderUtil.getFarClipPlaneDistanceInBlocks(); + int vanillaDrawDistance = MC_RENDER.getRenderDistance() * LodUtil.CHUNK_WIDTH; +// super.bind(); + vanillaDrawDistance += 32; // Give it a 2 chunk boundary for near fog. +// // uniforms +// this.shader.setUniform(combinedMatUniform, combinedMatrix); +// this.shader.setUniform(mircoOffsetUniform, 0.01f); // 0.01 block offset +// +// // setUniform(skyLightUniform, skyLight); +// this.shader.setUniform(lightMapUniform, lightmapBindPoint); +// +// if (worldYOffsetUniform != -1) this.shader.setUniform(worldYOffsetUniform, (float)worldYOffset); + + // Fog + this.shader.setUniform(fullFogModeUniform, MC_RENDER.isFogStateSpecial() ? 1 : 0); + this.shader.setUniform(fogColorUniform, MC_RENDER.isFogStateSpecial() ? getSpecialFogColor(partialTicks) : getFogColor(partialTicks)); + + float nearFogLen = vanillaDrawDistance * 0.2f / lodDrawDistance; + float nearFogStart = vanillaDrawDistance * (VERSION_CONSTANTS.isVanillaRenderedChunkSquare() ? (float)Math.sqrt(2.) : 1.f) / lodDrawDistance; + if (nearFogStartUniform != -1) this.shader.setUniform(nearFogStartUniform, nearFogStart); + if (nearFogLengthUniform != -1) this.shader.setUniform(nearFogLengthUniform, nearFogLen); + if (fogScaleUniform != -1) this.shader.setUniform(fogScaleUniform, 1.f/lodDrawDistance); + if (fogVerticalScaleUniform != -1) this.shader.setUniform(fogVerticalScaleUniform, 1.f/MC.getWrappedClientWorld().getHeight()); + } + + + + private Color getFogColor(float partialTicks) + { + Color fogColor; + + if (Config.Client.Advanced.Graphics.Fog.colorMode.get() == EFogColorMode.USE_SKY_COLOR) + fogColor = MC_RENDER.getSkyColor(); + else + fogColor = MC_RENDER.getFogColor(partialTicks); + + return fogColor; + } + private Color getSpecialFogColor(float partialTicks) + { + return MC_RENDER.getSpecialFogColor(partialTicks); + } +} diff --git a/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/SSAORenderer.java b/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/SSAORenderer.java new file mode 100644 index 000000000..8625382a9 --- /dev/null +++ b/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/SSAORenderer.java @@ -0,0 +1,196 @@ +package com.seibel.distanthorizons.core.render.renderer.shaders; + +import com.seibel.distanthorizons.api.enums.config.EGpuUploadMethod; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.render.glObject.GLState; +import com.seibel.distanthorizons.core.render.glObject.buffer.GLVertexBuffer; +import com.seibel.distanthorizons.core.render.glObject.shader.ShaderProgram; +import com.seibel.distanthorizons.core.render.glObject.vertexAttribute.VertexAttribute; +import com.seibel.distanthorizons.core.util.LodUtil; +import com.seibel.distanthorizons.core.util.RenderUtil; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.coreapi.util.math.Mat4f; +import org.lwjgl.opengl.GL11; +import org.lwjgl.opengl.GL32; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; + +// TODO: Move over to SSAOShader +// For some reason this version looks slightly different to that, even tough there isnt much visible change in the code +public class SSAORenderer { + public static SSAORenderer INSTANCE = new SSAORenderer(); + + public SSAORenderer() { + } + + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + + private static final float[] box_vertices = { + -1, -1, + 1, -1, + 1, 1, + -1, -1, + 1, 1, + -1, 1, + }; + + ShaderProgram ssaoShader; + ShaderProgram applyShader; + GLVertexBuffer boxBuffer; + VertexAttribute va; + boolean init = false; + + private static final int MAX_KERNEL_SIZE = 32; + private float[] kernel = new float[MAX_KERNEL_SIZE * 3]; + + public void init() { + if (init) return; + + init = true; + va = VertexAttribute.create(); + va.bind(); + // Pos + va.setVertexAttribute(0, 0, VertexAttribute.VertexPointer.addVec2Pointer(false)); + va.completeAndCheck(Float.BYTES * 2); + ssaoShader = new ShaderProgram("shaders/normal.vert", "shaders/ssao/ao.frag", + "fragColor", new String[]{"vPosition"}); + + applyShader = new ShaderProgram("shaders/normal.vert", "shaders/ssao/apply-frag.frag", + "fragColor", new String[]{"vPosition"}); + + + // Generate kernel + kernel = genKernel(); + // Framebuffer + createBuffer(); + } + + private int width = -1; + private int height = -1; + private int ssaoFramebuffer = -1; + + private int ssaoTexture = -1; + + private void createFramebuffer(int width, int height) { + if (ssaoFramebuffer != -1) { + GL32.glDeleteFramebuffers(ssaoFramebuffer); + ssaoFramebuffer = -1; + } + + if (ssaoTexture != -1) { + GL32.glDeleteTextures(ssaoTexture); + ssaoTexture = -1; + } + + ssaoFramebuffer = GL32.glGenFramebuffers(); + GL32.glBindFramebuffer(GL32.GL_FRAMEBUFFER, ssaoFramebuffer); + + ssaoTexture = GL32.glGenTextures(); + GL32.glBindTexture(GL32.GL_TEXTURE_2D, ssaoTexture); + GL32.glTexImage2D(GL32.GL_TEXTURE_2D, 0, GL32.GL_RED, width, height, 0, GL32.GL_RED, GL32.GL_FLOAT, (ByteBuffer) null); + GL32.glTexParameteri(GL32.GL_TEXTURE_2D, GL32.GL_TEXTURE_MIN_FILTER, GL32.GL_NEAREST); + GL32.glTexParameteri(GL32.GL_TEXTURE_2D, GL32.GL_TEXTURE_MAG_FILTER, GL32.GL_NEAREST); + GL32.glFramebufferTexture2D(GL32.GL_FRAMEBUFFER, GL32.GL_COLOR_ATTACHMENT0, GL32.GL_TEXTURE_2D, ssaoTexture, 0); + } + + private void createBuffer() { + ByteBuffer buffer = ByteBuffer.allocateDirect(box_vertices.length * Float.BYTES); + buffer.order(ByteOrder.nativeOrder()); + buffer.asFloatBuffer().put(box_vertices); + buffer.rewind(); + boxBuffer = new GLVertexBuffer(false); + boxBuffer.bind(); + boxBuffer.uploadBuffer(buffer, box_vertices.length, EGpuUploadMethod.DATA, box_vertices.length * Float.BYTES); + } + + private static float[] genKernel() { + float[] kernel = new float[MAX_KERNEL_SIZE * 3]; + for (int i = 0; i < MAX_KERNEL_SIZE; i++) { + float sampleX = (float) (Math.random() * 2.0 - 1.0); + float sampleY = (float) (Math.random() * 2.0 - 1.0); + float sampleZ = (float) Math.random(); + + + // Normalize + float magnitude = (float) Math.sqrt(Math.pow(sampleX, 2) + Math.pow(sampleY, 2) + Math.pow(sampleZ, 2)); + sampleX /= magnitude; + sampleY /= magnitude; + sampleZ /= magnitude; + + float scale = i / (float) MAX_KERNEL_SIZE; + float interpolatedScale = (float) (0.1 + (scale * scale) * (0.9)); + + sampleX *= interpolatedScale; + sampleY *= interpolatedScale; + sampleZ *= interpolatedScale; + kernel[i * 3] = sampleX; + kernel[i * 3 + 1] = sampleY; + kernel[i * 3 + 2] = sampleZ; + } + return kernel; + } + + public void render(float partialTicks) { + GLState state = new GLState(); + init(); + //GL32.glDepthMask(false); + int width = MC_RENDER.getTargetFrameBufferViewportWidth(); + int height = MC_RENDER.getTargetFrameBufferViewportHeight(); + + if (this.width != width || this.height != height) { + this.width = width; + this.height = height; + createFramebuffer(width, height); + } + + GL32.glBindFramebuffer(GL32.GL_FRAMEBUFFER, ssaoFramebuffer); + GL32.glViewport(0, 0, width, height); + GL32.glDisable(GL32.GL_DEPTH_TEST); + GL32.glDisable(GL32.GL_BLEND); + GL32.glDisable(GL32.GL_SCISSOR_TEST); + + + Mat4f perspective = Mat4f.perspective( + (float) MC_RENDER.getFov(partialTicks), + MC_RENDER.getTargetFrameBufferViewportWidth() / (float) MC_RENDER.getTargetFrameBufferViewportHeight(), + RenderUtil.getNearClipPlaneDistanceInBlocks(partialTicks), + (float) ((RenderUtil.getFarClipPlaneDistanceInBlocks() + LodUtil.REGION_WIDTH) * Math.sqrt(2))); + + ssaoShader.bind(); + ssaoShader.setUniform(ssaoShader.getUniformLocation("gProj"), perspective); + ssaoShader.setUniform(ssaoShader.getUniformLocation("gSampleRad"), 3.0f); + ssaoShader.setUniform(ssaoShader.getUniformLocation("gFactor"), 0.8f); + ssaoShader.setUniform(ssaoShader.getUniformLocation("gPower"), 1.0f); + va.bind(); + va.bindBufferToAllBindingPoint(boxBuffer.getId()); + + GL32.glActiveTexture(GL32.GL_TEXTURE0); + GL32.glBindTexture(GL32.GL_TEXTURE_2D, MC_RENDER.getDepthTextureId()); + + GL32.glUniform3fv(ssaoShader.getUniformLocation("gKernel"), kernel); + GL32.glUniform1i(ssaoShader.getUniformLocation("gDepthMap"), 0); + GL32.glDrawArrays(GL32.GL_TRIANGLES, 0, 6); + + applyShader.bind(); + GL32.glEnable(GL11.GL_BLEND); + GL32.glBlendFunc(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA); + GL32.glBindFramebuffer(GL32.GL_FRAMEBUFFER, MC_RENDER.getTargetFrameBuffer()); + GL32.glActiveTexture(GL32.GL_TEXTURE0); + GL32.glBindTexture(GL32.GL_TEXTURE_2D, ssaoTexture); + GL32.glDrawArrays(GL32.GL_TRIANGLES, 0, 6); + + //GL32.glBindFramebuffer(GL32.GL_READ_FRAMEBUFFER, ssaoFramebuffer); + //GL32.glBindFramebuffer(GL32.GL_DRAW_FRAMEBUFFER, MC_RENDER.getTargetFrameBuffer()); + //GL32.glBlitFramebuffer( + // 0, 0, width, height, + // 0, 0, width, height, + // GL11.GL_COLOR_BUFFER_BIT, + // GL11.GL_NEAREST + //); + + state.restore(); + } + + +} diff --git a/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/SSAOShader.java b/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/SSAOShader.java index 4c3495ee4..db7a18cf6 100644 --- a/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/SSAOShader.java +++ b/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/SSAOShader.java @@ -15,9 +15,9 @@ public class SSAOShader extends AbstractShaderRenderer { public SSAOShader() { super( - new ShaderProgram("shaders/ssao/ao.vert", "shaders/ssao/ao.frag", + new ShaderProgram("shaders/normal.vert", "shaders/ssao/ao.frag", "fragColor", new String[]{"vPos"}), - new ShaderProgram("shaders/ssao/ao.vert", "shaders/ssao/apply-frag.frag", + new ShaderProgram("shaders/normal.vert", "shaders/ssao/apply-frag.frag", "fragColor", new String[]{"vPos"}) ); diff --git a/core/src/main/resources/shaders/fog/fog.frag b/core/src/main/resources/shaders/fog/fog.frag index 5537efda0..90aaf0352 100644 --- a/core/src/main/resources/shaders/fog/fog.frag +++ b/core/src/main/resources/shaders/fog/fog.frag @@ -1,10 +1,7 @@ -#version 150 core - -in vec4 vertexColor; in vec3 vertexWorldPos; in float vertexYPos; -in vec4 vPos; +in vec2 TexCoord; out vec4 fragColor; @@ -30,6 +27,20 @@ float mixFogThickness(float near, float far, float height); // ========================================================= +// Puts steps in a float +// EG. setting stepSize to 4 then this would be the result of this function +// In: 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, ..., 1.1, 1.2, 1.3 +// Out: 0.0, 0.0, 0.0, 0.25, 0.25, 0.5, 0.5, ..., 1.0, 1.0, 1.25 +float quantize(float val, int stepSize) { + return floor(val*stepSize)/stepSize; +} + +// The modulus function dosnt exist in GLSL so I made my own +// To speed up the mod function, this only accepts full numbers for y +float mod(float x, int y) { + return x - y * floor(x/y); +} + /** @@ -39,19 +50,31 @@ float mixFogThickness(float near, float far, float height); * version: 2023-6-21 */ void main() { - float horizontalDist = length(vertexWorldPos.xz) * fogScale; - float heightDist = calculateHeightFogDepth( + if (fullFogMode != 0) { + fragColor = vec4(fogColor.r, fogColor.g, fogColor.b, 1.); + } else { + float horizontalDist = length(vertexWorldPos.xz) * fogScale; + float heightDist = calculateHeightFogDepth( vertexWorldPos.y, vertexYPos) * fogVerticalScale; - float farDist = calculateFarFogDepth(horizontalDist, + float farDist = calculateFarFogDepth(horizontalDist, length(vertexWorldPos.xyz) * fogScale, nearFogStart); - float nearFogThickness = getNearFogThickness(horizontalDist); - float farFogThickness = getFarFogThickness(farDist); - float heightFogThickness = getHeightFogThickness(heightDist); - float mixedFogThickness = clamp(mixFogThickness( + float nearFogThickness = getNearFogThickness(horizontalDist); + float farFogThickness = getFarFogThickness(farDist); + float heightFogThickness = getHeightFogThickness(heightDist); + float mixedFogThickness = clamp(mixFogThickness( nearFogThickness, farFogThickness, heightFogThickness), 0.0, 1.0); - fragColor = mix(vertexColor, vec4(fogColor.rgb, 1.0), mixedFogThickness); + fragColor = vec4(fogColor.r, fogColor.g, fogColor.b, mixedFogThickness); + } + if (fragColor.r != 6969.) { + fragColor = vec4( + mod(vertexWorldPos.x, 1), + mod(vertexWorldPos.y, 1), + mod(vertexWorldPos.z, 1), + 1. + ); + } } diff --git a/core/src/main/resources/shaders/noise/noise.frag b/core/src/main/resources/shaders/noise/noise.frag index d64f051dc..4eeff968c 100644 --- a/core/src/main/resources/shaders/noise/noise.frag +++ b/core/src/main/resources/shaders/noise/noise.frag @@ -81,11 +81,11 @@ void main() { ); // For testing - if (vertexColor.r != 69420.) { - fragColor = vec4( - mod(fixedVPos.x, 1), - mod(fixedVPos.y, 1), - mod(fixedVPos.z, 1), - 1f); - } +// if (vertexColor.r != 69420.) { +// fragColor = vec4( +// mod(fixedVPos.x, 1), +// mod(fixedVPos.y, 1), +// mod(fixedVPos.z, 1), +// 1f); +// } } \ No newline at end of file diff --git a/core/src/main/resources/shaders/ssao/ao.vert b/core/src/main/resources/shaders/normal.vert similarity index 67% rename from core/src/main/resources/shaders/ssao/ao.vert rename to core/src/main/resources/shaders/normal.vert index b65ef2cff..656402aa9 100644 --- a/core/src/main/resources/shaders/ssao/ao.vert +++ b/core/src/main/resources/shaders/normal.vert @@ -1,5 +1,6 @@ #version 150 core +in uvec4 vPosition; // Fixme in vec2 vPos; out vec2 TexCoord; @@ -10,6 +11,7 @@ out float vertexYPos; void main() { + vertexWorldPos = vec3(vPosition.x, vPosition.y, vPosition.z); // Fixme gl_Position = vec4(vPos, 1.0, 1.0); TexCoord = vPos.xy * 0.5 + 0.5; } \ No newline at end of file diff --git a/core/src/main/resources/shaders/ssao/ao.frag b/core/src/main/resources/shaders/ssao/ao.frag index d8d77ccf0..9e3ccf0e8 100644 --- a/core/src/main/resources/shaders/ssao/ao.frag +++ b/core/src/main/resources/shaders/ssao/ao.frag @@ -30,6 +30,11 @@ vec3 calcViewPosition(vec2 coords) { vs_pos.xyz = vs_pos.xyz / vs_pos.w; return vs_pos.xyz; } +// The modulus function dosnt exist in GLSL so I made my own +// To speed up the mod function, this only accepts full numbers for y +float mod(float x, int y) { + return x - y * floor(x/y); +} void main() { diff --git a/core/src/main/resources/shaders/ssao/apply-frag.frag b/core/src/main/resources/shaders/ssao/apply-frag.frag index db95aebd8..7cfa9df34 100644 --- a/core/src/main/resources/shaders/ssao/apply-frag.frag +++ b/core/src/main/resources/shaders/ssao/apply-frag.frag @@ -9,5 +9,5 @@ uniform sampler2D gSSAOMap; void main() { - fragColor = vec4(0.0, 0.0, 0.0, texture(gSSAOMap, TexCoord).r); + fragColor = vec4(0.0, 0.0, 0.0, 1-texture(gSSAOMap, TexCoord).r); } \ No newline at end of file diff --git a/core/src/main/resources/shaders/test/dark.frag b/core/src/main/resources/shaders/test/dark.frag new file mode 100644 index 000000000..ab99d05ce --- /dev/null +++ b/core/src/main/resources/shaders/test/dark.frag @@ -0,0 +1,9 @@ +#version 150 core + +out vec4 fragColor; + +// A test shader that makes everything darker +void main() +{ + fragColor = vec4(0., 0., 1., 0.5); +} \ No newline at end of file From 675682d631ff09157119e6b13be8dfb812b5dc0e Mon Sep 17 00:00:00 2001 From: coolGi Date: Thu, 20 Jul 2023 21:06:07 +0930 Subject: [PATCH 2/2] Another save commit for fog fix --- .../core/render/renderer/LodRenderer.java | 10 +++++-- .../render/renderer/shaders/FogShader.java | 30 ++++++++++++------- .../render/renderer/shaders/SSAORenderer.java | 5 +++- core/src/main/resources/shaders/fog/fog.frag | 26 ++++++++++------ core/src/main/resources/shaders/fog/fog.vert | 19 ++++++++++++ core/src/main/resources/shaders/normal.vert | 6 ---- core/src/main/resources/shaders/ssao/ao.frag | 5 ---- 7 files changed, 67 insertions(+), 34 deletions(-) create mode 100644 core/src/main/resources/shaders/fog/fog.vert diff --git a/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/LodRenderer.java b/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/LodRenderer.java index 45262125a..217318e82 100644 --- a/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/LodRenderer.java +++ b/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/LodRenderer.java @@ -79,7 +79,10 @@ public class LodRenderer public void setupOffset(DhBlockPos pos) { Vec3d cam = MC_RENDER.getCameraExactPosition(); - shaderProgram.setModelPos(new Vec3f((float) (pos.x - cam.x), (float) (pos.y - cam.y), (float) (pos.z - cam.z))); + Vec3f modelPos = new Vec3f((float) (pos.x - cam.x), (float) (pos.y - cam.y), (float) (pos.z - cam.z)); + + shaderProgram.setModelPos(modelPos); +// FogShader.INSTANCE.setModelPos(modelPos); } public void drawVbo(GLVertexBuffer vbo) { @@ -206,6 +209,8 @@ public class LodRenderer if (newConfig != null) { shaderProgram.free(); shaderProgram = new LodRenderProgram(newConfig); +// FogShader.INSTANCE.free(); +// FogShader.INSTANCE = new FogShader(newConfig); } shaderProgram.bind(); } @@ -252,7 +257,7 @@ public class LodRenderer } { // FogShader.INSTANCE.render(partialTicks); -// DarkShader.INSTANCE.render(partialTicks); +// DarkShader.INSTANCE.render(partialTicks); // A test shader to make the world darker } //======================// @@ -356,6 +361,7 @@ public class LodRenderer isSetupComplete = false; EVENT_LOGGER.info("Renderer Cleanup Started"); shaderProgram.free(); +// FogShader.INSTANCE.free(); if (quadIBO != null) quadIBO.destroy(false); EVENT_LOGGER.info("Renderer Cleanup Complete"); } diff --git a/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/FogShader.java b/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/FogShader.java index 4f978a080..87a5805f8 100644 --- a/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/FogShader.java +++ b/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/FogShader.java @@ -10,6 +10,7 @@ import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.wrapperInterfaces.IVersionConstants; import com.seibel.distanthorizons.coreapi.util.math.Mat4f; +import com.seibel.distanthorizons.coreapi.util.math.Vec3f; import org.lwjgl.opengl.GL32; import java.awt.*; @@ -18,6 +19,10 @@ public class FogShader extends AbstractShaderRenderer { public static FogShader INSTANCE = new FogShader(LodFogConfig.generateFogConfig()); private static final IVersionConstants VERSION_CONSTANTS = SingletonInjector.INSTANCE.get(IVersionConstants.class); + +// public final int modelOffsetUniform; + public final int worldYOffsetUniform; + // Fog Uniforms public final int fogColorUniform; public final int fogScaleUniform; @@ -27,13 +32,17 @@ public class FogShader extends AbstractShaderRenderer { public final int fullFogModeUniform; public FogShader(LodFogConfig fogConfig) { - // TODO & Note: This code is a bit jank, so try to update it later (preferably not using something to process the shader) + // TODO & Note: This code is a bit jank, so try to make it better later (preferably not using something to process the shader) + // This code is just a temp fix so that it looks fine for the time being + // and even with the jank soloution, i cannot get it to work super(new ShaderProgram( - () -> Shader.loadFile("shaders/normal.vert", false, new StringBuilder()).toString(), + () -> Shader.loadFile("shaders/fog/fog.vert", false, new StringBuilder()).toString(), () -> fogConfig.loadAndProcessFragShader("shaders/fog/fog.frag", false).toString(), - "fragColor", new String[] { "vPos", "vPosition", "color" } + "fragColor", new String[] { "vPosition", "vPos", "color" } )); +// modelOffsetUniform = this.shader.getUniformLocation("modelOffset"); + worldYOffsetUniform = this.shader.getUniformLocation("worldYOffset"); // Fog uniforms fogColorUniform = this.shader.getUniformLocation("fogColor"); fullFogModeUniform = this.shader.getUniformLocation("fullFogMode"); @@ -51,14 +60,9 @@ public class FogShader extends AbstractShaderRenderer { int vanillaDrawDistance = MC_RENDER.getRenderDistance() * LodUtil.CHUNK_WIDTH; // super.bind(); vanillaDrawDistance += 32; // Give it a 2 chunk boundary for near fog. -// // uniforms -// this.shader.setUniform(combinedMatUniform, combinedMatrix); -// this.shader.setUniform(mircoOffsetUniform, 0.01f); // 0.01 block offset -// -// // setUniform(skyLightUniform, skyLight); -// this.shader.setUniform(lightMapUniform, lightmapBindPoint); -// -// if (worldYOffsetUniform != -1) this.shader.setUniform(worldYOffsetUniform, (float)worldYOffset); + + + this.shader.setUniform(worldYOffsetUniform, (float) MC.getWrappedClientWorld().getMinHeight()); // Fog this.shader.setUniform(fullFogModeUniform, MC_RENDER.isFogStateSpecial() ? 1 : 0); @@ -89,4 +93,8 @@ public class FogShader extends AbstractShaderRenderer { { return MC_RENDER.getSpecialFogColor(partialTicks); } + + public void setModelPos(Vec3f modelPos) { +// this.shader.setUniform(modelOffsetUniform, modelPos); + } } diff --git a/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/SSAORenderer.java b/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/SSAORenderer.java index 8625382a9..9e7bb8682 100644 --- a/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/SSAORenderer.java +++ b/core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/SSAORenderer.java @@ -192,5 +192,8 @@ public class SSAORenderer { state.restore(); } - + public void free() { + ssaoShader.free(); + applyShader.free(); + } } diff --git a/core/src/main/resources/shaders/fog/fog.frag b/core/src/main/resources/shaders/fog/fog.frag index 90aaf0352..d4a5a4653 100644 --- a/core/src/main/resources/shaders/fog/fog.frag +++ b/core/src/main/resources/shaders/fog/fog.frag @@ -1,7 +1,7 @@ in vec3 vertexWorldPos; in float vertexYPos; -in vec2 TexCoord; +//in vec2 TexCoord; out vec4 fragColor; @@ -67,14 +67,22 @@ void main() { fragColor = vec4(fogColor.r, fogColor.g, fogColor.b, mixedFogThickness); } - if (fragColor.r != 6969.) { - fragColor = vec4( - mod(vertexWorldPos.x, 1), - mod(vertexWorldPos.y, 1), - mod(vertexWorldPos.z, 1), - 1. - ); - } + + // Testing +// if (fragColor.r != 6969.) { // This line is so that the compiler doesnt delete the previos code +//// fragColor = vec4( +//// mod(vertexWorldPos.x, 1), +//// mod(vertexWorldPos.y, 1), +//// mod(vertexWorldPos.z, 1), +//// 1. +//// ); +// fragColor = vec4( +// mod(vertexYPos, 1), +// mod(vertexYPos, 1), +// mod(vertexYPos, 1), +// 1. +// ); +// } } diff --git a/core/src/main/resources/shaders/fog/fog.vert b/core/src/main/resources/shaders/fog/fog.vert new file mode 100644 index 000000000..463249402 --- /dev/null +++ b/core/src/main/resources/shaders/fog/fog.vert @@ -0,0 +1,19 @@ +#version 150 core + + +//uniform vec3 modelOffset; +uniform float worldYOffset; + +in vec2 vPos; +in uvec4 vPosition; +out vec3 vertexWorldPos; +out float vertexYPos; + + +void main() +{ +// vertexWorldPos = vPosition.xyz + modelOffset; + vertexYPos = vPosition.y + worldYOffset; + + gl_Position = vec4(vPos, 1.0, 1.0); +} \ No newline at end of file diff --git a/core/src/main/resources/shaders/normal.vert b/core/src/main/resources/shaders/normal.vert index 656402aa9..1485baf0e 100644 --- a/core/src/main/resources/shaders/normal.vert +++ b/core/src/main/resources/shaders/normal.vert @@ -1,17 +1,11 @@ #version 150 core -in uvec4 vPosition; // Fixme in vec2 vPos; out vec2 TexCoord; -out vec4 vertexColor; -out vec3 vertexWorldPos; -out float vertexYPos; - void main() { - vertexWorldPos = vec3(vPosition.x, vPosition.y, vPosition.z); // Fixme gl_Position = vec4(vPos, 1.0, 1.0); TexCoord = vPos.xy * 0.5 + 0.5; } \ No newline at end of file diff --git a/core/src/main/resources/shaders/ssao/ao.frag b/core/src/main/resources/shaders/ssao/ao.frag index 9e3ccf0e8..d8d77ccf0 100644 --- a/core/src/main/resources/shaders/ssao/ao.frag +++ b/core/src/main/resources/shaders/ssao/ao.frag @@ -30,11 +30,6 @@ vec3 calcViewPosition(vec2 coords) { vs_pos.xyz = vs_pos.xyz / vs_pos.w; return vs_pos.xyz; } -// The modulus function dosnt exist in GLSL so I made my own -// To speed up the mod function, this only accepts full numbers for y -float mod(float x, int y) { - return x - y * floor(x/y); -} void main() {