[merge] Merge pull request #414 from inexorgame/hanni/typo_fixes

[*] Fix typos and remove semicolons for namespaces

Author: IAmNotHanni

benchmarks/world/cube_collision.cpp

@@ -20,4 +20,4 @@ void CubeCollision(benchmark::State &state) {
 
 BENCHMARK(CubeCollision);
 
-}; // namespace inexor::vulkan_renderer
+} // namespace inexor::vulkan_renderer

include/inexor/vulkan-renderer/bezier_curve.hpp

@@ -5,7 +5,7 @@
 // INTRODUCTION
 // A bezier curve (named after french mathematician PIERRE ETIENNE BEZIER) is a parametric curve
 // whose only purpose is to look soft and smooth. Bezier curves are all about elegance!
-// Those curves can be used to represent the path of a everything (imagin a camera which is moving along a path for
+// Those curves can be used to represent the path of a everything (imagine a camera which is moving along a path for
 // example).
 //
 // Bezier curves are fast, flexible, beautiful and easy to compute. You just pass a bunch of parameter points to

include/inexor/vulkan-renderer/camera.hpp

@@ -16,7 +16,7 @@ constexpr glm::vec3 DEFAULT_FRONT{1.0f, 0.0f, 0.0f};
 constexpr glm::vec3 DEFAULT_RIGHT{0.0f, 1.0f, 0.0f};
 /// The default value of the camera's up vector.
 constexpr glm::vec3 DEFAULT_UP{0.0f, 0.0f, 1.0f};
-}; // namespace directions
+} // namespace directions
 
 enum class CameraMovement { FORWARD, BACKWARD, LEFT, RIGHT };
 
@@ -67,7 +67,7 @@ class Camera {
     float m_movement_speed{2.0f};
     /// The camera's aspect ratio (width divided by height).
     float m_aspect_ratio{1920.0f / 1080.0f};
-    /// The sensivity of the mouse.
+    /// The sensitivity of the mouse.
     float m_mouse_sensitivity{0.005f};
     /// The camera's near plane.
     float m_near_plane{0.001f};
@@ -225,4 +225,4 @@ class Camera {
         return m_perspective_matrix;
     }
 };
-}; // namespace inexor::vulkan_renderer
+} // namespace inexor::vulkan_renderer

include/inexor/vulkan-renderer/render_graph.hpp

@@ -198,8 +198,8 @@ class RenderStage : public RenderGraphObject {
         m_descriptor_layouts.push_back(layout);
     }
 
-    /// @brief Specifies a function that will be called during command buffer recordation for this stage
-    /// @details This function can be used to specify other vulkan commands during command buffer recordation. The most
+    /// @brief Specifies a function that will be called during command buffer recording for this stage
+    /// @details This function can be used to specify other vulkan commands during command buffer recording. The most
     ///          common use for this is for draw commands.
     void set_on_record(std::function<void(const class PhysicalStage *, const wrapper::CommandBuffer &)> on_record) {
         m_on_record = std::move(on_record);

include/inexor/vulkan-renderer/renderer.hpp

@@ -98,7 +98,7 @@ class VulkanRenderer {
 
     bool m_window_resized{false};
 
-    /// Neccesary for taking into account the relative speed of the system's CPU.
+    /// Necessary for taking into account the relative speed of the system's CPU.
     float m_time_passed{0.0f};
 
     ///

include/inexor/vulkan-renderer/settings_decision_maker.hpp

@@ -22,18 +22,18 @@ struct SwapchainSettings {
 /// - Which presentation modes should be used?
 struct VulkanSettingsDecisionMaker {
 
-    /// @brief Rate a graphcs card by its features.
+    /// @brief Rate a graphics card by its features.
     /// @note The current implementation just sums up all available memory as a score.
     /// @todo Implement additional graphics card rating criteria if desired.
     /// @param graphics_card The graphics card which will be rated.
     /// @return The graphics card's score which is greater or equal to 0.
     [[nodiscard]] static std::size_t rate_graphics_card(VkPhysicalDevice graphics_card);
 
     /// @brief Automatically decide if a graphics card is suitable for this application's purposes.
-    /// In order to be a suitable graphcs card for Inexor's purposes, it must fulfill the following criteria:
+    /// In order to be a suitable graphics card for Inexor's purposes, it must fulfill the following criteria:
     /// - It must support a swapchain.
     /// - It must support presentation.
-    /// @todo Add more checks to the validation mechanism if neccesary, e.h. check for geometry shader support.
+    /// @todo Add more checks to the validation mechanism if necessary, e.h. check for geometry shader support.
     /// @param graphics_card The graphics card which will be checked for suitability.
     /// @return ``true`` if the graphics card is suitable.
     /// @warning When implementing additional graphics card suitability criteria, do not return false for graphics cards
@@ -65,7 +65,7 @@ struct VulkanSettingsDecisionMaker {
     [[nodiscard]] static std::uint32_t decide_how_many_images_in_swapchain_to_use(VkPhysicalDevice graphics_card,
                                                                                   VkSurfaceKHR surface);
 
-    /// @brief Automatically decide whcih surface color to use in swapchain.
+    /// @brief Automatically decide which surface color to use in swapchain.
     /// @param graphics_card The selected graphics card.
     /// @param surface The selected (window) surface.
     /// @return The surface format for swapchain if any could be determined, std::nullopt otherwise.

include/inexor/vulkan-renderer/time_step.hpp

@@ -5,7 +5,7 @@
 namespace inexor::vulkan_renderer {
 
 /// @brief Responsible for calculating the amount of time which has passed between rendering two frames.
-/// Since every machine has slightly different speed, it is neccesary to the timestep when animating something.
+/// Since every machine has slightly different speed, it is necessary to the timestep when animating something.
 /// @todo Implement time step for every thread?
 class TimeStep {
     // The time point of the last render call.

include/inexor/vulkan-renderer/world/collision.hpp

@@ -9,7 +9,7 @@ namespace inexor::vulkan_renderer::world {
 
 /// @brief A wrapper for collisions between a ray and octree geometry.
 /// This class is used for octree collision, but it can be used for every cube-like data structure
-/// @tparam T A templatable type which offers a size() and center() method.
+/// @tparam T A template type which offers a size() and center() method.
 template <typename T>
 class RayCubeCollision {
     const T &m_cube;

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

@@ -111,7 +111,7 @@ class Device {
     }
 
     /// @note Transfer queues are the fastest way to copy data across the PCIe bus. They are heavily underutilized
-    /// even in modern games. Transfer queues can be used asynchronously to graphics queuey.
+    /// even in modern games. Transfer queues can be used asynchronously to graphics queue.
     [[nodiscard]] VkQueue transfer_queue() const {
         return m_transfer_queue;
     }

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

@@ -20,7 +20,7 @@ class Fence {
     /// @brief Default constructor.
     /// @param device The const reference to a device RAII wrapper instance.
     /// @param name The internal debug marker name of the VkFence.
-    /// @param in_signaled_state True if the VkFence will be constructored in signaled state, false otherwise.
+    /// @param in_signaled_state True if the VkFence will be constructed in signaled state, false otherwise.
     /// @warning Make sure to specify in_signaled_state correctly as needed, otherwise synchronization problems occur.
     Fence(const wrapper::Device &device, const std::string &name, bool in_signaled_state);