Kaltenberg/modules/window/src-c/window.c

#include <voxula/internals/window.h>
#include <glad/glad.h>

vx_window_s * vx_find_window_with_id(vx_input_controller_s *controller, uint32_t window_id)
{
    uint32_t window_index = 0;
    while(window_index < controller->num_windows)
    {
        if(window_id == SDL_GetWindowID(controller->windows[window_index]->window))
        {
            return controller->windows[window_index];
        }
        ++window_index;
    }
    return NULL;
}

int vx_input_controller_mainloop(void *userdata)
{
    vx_input_controller_s *controller = userdata;
    controller->running = true;
    while(controller->running)
    {
        SDL_Event event;
        while(SDL_PollEvent(&event))
        {
            if(event.type == SDL_WINDOWEVENT_CLOSE)
            {
                vx_window_s *window = vx_find_window_with_id(controller, event.window.windowID);
                if(window == NULL)
                {
                    continue;
                }
                if(window->fn_handle_input == NULL)
                {
                    continue;
                }
                vx_window_event_s quit_event;
                quit_event.type = VX_WINDOW_EVENT_CLOSE;
                quit_event.association = window;
                window->fn_handle_input(window, quit_event);
            }
            if(event.type == SDL_QUIT)
            {
                vx_window_event_s quit_event;
                quit_event.type = VX_WINDOW_EVENT_QUIT;
                quit_event.association = NULL;
                uint32_t window_index = 0;
                while(window_index < controller->num_windows)
                {
                    vx_window_s *window = controller->windows[window_index];
                    window->fn_handle_input(window, quit_event);
                    ++window_index;
                }
                controller->running = false;
            }
        }
        SDL_Delay(2);
    }
    return 0;
}

vx_input_controller_s * vx_new_input_controller()
{
    vx_input_controller_s *controller = malloc(sizeof(vx_input_controller_s));
    controller->num_windows = 0;
    controller->window_list_capacity = 8;
    controller->windows = malloc(controller->window_list_capacity * sizeof(vx_window_s));
    thrd_create(&controller->thread, vx_input_controller_mainloop, controller);

    return controller;
}

void vx_free_input_controller(vx_input_controller_s *controller)
{
    uint32_t window_index = 0;
    while(window_index < controller->num_windows)
    {
        vx_window_s *window = controller->windows[window_index];
        vx_free_window(window);
        ++window_index;
    }
    controller->running = false;
    thrd_join(controller->thread, NULL);
    free(controller->windows);
    free(controller);
}

void vx_start_input_controller(vx_input_controller_s *controller)
{
    controller->running = true;
    thrd_detach(controller->thread);
}

void vx_stop_input_controller(vx_input_controller_s *controller)
{
    controller->running = false;
}

vx_window_s * vx_new_window(vx_input_controller_s *controller)
{
    vx_window_s *window = malloc(sizeof(vx_window_s));
    if(controller->window_list_capacity >= controller->num_windows)
    {
        controller->window_list_capacity *= 2;
        controller->windows = realloc(
            controller->windows,
            controller->window_list_capacity
          * sizeof(vx_window_s *)
        );
    }
    controller->windows[controller->num_windows++] = window;
    window->controller = controller;
    window->window = SDL_CreateWindow(
        "Voxula Window",
        SDL_WINDOWPOS_CENTERED,
        SDL_WINDOWPOS_CENTERED,
        1200,
        750,
        SDL_WINDOW_HIDDEN | SDL_WINDOW_OPENGL
    );
    window->gl_context = SDL_GL_CreateContext(window->window);
    gladLoadGLLoader(SDL_GL_GetProcAddress);
    gladLoadGL();

    return window;
}

void vx_free_window(vx_window_s *window)
{
    SDL_DestroyWindow(window->window);
    SDL_GL_DeleteContext(window->gl_context);
    free(window);
}

void vx_win_set_title(vx_window_s *window, const char *title)
{
    SDL_SetWindowTitle(window->window, title);
}

void vx_win_resize(vx_window_s *window, vx_vec2u_s size)
{
    SDL_SetWindowSize(window->window, size.x, size.y);
}

void vx_win_move(vx_window_s *window, vx_vec2i_s position)
{
    SDL_SetWindowPosition(window->window, position.x, position.y);
}

void vx_win_show(vx_window_s *window)
{
    SDL_ShowWindow(window->window);
}

void vx_win_hide(vx_window_s *window)
{
    SDL_HideWindow(window->window);
}

void vx_win_present(vx_window_s *window)
{
    SDL_GL_SwapWindow(window->window);
}