Window.cpp

Go to the documentation of this file.

 
#define SDL_STBIMG_SDL3
 
#include <display.h>
#include <system.h>
#include <glad/glad.h>
#include <SDL_stbimage.h>
 
#include "galaxy/core/Settings.hpp"
#include "galaxy/fs/VirtualFileSystem.hpp"
#include "galaxy/logging/Log.hpp"
#include "galaxy/platform/Pragma.hpp"
 
#include "Window.hpp"
 
#ifdef GALAXY_WIN_PLATFORM
GALAXY_DISABLE_WARNING_PUSH
GALAXY_DISABLE_WARNING(26818)
#endif
 
namespace galaxy
{
    Window::Window()
        : m_window {nullptr}
        , m_context {nullptr}
        , m_open {true}
    {
        if (SDL_ScreenSaverEnabled())
        {
            SDL_DisableScreenSaver();
        }
 
        int             driver = sl::GFX_AUTODETECT_WINDOWED;
        SDL_WindowFlags flags  = SDL_WINDOW_OPENGL | SDL_WINDOW_INPUT_FOCUS | SDL_WINDOW_MOUSE_FOCUS | SDL_WINDOW_HIDDEN | SDL_WINDOW_HIGH_PIXEL_DENSITY;
        if (Settings::fullscreen())
        {
            flags  |= SDL_WINDOW_FULLSCREEN;
            driver  = sl::GFX_AUTODETECT_FULLSCREEN;
        }
        else
        {
            if (Settings::maximized())
            {
                flags |= SDL_WINDOW_MAXIMIZED;
            }
        }
 
        if (Settings::mouse_grabbed())
        {
            flags |= SDL_WINDOW_MOUSE_GRABBED;
        }
 
        if (Settings::window_resizable())
        {
            flags |= SDL_WINDOW_RESIZABLE;
        }
 
        SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
        SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
        SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
        SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
        SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
        SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
        SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
        SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
        SDL_GL_SetAttribute(SDL_GL_STEREO, 0);
        SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 0);
        SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 0);
        SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1);
        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 6);
        SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG | SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG);
        SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
        SDL_GL_SetAttribute(SDL_GL_SHARE_WITH_CURRENT_CONTEXT, 0);
        SDL_GL_SetAttribute(SDL_GL_FRAMEBUFFER_SRGB_CAPABLE, 1);
        SDL_GL_SetAttribute(SDL_GL_CONTEXT_RELEASE_BEHAVIOR, SDL_GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH);
        SDL_GL_SetAttribute(SDL_GL_CONTEXT_RESET_NOTIFICATION, SDL_GL_CONTEXT_RESET_NO_NOTIFICATION);
 
        sl::set_graphics_backend(sl::GraphicsBackend::opengl);
        const auto result = sl::set_gfx_mode(
            Settings::title().c_str(),
            flags,
            driver,
            Settings::requested_width(),
            Settings::requested_height(),
            Settings::virtual_width(),
            Settings::virtual_height()
        );
 
        if (result)
        {
            m_window  = sl::get_window();
            m_context = sl::get_gl_context();
 
            SDL_GL_SetSwapInterval(Settings::vsync());
            SDL_SetWindowAlwaysOnTop(m_window, false);
            SDL_SetWindowBordered(m_window, Settings::window_border());
            SDL_SetWindowFocusable(m_window, true);
            SDL_SetWindowFullscreenMode(m_window, nullptr); // Borderless Fullscreen mode.
            SDL_SetWindowKeyboardGrab(m_window, false);
            SDL_SetWindowMinimumSize(m_window, 640, 360);
            SDL_SetWindowPosition(m_window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
 
            // Debug configuration.
            glEnable(GL_DEBUG_OUTPUT);
            glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
 
            glDebugMessageCallback(
                [](GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, const void* userParam) {
                    GALAXY_UNUSED(source);
                    GALAXY_UNUSED(type);
                    GALAXY_UNUSED(id);
                    GALAXY_UNUSED(length);
                    GALAXY_UNUSED(userParam);
 
                    switch (severity)
                    {
                        case GL_DEBUG_SEVERITY_HIGH:
                            GALAXY_LOG(GALAXY_ERROR, "[OpenGL] - {0}", message);
                            break;
                        case GL_DEBUG_SEVERITY_MEDIUM:
                            GALAXY_LOG(GALAXY_WARN, "[OpenGL] - {0}", message);
                            break;
                        case GL_DEBUG_SEVERITY_LOW:
                            GALAXY_LOG(GALAXY_INFO, "[OpenGL] - {0}", message);
                            break;
                        default:
                            GALAXY_LOG(GALAXY_INFO, "[OpenGL] - {0}", message);
                            break;
                    };
                },
                nullptr
            );
 
            glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_NOTIFICATION, 0, nullptr, GL_FALSE);
        }
        else
        {
            GALAXY_LOG(GALAXY_FATAL, "Failed to initialize SDL window.");
        }
    }
 
    Window::~Window()
    {
        sl::shutdown(); // calls display_shutdown which calls wait_for_graphics.
 
        m_context = nullptr;
        m_window  = nullptr;
        m_open    = false;
    }
 
    void Window::close() noexcept
    {
        m_open = false;
    }
 
    void Window::swap() const noexcept
    {
        sl::show_video_bitmap();
        sl::end_frame();
    }
 
    void Window::show() const noexcept
    {
        SDL_ShowWindow(m_window);
    }
 
    void Window::hide() const noexcept
    {
        SDL_HideWindow(m_window);
    }
 
    void Window::minimize() const noexcept
    {
        SDL_MinimizeWindow(m_window);
        SDL_SyncWindow(m_window);
    }
 
    void Window::maximize() const noexcept
    {
        SDL_MaximizeWindow(m_window);
        SDL_SyncWindow(m_window);
        sl::resize();
    }
 
    void Window::restore() const noexcept
    {
        SDL_RestoreWindow(m_window);
        SDL_SyncWindow(m_window);
        sl::resize();
    }
 
    void Window::raise() const noexcept
    {
        SDL_RaiseWindow(m_window);
    }
 
    void Window::request_attention() const noexcept
    {
        SDL_FlashWindow(m_window, SDL_FlashOperation::SDL_FLASH_UNTIL_FOCUSED);
    }
 
    void Window::resize(const int width, const int height) const noexcept
    {
        SDL_SetWindowSize(m_window, width, height);
        sl::resize();
    }
 
    void Window::set_fullscreen(const bool fullscreen) const noexcept
    {
        sl::set_fullscreen(fullscreen);
    }
 
    void Window::set_taskbar_progress(const float progress) noexcept
    {
        SDL_SetWindowProgressValue(m_window, std::clamp(progress, 0.0f, 1.0f));
    }
 
    void Window::set_title(const std::string& title)
    {
        sl::set_window_title(title.c_str());
    }
 
    void Window::append_title(const std::string& append)
    {
        const auto title = Settings::title() + append;
        SDL_SetWindowTitle(m_window, title.c_str());
    }
 
    void Window::set_icon(const std::string& icon) noexcept
    {
        if (!icon.empty())
        {
            auto& fs = entt::locator<VirtualFileSystem>::value();
 
            auto data = fs.read_binary(icon);
            if (!data.empty())
            {
                auto surface = STBIMG_LoadFromMemory(data.data(), static_cast<int>(data.size()));
                if (surface)
                {
                    SDL_SetWindowIcon(m_window, surface);
                }
                else
                {
                    GALAXY_LOG(GALAXY_ERROR, SDL_GetError());
                }
 
                SDL_DestroySurface(surface);
            }
        }
    }
 
    void Window::handle_window_events(const SDL_Event& events)
    {
        switch (events.type)
        {
            case SDL_EVENT_QUIT:
                close();
                break;
 
            case SDL_EVENT_WINDOW_CLOSE_REQUESTED:
                if (events.window.windowID == SDL_GetWindowID(m_window))
                {
                    close();
                }
                break;
 
            default:
                sl::display_handle_event(events);
                break;
        }
    }
 
    int Window::screen_width() const noexcept
    {
        return sl::screen_width();
    }
 
    int Window::screen_height() const noexcept
    {
        return sl::screen_height();
    }
 
    int Window::virtual_screen_width() const noexcept
    {
        return sl::virtual_screen_width();
    }
 
    int Window::virtual_screen_height() const noexcept
    {
        return sl::virtual_screen_height();
    }
 
    bool Window::is_open() const noexcept
    {
        return m_open;
    }
 
    float Window::get_display_scale() const noexcept
    {
        return SDL_GetDisplayContentScale(SDL_GetPrimaryDisplay());
    }
 
    SDL_Window* Window::handle() const noexcept
    {
        return m_window;
    }
 
    SDL_GLContext Window::context() const noexcept
    {
        return m_context;
    }
} // namespace galaxy
 
#ifdef GALAXY_WIN_PLATFORM
GALAXY_DISABLE_WARNING_POP
#endif