debug log: (2/2)

        waterColor = mix(waterColor, skyColor, blocklight.a * (1-fresnel));
    
    
        vec3 lightTint = max(blocklight.rgb, blocklight.a * skyAmbientColor);
        float alpha = mix(texColor.a*2.0, texColor.a*0.5, fresnel);
        
        if(alpha == 0)
        {
            discard;
        }
    
        outColor = vec4(waterColor * lightTint, alpha);
        outColor.rgb = mix(outColor.rgb, skyColor, blocklight.a * (1-fresnel));
        outColor *= tintColor;
        outColor.rgb = max(outColor.rgb, texColor.rgb * worldAmbientColor);
    }
    #endif //chunk_water_frag_glsl
    
* SkyStarShader: sky-star.vert.glsl, sky-star.frag.glsl
    VERTEX: #version 150
    #ifndef sky_star_vert_glsl
    #define sky_star_vert_glsl
    
    in vec3 a_position;
    
    uniform mat4 u_projViewTrans;
    
    void main() 
    {
        gl_Position = u_projViewTrans * vec4(a_position, 1.0);
        
    }
    #endif //sky_star_vert_glsl
    
    FRAG: #version 150
    #ifndef sky_star_frag_glsl
    #define sky_star_frag_glsl
    #ifdef GL_ES 
    precision mediump float;
    #endif
    
    out vec4 outColor;
    
    void main() 
    {
        outColor = vec4(1);
    }
    #endif //sky_star_frag_glsl
    
* SkyShader: sky.vert.glsl, sky.frag.glsl
    VERTEX: #version 150
    #ifndef sky_vert_glsl
    #define sky_vert_glsl
    
    in vec3 a_position;
    in vec3 a_normal;
    
    uniform mat4 u_projViewTrans;
    uniform vec3 cameraPosition;
    
    out vec3 v_position;
    out vec3 v_position_adjusted;
    out vec3 v_normal;
    
    void main() 
    {
        v_normal = a_normal;
        vec3 p = a_position;// - vec3(0, min(cameraPosition.y, 20), 0);
        gl_Position = u_projViewTrans * vec4(p, 1.0);
        v_position = p;
        v_position_adjusted = p;// + vec3(0, cameraPosition.y - 32, 0);
    }
    #endif //sky_vert_glsl
    
    FRAG: #version 150
    #ifndef sky_frag_glsl
    #define sky_frag_glsl
    #ifdef GL_ES 
    precision mediump float;
    #endif
    
    in vec3 v_position;
    in vec3 v_position_adjusted;
    in vec3 v_normal;
    out vec4 outColor;
    uniform vec3 u_sunDirection;
    uniform vec3 cameraPosition;
    
    void main() 
    {
        vec3 pos_normal = normalize(v_position);
        vec3 pos_adj_normal = normalize(v_position);
        float sunRadius = 0.005;
        float sun_dot = dot(u_sunDirection, pos_normal);
        float noon_dot = dot(u_sunDirection, vec3(0, 1, 0));
        float sunFactor = (sun_dot - (1 - sunRadius)) / sunRadius;
        float horizonFactor = 1-abs(pos_adj_normal.y);
        
        vec3 upperColor = vec3(0.1, 0.4, 0.7);
        float upperHalfFactor = sqrt(max(0, dot(vec3(0,1,0), pos_adj_normal)));
        float upperColorFactor = upperHalfFactor * clamp(1 - (pow(1 - noon_dot, 3)), 0, 1);
        vec3 lowerColor = vec3(0.2, 0.4, 0.7) * 3;
        float lowerColorFactor = (1 - max(0, upperHalfFactor)) * max(0, (noon_dot +0.75)/1.75);
        vec3 skyColor = (upperColor * upperColorFactor) + (lowerColor * lowerColorFactor);
    
        float sunsetOrSunRiseFactor = pow(1-abs(noon_dot), 2);
        vec3 redHorizonColor = vec3(3, 0, 0) * pow(horizonFactor,4) * sunsetOrSunRiseFactor;
        skyColor = max(skyColor, redHorizonColor);
    
        vec3 crossDir = cross(u_sunDirection, vec3(0,1,0));
        float sunHorizonFlareFactor = pow(1 - pow(dot(cross(u_sunDirection, crossDir), pos_normal), 2), 8) * pow(1 - abs(noon_dot), 4) * sun_dot;// * max(0, (noon_dot+0.25)/1.25);
        vec3 sunFlareHorizonColor = vec3(1,1,0) * sunHorizonFlareFactor;
        skyColor = max(skyColor, sunFlareHorizonColor);
    
    
        vec3 sunColor = vec3(1, 0.9, 0.6) * sunFactor;
    
        skyColor = max(skyColor, sunColor);
    
        float alpha = max(0.1, max(min(length(skyColor), (sun_dot+2)/3), min(1, round(sunFactor*2)))) + max(0, noon_dot);
        alpha = max(0, min(alpha, 1));
       
        outColor = vec4(skyColor / alpha, alpha);
    }
    #endif //sky_frag_glsl
    
* EntityShader: entity.vert.glsl, entity.frag.glsl
    VERTEX: #version 150
    #ifndef entity_vert_glsl
    #define entity_vert_glsl
    
    in vec3 a_position;
    in vec2 a_texCoord0;
    
    out vec2 v_texCoord0;
    
    uniform mat4 u_projViewTrans;
    uniform mat4 u_modelMat;
    
    void main() 
    {
        v_texCoord0 = a_texCoord0;
        gl_Position = u_projViewTrans * u_modelMat * vec4(a_position, 1.0);    
    }
    #endif //entity_vert_glsl
    
    FRAG: #version 150
    #ifndef entity_frag_glsl
    #define entity_frag_glsl
    #ifdef GL_ES 
    precision mediump float;
    #endif
    
    in vec2 v_texCoord0;
    
    uniform sampler2D texDiffuse;
    uniform vec4 tintColor;
    
    out vec4 outColor;
    
    void main() 
    {
        vec4 texColor = texture(texDiffuse, v_texCoord0);
    
        if(texColor.a == 0)
        {
            discard;
        }
    
        outColor = texColor * tintColor;
    }
    #endif //entity_frag_glsl
    
* SpriteBatchShader: death-screen.vert.glsl, death-screen.frag.glsl
    VERTEX: #version 150
    #ifndef death_screen_vert_glsl
    #define death_screen_vert_glsl
    
    in vec4 a_position;
    in vec4 a_color;
    in vec2 a_texCoord0;
    
    uniform mat4 u_projTrans;
    
    out vec4 v_color;
    out vec2 v_texCoords;
    
    void main()
    {
       v_color = a_color;
       v_color.a = v_color.a * (255.0/254.0);
       v_texCoords = a_texCoord0;
       gl_Position =  u_projTrans * a_position;
    }
    #endif //death_screen_vert_glsl
    
    FRAG: #version 150
    #ifndef death_screen_frag_glsl
    #define death_screen_frag_glsl
    
    in vec4 v_color;
    in vec2 v_texCoords;
    
    uniform sampler2D u_texture;
    uniform float u_time;
    
    out vec4 outColor;
    
    void main()
    {
        float s1 = u_time + v_texCoords.y*100 + 3*cos(u_time/10 + v_texCoords.x);
        float s2 = dot(normalize(vec2(v_texCoords)-0.5), vec2(sin(u_time), cos(u_time)));
    
        outColor = v_color * texture2D(u_texture, v_texCoords) * vec4(vec3((0.9 + 0.1*sin(s1))), 1) * (6+s2)/7;
    }
    #endif //death_screen_frag_glsl
    
* ItemShader: assets/base/shaders/item_shader.vert.glsl, assets/base/shaders/item_shader.frag.glsl
    VERTEX: #version 150
    #ifndef assets_base_shaders_item_shader_vert_glsl
    #define assets_base_shaders_item_shader_vert_glsl
    
    // Contributors: Shfloop, Mr-Zombii
    
    in vec3 a_position;
    in vec2 a_texCoord0;
    in vec3 a_normal;
    out vec2 v_texCoord0;
    
    uniform mat4 u_projViewTrans;
    uniform mat4 u_modelMat;
    
    out vec3 v_normal;
    
    void main()
    {
    
        v_normal = normalize(a_normal); // Mult by u_modelMat for world space vectors
        v_texCoord0 = a_texCoord0;
        gl_Position = u_projViewTrans * u_modelMat * vec4(a_position, 1.0);
    }
    #endif //assets_base_shaders_item_shader_vert_glsl
    
    FRAG: #version 150
    #ifndef assets_base_shaders_item_shader_frag_glsl
    #define assets_base_shaders_item_shader_frag_glsl
    #ifdef GL_ES
    precision mediump float;
    #endif
    
    // Contributors: Shfloop, Mr-Zombii
    
    in vec2 v_texCoord0;
    in vec3 v_normal;
    
    uniform sampler2D texDiffuse;
    uniform vec4 tintColor;
    uniform int isInSlot;
    
    out vec4 outColor;
    
    void main()
    {
        // arbitrary numbers might want to mess around with
        float faceShade = abs(dot(vec3(0,0,1), v_normal) ) + 0.6;
        faceShade *= abs(dot(vec3(0,1,0), v_normal) + 0.8);
        faceShade *= 1.0;
        vec4 texColor = texture(texDiffuse, v_texCoord0);
    
        if(texColor.a == 0)
        {
            discard;
        }
    
        if (isInSlot == 1) {
            outColor = texColor;
            return;
        } else outColor = vec4(texColor.rgb * faceShade , texColor.a) * tintColor;
    }
    #endif //assets_base_shaders_item_shader_frag_glsl
    

    at finalforeach.cosmicreach.gamestates.OptionsMenu$10.onClick(OptionsMenu.java:292)
    at finalforeach.cosmicreach.ui.UIElement.drawBackground(UIElement.java:145)
    at finalforeach.cosmicreach.gamestates.GameState.drawUIElements(GameState.java:121)
    at finalforeach.cosmicreach.gamestates.OptionsMenu.render(OptionsMenu.java:335)
    at finalforeach.cosmicreach.BlockGame.render(BlockGame.java:132)
    at com.badlogic.gdx.backends.lwjgl3.Lwjgl3Window.update(Lwjgl3Window.java:387)
    at com.badlogic.gdx.backends.lwjgl3.Lwjgl3Application.loop(Lwjgl3Application.java:193)
    at com.badlogic.gdx.backends.lwjgl3.Lwjgl3Application.<init>(Lwjgl3Application.java:167)
    at finalforeach.cosmicreach.lwjgl3.Lwjgl3Launcher.createApplication(Lwjgl3Launcher.java:104)
    at finalforeach.cosmicreach.lwjgl3.Lwjgl3Launcher.main(Lwjgl3Launcher.java:92)```

Debug log: (1/2)

* Game version: 0.2.5
* Ran for : 6 minutes, 30 seconds
* Current time: 2024-09-13 at 21:00:38.515505400+02:00[Europe/Amsterdam]
* Operating system: Windows 10 10.0
* Arch: amd64
* Java VM name: Java HotSpot(TM) 64-Bit Server VM
* Java runtime version: 21.0.4+8-LTS-274
* System user language: nl
* CPU model: Intel(R) Core(TM) i5-6400 CPU @ 2.70GHz
* Save location free / total space: 549,98 GB / 930,703 GB
* Available processors: 4
* Native heap use: 19 MB
* Java heap use: 19 MB
* Max memory available: 3,967 GB
* RAM available: 15,863 GB
* getGLVersion: 
Type: OpenGL
Version: 4:6:0
Vendor: Intel
Renderer: Intel(R) HD Graphics 530
* Prestart error logs: 
[LWJGL] OpenGL debug message
    ID: 0x0
    Source: SHADER COMPILER
    Type: OTHER
    Severity: MEDIUM
    Message: SHADER_ID_COMPILE other warning has been generated. GLSL compile warning(s) for shader 22, "": WARNING: 0:1: '' :  #version directive missing


[LWJGL] OpenGL debug message
    ID: 0x0
    Source: SHADER COMPILER
    Type: OTHER
    Severity: MEDIUM
    Message: SHADER_ID_COMPILE other warning has been generated. GLSL compile warning(s) for shader 23, "": WARNING: 0:5: '' :  #version directive missing


[LWJGL] OpenGL debug message
    ID: 0x0
    Source: SHADER COMPILER
    Type: OTHER
    Severity: MEDIUM
    Message: SHADER_ID_COMPILE other warning has been generated. GLSL compile warning(s) for shader 25, "": WARNING: 0:1: '' :  #version directive missing


[LWJGL] OpenGL debug message
    ID: 0x0
    Source: SHADER COMPILER
    Type: OTHER
    Severity: MEDIUM
    Message: SHADER_ID_COMPILE other warning has been generated. GLSL compile warning(s) for shader 26, "": WARNING: 0:5: '' :  #version directive missing



* Exception logs: 
java.lang.RuntimeException: Caused a manual crash, not a bug!
SHADERS:
* ChunkShader: chunk.vert.glsl, chunk.frag.glsl
    VERTEX: #version 150
    #ifndef chunk_vert_glsl
    #define chunk_vert_glsl
    
    //in vec3 a_position;
    //in int a_uvAoPackedColorAttrib;
    
    in vec4 a_lighting;
    uniform vec3 u_batchPosition;
    uniform mat4 u_projViewTrans;
    uniform mat4 u_modelMat;
    
    out vec2 v_texCoord0;
    out vec3 worldPos;
    out vec4 blocklight;
    out vec3 faceNormal;
    
    #ifndef common_bitUnpacker_glsl
    #define common_bitUnpacker_glsl
    #define GET_TEX_COORDS getTexCoordsFromUVIdx(int(a_uvIdx))
    #define GET_VERT_NORMAL getVertNormalFromIdx(int(a_uvIdx))
    #define GET_FACE_NORMAL getFaceNormalFromIdx(int(a_uvIdx))
    #define GET_BLOCK_VERT_POSITION getBlockVertexPosition(int(a_uvIdx), int(a_positionPacked))
    
    #define NUM_FLOATS_PER_FACE_UVTEXBUFF (2 + 3 + 3 + 3)
    
    in float a_positionPacked;
    in float a_uvIdx;
    uniform samplerBuffer texBuffer;
    
    vec2 getTexCoordsFromUVIdx(int modelId)
    {
        int i = NUM_FLOATS_PER_FACE_UVTEXBUFF * modelId;
        return vec2(texelFetch(texBuffer, i).r, 
                    texelFetch(texBuffer, i+1).r);
    }
    vec3 getVertNormalFromIdx(int modelId)
    {
        int i = NUM_FLOATS_PER_FACE_UVTEXBUFF * modelId;
        return vec3(texelFetch(texBuffer, i+2).r,
                    texelFetch(texBuffer, i+3).r,
                    texelFetch(texBuffer, i+4).r);
    }
    vec3 getFaceNormalFromIdx(int modelId)
    {
        int i = NUM_FLOATS_PER_FACE_UVTEXBUFF * modelId;
        return vec3(texelFetch(texBuffer, i+5).r,
                    texelFetch(texBuffer, i+6).r,
                    texelFetch(texBuffer, i+7).r);
    }
    
    vec3 getBlockVertexPosition(int modelId, int packedPosition)
    {
        int i = NUM_FLOATS_PER_FACE_UVTEXBUFF * modelId;
        vec3 offset = vec3(texelFetch(texBuffer, i+8).r,
                    texelFetch(texBuffer, i+9).r,
                    texelFetch(texBuffer, i+10).r);
    
        int px = (packedPosition >> 12) & 0x3F;
        int py = (packedPosition >> 6) & 0x3F;
        int pz = (packedPosition) & 0x3F;
        vec3 blockPos = vec3(float(px), float(py), float(pz));
    
        return blockPos + offset;
    }
    
    int getUvAoBits(int uvAoPackedColor)
    {
        return (uvAoPackedColor >> 16) & 65535;
    }
    
    int getPackedColorBits(int uvAoPackedColor)
    {
        return uvAoPackedColor & 65535;
    }
    
    vec4 getBlockLight(int packedColorBits)
    {
        return vec4(((packedColorBits) & 15), (packedColorBits >> 4) & 15, (packedColorBits >> 8) & 15, (packedColorBits >> 12)) / 16.0;
    }
    #endif //common_bitUnpacker_glsl
    
    
    void main() 
    {
        worldPos = GET_BLOCK_VERT_POSITION + u_batchPosition;
        
        //int packedColorBits = getPackedColorBits(a_uvAoPackedColorAttrib);
        blocklight = a_lighting;//getBlockLight(packedColorBits);
        
        //int uvAoBits = getUvAoBits(a_uvAoPackedColorAttrib);
        v_texCoord0 = GET_TEX_COORDS;
    
        faceNormal = GET_FACE_NORMAL;
    
        gl_Position = (u_projViewTrans * u_modelMat * vec4(worldPos, 1.0));
    }
    #endif //chunk_vert_glsl
    
    FRAG: #version 150
    #ifndef chunk_frag_glsl
    #define chunk_frag_glsl
    #ifdef GL_ES 
    precision mediump float;
    #endif
    
    uniform vec3 skyAmbientColor;
    uniform vec4 tintColor;
    uniform vec3 worldAmbientColor;
    
    in vec2 v_texCoord0;
    in vec3 worldPos;
    in vec4 blocklight;
    in vec3 faceNormal;
    
    uniform sampler2D texDiffuse;
    uniform vec3 u_sunDirection;
    
    out vec4 outColor;
    
    void main() 
    {
        vec2 tilingTexCoords = v_texCoord0;
    
        vec4 texColor = texture(texDiffuse, v_texCoord0);
    
        if(texColor.a == 0)
        {
            discard;
        }
    
        vec3 blockAmbientColor = skyAmbientColor * max(dot(u_sunDirection, faceNormal), 0.5);
    
        // https://www.desmos.com/calculator
        // y\ =\ \frac{30}{1+e^{-15\left(\frac{x}{25}\right)^{2}}}-15
        vec3 it =  pow(15*blocklight.rgb / 25.0, vec3(2));
        vec3 t = 30.0/(1.0 + exp(-15.0 * it)) - 15;
        vec3 lightTint = max(t/15, blocklight.a * blockAmbientColor);
    
        //lightTint = max(lightTint, vec3(0.1));
        //texColor = vec4(1);
       
        outColor = tintColor * vec4(texColor.rgb * lightTint, texColor.a);
    
        outColor.rgb = max(outColor.rgb, texColor.rgb * worldAmbientColor);
    
    }
    #endif //chunk_frag_glsl
    
* ChunkShader: chunk-water.vert.glsl, chunk-water.frag.glsl
    VERTEX: #version 150
    #ifndef chunk_water_vert_glsl
    #define chunk_water_vert_glsl
    
    //in vec3 a_position;
    //in int a_uvAoPackedColorAttrib;
    in vec4 a_lighting;
    uniform vec3 u_batchPosition;
    
    uniform mat4 u_projViewTrans;
    uniform mat4 u_modelMat;
    uniform float u_time;
    uniform vec3 cameraPosition;
    
    out vec2 v_texCoord0;
    out vec4 blocklight;
    out float waveStrength;
    out vec3 worldPos;
    out vec3 toCameraVector;
    
    #ifndef common_bitUnpacker_glsl
    #define common_bitUnpacker_glsl
    #define GET_TEX_COORDS getTexCoordsFromUVIdx(int(a_uvIdx))
    #define GET_VERT_NORMAL getVertNormalFromIdx(int(a_uvIdx))
    #define GET_FACE_NORMAL getFaceNormalFromIdx(int(a_uvIdx))
    #define GET_BLOCK_VERT_POSITION getBlockVertexPosition(int(a_uvIdx), int(a_positionPacked))
    
    #define NUM_FLOATS_PER_FACE_UVTEXBUFF (2 + 3 + 3 + 3)
    
    in float a_positionPacked;
    in float a_uvIdx;
    uniform samplerBuffer texBuffer;
    
    vec2 getTexCoordsFromUVIdx(int modelId)
    {
        int i = NUM_FLOATS_PER_FACE_UVTEXBUFF * modelId;
        return vec2(texelFetch(texBuffer, i).r, 
                    texelFetch(texBuffer, i+1).r);
    }
    vec3 getVertNormalFromIdx(int modelId)
    {
        int i = NUM_FLOATS_PER_FACE_UVTEXBUFF * modelId;
        return vec3(texelFetch(texBuffer, i+2).r,
                    texelFetch(texBuffer, i+3).r,
                    texelFetch(texBuffer, i+4).r);
    }
    vec3 getFaceNormalFromIdx(int modelId)
    {
        int i = NUM_FLOATS_PER_FACE_UVTEXBUFF * modelId;
        return vec3(texelFetch(texBuffer, i+5).r,
                    texelFetch(texBuffer, i+6).r,
                    texelFetch(texBuffer, i+7).r);
    }
    
    vec3 getBlockVertexPosition(int modelId, int packedPosition)
    {
        int i = NUM_FLOATS_PER_FACE_UVTEXBUFF * modelId;
        vec3 offset = vec3(texelFetch(texBuffer, i+8).r,
                    texelFetch(texBuffer, i+9).r,
                    texelFetch(texBuffer, i+10).r);
    
        int px = (packedPosition >> 12) & 0x3F;
        int py = (packedPosition >> 6) & 0x3F;
        int pz = (packedPosition) & 0x3F;
        vec3 blockPos = vec3(float(px), float(py), float(pz));
    
        return blockPos + offset;
    }
    
    int getUvAoBits(int uvAoPackedColor)
    {
        return (uvAoPackedColor >> 16) & 65535;
    }
    
    int getPackedColorBits(int uvAoPackedColor)
    {
        return uvAoPackedColor & 65535;
    }
    
    vec4 getBlockLight(int packedColorBits)
    {
        return vec4(((packedColorBits) & 15), (packedColorBits >> 4) & 15, (packedColorBits >> 8) & 15, (packedColorBits >> 12)) / 16.0;
    }
    #endif //common_bitUnpacker_glsl
    
    
    void main() 
    {
        worldPos = GET_BLOCK_VERT_POSITION + u_batchPosition;
    
        v_texCoord0 = GET_TEX_COORDS;
        blocklight = a_lighting;
    
        toCameraVector = cameraPosition - worldPos;
        vec3 normal = GET_VERT_NORMAL;
    
    
        float xOff = 0;
        float zOff = 0;
        if(normal.y < 0)
        {
            //waveStrength = 0.2;
            xOff = normal.x * -0.001;
            zOff = normal.z * -0.001;
        }
        //else
        {
            float waveSpeed = 0.25;
            float waveTime = waveSpeed * u_time;
            float scale = 5;
            float wavePositionA = 10 * (cos(worldPos.x*scale) + sin(worldPos.z*scale));
            float wavePositionB = 10 * (sin(worldPos.x*scale) + cos(worldPos.z*scale));
    
            waveStrength = 0.1 * (sin(waveTime + wavePositionA) * cos(waveTime + wavePositionB));
        }
        
        gl_Position = u_projViewTrans * u_modelMat * vec4(worldPos.x + xOff, worldPos.y + waveStrength - 0.2, worldPos.z + zOff, 1.0);
    }
    #endif //chunk_water_vert_glsl
    
    FRAG: #version 150
    #ifndef chunk_water_frag_glsl
    #define chunk_water_frag_glsl
    #ifdef GL_ES 
    precision mediump float;
    #endif
    
    uniform float u_time;
    uniform vec3 skyAmbientColor;
    uniform vec3 skyColor;
    uniform vec4 tintColor;
    uniform vec3 worldAmbientColor;
    
    in vec2 v_texCoord0;
    in vec4 blocklight;
    in float waveStrength;
    in vec3 worldPos;
    in vec3 toCameraVector;
    
    uniform sampler2D texDiffuse;
    uniform sampler2D noiseTex;
    
    out vec4 outColor;
    
    void main() 
    {
    
        vec2 numTiles = floor(v_texCoord0);
        vec2 tilingTexCoords = v_texCoord0;
        
        if(numTiles.xy != vec2(0, 0))
        {
            tilingTexCoords = (v_texCoord0 - numTiles);
            vec2 flooredTexCoords = floor((v_texCoord0 - numTiles) * 16) / 16;
            numTiles = numTiles + vec2(1,1);
    
            tilingTexCoords = flooredTexCoords + mod(((tilingTexCoords - flooredTexCoords) * numTiles) * 16, 1) / 16;
        }
    
        vec4 texColor = texture(texDiffuse, tilingTexCoords);
    
        vec3 viewVector = normalize(toCameraVector);
        vec3 faceNormal = vec3(0.0, 1.0, 0.0);
        float fresnel = abs(dot(viewVector, faceNormal));
    
        vec2 noiseUV = 0.2*vec2(waveStrength - 0.1) + worldPos.xz / 16.0;
        noiseUV+=vec2(u_time*0.02);
        vec2 distortion = fresnel * texture(noiseTex, noiseUV).rg;
        vec3 waterColor = texColor.rgb;
    
        fresnel = pow(fresnel, mix(3, 1, 2*(waveStrength - 0.1 + distortion.r/3.0)));
        fresnel = pow(fresnel, 0.35);
        waterColor = mix(waterColor * 0.5, waterColor, 0.5 + 0.5*waveStrength*(1-fresnel));```

close up shot of java versions: close up to logs: Black blob: (note: image is dark) render glitch at night: render glitch at day:

its realy fun to play with collerd light and I almost dont have a lot of issues compaired to the previous time: When in a cave I dont get a lot of rendering issues, but I seem to have some dark block blobs that seem to exist, but also not! and a bit of the orginail rendering glitch, but a lot less than before. my last post from 3 month ago It seem to have picked up java 21 and I have more than 3 or 4 java versions installed on my pc: java 8, 16, 17 and 21 image of java versions: game debug log java 21 picked up: I cant change it as far as I know, if someone knows how to change the java version used in the game when launched via itch (example: in itch, some setting), plz. reply where! I find it playeble at the moment even with the rendering glitch what may be caused by using java 21 instead of my installed java 17 (added replies with more info)

the glitch is still there

read more:previus message

[win.zip V0.1.37]

[jar.zip V0.1.37]

I think this is a nice game, but I coulnt play it that well because of this

visual glitches are still there

* in 0.1.36

Read for more info: https://itch.io/post/9995748

oke, I just want to mention it so its known and can be fixed.

I like to try the game again on the next version to look if its fixt

Have No GPU, Use Intel CPU ghrapics

java version: C:\Users\bouma>java -version java version “17.0.6” 2023-01-17 LTS Java(TM) SE Runtime Environment (build 17.0.6+9-LTS-190) Java HotSpot(TM) 64-Bit Server VM (build 17.0.6+9-LTS-190, mixed mode, sharing)

I have got this issue on the .jar version and windows .zip version, can u fix it, I have seen other people having this too (screenshot is from windows .zip)