[Render/Window] Reworked callbacks to be more readable

- Declared actual structures instead of using tuples

- Made use of C++20 ranges in several places

Author: Razakhel

include/RaZ/Data/Graph.inl

@@ -34,10 +34,10 @@ void GraphNode<T>::addParents(GraphNode& node, OtherNodesTs&&... otherNodes) {
   if (&node == this)
     throw std::invalid_argument("Error: A graph node cannot be a parent of itself");
 
-  if (std::find(m_parents.cbegin(), m_parents.cend(), &node) == m_parents.cend())
+  if (std::ranges::find(m_parents, &node) == m_parents.cend())
     m_parents.emplace_back(static_cast<T*>(&node));
 
-  if (std::find(node.m_children.cbegin(), node.m_children.cend(), this) == node.m_children.cend())
+  if (std::ranges::find(node.m_children, this) == node.m_children.cend())
     node.m_children.emplace_back(static_cast<T*>(this));
 
   // Stop the recursive unpacking if no more nodes are to be added as parents
@@ -62,10 +62,10 @@ void GraphNode<T>::addChildren(GraphNode& node, OtherNodesTs&&... otherNodes) {
   if (&node == this)
     throw std::invalid_argument("Error: A graph node cannot be a child of itself");
 
-  if (std::find(m_children.cbegin(), m_children.cend(), &node) == m_children.cend())
+  if (std::ranges::find(m_children, &node) == m_children.cend())
     m_children.emplace_back(static_cast<T*>(&node));
 
-  if (std::find(node.m_parents.cbegin(), node.m_parents.cend(), this) == node.m_parents.cend())
+  if (std::ranges::find(node.m_parents, this) == node.m_parents.cend())
     node.m_parents.emplace_back(static_cast<T*>(this));
 
   // Stop the recursive unpacking if no more nodes are to be added as children
@@ -89,7 +89,7 @@ void GraphNode<T>::unlinkParent(const GraphNode& node) {
   if (&node == this)
     throw std::invalid_argument("Error: A graph node cannot be unlinked from itself");
 
-  const auto parentIt = std::find(m_parents.cbegin(), m_parents.cend(), &node);
+  const auto parentIt = std::ranges::find(m_parents, &node);
   if (parentIt != m_parents.cend())
     m_parents.erase(parentIt);
 }
@@ -99,7 +99,7 @@ void GraphNode<T>::unlinkChild(const GraphNode& node) {
   if (&node == this)
     throw std::invalid_argument("Error: A graph node cannot be unlinked from itself");
 
-  const auto childIt = std::find(m_children.cbegin(), m_children.cend(), &node);
+  const auto childIt = std::ranges::find(m_children, &node);
   if (childIt != m_children.cend())
     m_children.erase(childIt);
 }
@@ -125,7 +125,7 @@ NodeT& Graph<NodeT>::addNode(Args&& ... args) {
 
 template <typename NodeT>
 void Graph<NodeT>::removeNode(NodeT& node) {
-  const auto nodeIt = std::find_if(m_nodes.cbegin(), m_nodes.cend(), [&node] (const NodePtr& nodePtr) { return (nodePtr.get() == &node); });
+  const auto nodeIt = std::ranges::find_if(m_nodes, [&node] (const NodePtr& nodePtr) noexcept { return (nodePtr.get() == &node); });
 
   if (nodeIt == m_nodes.cend())
     throw std::invalid_argument("Error: The graph node to be removed does not exist");

include/RaZ/Math/Matrix.hpp

@@ -197,7 +197,7 @@ class Matrix {
   /// \param mat Matrix to be compared with.
   /// \return True if matrices are [nearly] equal, else otherwise.
   constexpr bool operator==(const Matrix& mat) const noexcept;
-  /// Output stream operator.
+  /// Matrix output stream operator.
   /// \param stream Stream to output into.
   /// \param mat Matrix to be output.
   friend std::ostream& operator<< <>(std::ostream& stream, const Matrix& mat);

include/RaZ/Math/Quaternion.hpp

@@ -116,7 +116,7 @@ class Quaternion {
   /// Matrix conversion operator; computes the rotation matrix represented by the quaternion.
   /// \return Rotation matrix.
   constexpr operator Mat4<T>() const noexcept { return computeMatrix(); }
-  /// Output stream operator.
+  /// Quaternion output stream operator.
   /// \param stream Stream to output into.
   /// \param quat Quaternion to be output.
   friend std::ostream& operator<< <>(std::ostream& stream, const Quaternion& quat);

include/RaZ/Math/Vector.hpp

@@ -222,7 +222,7 @@ class Vector {
   /// \tparam T2 Type to convert the vector's values to.
   /// \return Vector object of the new type.
   template <typename T2> constexpr explicit operator Vector<T2, Size>() const noexcept;
-  /// Output stream operator.
+  /// Vector output stream operator.
   /// \param stream Stream to output into.
   /// \param vec Vector to be output.
   friend std::ostream& operator<< <>(std::ostream& stream, const Vector& vec);
@@ -234,16 +234,16 @@ class Vector {
 /// Element-wise value-vector addition operator (of the form val + vec).
 /// \tparam T Type of the vector's data.
 /// \tparam Size Vector's size.
-/// \param val Value to be added to the vectors's element.
-/// \param vec Vector to be additioned.
-/// \return Additioned vector.
+/// \param val Value to be added to the vector's elements.
+/// \param vec Vector to be added.
+/// \return Added vector.
 template <typename T, std::size_t Size>
 constexpr Vector<T, Size> operator+(T val, const Vector<T, Size>& vec) noexcept { return vec + val; }
 
 /// Element-wise value-vector multiplication operator (of the form val * vec).
 /// \tparam T Type of the vector's data.
 /// \tparam Size Vector's size.
-/// \param val Value to be multiplied by the vectors's element.
+/// \param val Value to multiply the vector's elements by.
 /// \param vec Vector to be multiplied.
 /// \return Multiplied vector.
 template <typename T, std::size_t Size>

include/RaZ/Math/Vector.inl

@@ -248,7 +248,7 @@ constexpr Vector<T, Size>& Vector<T, Size>::operator*=(ValT val) noexcept {
 template <typename T, std::size_t Size>
 constexpr Vector<T, Size>& Vector<T, Size>::operator/=(const Vector& vec) noexcept {
   if constexpr (std::is_integral_v<T>)
-    assert("Error: Integer vector division by 0 is undefined." && (std::find(vec.m_data.cbegin(), vec.m_data.cend(), 0) == vec.m_data.cend()));
+    assert("Error: Integer vector division by 0 is undefined." && (std::ranges::find(vec.m_data, 0) == vec.m_data.cend()));
 
   for (std::size_t i = 0; i < Size; ++i)
     m_data[i] /= vec[i];

include/RaZ/Render/ShaderProgram.hpp

@@ -45,7 +45,7 @@ class ShaderProgram {
   /// Checks if an attribute has been set with the given uniform name.
   /// \param uniformName Uniform name to be checked.
   /// \return True if an attribute exists with the given name, false otherwise.
-  bool hasAttribute(const std::string& uniformName) const noexcept;
+  bool hasAttribute(const std::string& uniformName) const noexcept { return m_attributes.contains(uniformName); }
   /// Checks if an attribute has been set with the given uniform name and type.
   /// \tparam T Type to be checked.
   /// \param uniformName Uniform name to be checked.

include/RaZ/Render/Window.hpp

@@ -19,14 +19,6 @@ class RenderSystem;
 class Window;
 using WindowPtr = std::unique_ptr<Window>;
 
-using KeyboardCallbacks    = std::vector<std::tuple<int, std::function<void(float)>, Input::ActionTrigger, std::function<void()>>>;
-using MouseButtonCallbacks = std::vector<std::tuple<int, std::function<void(float)>, Input::ActionTrigger, std::function<void()>>>;
-using MouseScrollCallback  = std::function<void(double, double)>;
-using MouseMoveCallback    = std::tuple<double, double, std::function<void(double, double)>>;
-using InputActions         = std::unordered_map<int, std::pair<std::function<void(float)>, Input::ActionTrigger>>;
-using InputCallbacks       = std::tuple<KeyboardCallbacks, MouseButtonCallbacks, MouseScrollCallback, MouseMoveCallback, InputActions>;
-using CloseCallback        = std::function<void()>;
-
 enum class WindowSetting : unsigned int {
   FOCUSED        = 1,   ///< Forces the window to take the focus.
   RESIZABLE      = 2,   ///< Makes the window able to be resized, either by dragging the edges & corners or by maximizing it.
@@ -92,7 +84,7 @@ class Window {
   /// \param width New window width.
   /// \param height New window height.
   /// \note The width & height are to be considered just hints; the window manager remains responsible for the actual dimensions, which may be lower.
-  ///   This can notably happen when the requested window size exceeds what the screens can display. The actual window's size can be queried afterward.
+  ///   This can notably happen when the requested window size exceeds what the screens can display. The actual size can be queried afterward.
   /// \see getWidth(), getHeight()
   void resize(unsigned int width, unsigned int height);
   /// Sets the window in a fullscreen mode, taking the whole main monitor's screen.
@@ -155,7 +147,7 @@ class Window {
   /// Sets the action to be executed on window close.
   /// \param func Action to be executed when the window is closed.
   void setCloseCallback(std::function<void()> func);
-  /// Associates all of the callbacks, making them active.
+  /// Associates all the callbacks, making them active.
   void updateCallbacks() const;
 #if !defined(RAZ_NO_OVERLAY)
   /// Changes the overlay's enabled state.
@@ -178,6 +170,31 @@ class Window {
   ~Window() { close(); }
 
 private:
+  struct KeyboardCallback {
+    Keyboard::Key key;
+    std::function<void(float)> actionPress;
+    Input::ActionTrigger frequency;
+    std::function<void()> actionRelease;
+  };
+
+  struct MouseButtonCallback {
+    Mouse::Button button;
+    std::function<void(float)> actionPress;
+    Input::ActionTrigger frequency;
+    std::function<void()> actionRelease;
+  };
+
+  struct MouseMoveCallback {
+    double xPrevPos {};
+    double yPrevPos {};
+    std::function<void(double, double)> action;
+  };
+
+  struct InputAction {
+    std::function<void(float)> action;
+    Input::ActionTrigger frequency;
+  };
+
   /// Processes actions corresponding to keyboard & mouse inputs.
   /// \param deltaTime Amount of time elapsed since the last frame.
   void processInputs(float deltaTime);
@@ -196,8 +213,12 @@ class Window {
   int m_posX {};
   int m_posY {};
 
-  InputCallbacks m_callbacks {};
-  CloseCallback m_closeCallback {};
+  std::vector<KeyboardCallback> m_keyboardCallbacks;
+  std::vector<MouseButtonCallback> m_mouseButtonCallbacks;
+  std::function<void(double, double)> m_mouseScrollCallback;
+  MouseMoveCallback m_mouseMoveCallback;
+  std::unordered_map<int, InputAction> m_inputActions;
+  std::function<void()> m_closeCallback;
 
 #if !defined(RAZ_NO_OVERLAY)
   Overlay m_overlay {};

include/RaZ/Utils/StrUtils.hpp

@@ -211,7 +211,7 @@ inline std::wstring toUppercaseCopy(std::wstring text) {
 /// \param text String to be trimmed.
 /// \return Reference to the trimmed string.
 inline std::string& trimLeft(std::string& text) {
-  text.erase(text.begin(), std::find_if_not(text.begin(), text.end(), [] (unsigned char c) {
+  text.erase(text.begin(), std::ranges::find_if_not(text, [] (unsigned char c) noexcept(noexcept(std::isspace(c))) {
     return std::isspace(c);
   }));
   return text;
@@ -221,7 +221,7 @@ inline std::string& trimLeft(std::string& text) {
 /// \param text Wide string to be trimmed.
 /// \return Reference to the trimmed wide string.
 inline std::wstring& trimLeft(std::wstring& text) {
-  text.erase(text.begin(), std::find_if_not(text.begin(), text.end(), [] (wchar_t c) {
+  text.erase(text.begin(), std::ranges::find_if_not(text, [] (wchar_t c) noexcept(noexcept(std::iswspace(c))) {
     return std::iswspace(c);
   }));
   return text;

src/RaZ/Render/Framebuffer.cpp

@@ -10,6 +10,8 @@
 #include "GL/glew.h" // Needed by TracyOpenGL.hpp
 #include "tracy/TracyOpenGL.hpp"
 
+#include <ranges>
+
 namespace Raz {
 
 namespace {
@@ -96,7 +98,7 @@ void Framebuffer::addColorBuffer(Texture2DPtr texture, unsigned int index) {
   if (texture->getColorspace() == TextureColorspace::DEPTH || texture->getColorspace() == TextureColorspace::INVALID)
     throw std::invalid_argument("Error: Invalid color buffer");
 
-  const auto bufferIt = std::find_if(m_colorBuffers.cbegin(), m_colorBuffers.cend(), [&texture, index] (const auto& colorBuffer) {
+  const auto bufferIt = std::ranges::find_if(m_colorBuffers, [&texture, index] (const auto& colorBuffer) noexcept {
     return (texture == colorBuffer.first && index == colorBuffer.second);
   });
 
@@ -111,10 +113,9 @@ void Framebuffer::removeTextureBuffer(const Texture2DPtr& texture) {
   if (texture == m_depthBuffer) {
     m_depthBuffer.reset();
   } else {
-    const auto bufferIt = std::remove_if(m_colorBuffers.begin(), m_colorBuffers.end(), [&texture] (const auto& buffer) {
+    std::erase_if(m_colorBuffers, [&texture] (const auto& buffer) noexcept {
       return (texture == buffer.first);
     });
-    m_colorBuffers.erase(bufferIt, m_colorBuffers.end());
   }
 
   mapBuffers();
@@ -131,7 +132,7 @@ void Framebuffer::resizeBuffers(unsigned int width, unsigned int height) {
   if (m_depthBuffer)
     m_depthBuffer->resize(width, height);
 
-  for (const auto& [colorBuffer, _] : m_colorBuffers)
+  for (const Texture2DPtr& colorBuffer : m_colorBuffers | std::views::keys)
     colorBuffer->resize(width, height);
 }
 

src/RaZ/Render/RenderGraph.cpp

@@ -1,5 +1,4 @@
 #include "RaZ/Math/Transform.hpp"
-#include "RaZ/Render/Camera.hpp"
 #include "RaZ/Render/MeshRenderer.hpp"
 #include "RaZ/Render/RenderGraph.hpp"
 #include "RaZ/Render/RenderSystem.hpp"
@@ -11,7 +10,7 @@
 namespace Raz {
 
 bool RenderGraph::isValid() const {
-  return std::all_of(m_nodes.cbegin(), m_nodes.cend(), [] (const std::unique_ptr<RenderPass>& renderPass) {
+  return std::ranges::all_of(m_nodes, [] (const std::unique_ptr<RenderPass>& renderPass) {
     return renderPass->isValid();
   });
 }