[merge] Merge pull request #408 from inexorgame/yeetari/fov-fix

[camera] Make sure to convert horizontal fov to vertical fov before passing to glm

Author: IAmNotHanni

configuration/renderer.toml

@@ -13,8 +13,8 @@ name = "Inexor-Engine"
 
 [application.window]
 mode = "windowed"
-width = 800
-height = 800
+width = 1280
+height = 720
 name = "Inexor-Vulkan-Renderer"
 
 [shaders]

include/inexor/vulkan-renderer/camera.hpp

@@ -53,7 +53,7 @@ class Camera {
     /// The camera's maximum pitch angle.
     /// Looking straight upwards is the maximum pitch angle.
     float m_pitch_max{+89.0f};
-    /// The camera's field of view.
+    /// The camera's horizontal field of view.
     float m_fov{90.0f};
     /// The camera's maximum field of view.
     float m_fov_max{90.0f};
@@ -76,8 +76,12 @@ class Camera {
 
     /// The keys for the movement FORWARD, BACKWARD, LEFT, RIGHT.
     std::array<bool, 4> m_keys{false, false, false, false};
-    /// Will be set to ``true`` if the matrices need to be recalculated.
-    bool m_update_needed{true};
+
+    float m_vertical_fov{0.0f};
+
+    bool m_update_vertical_fov{false};
+    bool m_update_view_matrix{false};
+    bool m_update_perspective_matrix{false};
 
     void update_vectors();
 
@@ -212,16 +216,12 @@ class Camera {
     void update(float delta_time);
 
     [[nodiscard]] const glm::mat4 &view_matrix() {
-        if (m_update_needed) {
-            update_matrices();
-        }
+        update_matrices();
         return m_view_matrix;
     }
 
     [[nodiscard]] const glm::mat4 &perspective_matrix() {
-        if (m_update_needed) {
-            update_matrices();
-        }
+        update_matrices();
         return m_perspective_matrix;
     }
 };

src/vulkan-renderer/camera.cpp

@@ -22,15 +22,25 @@ void Camera::update_vectors() {
         m_front = glm::normalize(front);
         m_right = glm::normalize(glm::cross(m_front, m_world_up));
         m_up = glm::normalize(glm::cross(m_right, m_front));
-        m_update_needed = false;
+
+        m_update_view_matrix = true;
     }
 }
 
 void Camera::update_matrices() {
     if (m_type == CameraType::LOOK_AT) {
-        m_view_matrix = glm::lookAt(m_position, m_position + m_front, m_up);
-        m_perspective_matrix = glm::perspective(glm::radians(m_fov), m_aspect_ratio, m_near_plane, m_far_plane);
-        m_update_needed = false;
+        if (m_update_vertical_fov) {
+            m_vertical_fov = 2.0f * glm::atan(glm::tan(glm::radians(m_fov) / 2.0f) / m_aspect_ratio);
+            m_update_vertical_fov = false;
+        }
+        if (m_update_view_matrix) {
+            m_view_matrix = glm::lookAt(m_position, m_position + m_front, m_up);
+            m_update_view_matrix = false;
+        }
+        if (m_update_perspective_matrix) {
+            m_perspective_matrix = glm::perspective(m_vertical_fov, m_aspect_ratio, m_near_plane, m_far_plane);
+            m_update_perspective_matrix = false;
+        }
     }
 }
 
@@ -61,10 +71,13 @@ void Camera::set_movement_state(const CameraMovement key, const bool pressed) {
 
 void Camera::set_position(const glm::vec3 position) {
     m_position = position;
+    m_update_view_matrix = true;
 }
 
 void Camera::set_aspect_ratio(const float width, const float height) {
     m_aspect_ratio = width / height;
+    m_update_perspective_matrix = true;
+    m_update_vertical_fov = true;
 }
 
 void Camera::set_movement_speed(const float speed) {
@@ -92,22 +105,25 @@ void Camera::set_rotation(const float yaw, const float pitch, const float roll)
 
 void Camera::set_near_plane(const float near_plane) {
     m_near_plane = near_plane;
+    m_update_perspective_matrix = true;
 }
 
 void Camera::set_far_plane(const float far_plane) {
     m_far_plane = far_plane;
+    m_update_perspective_matrix = true;
 }
 
 void Camera::change_zoom(const float offset) {
     m_fov -= offset * m_zoom_step;
 
     // Make sure field of view is in range between specified minimum and maximum value.
     m_fov = std::clamp(m_fov, m_fov_min, m_fov_max);
+
+    m_update_vertical_fov = true;
+    m_update_perspective_matrix = true;
 }
 
 void Camera::update(const float delta_time) {
-    m_update_needed = true;
-
     if (m_type == CameraType::LOOK_AT && is_moving()) {
         const float move_speed = delta_time * m_movement_speed;
 
@@ -123,6 +139,8 @@ void Camera::update(const float delta_time) {
         if (m_keys[3] && !m_keys[1]) {
             m_position += m_right * move_speed;
         }
+
+        m_update_view_matrix = true;
     }
 }