natsirt/wmo-editor
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added nuklear immediate mode gui, refactoring main glfw loop to look a bit cleaner, fixed wrong model matrix on render, added depth testing check

Browse Source
This commit is contained in:
Natsirt867
2026-01-08 13:54:16 -06:00
parent 482f92b5c9
commit 6bb012614d
3 changed files with 31876 additions and 154 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31109
include/nuklear/nuklear.h Normal file
View File

File diff suppressed because it is too large Load Diff

587
include/nuklear/nuklear_glfw_gl3.h Normal file
View File

@@ -0,0 +1,587 @@
/*
* Nuklear - 1.32.0 - public domain
* no warrenty implied; use at your own risk.
* authored from 2015-2016 by Micha Mettke
*/
/*
* ==============================================================
*
* API
*
* ===============================================================
*/
#ifndef NK_GLFW_GL3_H_
#define NK_GLFW_GL3_H_
#include <GLFW/glfw3.h>
enum nk_glfw_init_state{
NK_GLFW3_DEFAULT=0,
NK_GLFW3_INSTALL_CALLBACKS
};
#ifndef NK_GLFW_TEXT_MAX
#define NK_GLFW_TEXT_MAX 256
#endif
struct nk_glfw_device {
struct nk_buffer cmds;
struct nk_draw_null_texture tex_null;
GLuint vbo, vao, ebo;
GLuint prog;
GLuint vert_shdr;
GLuint frag_shdr;
GLint attrib_pos;
GLint attrib_uv;
GLint attrib_col;
GLint uniform_tex;
GLint uniform_proj;
GLuint font_tex;
};
struct nk_glfw {
GLFWwindow *win;
int width, height;
int display_width, display_height;
struct nk_glfw_device ogl;
struct nk_context ctx;
struct nk_font_atlas atlas;
struct nk_vec2 fb_scale;
unsigned int text[NK_GLFW_TEXT_MAX];
nk_char key_events[NK_KEY_MAX];
int text_len;
struct nk_vec2 scroll;
double last_button_click;
int is_double_click_down;
struct nk_vec2 double_click_pos;
float delta_time_seconds_last;
};
NK_API struct nk_context* nk_glfw3_init(struct nk_glfw* glfw, GLFWwindow *win, enum nk_glfw_init_state);
NK_API void nk_glfw3_shutdown(struct nk_glfw* glfw);
NK_API void nk_glfw3_font_stash_begin(struct nk_glfw* glfw, struct nk_font_atlas **atlas);
NK_API void nk_glfw3_font_stash_end(struct nk_glfw* glfw);
NK_API void nk_glfw3_new_frame(struct nk_glfw* glfw);
NK_API void nk_glfw3_render(struct nk_glfw* glfw, enum nk_anti_aliasing, int max_vertex_buffer, int max_element_buffer);
NK_API void nk_glfw3_device_destroy(struct nk_glfw* glfw);
NK_API void nk_glfw3_device_create(struct nk_glfw* glfw);
NK_API void nk_glfw3_char_callback(GLFWwindow *win, unsigned int codepoint);
NK_API void nk_glfw3_key_callback(GLFWwindow *win, int key, int scancode, int action, int mods);
NK_API void nk_gflw3_scroll_callback(GLFWwindow *win, double xoff, double yoff);
NK_API void nk_glfw3_mouse_button_callback(GLFWwindow *win, int button, int action, int mods);
#endif
/*
* ==============================================================
*
* IMPLEMENTATION
*
* ===============================================================
*/
#ifdef NK_GLFW_GL3_IMPLEMENTATION
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#ifndef NK_GLFW_DOUBLE_CLICK_LO
#define NK_GLFW_DOUBLE_CLICK_LO 0.02
#endif
#ifndef NK_GLFW_DOUBLE_CLICK_HI
#define NK_GLFW_DOUBLE_CLICK_HI 0.2
#endif
struct nk_glfw_vertex {
float position[2];
float uv[2];
nk_byte col[4];
};
#ifdef __APPLE__
#define NK_SHADER_VERSION "#version 150\n"
#else
#define NK_SHADER_VERSION "#version 300 es\n"
#endif
NK_API void
nk_glfw3_device_create(struct nk_glfw* glfw)
{
GLint status;
static const GLchar *vertex_shader =
NK_SHADER_VERSION
"uniform mat4 ProjMtx;\n"
"in vec2 Position;\n"
"in vec2 TexCoord;\n"
"in vec4 Color;\n"
"out vec2 Frag_UV;\n"
"out vec4 Frag_Color;\n"
"void main() {\n"
" Frag_UV = TexCoord;\n"
" Frag_Color = Color;\n"
" gl_Position = ProjMtx * vec4(Position.xy, 0, 1);\n"
"}\n";
static const GLchar *fragment_shader =
NK_SHADER_VERSION
"precision mediump float;\n"
"uniform sampler2D Texture;\n"
"in vec2 Frag_UV;\n"
"in vec4 Frag_Color;\n"
"out vec4 Out_Color;\n"
"void main(){\n"
" Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
"}\n";
struct nk_glfw_device *dev = &glfw->ogl;
nk_buffer_init_default(&dev->cmds);
dev->prog = glCreateProgram();
dev->vert_shdr = glCreateShader(GL_VERTEX_SHADER);
dev->frag_shdr = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(dev->vert_shdr, 1, &vertex_shader, 0);
glShaderSource(dev->frag_shdr, 1, &fragment_shader, 0);
glCompileShader(dev->vert_shdr);
glCompileShader(dev->frag_shdr);
glGetShaderiv(dev->vert_shdr, GL_COMPILE_STATUS, &status);
assert(status == GL_TRUE);
glGetShaderiv(dev->frag_shdr, GL_COMPILE_STATUS, &status);
assert(status == GL_TRUE);
glAttachShader(dev->prog, dev->vert_shdr);
glAttachShader(dev->prog, dev->frag_shdr);
glLinkProgram(dev->prog);
glGetProgramiv(dev->prog, GL_LINK_STATUS, &status);
assert(status == GL_TRUE);
dev->uniform_tex = glGetUniformLocation(dev->prog, "Texture");
dev->uniform_proj = glGetUniformLocation(dev->prog, "ProjMtx");
dev->attrib_pos = glGetAttribLocation(dev->prog, "Position");
dev->attrib_uv = glGetAttribLocation(dev->prog, "TexCoord");
dev->attrib_col = glGetAttribLocation(dev->prog, "Color");
{
/* buffer setup */
GLsizei vs = sizeof(struct nk_glfw_vertex);
size_t vp = offsetof(struct nk_glfw_vertex, position);
size_t vt = offsetof(struct nk_glfw_vertex, uv);
size_t vc = offsetof(struct nk_glfw_vertex, col);
glGenBuffers(1, &dev->vbo);
glGenBuffers(1, &dev->ebo);
glGenVertexArrays(1, &dev->vao);
glBindVertexArray(dev->vao);
glBindBuffer(GL_ARRAY_BUFFER, dev->vbo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, dev->ebo);
glEnableVertexAttribArray((GLuint)dev->attrib_pos);
glEnableVertexAttribArray((GLuint)dev->attrib_uv);
glEnableVertexAttribArray((GLuint)dev->attrib_col);
glVertexAttribPointer((GLuint)dev->attrib_pos, 2, GL_FLOAT, GL_FALSE, vs, (void*)vp);
glVertexAttribPointer((GLuint)dev->attrib_uv, 2, GL_FLOAT, GL_FALSE, vs, (void*)vt);
glVertexAttribPointer((GLuint)dev->attrib_col, 4, GL_UNSIGNED_BYTE, GL_TRUE, vs, (void*)vc);
}
glBindTexture(GL_TEXTURE_2D, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindVertexArray(0);
}
NK_INTERN void
nk_glfw3_device_upload_atlas(struct nk_glfw* glfw, const void *image, int width, int height)
{
struct nk_glfw_device *dev = &glfw->ogl;
glGenTextures(1, &dev->font_tex);
glBindTexture(GL_TEXTURE_2D, dev->font_tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)width, (GLsizei)height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, image);
}
NK_API void
nk_glfw3_device_destroy(struct nk_glfw* glfw)
{
struct nk_glfw_device *dev = &glfw->ogl;
glDetachShader(dev->prog, dev->vert_shdr);
glDetachShader(dev->prog, dev->frag_shdr);
glDeleteShader(dev->vert_shdr);
glDeleteShader(dev->frag_shdr);
glDeleteProgram(dev->prog);
glDeleteTextures(1, &dev->font_tex);
glDeleteBuffers(1, &dev->vbo);
glDeleteBuffers(1, &dev->ebo);
nk_buffer_free(&dev->cmds);
}
NK_API void
nk_glfw3_render(struct nk_glfw* glfw, enum nk_anti_aliasing AA, int max_vertex_buffer, int max_element_buffer)
{
struct nk_glfw_device *dev = &glfw->ogl;
struct nk_buffer vbuf, ebuf;
GLfloat ortho[4][4] = {
{2.0f, 0.0f, 0.0f, 0.0f},
{0.0f,-2.0f, 0.0f, 0.0f},
{0.0f, 0.0f,-1.0f, 0.0f},
{-1.0f,1.0f, 0.0f, 1.0f},
};
ortho[0][0] /= (GLfloat)glfw->width;
ortho[1][1] /= (GLfloat)glfw->height;
/* setup global state */
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
glEnable(GL_SCISSOR_TEST);
glActiveTexture(GL_TEXTURE0);
/* setup program */
glUseProgram(dev->prog);
glUniform1i(dev->uniform_tex, 0);
glUniformMatrix4fv(dev->uniform_proj, 1, GL_FALSE, &ortho[0][0]);
glViewport(0,0,(GLsizei)glfw->display_width,(GLsizei)glfw->display_height);
{
/* convert from command queue into draw list and draw to screen */
const struct nk_draw_command *cmd;
void *vertices, *elements;
nk_size offset = 0;
/* allocate vertex and element buffer */
glBindVertexArray(dev->vao);
glBindBuffer(GL_ARRAY_BUFFER, dev->vbo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, dev->ebo);
glBufferData(GL_ARRAY_BUFFER, max_vertex_buffer, NULL, GL_STREAM_DRAW);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, max_element_buffer, NULL, GL_STREAM_DRAW);
/* load draw vertices & elements directly into vertex + element buffer */
vertices = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
elements = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY);
{
/* fill convert configuration */
struct nk_convert_config config;
static const struct nk_draw_vertex_layout_element vertex_layout[] = {
{NK_VERTEX_POSITION, NK_FORMAT_FLOAT, NK_OFFSETOF(struct nk_glfw_vertex, position)},
{NK_VERTEX_TEXCOORD, NK_FORMAT_FLOAT, NK_OFFSETOF(struct nk_glfw_vertex, uv)},
{NK_VERTEX_COLOR, NK_FORMAT_R8G8B8A8, NK_OFFSETOF(struct nk_glfw_vertex, col)},
{NK_VERTEX_LAYOUT_END}
};
memset(&config, 0, sizeof(config));
config.vertex_layout = vertex_layout;
config.vertex_size = sizeof(struct nk_glfw_vertex);
config.vertex_alignment = NK_ALIGNOF(struct nk_glfw_vertex);
config.tex_null = dev->tex_null;
config.circle_segment_count = 22;
config.curve_segment_count = 22;
config.arc_segment_count = 22;
config.global_alpha = 1.0f;
config.shape_AA = AA;
config.line_AA = AA;
/* setup buffers to load vertices and elements */
nk_buffer_init_fixed(&vbuf, vertices, (size_t)max_vertex_buffer);
nk_buffer_init_fixed(&ebuf, elements, (size_t)max_element_buffer);
nk_convert(&glfw->ctx, &dev->cmds, &vbuf, &ebuf, &config);
}
glUnmapBuffer(GL_ARRAY_BUFFER);
glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
/* iterate over and execute each draw command */
nk_draw_foreach(cmd, &glfw->ctx, &dev->cmds)
{
if (!cmd->elem_count) continue;
glBindTexture(GL_TEXTURE_2D, (GLuint)cmd->texture.id);
glScissor(
(GLint)(cmd->clip_rect.x * glfw->fb_scale.x),
(GLint)((glfw->height - (GLint)(cmd->clip_rect.y + cmd->clip_rect.h)) * glfw->fb_scale.y),
(GLint)(cmd->clip_rect.w * glfw->fb_scale.x),
(GLint)(cmd->clip_rect.h * glfw->fb_scale.y));
glDrawElements(GL_TRIANGLES, (GLsizei)cmd->elem_count, GL_UNSIGNED_SHORT, (const void*) offset);
offset += cmd->elem_count * sizeof(nk_draw_index);
}
nk_clear(&glfw->ctx);
nk_buffer_clear(&dev->cmds);
}
/* default OpenGL state */
glUseProgram(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindVertexArray(0);
glDisable(GL_BLEND);
glDisable(GL_SCISSOR_TEST);
}
NK_API void
nk_glfw3_char_callback(GLFWwindow *win, unsigned int codepoint)
{
struct nk_glfw* glfw = (struct nk_glfw *)glfwGetWindowUserPointer(win);
if (glfw->text_len < NK_GLFW_TEXT_MAX)
glfw->text[glfw->text_len++] = codepoint;
}
NK_API void
nk_glfw3_key_callback(GLFWwindow *win, int key, int scancode, int action, int mods)
{
static int insert_toggle = 0;
struct nk_glfw* glfw = (struct nk_glfw *)glfwGetWindowUserPointer(win);
/*
* convert GLFW_REPEAT to down (technically GLFW_RELEASE, GLFW_PRESS, GLFW_REPEAT are
* already 0, 1, 2 but just to be clearer)
*/
nk_char a = (action == GLFW_RELEASE) ? nk_false : nk_true;
NK_UNUSED(scancode);
NK_UNUSED(mods);
switch (key) {
case GLFW_KEY_DELETE: glfw->key_events[NK_KEY_DEL] = a; break;
case GLFW_KEY_TAB: glfw->key_events[NK_KEY_TAB] = a; break;
case GLFW_KEY_BACKSPACE: glfw->key_events[NK_KEY_BACKSPACE] = a; break;
case GLFW_KEY_UP: glfw->key_events[NK_KEY_UP] = a; break;
case GLFW_KEY_DOWN: glfw->key_events[NK_KEY_DOWN] = a; break;
case GLFW_KEY_LEFT: glfw->key_events[NK_KEY_LEFT] = a; break;
case GLFW_KEY_RIGHT: glfw->key_events[NK_KEY_RIGHT] = a; break;
case GLFW_KEY_ESCAPE: glfw->key_events[NK_KEY_TEXT_RESET_MODE] = a; break;
case GLFW_KEY_PAGE_UP: glfw->key_events[NK_KEY_SCROLL_UP] = a; break;
case GLFW_KEY_PAGE_DOWN: glfw->key_events[NK_KEY_SCROLL_DOWN] = a; break;
case GLFW_KEY_C: glfw->key_events[NK_KEY_COPY] = a; break;
case GLFW_KEY_V: glfw->key_events[NK_KEY_PASTE] = a; break;
case GLFW_KEY_X: glfw->key_events[NK_KEY_CUT] = a; break;
case GLFW_KEY_Z: glfw->key_events[NK_KEY_TEXT_UNDO] = a; break;
case GLFW_KEY_R: glfw->key_events[NK_KEY_TEXT_REDO] = a; break;
case GLFW_KEY_B: glfw->key_events[NK_KEY_TEXT_LINE_START] = a; break;
case GLFW_KEY_E: glfw->key_events[NK_KEY_TEXT_LINE_END] = a; break;
case GLFW_KEY_A: glfw->key_events[NK_KEY_TEXT_SELECT_ALL] = a; break;
case GLFW_KEY_ENTER:
case GLFW_KEY_KP_ENTER:
glfw->key_events[NK_KEY_ENTER] = a;
break;
case GLFW_KEY_INSERT:
/* Only switch on release to avoid repeat issues
* kind of confusing since we have to negate it but we're already
* hacking it since Nuklear treats them as two separate keys rather
* than a single toggle state */
if (!a) {
insert_toggle = !insert_toggle;
if (insert_toggle) {
glfw->key_events[NK_KEY_TEXT_INSERT_MODE] = !a;
/* glfw->key_events[NK_KEY_TEXT_REPLACE_MODE] = a; */
} else {
/* glfw->key_events[NK_KEY_TEXT_INSERT_MODE] = a; */
glfw->key_events[NK_KEY_TEXT_REPLACE_MODE] = !a;
}
}
break;
default:
;
}
}
NK_API void
nk_gflw3_scroll_callback(GLFWwindow *win, double xoff, double yoff)
{
struct nk_glfw* glfw = (struct nk_glfw *)glfwGetWindowUserPointer(win);
(void)xoff;
glfw->scroll.x += (float)xoff;
glfw->scroll.y += (float)yoff;
}
NK_API void
nk_glfw3_mouse_button_callback(GLFWwindow* win, int button, int action, int mods)
{
struct nk_glfw* glfw = (struct nk_glfw *)glfwGetWindowUserPointer(win);
double x, y;
NK_UNUSED(mods);
if (button != GLFW_MOUSE_BUTTON_LEFT) return;
glfwGetCursorPos(win, &x, &y);
if (action == GLFW_PRESS) {
double dt = glfwGetTime() - glfw->last_button_click;
if (dt > NK_GLFW_DOUBLE_CLICK_LO && dt < NK_GLFW_DOUBLE_CLICK_HI) {
glfw->is_double_click_down = nk_true;
glfw->double_click_pos = nk_vec2((float)x, (float)y);
}
glfw->last_button_click = glfwGetTime();
} else glfw->is_double_click_down = nk_false;
}
NK_INTERN void
nk_glfw3_clipboard_paste(nk_handle usr, struct nk_text_edit *edit)
{
struct nk_glfw* glfw = (struct nk_glfw*)usr.ptr;
const char *text = glfwGetClipboardString(glfw->win);
if (text) nk_textedit_paste(edit, text, nk_strlen(text));
(void)usr;
}
NK_INTERN void
nk_glfw3_clipboard_copy(nk_handle usr, const char *text, int len)
{
struct nk_glfw* glfw = (struct nk_glfw*)usr.ptr;
char *str = 0;
if (!len) return;
str = (char*)malloc((size_t)len+1);
if (!str) return;
memcpy(str, text, (size_t)len);
str[len] = '\0';
glfwSetClipboardString(glfw->win, str);
free(str);
}
NK_API struct nk_context*
nk_glfw3_init(struct nk_glfw* glfw, GLFWwindow *win, enum nk_glfw_init_state init_state)
{
glfwSetWindowUserPointer(win, glfw);
glfw->win = win;
if (init_state == NK_GLFW3_INSTALL_CALLBACKS) {
glfwSetScrollCallback(win, nk_gflw3_scroll_callback);
glfwSetCharCallback(win, nk_glfw3_char_callback);
glfwSetKeyCallback(win, nk_glfw3_key_callback);
glfwSetMouseButtonCallback(win, nk_glfw3_mouse_button_callback);
}
nk_init_default(&glfw->ctx, 0);
glfw->ctx.clip.copy = nk_glfw3_clipboard_copy;
glfw->ctx.clip.paste = nk_glfw3_clipboard_paste;
glfw->ctx.clip.userdata = nk_handle_ptr(&glfw);
glfw->last_button_click = 0;
nk_glfw3_device_create(glfw);
glfw->is_double_click_down = nk_false;
glfw->double_click_pos = nk_vec2(0, 0);
glfw->delta_time_seconds_last = (float)glfwGetTime();
return &glfw->ctx;
}
NK_API void
nk_glfw3_font_stash_begin(struct nk_glfw* glfw, struct nk_font_atlas **atlas)
{
nk_font_atlas_init_default(&glfw->atlas);
nk_font_atlas_begin(&glfw->atlas);
*atlas = &glfw->atlas;
}
NK_API void
nk_glfw3_font_stash_end(struct nk_glfw* glfw)
{
const void *image; int w, h;
image = nk_font_atlas_bake(&glfw->atlas, &w, &h, NK_FONT_ATLAS_RGBA32);
nk_glfw3_device_upload_atlas(glfw, image, w, h);
nk_font_atlas_end(&glfw->atlas, nk_handle_id((int)glfw->ogl.font_tex), &glfw->ogl.tex_null);
if (glfw->atlas.default_font)
nk_style_set_font(&glfw->ctx, &glfw->atlas.default_font->handle);
}
NK_API void
nk_glfw3_new_frame(struct nk_glfw* glfw)
{
int i;
double x, y;
struct nk_context *ctx = &glfw->ctx;
struct GLFWwindow *win = glfw->win;
nk_char* k_state = glfw->key_events;
/* update the timer */
float delta_time_now = (float)glfwGetTime();
glfw->ctx.delta_time_seconds = delta_time_now - glfw->delta_time_seconds_last;
glfw->delta_time_seconds_last = delta_time_now;
glfwGetWindowSize(win, &glfw->width, &glfw->height);
glfwGetFramebufferSize(win, &glfw->display_width, &glfw->display_height);
glfw->fb_scale.x = (float)glfw->display_width/(float)glfw->width;
glfw->fb_scale.y = (float)glfw->display_height/(float)glfw->height;
nk_input_begin(ctx);
for (i = 0; i < glfw->text_len; ++i)
nk_input_unicode(ctx, glfw->text[i]);
#ifdef NK_GLFW_GL3_MOUSE_GRABBING
/* optional grabbing behavior */
if (ctx->input.mouse.grab)
glfwSetInputMode(glfw.win, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
else if (ctx->input.mouse.ungrab)
glfwSetInputMode(glfw->win, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
#endif
if (k_state[NK_KEY_DEL] >= 0) nk_input_key(ctx, NK_KEY_DEL, k_state[NK_KEY_DEL]);
if (k_state[NK_KEY_ENTER] >= 0) nk_input_key(ctx, NK_KEY_ENTER, k_state[NK_KEY_ENTER]);
if (k_state[NK_KEY_TEXT_RESET_MODE] >= 0) nk_input_key(ctx, NK_KEY_TEXT_RESET_MODE, k_state[NK_KEY_TEXT_RESET_MODE]);
if (k_state[NK_KEY_TAB] >= 0) nk_input_key(ctx, NK_KEY_TAB, k_state[NK_KEY_TAB]);
if (k_state[NK_KEY_BACKSPACE] >= 0) nk_input_key(ctx, NK_KEY_BACKSPACE, k_state[NK_KEY_BACKSPACE]);
if (k_state[NK_KEY_UP] >= 0) nk_input_key(ctx, NK_KEY_UP, k_state[NK_KEY_UP]);
if (k_state[NK_KEY_DOWN] >= 0) nk_input_key(ctx, NK_KEY_DOWN, k_state[NK_KEY_DOWN]);
if (k_state[NK_KEY_SCROLL_UP] >= 0) nk_input_key(ctx, NK_KEY_SCROLL_UP, k_state[NK_KEY_SCROLL_UP]);
if (k_state[NK_KEY_SCROLL_DOWN] >= 0) nk_input_key(ctx, NK_KEY_SCROLL_DOWN, k_state[NK_KEY_SCROLL_DOWN]);
if (k_state[NK_KEY_TEXT_INSERT_MODE] >= 0) nk_input_key(ctx, NK_KEY_TEXT_INSERT_MODE, k_state[NK_KEY_TEXT_INSERT_MODE]);
if (k_state[NK_KEY_TEXT_REPLACE_MODE] >= 0) nk_input_key(ctx, NK_KEY_TEXT_REPLACE_MODE, k_state[NK_KEY_TEXT_REPLACE_MODE]);
nk_input_key(ctx, NK_KEY_TEXT_START, glfwGetKey(win, GLFW_KEY_HOME) == GLFW_PRESS);
nk_input_key(ctx, NK_KEY_TEXT_END, glfwGetKey(win, GLFW_KEY_END) == GLFW_PRESS);
nk_input_key(ctx, NK_KEY_SCROLL_START, glfwGetKey(win, GLFW_KEY_HOME) == GLFW_PRESS);
nk_input_key(ctx, NK_KEY_SCROLL_END, glfwGetKey(win, GLFW_KEY_END) == GLFW_PRESS);
nk_input_key(ctx, NK_KEY_SHIFT, glfwGetKey(win, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS||
glfwGetKey(win, GLFW_KEY_RIGHT_SHIFT) == GLFW_PRESS);
if (glfwGetKey(win, GLFW_KEY_LEFT_CONTROL) == GLFW_PRESS ||
glfwGetKey(win, GLFW_KEY_RIGHT_CONTROL) == GLFW_PRESS) {
/* Note these are physical keys and won't respect any layouts/key mapping */
if (k_state[NK_KEY_COPY] >= 0) nk_input_key(ctx, NK_KEY_COPY, k_state[NK_KEY_COPY]);
if (k_state[NK_KEY_PASTE] >= 0) nk_input_key(ctx, NK_KEY_PASTE, k_state[NK_KEY_PASTE]);
if (k_state[NK_KEY_CUT] >= 0) nk_input_key(ctx, NK_KEY_CUT, k_state[NK_KEY_CUT]);
if (k_state[NK_KEY_TEXT_UNDO] >= 0) nk_input_key(ctx, NK_KEY_TEXT_UNDO, k_state[NK_KEY_TEXT_UNDO]);
if (k_state[NK_KEY_TEXT_REDO] >= 0) nk_input_key(ctx, NK_KEY_TEXT_REDO, k_state[NK_KEY_TEXT_REDO]);
if (k_state[NK_KEY_TEXT_LINE_START] >= 0) nk_input_key(ctx, NK_KEY_TEXT_LINE_START, k_state[NK_KEY_TEXT_LINE_START]);
if (k_state[NK_KEY_TEXT_LINE_END] >= 0) nk_input_key(ctx, NK_KEY_TEXT_LINE_END, k_state[NK_KEY_TEXT_LINE_END]);
if (k_state[NK_KEY_TEXT_SELECT_ALL] >= 0) nk_input_key(ctx, NK_KEY_TEXT_SELECT_ALL, k_state[NK_KEY_TEXT_SELECT_ALL]);
if (k_state[NK_KEY_LEFT] >= 0) nk_input_key(ctx, NK_KEY_TEXT_WORD_LEFT, k_state[NK_KEY_LEFT]);
if (k_state[NK_KEY_RIGHT] >= 0) nk_input_key(ctx, NK_KEY_TEXT_WORD_RIGHT, k_state[NK_KEY_RIGHT]);
} else {
if (k_state[NK_KEY_LEFT] >= 0) nk_input_key(ctx, NK_KEY_LEFT, k_state[NK_KEY_LEFT]);
if (k_state[NK_KEY_RIGHT] >= 0) nk_input_key(ctx, NK_KEY_RIGHT, k_state[NK_KEY_RIGHT]);
nk_input_key(ctx, NK_KEY_COPY, 0);
nk_input_key(ctx, NK_KEY_PASTE, 0);
nk_input_key(ctx, NK_KEY_CUT, 0);
}
glfwGetCursorPos(win, &x, &y);
nk_input_motion(ctx, (int)x, (int)y);
#ifdef NK_GLFW_GL3_MOUSE_GRABBING
if (ctx->input.mouse.grabbed) {
glfwSetCursorPos(glfw->win, ctx->input.mouse.prev.x, ctx->input.mouse.prev.y);
ctx->input.mouse.pos.x = ctx->input.mouse.prev.x;
ctx->input.mouse.pos.y = ctx->input.mouse.prev.y;
}
#endif
nk_input_button(ctx, NK_BUTTON_LEFT, (int)x, (int)y, glfwGetMouseButton(win, GLFW_MOUSE_BUTTON_LEFT) == GLFW_PRESS);
nk_input_button(ctx, NK_BUTTON_MIDDLE, (int)x, (int)y, glfwGetMouseButton(win, GLFW_MOUSE_BUTTON_MIDDLE) == GLFW_PRESS);
nk_input_button(ctx, NK_BUTTON_RIGHT, (int)x, (int)y, glfwGetMouseButton(win, GLFW_MOUSE_BUTTON_RIGHT) == GLFW_PRESS);
nk_input_button(ctx, NK_BUTTON_DOUBLE, (int)glfw->double_click_pos.x, (int)glfw->double_click_pos.y, glfw->is_double_click_down);
nk_input_scroll(ctx, glfw->scroll);
nk_input_end(&glfw->ctx);
/* clear after nk_input_end (-1 since we're doing up/down boolean) */
memset(glfw->key_events, -1, sizeof(glfw->key_events));
glfw->text_len = 0;
glfw->scroll = nk_vec2(0,0);
}
NK_API
void nk_glfw3_shutdown(struct nk_glfw* glfw)
{
nk_font_atlas_clear(&glfw->atlas);
nk_free(&glfw->ctx);
nk_glfw3_device_destroy(glfw);
memset(glfw, 0, sizeof(*glfw));
}
#endif

334
src/main.c
View File

@@ -1,9 +1,25 @@
// glad needs to be initialized before GLFW
//#define GLFW_INCLUDE_NONE
#include <math.h>
#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <stdio.h>
#include <string.h>
#include <StormLib.h>
#define NK_INCLUDE_FIXED_TYPES
#define NK_INCLUDE_STANDARD_IO
#define NK_INCLUDE_STANDARD_VARARGS
#define NK_INCLUDE_DEFAULT_ALLOCATOR
#define NK_INCLUDE_VERTEX_BUFFER_OUTPUT
#define NK_INCLUDE_FONT_BAKING
#define NK_INCLUDE_DEFAULT_FONT
#define NK_IMPLEMENTATION
#define NK_GLFW_GL3_IMPLEMENTATION
#define NK_KEYSTATE_BASED_INPUT
#include "../include/nuklear/nuklear.h"
#include "../include/nuklear/nuklear_glfw_gl3.h"
#include "logger/log.h"
#include "util.h"
#include "logger/gl_log.h"
@@ -17,6 +33,10 @@
#define MAX_VERTEX_BUFFER 512 * 1024
#define MAX_ELEMENT_BUFFER 128 * 1024
// reported window size maybe good to know for a few things
int g_win_width = 640;
int g_win_height = 480;
@@ -27,6 +47,8 @@ int g_fb_height = 480;
double previous_seconds;
int frame_count;
bool depth_test = TRUE;
// function to update the window title with a frame rate
void _update_fps_counter(GLFWwindow* window) {
double current_seconds;
@@ -345,6 +367,12 @@ void init() {
glEnable(GL_MULTISAMPLE);
struct nk_glfw glfw = {0};
struct nk_context *ctx = nk_glfw3_init(&glfw, window, NK_GLFW3_INSTALL_CALLBACKS);
struct nk_font_atlas *atlas;
nk_glfw3_font_stash_begin(&glfw, &atlas);
nk_glfw3_font_stash_end(&glfw);
// log GL params
log_gl_params();
@@ -606,7 +634,7 @@ void init() {
char* names = (char*)wmo_root_data.modn_data_ptr;
size_t num_doodads = wmo_root_data.modd_size / sizeof(SMODoodadDef);
print_all(shader_programme);
for (int i = 0; i < num_doodads; i++) {
uint32_t name_index = doodads[i].ref.name_index;
@@ -622,243 +650,241 @@ void init() {
glUseProgram(shader_programme);
glBindVertexArray(cubeVAO);
print_all(shader_programme);
// call `glPolygonMode` before rendering if you want to use wire-frame rendering mode
// Loop until the user closes the window
while(!glfwWindowShouldClose(window)) {
// Poll input events first so nuklear and GLFW have fresh data
glfwPollEvents();
_update_fps_counter(window);
// add a timer for doing animation
nk_glfw3_new_frame(&glfw);
static double previous_seconds = 0;
double current_seconds = glfwGetTime();
double elapsed_seconds = current_seconds - previous_seconds;
previous_seconds = current_seconds;
// TODO: review anton opengl chapter on movement but this is a test I think can remove
if (fabs(last_position) > 1.0f) {
speed = -speed;
}
//rotation_z += 0.1;
// update the matrix
//matrix[12] = elapsed_seconds * speed + last_position;
//last_position = matrix[12];
//glUseProgram(shader_programme);
//glUniformMatrix4fv(matrix_location, 1, GL_FALSE, rotation_matrix_z.m);
double current_time = glfwGetTime();
/*if (current_time > 5000) {
mat4_t new_scale_matrix = mat4_make_scale(0.5f, 2.0f, 1.0f);
glUseProgram(shader_programme);
glUniformMatrix4fv(matrix_location, 1, GL_FALSE, new_scale_matrix.m);
}*/
/*
if (current_time > 5000) {
// Scale the vectors, rotate, then translate
mat4_t S = mat4_make_scale(1.5f, 1.5f, 1.5f);
mat4_t Rz = mat4_make_rotation_z(M_PI / 4.0f);
mat4_t T = mat4_make_translation(1.0f, 0.0f, 0.0f);
// camera
bool cam_moved = false;
float move_dist = cam_speed * elapsed_seconds;
mat4_t temp_matrix = mat4_mul_mat4(Rz, S);
mat4_t final_matrix = mat4_mul_mat4(T, temp_matrix);
// check if a widget is active or mouse is hovering a window
if (!nk_item_is_any_active(ctx) && !nk_window_is_any_hovered(ctx)) {
glUseProgram(shader_programme);
glUniformMatrix4fv(matrix_location, 1, GL_FALSE, final_matrix.m);
}*/
// camera movement
if (glfwGetKey(window, GLFW_KEY_A)) {
vec3_t move_vec = vec3_mul(cam_right, move_dist);
cam_pos = vec3_sub(cam_pos, move_vec);
cam_moved = true;
}
if (glfwGetKey(window, GLFW_KEY_D)) {
vec3_t move_vec = vec3_mul(cam_right, move_dist);
cam_pos = vec3_add(cam_pos, move_vec);
cam_moved = true;
}
if (glfwGetKey(window, GLFW_KEY_PAGE_UP)) {
cam_pos.y += move_dist;
cam_moved = true;
}
if (glfwGetKey(window, GLFW_KEY_PAGE_DOWN)) {
cam_pos.y -= move_dist;
cam_moved = true;
}
if (glfwGetKey(window, GLFW_KEY_W)) {
vec3_t move_vec = vec3_mul(cam_front, move_dist);
cam_pos = vec3_add(cam_pos, move_vec);
cam_moved = true;
}
if (glfwGetKey(window, GLFW_KEY_S)) {
vec3_t move_vec = vec3_mul(cam_front, move_dist);
cam_pos = vec3_sub(cam_pos, move_vec);
cam_moved = true;
}
if (glfwGetKey(window, GLFW_KEY_LEFT)) {
cam_yaw += cam_yaw_speed * elapsed_seconds;
cam_moved = true;
}
if (glfwGetKey(window, GLFW_KEY_RIGHT)) {
cam_yaw -= cam_yaw_speed * elapsed_seconds;
cam_moved = true;
}
if (glfwGetKey(window, GLFW_KEY_UP)) {
cam_pitch += cam_yaw_speed * elapsed_seconds;
cam_moved = true;
}
if (glfwGetKey(window, GLFW_KEY_DOWN)) {
cam_pitch -= cam_yaw_speed * elapsed_seconds;
cam_moved = true;
}
// TODO: clamp pitch, need to look up a better way to not flip the whole camera
if (cam_pitch > 89.0f) cam_pitch = 89.0f;
if (cam_pitch < -89.0f) cam_pitch = -89.0f;
}
// camera vectors recalculation
yaw_rad = TO_RAD(cam_yaw);
pitch_rad = TO_RAD(cam_pitch);
cam_front.x = cosf(yaw_rad) * cosf(pitch_rad);
cam_front.y = sinf(pitch_rad);
cam_front.z = sinf(yaw_rad) * cosf(pitch_rad);
vec3_normalize(&cam_front);
cam_right = vec3_cross(cam_front, world_up);
vec3_normalize(&cam_right);
cam_up = vec3_cross(cam_right, cam_front);
vec3_normalize(&cam_up);
float move_dist = cam_speed * elapsed_seconds;
// calculate View Matrix
view_mat = mat4_look_at(
cam_pos.x, cam_pos.y, cam_pos.z,
cam_pos.x + cam_front.x, cam_pos.y + cam_front.y, cam_pos.z + cam_front.z,
cam_up.x, cam_up.y, cam_up.z
);
);
// nuklear UI layout
if (nk_begin(ctx, "Debug", nk_rect(50, 50, 230, 250),
NK_WINDOW_BORDER | NK_WINDOW_MOVABLE | NK_WINDOW_SCALABLE |
NK_WINDOW_MINIMIZABLE | NK_WINDOW_TITLE))
{
nk_layout_row_dynamic(ctx, 30, 1);
nk_label(ctx, "Hello OpenGL 4!", NK_TEXT_LEFT);
if (nk_button_label(ctx, "Test Button")) {
log_info("Button Clicked!");
}
if (nk_button_label(ctx, "Test Button 2")) {
log_info("Button Clicked!");
}
}
nk_end(ctx);
// hot shader reload
if (GLFW_PRESS == glfwGetKey(window, GLFW_KEY_7)) {
shader_reload(&shader_programme, vertex_shader, fragment_shader);
matrix_location = glGetUniformLocation(shader_programme, "matrix");
view_mat_location = glGetUniformLocation(shader_programme, "view");
proj_mat_location = glGetUniformLocation(shader_programme, "proj");
light_location = glGetUniformLocation(shader_programme, "u_lightDir");
light_influence_location = glGetUniformLocation(shader_programme, "u_lightInfluence");
override_loc = glGetUniformLocation(shader_programme, "u_overrideColour");
glUseProgram(shader_programme);
glUniformMatrix4fv(matrix_location, 1, GL_FALSE, model_mat.m);
glUniformMatrix4fv(view_mat_location, 1, GL_FALSE, view_mat.m);
glUniformMatrix4fv(proj_mat_location, 1, GL_FALSE, projection.m);
glUniform3fv(light_location, 1, lightDir);
glUniform1f(light_influence_location, 0.0f);
}
// Depth Test Keybind
if (GLFW_PRESS == glfwGetKey(window, GLFW_KEY_P)) {
if (depth_test) {
depth_test = FALSE;
} else if (!depth_test) {
depth_test = TRUE;
}
}
// Re-enable depth testing as nuklear disables for 2D overlay
if (depth_test) {
glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
} else {
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
}
// Render here
// wipe the drawing surface clear
// Clear screen
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Update viewport size for scaling
glViewport(0, 0, g_fb_width, g_fb_height);
// Draws 3D scene
glUseProgram(shader_programme);
// TODO: Necessary if we init already like this or should we confirm every frame, as a base or origin?
glUniformMatrix4fv(view_mat_location, 1, GL_FALSE, view_mat.m);
glUniformMatrix4fv(proj_mat_location, 1, GL_FALSE, projection.m);
glUniform3fv(light_location, 1, lightDir);
glUniform4f(override_loc, 0.0f, 0.0f, 0.0f, 0.0f);
// ensures proper matrix for model
glUniformMatrix4fv(matrix_location, 1, GL_FALSE, model_mat.m);
// draw WMO Groups
for (size_t i = 0; i < wmo_root_data.group_count; i++) {
if (meshes[i].is_outdoor) {
// enable sun
glUniform1f(light_influence_location, 1.0f);
glUniform1f(light_influence_location, 1.0f); // sun enabled
} else {
// disable sun (use baked lighting)
glUniform1f(light_influence_location, 0.0f);
glUniform1f(light_influence_location, 0.0f); // baked lighting only
}
if (meshes[i].VAO != 0) {
//glActiveTexture(GL_TEXTURE0);
//glBindTexture(GL_TEXTURE_2D, meshes[i].textureID);
draw_group_mesh(meshes[i]);
}
}
glUseProgram(shader_programme);
glBindVertexArray(cubeVAO);
glUniform4f(override_loc, 1.0f, 0.0f, 0.0f, 1.0f);
glUniform1f(light_influence_location, 0.0f);
// draw doodads as cubes
glUniform4f(override_loc, 1.0f, 0.0f, 0.0f, 1.0f); // Red overlay for doodads
glUniform1f(light_influence_location, 0.0f);
if (wmo_root_data.modd_data_ptr) {
glBindVertexArray(cubeVAO);
doodads = (SMODoodadDef*)wmo_root_data.modd_data_ptr;
num_doodads = wmo_root_data.modd_size / sizeof(SMODoodadDef);
for (size_t i = 0; i < num_doodads; i++) {
SMODoodadDef* d = &doodads[i];
// scale
// calculate model matrix for this doodad
mat4_t mat_scale = mat4_make_scale(d->scale, d->scale, d->scale);
// rotate
C4Quaternion q = {
d->orientation.x,
d->orientation.y,
d->orientation.z,
d->orientation.w
};
mat4_t mat_rot = mat4_from_quaternion(
q
);
// translate
C4Quaternion q = { d->orientation.x, d->orientation.y, d->orientation.z, d->orientation.w };
mat4_t mat_rot = mat4_from_quaternion(q);
mat4_t mat_trans = mat4_make_translation(d->position.x, d->position.y, d->position.z);
// combine (order: T * R * S)
// T * R * S
mat4_t model = mat4_identity();
model = mat4_mul_mat4(mat_rot, mat_scale);
model = mat4_mul_mat4(mat_trans, model);
glUniformMatrix4fv(matrix_location, 1, GL_FALSE, model.m);
// draw lines (24 indices)
// (void*)0 is the offset into the EBO bound earlier
// Draw Lines
glDrawElements(GL_LINES, 24, GL_UNSIGNED_INT, (void*)0);
}
}
glBindVertexArray(0);
// update other events like input handling
glfwPollEvents();
// Swap front and back buffers
// Nuklear switches shaders internally, draws, then unbinds program (sets to 0 per openGL standards)
nk_glfw3_render(&glfw, NK_ANTI_ALIASING_ON, MAX_VERTEX_BUFFER, MAX_ELEMENT_BUFFER);
// Swap buffers to display result
glfwSwapBuffers(window);
// Check if we should exit
// TODO: move additional keyboard commands elsewhere in case to other controls? not sure yet
if (GLFW_PRESS == glfwGetKey(window, GLFW_KEY_ESCAPE)) {
glfwSetWindowShouldClose(window, 1);
} else if (GLFW_PRESS == glfwGetKey(window, GLFW_KEY_9)) {
glfwSetWindowMonitor(window, NULL, 480, 270, vmode->width / 2, vmode->height / 2, GLFW_DONT_CARE);
} else if (GLFW_PRESS == glfwGetKey(window, GLFW_KEY_8)) {
glfwSetWindowMonitor(window, mon, 0, 0, vmode->width, vmode->height, vmode->refreshRate);
} else if (GLFW_PRESS == glfwGetKey(window, GLFW_KEY_7)) {
shader_reload(&shader_programme, vertex_shader, fragment_shader);
int new_matrix_loc = glGetUniformLocation(shader_programme, "matrix");
int new_view_loc = glGetUniformLocation(shader_programme, "view");
int new_proj_loc = glGetUniformLocation(shader_programme, "proj");
glUseProgram(shader_programme);
glUniformMatrix4fv(new_matrix_loc, 1, GL_FALSE, model_mat.m);
glUniformMatrix4fv(new_view_loc, 1, GL_FALSE, view_mat.m);
glUniformMatrix4fv(new_proj_loc, 1, GL_FALSE, projection.m);
}
// control keys
bool cam_moved = false;
if (glfwGetKey (window, GLFW_KEY_A)) {
//cam_pos[0] -= cam_speed * elapsed_seconds;
vec3_t move_vec = vec3_mul(cam_right, move_dist);
cam_pos = vec3_sub(cam_pos, move_vec);
cam_moved = true;
}
if (glfwGetKey (window, GLFW_KEY_D)) {
//cam_pos[0] += cam_speed * elapsed_seconds;
vec3_t move_vec = vec3_mul(cam_right, move_dist);
cam_pos = vec3_add(cam_pos, move_vec);
cam_moved = true;
}
if (glfwGetKey (window, GLFW_KEY_PAGE_UP)) {
//cam_pos[1] += cam_speed * elapsed_seconds;
cam_pos.y += move_dist;
cam_moved = true;
}
if (glfwGetKey (window, GLFW_KEY_PAGE_DOWN)) {
//cam_pos[1] -= cam_speed * elapsed_seconds;
cam_pos.y -= move_dist;
cam_moved = true;
}
if (glfwGetKey (window, GLFW_KEY_W)) {
//cam_pos[2] -= cam_speed * elapsed_seconds;
vec3_t move_vec = vec3_mul(cam_front, move_dist);
cam_pos = vec3_add(cam_pos, move_vec);
cam_moved = true;
}
if (glfwGetKey (window, GLFW_KEY_S)) {
//cam_pos[2] += cam_speed * elapsed_seconds;
vec3_t move_vec = vec3_mul(cam_front, move_dist);
cam_pos = vec3_sub(cam_pos, move_vec);
cam_moved = true;
}
if (glfwGetKey (window, GLFW_KEY_LEFT)) {
cam_yaw += cam_yaw_speed * elapsed_seconds;
cam_moved = true;
}
if (glfwGetKey (window, GLFW_KEY_RIGHT)) {
cam_yaw -= cam_yaw_speed * elapsed_seconds;
cam_moved = true;
}
if (glfwGetKey (window, GLFW_KEY_UP)) {
cam_pitch += cam_yaw_speed *elapsed_seconds;
cam_moved = true;
}
if (glfwGetKey (window, GLFW_KEY_DOWN)) {
cam_pitch -= cam_yaw_speed * elapsed_seconds;
cam_moved = true;
}
if (cam_pitch > 89.0f) {
cam_pitch = 89.0f;
}
if (cam_pitch < -89.0f) {
cam_pitch = -89.0f;
}
// update view matrix
if (cam_moved) {
//T = mat4_make_translation(-cam_pos.x, -cam_pos.y, -cam_pos.z);
//R = mat4_make_rotation_y(-cam_yaw);
//view_mat = mat4_mul_mat4(R, T);
view_mat = mat4_look_at(
cam_pos.x, cam_pos.y, cam_pos.z,
cam_pos.x + cam_front.x, cam_pos.y + cam_front.y, cam_pos.z + cam_front.z,
cam_up.x, cam_up.y, cam_up.z
);
glUniformMatrix4fv (view_mat_location, 1, GL_FALSE, view_mat.m);
}
}
// Cleanup after loop
free_group_mesh(meshes);
nk_glfw3_shutdown(&glfw);
glfwTerminate();
break;
}