window.hpp

Go to the documentation of this file.

#ifndef WINDOW_HPP
#define WINDOW_HPP
 
#include <glad/glad.h>
#include <GLFW/glfw3.h>
 
#include <numeric>
#include <optional>
#include <ostream>
#include <vector>
 
#include "sbpt_generated_includes.hpp"
 
struct VideoMode {
    int width;
    int height;
    int refresh_rate;
 
    friend std::ostream &operator<<(std::ostream &os, const VideoMode &vm) {
        os << vm.width << "x" << vm.height << " @ " << vm.refresh_rate << "Hz";
        return os;
    }
};
 
std::vector<std::string> get_available_resolutions(const std::optional<std::string> &aspect_ratio = std::nullopt);
 
class Window {
  private:
    Logger logger{"window"};
 
  public:
    unsigned int width_px, height_px;
    int top_left_corner_of_window_x, top_left_corner_of_window_y;
 
    Window(unsigned int width_px = 700, unsigned int height_px = 700, const std::string &window_name = "my program",
           bool start_in_fullscreen = false, bool start_with_mouse_captured = false, bool vsync = false,
           bool print_out_opengl_data = false);
    ~Window();
    GLFWwindow *glfw_window;
    void print_opengl_info();
    void toggle_mouse_mode();
    void disable_cursor();
    void enable_cursor();
 
    bool window_should_close() { return glfwWindowShouldClose(glfw_window); }
 
    // these functions only exist so I don't have to rember the opengl api for this
    void enable_wireframe_mode();
    void disable_wireframe_mode();
 
    void set_resolution(const std::string &resolution);
 
    void toggle_fullscreen();
    void enable_fullscreen();
    void disable_fullscreen();
    void set_fullscreen_by_on_off(const std::string &on_off_string);
 
    std::tuple<unsigned int, unsigned int> reduce_ratio(std::tuple<unsigned int, unsigned int> ratio) {
        auto [num, den] = ratio;
        if (den == 0) {
            // Handle division by zero gracefully (you can also throw an exception)
            return {0, 0};
        }
 
        unsigned int g = std::gcd(num, den);
        return {num / g, den / g};
    }
 
    std::tuple<unsigned int, unsigned int> get_aspect_ratio_in_simplest_terms() {
        return reduce_ratio({this->width_px, this->height_px});
    }
 
    std::function<void(double)> wrap_tick_with_required_glfw_calls(std::function<void(double)> tick) {
        return [tick, this](double dt) {
            // clear buffers before tick
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
            tick(dt);
 
            // swap and poll after tick
            glfwSwapBuffers(glfw_window);
            glfwPollEvents();
        };
    }
 
    bool cursor_is_disabled = false;
    bool window_in_fullscreen = false;
};
 
#endif // WINDOW_HPP