Post by xxxkingxl in Cosmic Reach comments

Viewing post in Cosmic Reach comments

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));```

xxxkingxl118 days ago (1 edit)

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)```

itch.io

Viewing post in Cosmic Reach comments