we can see a quad

src/lib/shader.hpp

@@ -3,84 +3,84 @@
 
 #include "globals.hpp"
 
+#include <memory>
+#include <string>
+#include <tuple>
 #include <unordered_map>
 #include <variant>
-#include <string>
 #include <vector>
-#include <memory>
-#include <tuple>
 
-namespace paradiso
-{
+namespace paradiso {
 
-    struct Shader final
-    {
-        Shader();
-        ~Shader();
-        Shader(const Shader &) = delete;
-        Shader(Shader &&) = default;
+struct Shader final {
+    Shader();
+    ~Shader();
+    Shader(const Shader&) = delete;
+    Shader(Shader&&) = default;
 
-        enum class Type
-        {
-            Vertex,
-            Fragment,
-            Geometry,
-            Compute
-        };
+    enum class Type { Vertex, Fragment, Geometry, Compute };
 
-        void set_source(Type t, const std::string &c) { source_[t] = c; }
-        std::string source(Type t) const { return source_.at(t); }
+    void set_source(Type t, const std::string& c) { source_[t] = c; }
+    std::string source(Type t) const { return source_.at(t); }
 
-        bool ready() const;
+    bool ready() const;
 
-        bool build();
+    bool build();
 
-        void use();
+    void use();
 
-        Shader &set_uniform_at_location(int location, float v);    //!< sets a float in a shader
-        Shader &set_uniform_at_location(int location, uint32_t v); //!< sets a 32bit unsigned in a shader
-        Shader &set_uniform_at_location(int location, int32_t v);  //!< sets a 32bit signed in a shader
+    Shader& set_uniform_at_location(int location,
+                                    float v); //!< sets a float in a shader
+    Shader&
+    set_uniform_at_location(int location,
+                            uint32_t v); //!< sets a 32bit unsigned in a shader
+    Shader&
+    set_uniform_at_location(int location,
+                            int32_t v); //!< sets a 32bit signed in a shader
 
-        /**
-         * @brief retrieves the position of a uniform
-         * @param name of the uniform
-         * @return position of the uniform or negative if it doesn't exist
-         */
-        int uniform_location(std::string const &name) const;
+    /**
+     * @brief retrieves the position of a uniform
+     * @param name of the uniform
+     * @return position of the uniform or negative if it doesn't exist
+     */
+    int uniform_location(std::string const& name) const;
 
-        /**
-         * @brief check if a uniform with the given name exists
-         * @param name of the uniform
-         * @return true if found
-         */
-        bool has_uniform(std::string const &name) const { return uniform_location(name) >= 0; }
+    /**
+     * @brief check if a uniform with the given name exists
+     * @param name of the uniform
+     * @return true if found
+     */
+    bool has_uniform(std::string const& name) const {
+        return uniform_location(name) >= 0;
+    }
 
-        /**
-         * sets data of the
-         */
-        template <typename T>
-        Shader &set_uniform(std::string const &name, T &&value)
-        {
-            return set_uniform_at_location(uniform_location(name), std::forward<T>(value));
-        }
+    /**
+     * sets data of the
+     */
+    template <typename T>
+    Shader& set_uniform(std::string const& name, T&& value) {
+        return set_uniform_at_location(uniform_location(name),
+                                       std::forward<T>(value));
+    }
 
+    using uniform_t =
+        std::variant<bool, int, float,
+                     double /*,vector2f,vector3f,vector4f,matrix4x4f*/>;
+    using uniform_entry_t = std::tuple<std::string, uniform_t, int>;
 
-        using uniform_t = std::variant<bool, int, float, double /*,vector2f,vector3f,vector4f,matrix4x4f*/>;
-        using uniform_entry_t = std::tuple<std::string, uniform_t, int>;
+    using uniform_cache_t = std::vector<uniform_entry_t>;
 
-        using uniform_cache_t = std::vector<uniform_entry_t>;
+    void set_uniforms(uniform_cache_t c);
 
-        void set_uniforms(uniform_cache_t c);
+    uint32_t native_handle() const;
 
-        uint32_t native_handle() const;
+  private:
+    std::unordered_map<Type, std::string> source_;
 
-    private:
-        std::unordered_map<Type, std::string> source_;
+    struct impl;
+    std::unique_ptr<impl> impl_;
+};
 
-        struct impl;
-        std::unique_ptr<impl> impl_;
-    };
-
-}
+} // namespace paradiso
 
 #endif