paradiso-win/src/lib/shader.hpp

#ifndef PARADISO_SHADER_HPP
#define PARADISO_SHADER_HPP

#include "globals.hpp"

#include <memory>
#include <string>
#include <tuple>
#include <unordered_map>
#include <variant>
#include <vector>

namespace paradiso {

struct Shader final {
    Shader();
    ~Shader();
    Shader(const Shader&) = delete;
    Shader(Shader&&) = default;

    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); }

    bool ready() const;

    bool build();

    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

    /**
     * @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;
    }

    /**
     * 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_cache_t = std::vector<uniform_entry_t>;

    void set_uniforms(uniform_cache_t c);

    uint32_t native_handle() const;

  private:
    std::unordered_map<Type, std::string> source_;

    struct impl;
    std::unique_ptr<impl> impl_;
};

} // namespace paradiso

#endif