Fixed the image blurring on FOV changes.

NVIDIA · Jun 14, 2019 · 9b4834c · 9b4834c
1 parent 6d2188b
commit 9b4834c
Show file tree

Hide file tree

Showing 6 changed files with 44 additions and 20 deletions.
diff --git a/src/refresh/vkpt/main.c b/src/refresh/vkpt/main.c
@@ -1886,6 +1886,10 @@ prepare_ubo(refdef_t *fd, mleaf_t* viewleaf, const reference_mode_t* ref_mode, c
 
 	QVKUniformBuffer_t *ubo = &vkpt_refdef.uniform_buffer;
 	memcpy(ubo->V_prev, ubo->V, sizeof(float) * 16);
+	memcpy(ubo->P_prev, ubo->P, sizeof(float) * 16);
+	memcpy(ubo->invP_prev, ubo->invP, sizeof(float) * 16);
+	ubo->cylindrical_hfov_prev = ubo->cylindrical_hfov;
+
 	{
 		float raw_proj[16];
 		create_projection_matrix(raw_proj, vkpt_refdef.z_near, vkpt_refdef.z_far, fd->fov_x, fd->fov_y);

diff --git a/src/refresh/vkpt/shader/asvgf_fwd_project.comp b/src/refresh/vkpt/shader/asvgf_fwd_project.comp
@@ -221,7 +221,7 @@ main()
 	float distance_curr;
 	vec3 view_pos_curr = (global_ubo.V * vec4(pos_ws, 1.0)).xyz;
 
-	if(!projection_view_to_screen(view_pos_curr, screen_pos_curr, distance_curr))
+	if(!projection_view_to_screen(view_pos_curr, screen_pos_curr, distance_curr, false))
 	{
 		return;
 	}

diff --git a/src/refresh/vkpt/shader/global_ubo.h b/src/refresh/vkpt/shader/global_ubo.h
@@ -140,18 +140,19 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 	GLOBAL_UBO_VAR_LIST_DO(int,             water_normal_texture) \
 	\
 	GLOBAL_UBO_VAR_LIST_DO(float,           pt_env_scale) \
-	GLOBAL_UBO_VAR_LIST_DO(float,           padding1) \
-	GLOBAL_UBO_VAR_LIST_DO(float,           padding2) \
+	GLOBAL_UBO_VAR_LIST_DO(float,           cylindrical_hfov) \
+	GLOBAL_UBO_VAR_LIST_DO(float,           cylindrical_hfov_prev) \
 	GLOBAL_UBO_VAR_LIST_DO(float,           padding3) \
 	\
 	GLOBAL_UBO_VAR_LIST_DO(vec4,            dynamic_light_data[MAX_LIGHT_SOURCES * 2]) \
-	GLOBAL_UBO_VAR_LIST_DO(vec3,            cam_pos) \
-	GLOBAL_UBO_VAR_LIST_DO(float,           cylindrical_hfov) \
+	GLOBAL_UBO_VAR_LIST_DO(vec4,            cam_pos) \
 	GLOBAL_UBO_VAR_LIST_DO(mat4,            V) \
 	GLOBAL_UBO_VAR_LIST_DO(mat4,            invV) \
 	GLOBAL_UBO_VAR_LIST_DO(mat4,            V_prev) \
 	GLOBAL_UBO_VAR_LIST_DO(mat4,            P) \
 	GLOBAL_UBO_VAR_LIST_DO(mat4,            invP) \
+	GLOBAL_UBO_VAR_LIST_DO(mat4,            P_prev) \
+	GLOBAL_UBO_VAR_LIST_DO(mat4,            invP_prev) \
 	GLOBAL_UBO_VAR_LIST_DO(mat4,            environment_rotation_matrix) \
 	\
 	UBO_CVAR_LIST // WARNING: Do not put any other members into global_ubo after this: the CVAR list is not vec4-aligned

diff --git a/src/refresh/vkpt/shader/god_rays.comp b/src/refresh/vkpt/shader/god_rays.comp
@@ -156,7 +156,7 @@ void main()
 
 	ivec2 sourcePixelPos = pixelPos.xy * 2 + GetRotatedGridOffset(pixelPos.xy);
 
-	vec3 view_dir = projection_screen_to_view(i_uv, 1.0);
+	vec3 view_dir = projection_screen_to_view(i_uv, 1.0, false);
 	vec3 direction = normalize((global_ubo.invV * vec4(view_dir, 0)).xyz);
 
 	float distance = texelFetch(t_DepthBuffer, sourcePixelPos.xy, 0).r;

diff --git a/src/refresh/vkpt/shader/primary_rays.rgen b/src/refresh/vkpt/shader/primary_rays.rgen
@@ -35,7 +35,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 Ray
 get_primary_ray(vec2 screen_pos)
 {
-	vec3 view_dir = projection_screen_to_view(screen_pos, 1);
+	vec3 view_dir = projection_screen_to_view(screen_pos, 1, false);
 	view_dir = normalize((global_ubo.invV * vec4(view_dir, 0)).xyz);
 
 	Ray ray;
@@ -123,7 +123,7 @@ main()
 		vec3 prev_view_dir = (global_ubo.V_prev * vec4(direction, 0)).xyz;
 		vec2 prev_screen_pos;
 		float prev_distance;
-		projection_view_to_screen(prev_view_dir, prev_screen_pos, prev_distance);
+		projection_view_to_screen(prev_view_dir, prev_screen_pos, prev_distance, true);
 		vec2 motion = prev_screen_pos - inUV;
 
 		// Store an empty surface into the G-buffer
@@ -218,8 +218,8 @@ main()
 
 	vec2 screen_pos_curr, screen_pos_prev;
 	float distance_curr, distance_prev;
-	projection_view_to_screen((global_ubo.V * vec4(pos_ws_curr, 1)).xyz, screen_pos_curr, distance_curr);
-	projection_view_to_screen((global_ubo.V_prev * vec4(pos_ws_prev, 1)).xyz, screen_pos_prev, distance_prev);
+	projection_view_to_screen((global_ubo.V * vec4(pos_ws_curr, 1)).xyz, screen_pos_curr, distance_curr, false);
+	projection_view_to_screen((global_ubo.V_prev * vec4(pos_ws_prev, 1)).xyz, screen_pos_prev, distance_prev, true);
 
 	float depth_vs_x = length(pos_ws_x - global_ubo.cam_pos.xyz);
 	float depth_vs_y = length(pos_ws_y - global_ubo.cam_pos.xyz);

diff --git a/src/refresh/vkpt/shader/projection.glsl b/src/refresh/vkpt/shader/projection.glsl
@@ -16,24 +16,33 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
-bool projection_view_to_screen(vec3 view_pos, out vec2 screen_pos, out float distance)
+bool projection_view_to_screen(vec3 view_pos, out vec2 screen_pos, out float distance, bool previous)
 {
-	if(global_ubo.cylindrical_hfov > 0)
+	float cylindrical_hfov = previous ? global_ubo.cylindrical_hfov_prev : global_ubo.cylindrical_hfov;
+
+	if(cylindrical_hfov > 0)
 	{
 		float y = view_pos.y / length(view_pos.xz);
-		y *= global_ubo.P[1][1];
+		if(previous)
+			y *= global_ubo.P_prev[1][1];
+		else
+			y *= global_ubo.P[1][1];
 		screen_pos.y = y * 0.5 + 0.5;
 
 		float angle = atan(view_pos.x, view_pos.z);
-		screen_pos.x = (angle / global_ubo.cylindrical_hfov) + 0.5;
+		screen_pos.x = (angle / cylindrical_hfov) + 0.5;
 
 		distance = length(view_pos);
 
 		return screen_pos.y > 0 && screen_pos.y < 1 && screen_pos.x > 0 && screen_pos.x < 1;
 	}
 	else
 	{
-		vec4 clip_pos = global_ubo.P * vec4(view_pos, 1);
+		vec4 clip_pos;
+		if(previous)
+			clip_pos = global_ubo.P_prev * vec4(view_pos, 1);
+		else
+			clip_pos = global_ubo.P * vec4(view_pos, 1);
 
 		vec3 normalized = clip_pos.xyz / clip_pos.w;
 		screen_pos.xy = normalized.xy * 0.5 + vec2(0.5);
@@ -43,14 +52,20 @@ bool projection_view_to_screen(vec3 view_pos, out vec2 screen_pos, out float dis
 	}
 }
 
-vec3 projection_screen_to_view(vec2 screen_pos, float distance)
+vec3 projection_screen_to_view(vec2 screen_pos, float distance, bool previous)
 {
-	if(global_ubo.cylindrical_hfov > 0)
+	float cylindrical_hfov = previous ? global_ubo.cylindrical_hfov_prev : global_ubo.cylindrical_hfov;
+
+	if(cylindrical_hfov > 0)
 	{
 		vec4 clip_pos = vec4(0, screen_pos.y * 2.0 - 1.0, 1, 1);
-		vec3 view_dir = (global_ubo.invP * clip_pos).xyz;
+		vec3 view_dir;
+		if(previous)
+			view_dir = (global_ubo.invP_prev * clip_pos).xyz;
+		else
+			view_dir = (global_ubo.invP * clip_pos).xyz;
 
-		float xangle = (screen_pos.x - 0.5) * global_ubo.cylindrical_hfov;
+		float xangle = (screen_pos.x - 0.5) * cylindrical_hfov;
 		view_dir.x = sin(xangle);
 		view_dir.z = cos(xangle);
 
@@ -61,7 +76,11 @@ vec3 projection_screen_to_view(vec2 screen_pos, float distance)
 	else
 	{
 		vec4 clip_pos = vec4(screen_pos.xy * 2.0 - vec2(1.0), 1, 1);
-		vec3 view_dir = normalize((global_ubo.invP * clip_pos).xyz);
+		vec3 view_dir;
+		if(previous)
+			view_dir = normalize((global_ubo.invP_prev * clip_pos).xyz);
+		else
+			view_dir = normalize((global_ubo.invP * clip_pos).xyz);
 
 		return view_dir * distance;
 	}