diff --git a/addons/MyJumpFloodIteration/jfp_backtracking_experimental.glsl b/addons/MyJumpFloodIteration/jfp_backtracking_experimental.glsl index ad0268d..c84ada9 100644 --- a/addons/MyJumpFloodIteration/jfp_backtracking_experimental.glsl +++ b/addons/MyJumpFloodIteration/jfp_backtracking_experimental.glsl @@ -3,8 +3,6 @@ #define FLT_MAX 3.402823466e+38 #define FLT_MIN 1.175494351e-38 -#define DBL_MAX 1.7976931348623158e+308 -#define DBL_MIN 2.2250738585072014e-308 layout(set = 0, binding = 0) uniform sampler2D depth_sampler; layout(set = 0, binding = 1) uniform sampler2D velocity_sampler; @@ -15,7 +13,7 @@ layout(push_constant, std430) uniform Params { int iteration_index; int last_iteration_index; - int nan1; + int backtracking_sample_count; int nan2; float perpen_error_thresh; float sample_step_multiplier; @@ -81,9 +79,9 @@ void set_value(bool a, ivec2 uvi, vec4 value, ivec2 render_size) float get_motion_difference(vec2 V, vec2 V2, float parallel_sensitivity, float perpendicular_sensitivity) { vec2 VO = V - V2; - double parallel = abs(dot(VO, V) / max(DBL_MIN, dot(V, V))); + float parallel = abs(dot(VO, V) / max(FLT_MIN, dot(V, V))); vec2 perpen_V = vec2(V.y, -V.x); - double perpendicular = abs(dot(VO, perpen_V) / max(DBL_MIN, dot(V, V))); + float perpendicular = abs(dot(VO, perpen_V) / max(FLT_MIN, dot(V, V))); float difference = float(parallel) * parallel_sensitivity + float(perpendicular) * perpendicular_sensitivity; return clamp(difference, 0, 1); } @@ -103,19 +101,19 @@ vec4 sample_fitness(vec2 uv_offset, vec4 uv_sample) // uv_offset = normalize(sample_velocity) * FLT_MIN; // } - double velocity_space_distance = dot(sample_velocity, uv_offset) / max(FLT_MIN, dot(sample_velocity, sample_velocity)); + float velocity_space_distance = dot(sample_velocity, uv_offset) / max(FLT_MIN, dot(sample_velocity, sample_velocity)); - double mid_point = params.motion_blur_intensity / 2; + float mid_point = params.motion_blur_intensity / 2; - double absolute_velocity_space_distance = abs(velocity_space_distance - mid_point); + float absolute_velocity_space_distance = abs(velocity_space_distance - mid_point); - double within_velocity_range = step(absolute_velocity_space_distance, mid_point); + float within_velocity_range = step(absolute_velocity_space_distance, mid_point); vec2 perpen_offset = vec2(uv_offset.y, -uv_offset.x); - double side_offset = abs(dot(perpen_offset, sample_velocity)) / max(FLT_MIN, dot(sample_velocity, sample_velocity)); + float side_offset = abs(dot(perpen_offset, sample_velocity)) / max(FLT_MIN, dot(sample_velocity, sample_velocity)); - double within_perpen_error_range = step(side_offset, params.perpen_error_thresh * params.motion_blur_intensity); + float within_perpen_error_range = step(side_offset, params.perpen_error_thresh * params.motion_blur_intensity); return vec4(absolute_velocity_space_distance, velocity_space_distance, uv_sample.z, within_velocity_range * within_perpen_error_range); } @@ -135,8 +133,6 @@ bool is_sample_better(vec4 a, vec4 b) vec4 get_backtracked_sample(vec2 uvn, vec2 chosen_uv, vec2 chosen_velocity, vec4 best_sample_fitness, vec2 render_size) { //return vec4(chosen_uv, best_sample_fitness.x, 0);// comment this to enable backtracking - - int step_count = 16; float smallest_step = 1 / max(render_size.x, render_size.y); @@ -152,9 +148,9 @@ vec4 get_backtracked_sample(vec2 uvn, vec2 chosen_uv, vec2 chosen_velocity, vec4 int steps_to_compare = initial_steps_to_compare; - for(int i = -step_count; i < step_count + 1; i++) + for(int i = -params.backtracking_sample_count; i < params.backtracking_sample_count + 1; i++) { - float velocity_multiplier = general_velocity_multiplier * (1 + float(i) / float(step_count)); + float velocity_multiplier = general_velocity_multiplier * (1 + float(i) / float(params.backtracking_sample_count)); if(velocity_multiplier > params.motion_blur_intensity + 0.2 || velocity_multiplier < FLT_MIN) { diff --git a/addons/MyJumpFloodIteration/jump_flood_blur.gd b/addons/MyJumpFloodIteration/jump_flood_blur.gd index 02024ef..09613a5 100644 --- a/addons/MyJumpFloodIteration/jump_flood_blur.gd +++ b/addons/MyJumpFloodIteration/jump_flood_blur.gd @@ -31,9 +31,15 @@ class_name MotionBlurSphynxJumpFlood @export var perpen_error_threshold : float = 0.3 ## an initial step size that can increase the dilation radius proportionally, at the -## sacrifice of some quality in the final resolution of the dilation +## sacrifice of some quality in the final resolution of the dilation.[br][br] +## the formula for the maximum radius of the dilation (in pixels) is: pow(2, JFA_pass_count) * sample_step_multiplier @export var sample_step_multiplier : float = 8 +## how many steps along a range of 2 velocities from the +## dilation target velocity space do we go along to find a better fitting velocity sample +## higher samples meaning higher detail getting captured and blurred +@export var backtracking_sample_count : int = 8 + ## how sensitive the backtracking for velocities be @export var backtracking_velocity_match_threshold : float = 0.9 @@ -50,7 +56,8 @@ class_name MotionBlurSphynxJumpFlood @export var backtracbing_depth_match_threshold : float = 0.001 ## the number of passes performed by the jump flood algorithm based dilation, -## each pass added doubles the maximum radius of dilation available +## each pass added doubles the maximum radius of dilation available.[br][br] +## the formula for the maximum radius of the dilation (in pixels) is: pow(2, JFA_pass_count) * sample_step_multiplier @export var JFA_pass_count : int = 3 ## wether this motion blur stays the same intensity below @@ -180,8 +187,8 @@ func _render_callback(p_effect_callback_type, p_render_data): return ensure_texture(texture, render_scene_buffers) - ensure_texture(buffer_a, render_scene_buffers, true)#, Vector2(0.25, 0.25)) - ensure_texture(buffer_b, render_scene_buffers, true)#, Vector2(0.25, 0.25)) + ensure_texture(buffer_a, render_scene_buffers) + ensure_texture(buffer_b, render_scene_buffers) ensure_texture(past_color, render_scene_buffers) rd.draw_command_begin_label("Motion Blur", Color(1.0, 1.0, 1.0, 1.0)) @@ -229,7 +236,7 @@ func _render_callback(p_effect_callback_type, p_render_data): var jf_push_constants : PackedInt32Array = [ i, last_iteration_index, - 16, + backtracking_sample_count, 16 ] diff --git a/addons/MyJumpFloodIteration/jump_flood_blur.glsl b/addons/MyJumpFloodIteration/jump_flood_blur.glsl index c0b2554..b6733e4 100644 --- a/addons/MyJumpFloodIteration/jump_flood_blur.glsl +++ b/addons/MyJumpFloodIteration/jump_flood_blur.glsl @@ -118,10 +118,15 @@ float get_velocity_curl(vec2 uv, vec2 render_size) // McGuire's functions https://docs.google.com/document/d/1IIlAKTj-O01hcXEdGxTErQbCHO9iBmRx6oFUy_Jm0fI/edit // ---------------------------------------------------------- +// This function would return 1 if depth_x is bigger than depth_y by sze amount. meaning, it would return 1 if x is closer to camera float soft_depth_compare(float depth_X, float depth_Y) { return clamp(1 - (depth_X - depth_Y) / sze, 0, 1); } +float soft_depth_compare_custom(float depth_X, float depth_Y, float csze) +{ + return clamp(1 - (depth_X - depth_Y) / csze, 0, 1); +} float cone(vec2 X, vec2 Y, vec2 v) { @@ -173,9 +178,9 @@ void main() vec3 naive_velocity = -textureLod(vector_sampler, uvn, 0.0).xyz; - float max_dialtion_radius = pow(2, params.last_iteration_index) * params.sample_step_multiplier / max(render_size.x, render_size.y); + float max_dialtion_radius = pow(2, params.last_iteration_index) * params.sample_step_multiplier * 2 / max(render_size.x, render_size.y); - if ((dot(velocity, velocity) == 0 || params.motion_blur_intensity == 0) && params.debug == 0) //(uvn.y > 0.5)// + if ((dot(velocity, velocity) == 0 || params.motion_blur_intensity == 0) && params.debug == 0) { imageStore(output_image, uvi, base); imageStore(past_color_image, uvi, base); @@ -193,19 +198,21 @@ void main() //float d = 1.0 - min(1.0, 2.0 * distance(uvn, vec2(0.5))); //sample_step *= 1.0 - d * params.fade_padding.x; - float total_weight = 1;// max(0.0001, length(naive_velocity)); + float total_weight = 1; - vec2 offset = vec2(sample_step * noise_offset); + vec2 offset = vec2(sample_step * noise_offset);//vec2(0);// vec4 col = base * total_weight; float depth = max(FLT_MIN, textureLod(depth_sampler, velocity_map_sample.xy, 0.0).x); float naive_depth = max(FLT_MIN, textureLod(depth_sampler, uvn, 0.0).x); - + + float naive_background = soft_depth_compare_custom(depth, naive_depth, 0.0001); + for (int i = 1; i < iteration_count; i++) { - offset += sample_step.xy;// * interleaved_gradient_noise(uvi, int(params.frame) + i); + offset += sample_step.xy; vec2 uvo = uvn + offset; @@ -220,17 +227,23 @@ void main() float current_depth = max(FLT_MIN, textureLod(depth_sampler, velocity_map_sample_step.xy, 0.0).x); - float sample_weight = 1; + float current_naive_depth = max(FLT_MIN, textureLod(depth_sampler, uvo, 0.0).x); float motion_difference = get_motion_difference(velocity.xy, current_velocity.xy, 0.1); float foreground = soft_depth_compare(npd / current_depth, npd / depth); + float naive_foreground = soft_depth_compare(npd / current_naive_depth - sze, npd / depth);//soft_depth_compare_custom(depth, current_naive_depth, 0.0001);// + + float sample_weight = 1; + sample_weight *= 1 - (foreground * motion_difference); total_weight += sample_weight; - col += textureLod(color_sampler, uvo, 0.0) * sample_weight; + vec2 sample_uv = mix(uvo, uvn, 1 - max(naive_background, naive_foreground));//uvo;// + + col += textureLod(color_sampler, sample_uv, 0.0) * sample_weight; } col /= total_weight; @@ -244,7 +257,7 @@ void main() vec4 tl_col = vec4(abs(textureLod(vector_sampler, uvn, 0.0).xy) * 10, 0, 1); - vec4 tr_col = vec4(abs(velocity.xy) * 10, 0, 1); + vec4 tr_col = vec4(abs(velocity.xy) * 10, 0, 1);//vec4(naive_background);// vec4 bl_col = vec4(abs(velocity_map_sample.xyw - vec3(uvn, 0)) * vec3(10, 10, 1), 1);