Fragment shader optimizations

diff --git a/deps/dragontype b/deps/dragontype
index c4d3a0bff0c158ad0efee031a531eb920d904d14..b3c245ba9b111462f2fff6178b08b486cd553f1b 160000 (submodule)
--- a/deps/dragontype
+++ b/deps/dragontype
@@ -1 +1 @@
-Subproject commit c4d3a0bff0c158ad0efee031a531eb920d904d14
+Subproject commit b3c245ba9b111462f2fff6178b08b486cd553f1b

diff --git a/shaders/3d/fragment.glsl b/shaders/3d/fragment.glsl
index dcfb212810f05672a9005d0669c2e79e31934538..653d579d3c372aa9ac3b322d2d6d2ce38fad5ae8 100755 (executable)
--- a/shaders/3d/fragment.glsl
+++ b/shaders/3d/fragment.glsl
@@ -6,25 +6,14 @@ in vec3 fragmentColor;
 
 out vec4 outColor;
 
-uniform float daylight;
-uniform vec3 lightDir;
+uniform vec3 fogColor;
 uniform vec3 cameraPos;
 uniform sampler2D textures[MAX_TEXTURE_UNITS];
 
 void main()
 {
-       vec3 lightColor = vec3(1.0);
-       vec3 fogColor = mix(vec3(0x03, 0x0A, 0x1A), vec3(0x87, 0xCE, 0xEB), daylight) / vec3(0xFF);
-
-       float ambientStrength = mix(0.3, 0.7, daylight);
-
-       vec3 ambient = ambientStrength * lightColor;
-       vec3 diffuse = 0.3 * daylight * clamp(dot(normalize(fragmentNormal), normalize(lightDir)), 0.0, 1.0) * lightColor;
-
-       vec3 light = ambient + diffuse;
-
-       outColor = texture(textures[int(fragmentTextureIndex + 0.5)], fragmentTextureCoords) * vec4(fragmentColor, 1.0) * vec4(light, 1.0);
-       outColor.rgb = mix(outColor.rgb, ambientStrength * fogColor, clamp(length(fragmentPosition - cameraPos) / 255.0, 0.0, 1.0));
+       outColor = texture(textures[int(fragmentTextureIndex + 0.5)], fragmentTextureCoords) * vec4(fragmentColor, 1.0);
+       outColor.rgb = mix(outColor.rgb, fogColor, clamp(length(fragmentPosition - cameraPos) / 255.0, 0.0, 1.0));
 
        if (outColor.a == 0.0)
                discard;

diff --git a/shaders/3d/vertex.glsl b/shaders/3d/vertex.glsl
index bb991ae628cccdbd53c344d5a08f5228043cfade..8d48d5347055f51dad4c91841c5aef4389b4c8d4 100755 (executable)
--- a/shaders/3d/vertex.glsl
+++ b/shaders/3d/vertex.glsl
@@ -12,6 +12,9 @@ out vec3 fragmentColor;
 
 uniform mat4 model;
 uniform mat4 VP;
+uniform float daylight;
+uniform float ambientLight;
+uniform vec3 lightDir;
 
 void main()
 {
@@ -23,4 +26,9 @@ void main()
        fragmentTextureIndex = vertexTextureIndex;
        fragmentTextureCoords = vertexTextureCoords;
        fragmentColor = vertexColor;
+
+       float diffuseLight = 0.3 * daylight * clamp(dot(normalize(fragmentNormal), normalize(lightDir)), 0.0, 1.0);
+       float light = ambientLight + diffuseLight;
+
+       fragmentColor *= light;
 }

diff --git a/src/client/scene.c b/src/client/scene.c
index d560c748dd22491c59eef60f433f5c764bb65139..93a569914489e0e02b7cd2066832d61defd985af 100644 (file)
--- a/src/client/scene.c
+++ b/src/client/scene.c
@@ -35,6 +35,8 @@ bool scene_init()
        scene.loc_model = glGetUniformLocation(scene.prog, "model");
        scene.loc_VP = glGetUniformLocation(scene.prog, "VP");
        scene.loc_daylight = glGetUniformLocation(scene.prog, "daylight");
+       scene.loc_fogColor = glGetUniformLocation(scene.prog, "fogColor");
+       scene.loc_ambientLight = glGetUniformLocation(scene.prog, "ambientLight");
        scene.loc_lightDir = glGetUniformLocation(scene.prog, "lightDir");
        scene.loc_cameraPos = glGetUniformLocation(scene.prog, "cameraPos");
 
@@ -88,11 +90,17 @@ void scene_render(f64 dtime)
 
        frustum_update(scene.VP);
 
+       f32 daylight = get_daylight();
+       f32 ambient_light = f32_mix(0.3f, 0.7f, daylight);
+       v3f32 fog_color = v3f32_mix((v3f32) {0x03, 0x0A, 0x1A}, (v3f32) {0x87, 0xCE, 0xEB}, daylight);
+
        glUseProgram(scene.prog);
        glUniformMatrix4fv(scene.loc_VP, 1, GL_FALSE, scene.VP[0]);
        glUniform3f(scene.loc_lightDir, sunlight_dir[0], sunlight_dir[1], sunlight_dir[2]);
        glUniform3f(scene.loc_cameraPos, camera.eye[0], camera.eye[1], camera.eye[2]);
-       glUniform1f(scene.loc_daylight, get_daylight());
+       glUniform1f(scene.loc_daylight, daylight);
+       glUniform3f(scene.loc_fogColor, fog_color.x / 0xFF * ambient_light, fog_color.y / 0xFF * ambient_light, fog_color.z / 0xFF * ambient_light);
+       glUniform1f(scene.loc_ambientLight, ambient_light);
 
        for (ListPair **pairptr = &scene.objects.first; *pairptr != NULL; ) {
                ListPair *pair = *pairptr;

diff --git a/src/client/scene.h b/src/client/scene.h
index 2941db0f906ad487f9b9a90e196f098f2cde9456..bb8fd2066f20cc89ec939409b6b9613e752893f0 100644 (file)
--- a/src/client/scene.h
+++ b/src/client/scene.h
@@ -18,6 +18,8 @@ extern struct Scene
        GLint loc_model;
        GLint loc_VP;
        GLint loc_daylight;
+       GLint loc_fogColor;
+       GLint loc_ambientLight;
        GLint loc_lightDir;
        GLint loc_cameraPos;
        GLint max_texture_units;

diff --git a/src/server/biomes.c b/src/server/biomes.c
index 082c85c92dc75f32a035921c26f7208d3d67fa98..4a7834a1c27cc51d2fd040255848a89c1c608f39 100644 (file)
--- a/src/server/biomes.c
+++ b/src/server/biomes.c
@@ -122,11 +122,6 @@ static bool find_near_vulcano(v2s32 pos, v2s32 *result)
        return false;
 }
 
-static f64 mix(f64 a, f64 b, f64 f)
-{
-       return (a * (1.0 - f) + b * f);
-}
-
 static inline f64 min(f64 a, f64 b)
 {
        return a < b ? a : b;
@@ -146,16 +141,16 @@ static s32 calculate_ocean_floor(f64 factor, s32 height)
 {
        switch (get_ocean_level(factor)) {
                case OL_BEACH_EDGE:
-                       return mix(height + 1, 0, pow(get_ocean_level_factor(factor, OL_BEACH_EDGE), 0.8));
+                       return f64_mix(height + 1, 0, pow(get_ocean_level_factor(factor, OL_BEACH_EDGE), 0.8));
 
                case OL_BEACH:
                        return 0;
 
                case OL_OCEAN:
-                       return mix(0, -10, pow(get_ocean_level_factor(factor, OL_OCEAN), 0.5));
+                       return f64_mix(0, -10, pow(get_ocean_level_factor(factor, OL_OCEAN), 0.5));
 
                case OL_DEEP_OCEAN:
-                       return mix(-10, -50, pow(get_ocean_level_factor(factor, OL_DEEP_OCEAN), 0.5));
+                       return f64_mix(-10, -50, pow(get_ocean_level_factor(factor, OL_DEEP_OCEAN), 0.5));
 
                default:
                        break;

diff --git a/src/server/voxelctx.c b/src/server/voxelctx.c
index 59b3251f45e29f9f59cffd33fe3355ed273b9276..5023f09dc89f95cbb9b2cfebdbe3c00a2bfbec00 100644 (file)
--- a/src/server/voxelctx.c
+++ b/src/server/voxelctx.c
@@ -57,16 +57,11 @@ void voxelctx_delete(Voxelctx *ctx)
        free(ctx);
 }
 
-static inline f32 mix(f32 x, f32 y, f32 t)
-{
-    return (1.0 - t) * x + t * y;
-}
-
 static void move_value(f32 *x, f32 v, f32 range)
 {
     f32 dst = v >= 0 ? range : 0;
     v = fabs(v);
-    *x = mix(*x, dst, v);
+    *x = f32_mix(*x, dst, v);
 }
 
 void voxelctx_hue(Voxelctx *ctx, f32 value)
@@ -227,9 +222,9 @@ void voxelctx_cube(Voxelctx *ctx, Node node, bool use_color)
 
                for (int i = 0; i < 3; i++) {
                        f32 f = trunc(
-                               + mix(corners[0][i], corners[4][i], (f32) x / (f32) max_len / 2.0f)
-                               + mix(corners[0][i], corners[2][i], (f32) y / (f32) max_len / 2.0f)
-                               + mix(corners[0][i], corners[1][i], (f32) z / (f32) max_len / 2.0f));
+                               + f32_mix(corners[0][i], corners[4][i], (f32) x / (f32) max_len / 2.0f)
+                               + f32_mix(corners[0][i], corners[2][i], (f32) y / (f32) max_len / 2.0f)
+                               + f32_mix(corners[0][i], corners[1][i], (f32) z / (f32) max_len / 2.0f));
 
                        v[i] = floor(VOXELCTXSTATE(ctx).pos[i] + f + 0.5f);
                }