2021-11-30 21:29:18 -06:00
|
|
|
#include "window.h"
|
|
|
|
#include <string.h>
|
2022-01-19 16:43:21 -06:00
|
|
|
#include "texture.h"
|
2021-11-30 21:29:18 -06:00
|
|
|
#include "log.h"
|
2022-02-06 10:14:57 -06:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <stdio.h>
|
2022-06-27 14:12:26 -05:00
|
|
|
#include <vec.h>
|
2022-06-30 10:31:23 -05:00
|
|
|
#include "input.h"
|
2021-11-30 21:29:18 -06:00
|
|
|
|
2022-07-03 00:43:42 -05:00
|
|
|
struct mSDLWindow *mainwin;
|
2022-06-27 14:12:26 -05:00
|
|
|
|
|
|
|
static struct vec windows;
|
|
|
|
struct Texture *icon = NULL;
|
2021-11-30 21:29:18 -06:00
|
|
|
|
2022-06-30 10:31:23 -05:00
|
|
|
int is_win(struct mSDLWindow *s, GLFWwindow *w)
|
|
|
|
{
|
|
|
|
return s->window == w;
|
|
|
|
}
|
|
|
|
|
|
|
|
void window_size_callback(GLFWwindow *w)
|
|
|
|
{
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void window_iconify_callback(GLFWwindow *w, int iconified)
|
|
|
|
{
|
|
|
|
struct mSDLWindow *win = vec_find(&windows, is_win, w);
|
|
|
|
win->iconified = iconified;
|
|
|
|
}
|
|
|
|
|
|
|
|
void window_focus_callback(GLFWwindow *w, int focused)
|
|
|
|
{
|
|
|
|
struct mSDLWindow *win = vec_find(&windows, is_win, w);
|
|
|
|
win->keyboardFocus = focused;
|
|
|
|
}
|
|
|
|
|
|
|
|
void window_maximize_callback(GLFWwindow *w, int maximized)
|
|
|
|
{
|
|
|
|
struct mSDLWindow *win = vec_find(&windows, is_win, w);
|
|
|
|
win->minimized = !maximized;
|
|
|
|
}
|
|
|
|
|
|
|
|
void window_framebuffer_size_cb(GLFWwindow *w, int width, int height)
|
|
|
|
{
|
|
|
|
struct mSDLWindow *win = vec_find(&windows, is_win, w);
|
|
|
|
win->width = width;
|
|
|
|
win->height = height;
|
|
|
|
window_makecurrent(win);
|
|
|
|
win->render = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void window_close_callback(GLFWwindow *w)
|
|
|
|
{
|
|
|
|
quit = 1;
|
|
|
|
}
|
|
|
|
|
2022-08-07 01:43:45 -05:00
|
|
|
void win_key_callback(GLFWwindow *w, int key, int scancode, int action, int mods)
|
|
|
|
{
|
|
|
|
char keystr[50] = {'\0'};
|
|
|
|
strcat(keystr, "input_");
|
|
|
|
strcat(keystr, glfwGetKeyName(key, 0));
|
|
|
|
switch (action) {
|
|
|
|
case GLFW_PRESS:
|
|
|
|
strcat(keystr, "_down");
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GLFW_RELEASE:
|
|
|
|
strcat(keystr, "_up");
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GLFW_REPEAT:
|
|
|
|
strcat(keystr, "_rep");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
script_call(keystr);
|
|
|
|
|
|
|
|
/* Example callback function
|
|
|
|
if (key == GLFW_KEY_F && action == GLFW_PRESS) {
|
|
|
|
printf("Pressed F.\n");
|
|
|
|
if (w == customerWindow->window) window_togglefullscreen(customerWindow);
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
|
2022-06-30 10:31:23 -05:00
|
|
|
struct mSDLWindow *MakeSDLWindow(const char *name, int width, int height, uint32_t flags)
|
2021-11-30 21:29:18 -06:00
|
|
|
{
|
2022-06-27 14:12:26 -05:00
|
|
|
struct mSDLWindow *w;
|
|
|
|
|
|
|
|
if (windows.data == NULL) {
|
|
|
|
windows = vec_init(sizeof(struct mSDLWindow), 5);
|
|
|
|
w = vec_add(&windows, NULL);
|
|
|
|
mainwin = w;
|
|
|
|
} else {
|
|
|
|
w = vec_add(&windows, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
GLFWwindow *sharewin = mainwin ? NULL : mainwin->window;
|
|
|
|
|
2021-11-30 21:29:18 -06:00
|
|
|
w->width = width;
|
|
|
|
w->height = height;
|
2022-07-28 14:07:20 -05:00
|
|
|
YughInfo("Number of windows: %d.\n", windows.len);
|
2022-06-27 14:12:26 -05:00
|
|
|
w->id = windows.len-1;
|
2021-11-30 21:29:18 -06:00
|
|
|
|
2022-06-27 14:12:26 -05:00
|
|
|
w->window = glfwCreateWindow(width, height, name, NULL, sharewin);
|
2022-02-01 14:50:25 -06:00
|
|
|
|
2022-06-27 14:12:26 -05:00
|
|
|
if (!w->window) {
|
|
|
|
YughError("Couldn't make GLFW window\n", 1);
|
|
|
|
return w;
|
|
|
|
}
|
2021-11-30 21:29:18 -06:00
|
|
|
|
2022-06-27 14:12:26 -05:00
|
|
|
if (icon) window_seticon(w, icon);
|
2022-06-25 23:19:29 -05:00
|
|
|
|
2022-06-27 14:12:26 -05:00
|
|
|
glfwMakeContextCurrent(w->window);
|
|
|
|
gladLoadGL(glfwGetProcAddress);
|
|
|
|
glfwSwapInterval(1);
|
2022-06-25 23:19:29 -05:00
|
|
|
|
2022-06-30 10:31:23 -05:00
|
|
|
// Set callbacks
|
|
|
|
glfwSetWindowCloseCallback(w->window, window_close_callback);
|
|
|
|
glfwSetWindowSizeCallback(w->window, window_size_callback);
|
|
|
|
glfwSetFramebufferSizeCallback(w->window, window_framebuffer_size_cb);
|
|
|
|
glfwSetWindowFocusCallback(w->window, window_focus_callback);
|
2022-08-07 01:43:45 -05:00
|
|
|
glfwSetKeyCallback(w->window, win_key_callback);
|
|
|
|
|
|
|
|
nuke_init(w);
|
|
|
|
|
|
|
|
w->nuke_cb = 0;
|
|
|
|
w->gui_cb = 0;
|
2021-11-30 21:29:18 -06:00
|
|
|
|
|
|
|
return w;
|
|
|
|
}
|
|
|
|
|
2022-06-27 14:12:26 -05:00
|
|
|
void window_set_icon(const char *png)
|
|
|
|
{
|
|
|
|
icon = texture_pullfromfile(png);
|
|
|
|
}
|
|
|
|
|
2022-02-06 10:14:57 -06:00
|
|
|
void window_destroy(struct mSDLWindow *w)
|
2021-11-30 21:29:18 -06:00
|
|
|
{
|
2022-02-06 10:14:57 -06:00
|
|
|
glfwDestroyWindow(w->window);
|
2022-06-27 14:12:26 -05:00
|
|
|
vec_delete(&windows, w->id);
|
2022-02-06 10:14:57 -06:00
|
|
|
}
|
|
|
|
|
2022-08-07 01:43:45 -05:00
|
|
|
struct mSDLWindow *window_i(int index) {
|
|
|
|
return vec_get(&windows, index);
|
|
|
|
}
|
2022-06-30 10:31:23 -05:00
|
|
|
|
2022-02-06 10:14:57 -06:00
|
|
|
void window_handle_event(struct mSDLWindow *w)
|
|
|
|
{
|
|
|
|
/*
|
2021-11-30 21:29:18 -06:00
|
|
|
if (e->type == SDL_WINDOWEVENT && e->window.windowID == w->id) { // TODO: Check ptr direct?
|
|
|
|
switch (e->window.event) {
|
|
|
|
case SDL_WINDOWEVENT_SHOWN:
|
|
|
|
YughLog(0, SDL_LOG_PRIORITY_INFO, "Showed window %d.", w->id);
|
|
|
|
w->shown = true;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SDL_WINDOWEVENT_HIDDEN:
|
|
|
|
w->shown = false;
|
|
|
|
YughLog(0, SDL_LOG_PRIORITY_INFO, "Hid window %d.", w->id);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SDL_WINDOWEVENT_SIZE_CHANGED:
|
|
|
|
|
|
|
|
w->width = e->window.data1;
|
|
|
|
w->height = e->window.data2;
|
|
|
|
YughLog(0, SDL_LOG_PRIORITY_INFO,
|
|
|
|
"Changed size of window %d: width %d, height %d.",
|
|
|
|
w->id, w->width, w->height);
|
|
|
|
window_makecurrent(w);
|
2022-02-06 10:14:57 -06:00
|
|
|
w.projection =
|
2021-11-30 21:29:18 -06:00
|
|
|
glm::ortho(0.f, (float) width, 0.f, (float) height, -1.f,
|
2022-02-06 10:14:57 -06:00
|
|
|
1.f);
|
2021-11-30 21:29:18 -06:00
|
|
|
w->render = true;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SDL_WINDOWEVENT_EXPOSED:
|
|
|
|
YughLog(0, SDL_LOG_PRIORITY_INFO, "Exposed window %d.", w->id);
|
|
|
|
w->render = true;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SDL_WINDOWEVENT_ENTER:
|
|
|
|
YughLog(0, SDL_LOG_PRIORITY_INFO, "Entered window %d.", w->id);
|
|
|
|
w->mouseFocus = true;
|
|
|
|
SDL_RaiseWindow(w->window);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SDL_WINDOWEVENT_LEAVE:
|
|
|
|
YughLog(0, SDL_LOG_PRIORITY_INFO, "Left window %d.", w->id);
|
|
|
|
w->mouseFocus = false;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SDL_WINDOWEVENT_FOCUS_LOST:
|
|
|
|
YughLog(0, SDL_LOG_PRIORITY_INFO,
|
|
|
|
"Lost focus on window %d.", w->id);
|
|
|
|
w->keyboardFocus = false;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SDL_WINDOWEVENT_FOCUS_GAINED:
|
|
|
|
YughLog(0, SDL_LOG_PRIORITY_INFO,
|
|
|
|
"Gained focus on window %d.", w->id);
|
|
|
|
w->keyboardFocus = true;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SDL_WINDOWEVENT_MINIMIZED:
|
|
|
|
YughLog(0, SDL_LOG_PRIORITY_INFO,
|
|
|
|
"Minimized window %d.", w->id);
|
|
|
|
w->minimized = true;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SDL_WINDOWEVENT_MAXIMIZED:
|
|
|
|
YughLog(0, SDL_LOG_PRIORITY_INFO,
|
|
|
|
"Maximized window %d.", w->id);
|
|
|
|
w->minimized = false;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SDL_WINDOWEVENT_RESTORED:
|
|
|
|
YughLog(0, SDL_LOG_PRIORITY_INFO,
|
|
|
|
"Restored window %d.", w->id);
|
|
|
|
w->minimized = false;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SDL_WINDOWEVENT_CLOSE:
|
|
|
|
YughLog(0, SDL_LOG_PRIORITY_INFO, "Closed window %d.", w->id);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2022-02-06 10:14:57 -06:00
|
|
|
*/
|
2021-11-30 21:29:18 -06:00
|
|
|
}
|
|
|
|
|
2022-02-06 10:14:57 -06:00
|
|
|
void window_all_handle_events()
|
2022-01-19 16:43:21 -06:00
|
|
|
{
|
2022-06-27 14:12:26 -05:00
|
|
|
vec_walk(&windows, window_handle_event);
|
2022-01-19 16:43:21 -06:00
|
|
|
}
|
|
|
|
|
2021-11-30 21:29:18 -06:00
|
|
|
void window_makefullscreen(struct mSDLWindow *w)
|
|
|
|
{
|
2022-02-06 10:14:57 -06:00
|
|
|
glfwMaximizeWindow(w->window);
|
2021-11-30 21:29:18 -06:00
|
|
|
w->fullscreen = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void window_togglefullscreen(struct mSDLWindow *w)
|
|
|
|
{
|
|
|
|
w->fullscreen = !w->fullscreen;
|
|
|
|
|
|
|
|
if (w->fullscreen) {
|
|
|
|
window_makefullscreen(w);
|
|
|
|
} else {
|
2022-02-06 10:14:57 -06:00
|
|
|
glfwRestoreWindow(w->window);
|
2021-11-30 21:29:18 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void window_makecurrent(struct mSDLWindow *w)
|
|
|
|
{
|
2022-06-23 11:05:47 -05:00
|
|
|
|
|
|
|
if (w->window != glfwGetCurrentContext())
|
|
|
|
glfwMakeContextCurrent(w->window);
|
2021-11-30 21:29:18 -06:00
|
|
|
glViewport(0, 0, w->width, w->height);
|
2022-06-23 11:05:47 -05:00
|
|
|
|
2021-11-30 21:29:18 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void window_swap(struct mSDLWindow *w)
|
|
|
|
{
|
2022-02-06 10:14:57 -06:00
|
|
|
glfwSwapBuffers(w->window);
|
2021-11-30 21:29:18 -06:00
|
|
|
}
|
2022-01-19 16:43:21 -06:00
|
|
|
|
|
|
|
void window_seticon(struct mSDLWindow *w, struct Texture *icon)
|
|
|
|
{
|
2022-06-23 11:05:47 -05:00
|
|
|
|
|
|
|
static GLFWimage images[1];
|
|
|
|
images[0].width = icon->width;
|
|
|
|
images[0].height = icon->height;
|
|
|
|
images[0].pixels = icon->data;
|
2022-02-06 10:14:57 -06:00
|
|
|
glfwSetWindowIcon(w->window, 1, images);
|
2022-06-23 11:05:47 -05:00
|
|
|
|
2022-01-19 16:43:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
int window_hasfocus(struct mSDLWindow *w)
|
|
|
|
{
|
2022-02-06 10:14:57 -06:00
|
|
|
return glfwGetWindowAttrib(w->window, GLFW_FOCUSED);
|
|
|
|
}
|
|
|
|
|
2022-08-07 01:43:45 -05:00
|
|
|
void window_render(struct mSDLWindow *w) {
|
|
|
|
window_makecurrent(w);
|
|
|
|
openglRender(w);
|
2022-02-06 10:14:57 -06:00
|
|
|
|
2022-08-07 01:43:45 -05:00
|
|
|
if (script_has_sym(w->nuke_cb)) {
|
|
|
|
nuke_start();
|
|
|
|
script_call_sym(w->nuke_cb);
|
|
|
|
nuke_end();
|
|
|
|
}
|
|
|
|
window_swap(w);
|
2022-02-06 10:14:57 -06:00
|
|
|
}
|
2022-06-23 11:05:47 -05:00
|
|
|
|
2022-08-07 01:43:45 -05:00
|
|
|
void window_renderall() {
|
|
|
|
vec_walk(&windows, window_render);
|
|
|
|
}
|