Merge pull request #263 from inexorgame/hanni/fix_code_warnings_backup

Fix clang-tidy warnings and Microsoft code analysis warnings.

Author: IAmNotHanni

example/main.cpp

@@ -5,8 +5,6 @@
 #include <spdlog/sinks/stdout_color_sinks.h>
 #include <spdlog/spdlog.h>
 
-using namespace inexor::vulkan_renderer;
-
 int main(int argc, char *argv[]) {
     spdlog::init_thread_pool(8192, 2);
 
@@ -24,7 +22,7 @@ int main(int argc, char *argv[]) {
     spdlog::debug("Inexor vulkan-renderer, BUILD " + std::string(__DATE__) + ", " + __TIME__);
     spdlog::debug("Parsing command line arguments.");
 
-    Application renderer(argc, argv);
+    inexor::vulkan_renderer::Application renderer(argc, argv);
     renderer.run();
     renderer.calculate_memory_budget();
     spdlog::debug("Window closed");

include/inexor/vulkan-renderer/camera.hpp

@@ -4,33 +4,32 @@
 
 namespace inexor::vulkan_renderer {
 
+enum class CameraType { LOOKAT, FIRSTPERSON };
+
 /// @brief A RAII wrapper class for camera position and movement.
 /// @todo Refactor method naming!
 class Camera {
-    float m_fov;
-    float m_z_near, m_z_far;
-
     /// @brief Update the view matrix.
     /// @note The view matrix should only be updated if necessary.
     void update_view_matrix();
 
-public:
-    // TODO: Why is so much stuff here public? refactor!
-
-    enum CameraType { LOOKAT, FIRSTPERSON };
     CameraType m_type{CameraType::LOOKAT};
 
-    glm::vec3 m_rotation{};
     glm::vec3 m_position{};
+    glm::vec3 m_rotation{};
 
-    float m_rotation_speed{1.0f};
     float m_movement_speed{1.0f};
+    float m_rotation_speed{1.0f};
+
+    float m_fov{0.0f};
+    float m_z_near{0.0f};
+    float m_z_far{0.0f};
 
     bool m_updated{false};
 
     struct {
-        glm::mat4 perspective;
-        glm::mat4 view;
+        glm::mat4 perspective = glm::mat4();
+        glm::mat4 view = glm::mat4();
     } m_matrices;
 
     struct {
@@ -40,6 +39,28 @@ class Camera {
         bool down{false};
     } m_keys;
 
+public:
+    Camera() = default;
+    /// @brief Constructs a camera based on camera properties.
+    /// @param type The type of the camera.
+    /// @param position The camera's position.
+    /// @param rotation The camera's rotation.
+    /// @param movement_speed The movement speed of the camera.
+    /// @param rotation_speed The rotation speed of the camera.
+    /// @param fov The camera's field of view.
+    /// @param z_near The near clipping value.
+    /// @param z_far The far clipping value.
+    /// @param window_width The width of the window which is used to calculate aspect ratio.
+    /// @param window_height The height of the window which is used to calculate aspect ratio.
+    Camera(CameraType type, glm::vec3 position, glm::vec3 rotation, float movement_speed, float rotation_speed,
+           float fov, float z_near, float z_far, std::uint32_t window_width, std::uint32_t window_height);
+    Camera(const Camera &) = default;
+    Camera(Camera &&) noexcept;
+    ~Camera() = default;
+
+    Camera &operator=(const Camera &) = default;
+    Camera &operator=(Camera &&) = default;
+
     /// @brief Check if any of the following keys is pressed: W, A, S, D.
     bool moving();
 
@@ -85,6 +106,22 @@ class Camera {
     /// @param delta_time The amount of time which passed since last update.
     /// @return Returns true if view or position has been changed.
     bool update_pad(glm::vec2 axis_left, glm::vec2 axis_right, float delta_time);
+
+    [[nodiscard]] glm::mat4 get_perspective() const {
+        return m_matrices.perspective;
+    }
+
+    [[nodiscard]] glm::mat4 get_view() const {
+        return m_matrices.view;
+    }
+
+    [[nodiscard]] float get_rotation_speed() const {
+        return m_rotation_speed;
+    }
+
+    [[nodiscard]] float get_movement_speed() const {
+        return m_movement_speed;
+    }
 };
 
 } // namespace inexor::vulkan_renderer

include/inexor/vulkan-renderer/frame_graph.hpp

@@ -30,8 +30,14 @@ class FrameGraph;
 /// @brief Base class of all frame graph objects (resources and stages)
 /// @note This is just for internal use
 struct FrameGraphObject {
+    FrameGraphObject() = default;
+    FrameGraphObject(const FrameGraphObject &) = delete;
+    FrameGraphObject(FrameGraphObject &&) = delete;
     virtual ~FrameGraphObject() = default;
 
+    FrameGraphObject &operator=(const FrameGraphObject &) = delete;
+    FrameGraphObject &operator=(FrameGraphObject &&) = delete;
+
     /// @brief Casts this object to type `T`
     /// @return The object as type `T` or `nullptr` if the cast failed
     template <typename T>
@@ -56,6 +62,7 @@ class RenderResource : public FrameGraphObject {
 public:
     RenderResource(const RenderResource &) = delete;
     RenderResource(RenderResource &&) = delete;
+    ~RenderResource() override = default;
 
     RenderResource &operator=(const RenderResource &) = delete;
     RenderResource &operator=(RenderResource &&) = delete;
@@ -173,6 +180,7 @@ class RenderStage : public FrameGraphObject {
 public:
     RenderStage(const RenderStage &) = delete;
     RenderStage(RenderStage &&) = delete;
+    ~RenderStage() override = default;
 
     RenderStage &operator=(const RenderStage &) = delete;
     RenderStage &operator=(RenderStage &&) = delete;
@@ -210,6 +218,7 @@ class GraphicsStage : public RenderStage {
     explicit GraphicsStage(std::string &&name) : RenderStage(name) {}
     GraphicsStage(const GraphicsStage &) = delete;
     GraphicsStage(GraphicsStage &&) = delete;
+    ~GraphicsStage() override = default;
 
     GraphicsStage &operator=(const GraphicsStage &) = delete;
     GraphicsStage &operator=(GraphicsStage &&) = delete;
@@ -242,6 +251,7 @@ class PhysicalResource : public FrameGraphObject {
 public:
     PhysicalResource(const PhysicalResource &) = delete;
     PhysicalResource(PhysicalResource &&) = delete;
+    ~PhysicalResource() override = default;
 
     PhysicalResource &operator=(const PhysicalResource &) = delete;
     PhysicalResource &operator=(PhysicalResource &&) = delete;
@@ -291,6 +301,7 @@ class PhysicalBackBuffer : public PhysicalResource {
         : PhysicalResource(allocator, device), m_swapchain(swapchain) {}
     PhysicalBackBuffer(const PhysicalBackBuffer &) = delete;
     PhysicalBackBuffer(PhysicalBackBuffer &&) = delete;
+    ~PhysicalBackBuffer() override = default;
 
     PhysicalBackBuffer &operator=(const PhysicalBackBuffer &) = delete;
     PhysicalBackBuffer &operator=(PhysicalBackBuffer &&) = delete;

include/inexor/vulkan-renderer/imgui.hpp

@@ -65,14 +65,14 @@ class ImGUIOverlay {
     ImGUIOverlay(ImGUIOverlay &&other) noexcept;
 
     ImGUIOverlay &operator=(const ImGUIOverlay &other) = delete;
-    ImGUIOverlay &operator=(ImGUIOverlay &&other) = default;
+    ImGUIOverlay &operator=(ImGUIOverlay &&other) = delete;
 
     [[nodiscard]] float get_scale() const {
         return m_scale;
     }
 
     void update();
-    void render(const std::uint32_t image_index);
+    void render(std::uint32_t image_index);
 };
 
 } // namespace inexor::vulkan_renderer

include/inexor/vulkan-renderer/octree_gpu_vertex.hpp

@@ -24,8 +24,8 @@ namespace std {
 template <>
 struct hash<inexor::vulkan_renderer::OctreeGpuVertex> {
     std::size_t operator()(const inexor::vulkan_renderer::OctreeGpuVertex &vertex) const {
-        auto h1 = std::hash<glm::vec3>{}(vertex.position);
-        auto h2 = std::hash<glm::vec3>{}(vertex.color);
+        const auto h1 = std::hash<glm::vec3>{}(vertex.position);
+        const auto h2 = std::hash<glm::vec3>{}(vertex.color);
         return h1 ^ h2;
     }
 };

include/inexor/vulkan-renderer/renderer.hpp

@@ -89,8 +89,14 @@ class VulkanRenderer {
     void render_frame();
 
 public:
+    VulkanRenderer() = default;
+    VulkanRenderer(const VulkanRenderer &) = delete;
+    VulkanRenderer(VulkanRenderer &&) = delete;
     ~VulkanRenderer();
 
+    VulkanRenderer &operator=(const VulkanRenderer &) = delete;
+    VulkanRenderer &operator=(VulkanRenderer &&) = delete;
+
     /// @brief Run Vulkan memory allocator's memory statistics
     void calculate_memory_budget();
 

include/inexor/vulkan-renderer/settings_decision_maker.hpp

@@ -8,6 +8,12 @@
 
 namespace inexor::vulkan_renderer {
 
+/// @brief A wrapper class for swapchain settings.
+struct SwapchainSettings {
+    VkExtent2D window_size;
+    VkExtent2D swapchain_size;
+};
+
 /// @brief This class makes automatic decisions about setting up Vulkan.
 /// Examples:
 /// - Which graphics card will be used if more than one is available?
@@ -72,11 +78,8 @@ struct VulkanSettingsDecisionMaker {
     /// @param surface The selected (window) surface.
     /// @param window_width The width of the window.
     /// @param window_height The height of the window.
-    /// @param swapchain_extent [out] The extent of the swapchain.
-    /// @todo Make this function return a std::optional<VkExtend2D> instead of using call by reference!
-    void decide_swapchain_extent(const VkPhysicalDevice &graphics_card, const VkSurfaceKHR &surface,
-                                 std::uint32_t &window_width, std::uint32_t &window_height,
-                                 VkExtent2D &swapchain_extent);
+    SwapchainSettings decide_swapchain_extent(const VkPhysicalDevice &graphics_card, const VkSurfaceKHR &surface,
+                                              std::uint32_t window_width, std::uint32_t window_height);
 
     /// @brief Automatically find the image transform, relative to the presentation engine's natural orientation,
     /// applied to the image content prior to presentation.
@@ -90,8 +93,8 @@ struct VulkanSettingsDecisionMaker {
     /// @param graphics_card The selected graphics card.
     /// @param surface The selected (window) surface.
     /// @return The composite alpha flag bits.
-    [[nodiscard]] VkCompositeAlphaFlagBitsKHR find_composite_alpha_format(const VkPhysicalDevice selected_graphics_card,
-                                                                          const VkSurfaceKHR surface);
+    [[nodiscard]] std::optional<VkCompositeAlphaFlagBitsKHR>
+    find_composite_alpha_format(VkPhysicalDevice selected_graphics_card, VkSurfaceKHR surface);
 
     /// @brief Automatically decide which presentation mode the presentation engine will be using.
     /// @note We can only use presentation modes that are available in the current system. The preferred presentation
@@ -162,8 +165,8 @@ struct VulkanSettingsDecisionMaker {
     /// @return A VkFormat value if a suitable depth buffer format could be found, std::nullopt otherwise.
     [[nodiscard]] std::optional<VkFormat> find_depth_buffer_format(const VkPhysicalDevice &graphics_card,
                                                                    const std::vector<VkFormat> &formats,
-                                                                   const VkImageTiling tiling,
-                                                                   const VkFormatFeatureFlags feature_flags);
+                                                                   VkImageTiling tiling,
+                                                                   VkFormatFeatureFlags feature_flags);
 };
 
 } // namespace inexor::vulkan_renderer

include/inexor/vulkan-renderer/wrapper/command_buffer.hpp

@@ -16,7 +16,7 @@ class ResourceDescriptor;
 class CommandBuffer {
     VkCommandBuffer m_command_buffer{VK_NULL_HANDLE};
     const wrapper::Device &m_device;
-    const std::string m_name;
+    std::string m_name;
 
 public:
     /// @brief Default constructor.
@@ -31,7 +31,7 @@ class CommandBuffer {
     ~CommandBuffer() = default;
 
     CommandBuffer &operator=(const CommandBuffer &) = delete;
-    CommandBuffer &operator=(CommandBuffer &&) = default;
+    CommandBuffer &operator=(CommandBuffer &&) = delete;
 
     /// @brief Call vkBeginCommandBuffer.
     /// @note Sometimes it's useful to pass VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT to specify that a command

include/inexor/vulkan-renderer/wrapper/command_pool.hpp

@@ -21,15 +21,15 @@ class CommandPool {
     /// because some wrappers require a queue family index which supports graphics bit, other require transfer bit.
     /// @param device The const reference to the device RAII wrapper class.
     /// @param queue_family_index The queue family index which is used by this command pool.
-    CommandPool(const Device &device, const std::uint32_t queue_family_index);
+    CommandPool(const Device &device, std::uint32_t queue_family_index);
 
     CommandPool(const CommandPool &) = delete;
     CommandPool(CommandPool &&) noexcept;
 
     ~CommandPool();
 
     CommandPool &operator=(const CommandPool &) = delete;
-    CommandPool &operator=(CommandPool &&) = default;
+    CommandPool &operator=(CommandPool &&) = delete;
 
     [[nodiscard]] VkCommandPool get() const {
         return m_command_pool;

include/inexor/vulkan-renderer/wrapper/cpu_texture.hpp

@@ -59,13 +59,14 @@ class CpuTexture {
         return m_mip_levels;
     }
 
-    [[nodiscard]] void *data() const {
-        return static_cast<void *>(m_texture_data);
+    [[nodiscard]] stbi_uc *data() const {
+        return m_texture_data;
     }
 
     [[nodiscard]] std::size_t data_size() const {
         // TODO: We will need to update this once we fully support mip levels.
-        return m_texture_width * m_texture_height * m_texture_channels;
+        return static_cast<std::size_t>(m_texture_width) * static_cast<std::size_t>(m_texture_height) *
+               static_cast<std::size_t>(m_texture_channels);
     }
 };