fix normals (AlpineMapsOrg#162)

Author: adam-ce

gl_engine/shaders/tile.glsl

@@ -39,19 +39,133 @@ highp float y_to_lat(highp float y) {
     return latRad;
 }
 
-highp vec3 camera_world_space_position(out vec2 uv, out float n_quads_per_direction, out float quad_width, out float quad_height, out float altitude_correction_factor) {
-    highp uvec3 instance_tile_id = unpack_tile_id(instance_tile_id_packed);
 
-    highp uvec3 dtm_tile_id = instance_tile_id;
+void compute_vertex(out vec3 position, out vec2 uv, out uvec3 tile_id, bool compute_normal, out vec3 normal) {
+    tile_id = unpack_tile_id(instance_tile_id_packed);
+
+    highp uvec3 dtm_tile_id = tile_id;
+    {
+        uint dtm_zoom = texelFetch(instance_2_zoom_sampler, ivec2(uint(gl_InstanceID), 0), 0).x;
+        decrease_zoom_level_until(dtm_tile_id, dtm_zoom);
+    }
+    highp int n_quads_per_direction_int = (n_edge_vertices - 1) >> (tile_id.z - dtm_tile_id.z);
+    highp float n_quads_per_direction = float(n_quads_per_direction_int);
+    highp float quad_size = (instance_bounds.z - instance_bounds.x) / n_quads_per_direction;
+
+    highp int row = gl_VertexID / n_edge_vertices;
+    highp int col = gl_VertexID - (row * n_edge_vertices);
+    highp int curtain_vertex_id = gl_VertexID - n_edge_vertices * n_edge_vertices;
+    if (curtain_vertex_id >= 0) {
+        if (curtain_vertex_id < n_edge_vertices) {
+            row = (n_edge_vertices - 1) - curtain_vertex_id;
+            col = (n_edge_vertices - 1);
+        }
+        else if (curtain_vertex_id >= n_edge_vertices && curtain_vertex_id < 2 * n_edge_vertices - 1) {
+            row = 0;
+            col = (n_edge_vertices - 1) - (curtain_vertex_id - n_edge_vertices) - 1;
+        }
+        else if (curtain_vertex_id >= 2 * n_edge_vertices - 1 && curtain_vertex_id < 3 * n_edge_vertices - 2) {
+            row = curtain_vertex_id - 2 * n_edge_vertices + 2;
+            col = 0;
+        }
+        else {
+            row = (n_edge_vertices - 1);
+            col = curtain_vertex_id - 3 * n_edge_vertices + 3;
+        }
+    }
+    if (row > n_quads_per_direction_int) {
+        row = n_quads_per_direction_int;
+        curtain_vertex_id = 1;
+    }
+    if (col > n_quads_per_direction_int) {
+        col = n_quads_per_direction_int;
+        curtain_vertex_id = 1;
+    }
+
+    position.y = float(n_quads_per_direction_int - row) * float(quad_size) + instance_bounds.y;
+    position.x = float(col) * quad_size + instance_bounds.x;
+    uv = vec2(float(col) / n_quads_per_direction, float(row) / n_quads_per_direction);
+
+    highp vec2 dtm_uv = uv;
+    uint dtm_zoom = dtm_tile_id.z;
+    dtm_tile_id = tile_id;
+    decrease_zoom_level_until(dtm_tile_id, dtm_uv, dtm_zoom);
+    highp float dtm_texture_layer_f = float(texelFetch(instance_2_array_index_sampler, ivec2(uint(gl_InstanceID), 0), 0).x);
+    float altitude_tex = float(texture(height_tex_sampler, vec3(dtm_uv, dtm_texture_layer_f)).r);
+
+    // Note: for higher zoom levels it would be enough to calculate the altitude_correction_factor on cpu
+    // for lower zoom levels we could bake it into the texture.
+    // there was no measurable difference despite a cos and a atan, so leaving as is for now.
+    highp float world_space_y = position.y + camera.position.y;
+    highp float altitude_correction_factor = 0.125 / cos(y_to_lat(world_space_y)); // https://github.com/AlpineMapsOrg/renderer/issues/5
+    float adjusted_altitude = altitude_tex * altitude_correction_factor;
+    position.z = adjusted_altitude - camera.position.z;
+
+    if (curtain_vertex_id >= 0) {
+        float curtain_height = CURTAIN_REFERENCE_HEIGHT;
+#if CURTAIN_HEIGHT_MODE == 1
+        float dist_factor = clamp(length(position) / 100000.0, 0.2, 1.0);
+        curtain_height *= dist_factor;
+#endif
+#if CURTAIN_HEIGHT_MODE == 2
+        float zoom_factor = 1.0 - max(0.1, float(tile_id.z) / 25.f);
+        curtain_height *= zoom_factor;
+#endif
+        position.z = position.z - curtain_height;
+    }
+
+    if (compute_normal) {
+        // from here: https://stackoverflow.com/questions/6656358/calculating-normals-in-a-triangle-mesh/21660173#21660173
+        vec2 offset = vec2(1.0, 0.0) / (n_edge_vertices - 1);
+
+        highp float hL = float(texture(height_tex_sampler, vec3(dtm_uv - offset.xy, dtm_texture_layer_f)).r);
+        hL *= altitude_correction_factor;
+        highp float hR = float(texture(height_tex_sampler, vec3(dtm_uv + offset.xy, dtm_texture_layer_f)).r);
+        hR *= altitude_correction_factor;
+        highp float hD = float(texture(height_tex_sampler, vec3(dtm_uv + offset.yx, dtm_texture_layer_f)).r);
+        hD *= altitude_correction_factor;
+        highp float hU = float(texture(height_tex_sampler, vec3(dtm_uv - offset.yx, dtm_texture_layer_f)).r);
+        hU *= altitude_correction_factor;
+
+        highp float threshold = 0.5 * offset.x;
+        highp float quad_height = quad_size;
+        highp float quad_width = quad_size;
+        if (dtm_uv.x < threshold || dtm_uv.x > 1.0 - threshold )
+            quad_width = quad_size / 2.0;                // half on the edge of a tile_id_packed, as the height texture is clamped
+
+        if (dtm_uv.y < threshold || dtm_uv.y > 1.0 - threshold )
+            quad_height = quad_size / 2.0;
+
+        normal = normalize(vec3((hL - hR)/quad_width, (hD - hU)/quad_height, 2.));
+    }
+}
+
+void compute_vertex(out vec3 position, out vec2 uv, out uvec3 tile_id, out vec3 normal) {
+    compute_vertex(position, uv, tile_id, true, normal);
+}
+
+void compute_vertex(out vec3 position) {
+    highp vec2 uv;
+    highp uvec3 tile_id;
+    vec3 normal;
+    compute_vertex(position, uv, tile_id, false, normal);
+}
+
+
+
+highp vec3 camera_world_space_position(out vec2 uv, out float n_quads_per_direction, out float quad_size, out float quad_height, out float altitude_correction_factor) {
+    highp uvec3 tile_id = unpack_tile_id(instance_tile_id_packed);
+
+    highp uvec3 dtm_tile_id = tile_id;
     {
         uint dtm_zoom = texelFetch(instance_2_zoom_sampler, ivec2(uint(gl_InstanceID), 0), 0).x;
         decrease_zoom_level_until(dtm_tile_id, dtm_zoom);
     }
 
-    highp int n_quads_per_direction_int = (n_edge_vertices - 1) >> (instance_tile_id.z - dtm_tile_id.z);
+    highp int n_quads_per_direction_int = (n_edge_vertices - 1) >> (tile_id.z - dtm_tile_id.z);
     n_quads_per_direction = float(n_quads_per_direction_int);
     // highp vec4 bounds = texelFetch(instance_2_bounds_sampler, ivec2(uint(gl_InstanceID), 0), 0);
-    quad_width = (instance_bounds.z - instance_bounds.x) / n_quads_per_direction;
+    quad_size = (instance_bounds.z - instance_bounds.x) / n_quads_per_direction;
     quad_height = (instance_bounds.w - instance_bounds.y) / n_quads_per_direction;
 
     highp int row = gl_VertexID / n_edge_vertices;
@@ -86,7 +200,7 @@ highp vec3 camera_world_space_position(out vec2 uv, out float n_quads_per_direct
     // Note: for higher zoom levels it would be enough to calculate the altitude_correction_factor on cpu
     // for lower zoom levels we could bake it into the texture.
     // but there was no measurable difference despite a cos and a atan, so leaving as is for now.
-    highp float var_pos_cws_y = float(n_quads_per_direction_int - row) * float(quad_width) + instance_bounds.y;
+    highp float var_pos_cws_y = float(n_quads_per_direction_int - row) * float(quad_size) + instance_bounds.y;
     highp float pos_y = var_pos_cws_y + camera.position.y;
     altitude_correction_factor = 0.125 / cos(y_to_lat(pos_y)); // https://github.com/AlpineMapsOrg/renderer/issues/5
 
@@ -95,7 +209,7 @@ highp vec3 camera_world_space_position(out vec2 uv, out float n_quads_per_direct
     /////////
     highp vec2 dtm_uv = uv;
     uint dtm_zoom = dtm_tile_id.z;
-    dtm_tile_id = instance_tile_id;
+    dtm_tile_id = tile_id;
     decrease_zoom_level_until(dtm_tile_id, dtm_uv, dtm_zoom);
 
     highp float dtm_texture_layer_f = float(texelFetch(instance_2_array_index_sampler, ivec2(uint(gl_InstanceID), 0), 0).x);
@@ -104,7 +218,7 @@ highp vec3 camera_world_space_position(out vec2 uv, out float n_quads_per_direct
     // float altitude_tex = float(texelFetch(height_tex_sampler, ivec3(col, row, height_texture_layer), 0).r);
     float adjusted_altitude = altitude_tex * altitude_correction_factor;
 
-    highp vec3 var_pos_cws = vec3(float(col) * quad_width + instance_bounds.x, var_pos_cws_y, adjusted_altitude - camera.position.z);
+    highp vec3 var_pos_cws = vec3(float(col) * quad_size + instance_bounds.x, var_pos_cws_y, adjusted_altitude - camera.position.z);
 
     if (curtain_vertex_id >= 0) {
         float curtain_height = CURTAIN_REFERENCE_HEIGHT;
@@ -125,13 +239,13 @@ highp vec3 camera_world_space_position(out vec2 uv, out float n_quads_per_direct
 highp vec3 camera_world_space_position() {
     vec2 uv;
     float n_quads_per_direction;
-    float quad_width;
+    float quad_size;
     float quad_height;
     float altitude_correction_factor;
-    return camera_world_space_position(uv, n_quads_per_direction, quad_width, quad_height, altitude_correction_factor);
+    return camera_world_space_position(uv, n_quads_per_direction, quad_size, quad_height, altitude_correction_factor);
 }
 
-highp vec3 normal_by_finite_difference_method(vec2 uv, float edge_vertices_count, float quad_width, float quad_height, float altitude_correction_factor) {
+highp vec3 normal_by_finite_difference_method(vec2 uv, float edge_vertices_count, float quad_size, float quad_height, float altitude_correction_factor) {
     // from here: https://stackoverflow.com/questions/6656358/calculating-normals-in-a-triangle-mesh/21660173#21660173
     vec2 offset = vec2(1.0, 0.0) / (edge_vertices_count);
 
@@ -148,10 +262,10 @@ highp vec3 normal_by_finite_difference_method(vec2 uv, float edge_vertices_count
 
     highp float threshold = 0.5 / edge_vertices_count;
     if (uv.x < threshold || uv.x > 1.0 - threshold )
-        quad_width = quad_width / 2.0;                // half on the edge of a instance_tile_id_packed, as the height texture is clamped
+        quad_size = quad_size / 2.0;                // half on the edge of a tile_id_packed, as the height texture is clamped
 
     if (uv.y < threshold || uv.y > 1.0 - threshold )
         quad_height = quad_height / 2.0;
 
-    return normalize(vec3((hL - hR)/quad_width, (hD - hU)/quad_height, 2.));
+    return normalize(vec3((hL - hR)/quad_size, (hD - hU)/quad_height, 2.));
 }

gl_engine/shaders/tile.vert

@@ -35,16 +35,17 @@ flat out highp uint instance_id;
 
 void main() {
     float n_quads_per_direction;
-    float quad_width;
+    float quad_size;
     float quad_height;
     float altitude_correction_factor;
-    var_pos_cws = camera_world_space_position(var_uv, n_quads_per_direction, quad_width, quad_height, altitude_correction_factor);
+    // var_pos_cws = camera_world_space_position(var_uv, n_quads_per_direction, quad_size, quad_height, altitude_correction_factor);
 
-    if (conf.normal_mode == 1u) {
-        var_normal = normal_by_finite_difference_method(var_uv, n_quads_per_direction, quad_width, quad_height, altitude_correction_factor);
-    }
+    // if (conf.normal_mode == 1u) {
+    //     var_normal = normal_by_finite_difference_method(var_uv, n_quads_per_direction, quad_size, quad_height, altitude_correction_factor);
+    // }
+    compute_vertex(var_pos_cws, var_uv, var_tile_id, conf.normal_mode == 1u, var_normal);
 
-    var_tile_id = unpack_tile_id(instance_tile_id_packed);
+    // var_tile_id = unpack_tile_id(instance_tile_id_packed);
     gl_Position = camera.view_proj_matrix * vec4(var_pos_cws, 1);
     instance_id = uint(gl_InstanceID);