829 lines
24 KiB
C++
829 lines
24 KiB
C++
#include "gui.h"
|
||
#include "../render/2d.h"
|
||
#include "../render/render.h"
|
||
#include "../lib/math.h"
|
||
#include "../lib/color.h"
|
||
#include "text_draw.h"
|
||
#include "../debug/logger.h"
|
||
#include "stdio.h"
|
||
#include "string.h"
|
||
#include "../platform.h"
|
||
#include "../lib/hashing.h"
|
||
|
||
Gui_State global_gui_state;
|
||
|
||
void gui_button_draw_inner_text(Gui_Context *ctx, Rect r, const char *text, v4 color, Rect *actual_drawn_rect = NULL);
|
||
|
||
bool gui_init()
|
||
{
|
||
gui_context_init(&global_gui_state.default_context);
|
||
global_gui_state.selected_context = &global_gui_state.default_context;
|
||
bool success = gui_text_draw_init();
|
||
return success;
|
||
}
|
||
|
||
void gui_deinit()
|
||
{
|
||
gui_text_draw_deinit();
|
||
}
|
||
|
||
void gui_context_init(Gui_Context *ctx)
|
||
{
|
||
ctx->width = 100;
|
||
ctx->height = 100;
|
||
|
||
ctx-> last_frame_time = 0;
|
||
ctx->current_frame_time = 0;
|
||
|
||
ctx-> active = NULL;
|
||
ctx-> hot = NULL;
|
||
ctx->possibly_hot = NULL;
|
||
ctx->active_start_time = 0;
|
||
ctx-> hot_start_time = 0;
|
||
ctx->active_status = 0;
|
||
|
||
ctx->text_cursor_position = 0;
|
||
ctx->text_length = 0;
|
||
|
||
ctx->windows = NULL;
|
||
ctx->window_count = 0;
|
||
ctx->window_capacity = 0;
|
||
ctx->current_window = NULL;
|
||
|
||
ctx->id_count = 0;
|
||
ctx->id_capacity = 8;
|
||
ctx->id_stack = (Gui_Id*)p_alloc(sizeof(Gui_Id) * ctx->id_capacity);
|
||
|
||
ctx->input.pointer_position = {0, 0};
|
||
ctx->input.absolute_pointer_position = {0, 0};
|
||
ctx->input.mouse_pressed = false;
|
||
ctx->input.mouse_pressed_this_frame = false;
|
||
ctx->input.mouse_released_this_frame = false;
|
||
ctx->input.text_cursor_move = 0;
|
||
ctx->input.text[0] = '\0';
|
||
|
||
ctx->input.absolute_pointer_position_last_frame = {0, 0};
|
||
|
||
|
||
ctx->style.font_size = 12;
|
||
ctx->style.animation_base_time = 0.100;
|
||
|
||
ctx->style.text_color = v4{1.0, 1.0, 1.0, 1.0};
|
||
ctx->style.text_align = GUI_ALIGN_CENTER;
|
||
|
||
|
||
ctx->style.button_color = v4{0.4f, 0.4f, 0.4f, 1.0f}*0.8f;
|
||
ctx->style.button_color_hovered = v4{0.3f, 0.3f, 0.3f, 1.0f}*0.9f;
|
||
ctx->style.button_color_pressed = v4{0.1f, 0.1f, 0.1f, 1.0f};
|
||
ctx->style.button_text_color = v4{1.0f, 1.0f, 1.0f, 1.0f};
|
||
ctx->style.button_text_color_hovered = v4{1.0f, 1.0f, 1.0f, 1.0f};
|
||
ctx->style.button_text_color_pressed = v4{1.0f, 1.0f, 1.0f, 1.0f};
|
||
ctx->style.button_radius = 3;
|
||
|
||
ctx->style.slider_fill_color = {0.0f, 0.3f, 0.9f, 1.0f};
|
||
|
||
ctx->style.window_background_color = {0.01,0.01,0.01, 0.98};
|
||
ctx->style.window_border_color = {1.0,0.06,0.0,1.0};
|
||
ctx->style.window_background_color_inactive = {0.05,0.05,0.05, 0.95};
|
||
ctx->style.window_border_color_inactive = {0.3,0.3,0.3, 1.0};
|
||
ctx->style.window_corner_radius = 5;
|
||
ctx->style.window_titlebar_color = ctx->style.window_border_color;
|
||
ctx->style.window_titlebar_color_inactive = {0.1,0.1,0.1,0.1};
|
||
}
|
||
|
||
void gui_context_select(Gui_Context *ctx)
|
||
{
|
||
global_gui_state.selected_context = ctx;
|
||
}
|
||
|
||
void gui_frame_begin(Gui_Context *ctx, f64 curr_time)
|
||
{
|
||
ctx-> last_frame_time = ctx->current_frame_time;
|
||
ctx->current_frame_time = curr_time;
|
||
}
|
||
|
||
void gui_frame_begin(f64 curr_time)
|
||
{
|
||
gui_frame_begin(&global_gui_state.default_context, curr_time);
|
||
}
|
||
|
||
void gui_frame_end(Gui_Context *ctx)
|
||
{
|
||
// Render windows
|
||
for(u32 i = 0; i < ctx->window_count; i++)
|
||
{
|
||
Gui_Window *w = &ctx->windows[i];
|
||
if(w->still_open)
|
||
{
|
||
Rect r_uv = Rect{0,0,1,-1}; // y is flipped when rendering framebuffer's textures
|
||
r_2d_immediate_rectangle(w->r, v4{1,1,1,1}, r_uv, &w->framebuffer.color_texture);
|
||
w->still_open = false; // Will be set to true if still open
|
||
}
|
||
}
|
||
// @Performance: cleanup unused windows
|
||
|
||
// Fix state
|
||
if(ctx->hot != ctx->possibly_hot)
|
||
{
|
||
ctx->hot = ctx->possibly_hot;
|
||
ctx->hot_start_time = ctx->current_frame_time;
|
||
}
|
||
|
||
ctx->input.mouse_pressed_this_frame = false;
|
||
ctx->input.mouse_released_this_frame = false;
|
||
|
||
ctx->input.absolute_pointer_position_last_frame = ctx->input.absolute_pointer_position;
|
||
|
||
ctx->input.text[0] = '\0';
|
||
ctx->input.text_cursor_move = 0;
|
||
|
||
ctx->possibly_hot = NULL;
|
||
}
|
||
|
||
void gui_frame_end()
|
||
{
|
||
gui_frame_end(&global_gui_state.default_context);
|
||
}
|
||
|
||
void gui_handle_event(Gui_Context *ctx, Event *e)
|
||
{
|
||
switch(e->type)
|
||
{
|
||
case EVENT_MOUSE_MOVE: {
|
||
if(!e->mouse_move.relative)
|
||
{
|
||
ctx->input.pointer_position = e->mouse_move.position;
|
||
ctx->input.absolute_pointer_position = e->mouse_move.position;
|
||
}
|
||
} break;
|
||
case EVENT_KEY: {
|
||
switch(e->key.key_code)
|
||
{
|
||
case KEY_MOUSE_LEFT: {
|
||
ctx->input.mouse_pressed = e->key.pressed;
|
||
if(e->key.pressed)
|
||
ctx->input.mouse_pressed_this_frame = true;
|
||
else
|
||
ctx->input.mouse_released_this_frame = true;
|
||
} break;
|
||
case KEY_ARROW_LEFT: {
|
||
if(e->key.pressed)
|
||
ctx->input.text_cursor_move--;
|
||
} break;
|
||
case KEY_ARROW_RIGHT: {
|
||
if(e->key.pressed)
|
||
ctx->input.text_cursor_move++;
|
||
} break;
|
||
default: {
|
||
} break;
|
||
}
|
||
} break;
|
||
case EVENT_RESIZE: {
|
||
|
||
} break;
|
||
case EVENT_TEXT: {
|
||
strcat(ctx->input.text, e->text.data);
|
||
} break;
|
||
default: {
|
||
} break;
|
||
}
|
||
}
|
||
|
||
void gui_handle_event(Event *e)
|
||
{
|
||
gui_handle_event(&global_gui_state.default_context, e);
|
||
}
|
||
|
||
// ### Widgets ###
|
||
// Text
|
||
void gui_text(Gui_Context *ctx, Rect r, const char *text)
|
||
{
|
||
// @Feature: Clip text to Rect r
|
||
gui_text_draw(r, text, ctx->style.font_size, ctx->style.text_color);
|
||
}
|
||
|
||
void gui_text(Rect r, const char *text)
|
||
{
|
||
gui_text(&global_gui_state.default_context, r, text);
|
||
}
|
||
|
||
void gui_text_aligned(Gui_Context *ctx, Rect r, const char *text, Gui_Text_Align alignment)
|
||
{
|
||
// @Cleanup: this should not depend on setting state. We should have a function that gets alignment as an argument
|
||
Gui_Text_Align old_alignment = ctx->style.text_align;
|
||
ctx->style.text_align = alignment;
|
||
gui_button_draw_inner_text(ctx, r, text, ctx->style.text_color);
|
||
ctx->style.text_align = old_alignment;
|
||
}
|
||
|
||
void gui_text_aligned(Rect r, const char *text, Gui_Text_Align alignment)
|
||
{
|
||
gui_text_aligned(&global_gui_state.default_context, r, text, alignment);
|
||
}
|
||
|
||
|
||
v2 gui_text_compute_size(Gui_Context *ctx, const char *text)
|
||
{
|
||
return gui_text_draw_size(text, ctx->style.font_size);
|
||
}
|
||
|
||
v2 gui_text_compute_size(const char *text)
|
||
{
|
||
return gui_text_compute_size(&global_gui_state.default_context, text);
|
||
}
|
||
|
||
// Button
|
||
bool gui_button(Gui_Context *ctx, Rect r, const char *text)
|
||
{
|
||
Gui_Id widget_id = gui_id_from_pointer(ctx, text);
|
||
bool behaviuor = gui_button_behaviuor(ctx, widget_id, r);
|
||
|
||
// Compute colors
|
||
v4 button_color = ctx->style.button_color;
|
||
v4 text_color = ctx->style.button_text_color;
|
||
{
|
||
if(ctx->hot == widget_id)
|
||
{
|
||
f64 delta_t = (ctx->current_frame_time - ctx->hot_start_time);
|
||
f32 interpolation = clamp(0, 1, delta_t / ctx->style.animation_base_time);
|
||
button_color = lerp(ctx->style.button_color, ctx->style.button_color_hovered, interpolation);
|
||
text_color = lerp(ctx->style.button_text_color, ctx->style.button_text_color_hovered, interpolation);
|
||
}
|
||
if(ctx->active == widget_id)
|
||
{
|
||
f64 delta_t = (ctx->current_frame_time - ctx->active_start_time);
|
||
f32 interpolation = clamp(0, 1, delta_t / ctx->style.animation_base_time);
|
||
button_color = lerp(ctx->style.button_color_hovered, ctx->style.button_color_pressed, interpolation * 0.4 + 0.6);
|
||
text_color = lerp(ctx->style.button_text_color_hovered, ctx->style.button_text_color_pressed, interpolation * 0.4 + 0.6);
|
||
}
|
||
}
|
||
|
||
// Draw button and text
|
||
r_2d_immediate_rounded_rectangle(r, ctx->style.button_radius, button_color);
|
||
gui_button_draw_inner_text(ctx, r, text, text_color);
|
||
|
||
return behaviuor;
|
||
}
|
||
|
||
bool gui_button(Rect r, const char *text)
|
||
{
|
||
return gui_button(&global_gui_state.default_context, r, text);
|
||
}
|
||
|
||
void gui_button_draw_inner_text(Gui_Context *ctx, Rect r, const char *text, v4 color, Rect *actual_drawn_rect)
|
||
{
|
||
v2 text_size = gui_text_draw_size(text, ctx->style.font_size);
|
||
// Alignment (center, left, right)
|
||
v2 text_position = r.position + (r.size - text_size) * v2{0.5, 0.5};
|
||
if(ctx->style.text_align == GUI_ALIGN_LEFT)
|
||
text_position = r.position + (r.size - text_size) * v2{0, 0.5};
|
||
if(ctx->style.text_align == GUI_ALIGN_RIGHT)
|
||
text_position = r.position + (r.size - text_size) * v2{1, 0.5};
|
||
// Draw
|
||
Rect text_rect = { .position = text_position, .size = text_size };
|
||
// @Feature: Clip text to Rect r
|
||
gui_text_draw(text_rect, text, ctx->style.font_size, color);
|
||
|
||
if(actual_drawn_rect)
|
||
*actual_drawn_rect = text_rect;
|
||
}
|
||
|
||
// Slider
|
||
bool gui_slider(Gui_Context *ctx, Rect r, f32 min, f32 max, f32 *value)
|
||
{
|
||
Gui_Id widget_id = gui_id_from_pointer(ctx, value);
|
||
bool behaviour = gui_button_behaviuor(ctx, widget_id, r);
|
||
|
||
if(ctx->active == widget_id)
|
||
{
|
||
f32 pointer_ratio = (ctx->input.pointer_position.x - r.position.x) / r.size.x;
|
||
*value = clamp(0.0f, 1.0f, pointer_ratio) * (max - min) + min;
|
||
}
|
||
|
||
// Colors
|
||
v4 button_color = ctx->style.button_color;
|
||
v4 text_color = ctx->style.button_text_color;
|
||
{
|
||
f64 delta_t = (ctx->current_frame_time - ctx->hot_start_time);
|
||
f32 interpolation = sin(10 * delta_t) * 0.5 + 0.5;
|
||
if(ctx->hot == widget_id)
|
||
{
|
||
button_color = lerp(ctx->style.button_color, ctx->style.button_color_hovered, interpolation);
|
||
text_color = lerp(ctx->style.button_text_color, ctx->style.button_text_color_hovered, interpolation);
|
||
}
|
||
if(ctx->active == widget_id)
|
||
{
|
||
button_color = lerp(ctx->style.button_color_hovered, ctx->style.button_color_pressed, interpolation * 0.4 + 0.6);
|
||
text_color = lerp(ctx->style.button_text_color_hovered, ctx->style.button_text_color_pressed, interpolation * 0.4 + 0.6);
|
||
}
|
||
}
|
||
|
||
// Draw
|
||
f32 border = 2;
|
||
f32 radius = ctx->style.button_radius;
|
||
|
||
// Draw background
|
||
v4 background_color = ctx->style.button_color;
|
||
r_2d_immediate_rounded_rectangle(r, radius, background_color); // Background
|
||
|
||
// Draw fill
|
||
f32 ratio = (*value - min) / (max - min);
|
||
Rect fill_r = r;
|
||
fill_r.position += v2{border, border};
|
||
fill_r.size = v2{maximum(0, fill_r.size.x - 2*border), maximum(0, fill_r.size.y - 2*border)};
|
||
f32 fill_radius = maximum(0, radius - border);
|
||
fill_r.size.x = fill_r.size.x * ratio;
|
||
r_2d_immediate_rounded_rectangle(fill_r, fill_radius, ctx->style.slider_fill_color);
|
||
|
||
// Draw border
|
||
v4 border_color = ctx->style.button_color_pressed;
|
||
Rect border_r = r;
|
||
border_r.position += v2{border, border} * 0.5;
|
||
border_r.size = v2{maximum(0, border_r.size.x - border), maximum(0, border_r.size.y - border)};
|
||
f32 border_radius = maximum(0, radius - border*0.5);
|
||
r_2d_immediate_rounded_rectangle_outline(border_r, border_radius, border_color, border);
|
||
|
||
// Draw value text
|
||
char text[64];
|
||
sprintf(text, "%f", *value);
|
||
gui_button_draw_inner_text(ctx, r, text, text_color);
|
||
|
||
return behaviour || ctx->active == widget_id;
|
||
}
|
||
|
||
bool gui_slider(Rect r, f32 min, f32 max, f32 *value)
|
||
{
|
||
return gui_slider(&global_gui_state.default_context, r, min, max, value);
|
||
}
|
||
|
||
|
||
// Images
|
||
bool gui_image(Gui_Context *ctx, Rect r, r_texture *texture)
|
||
{
|
||
Gui_Id widget_id = gui_id_from_pointer(ctx, texture);
|
||
|
||
v4 color = {1,1,1,1};
|
||
r_2d_immediate_rectangle(r, color, {0,0,1,1}, texture);
|
||
|
||
return gui_button_behaviuor(ctx, widget_id, r);;
|
||
}
|
||
|
||
bool gui_image(Rect r, r_texture *texture)
|
||
{
|
||
return gui_image(&global_gui_state.default_context, r, texture);
|
||
}
|
||
|
||
bool gui_image(Gui_Context *ctx, Rect r, const u8 *bmp, u32 width, u32 height, u32 channels, u32 flags)
|
||
{
|
||
r_texture texture = r_texture_create((u8*)bmp, {width, height}, flags | R_TEXTURE_DONT_OWN);
|
||
bool result = gui_image(ctx, r, &texture);
|
||
r_texture_destroy(&texture);
|
||
return result;
|
||
}
|
||
|
||
bool gui_image(Rect r, const u8 *bmp, u32 width, u32 height, u32 channels, u32 flags)
|
||
{
|
||
return gui_image(&global_gui_state.default_context, r, bmp, width, height, channels, flags);
|
||
}
|
||
|
||
|
||
// Text input
|
||
bool gui_text_input(Gui_Context *ctx, Rect r, char *text, u64 max_size)
|
||
{
|
||
Gui_Id widget_id = gui_id_from_pointer(ctx, text);
|
||
bool behaviour = gui_text_input_behaviuor(ctx, widget_id, r);
|
||
bool edited = false;
|
||
|
||
// Cursor, mouse click, input from keyboard/os
|
||
if(ctx->active == widget_id && ctx->input.mouse_pressed_this_frame)
|
||
{
|
||
ctx->text_length = strlen(text);
|
||
ctx->text_cursor_position = ctx->text_length;
|
||
}
|
||
|
||
// Move cursors between UTF8 codepoints (not bytes)
|
||
if(ctx->input.text_cursor_move != 0)
|
||
{
|
||
while(ctx->input.text_cursor_move > 0)
|
||
{
|
||
if(text[ctx->text_cursor_position] == '\0')
|
||
{
|
||
ctx->input.text_cursor_move = 0;
|
||
break;
|
||
}
|
||
ctx->text_cursor_position += utf8_bytes_to_next_valid_codepoint(text, ctx->text_cursor_position);
|
||
ctx->input.text_cursor_move--;
|
||
}
|
||
while(ctx->input.text_cursor_move < 0)
|
||
{
|
||
if(ctx->text_cursor_position == 0)
|
||
{
|
||
ctx->input.text_cursor_move = 0;
|
||
break;
|
||
}
|
||
ctx->text_cursor_position -= utf8_bytes_to_prev_valid_codepoint(text, ctx->text_cursor_position);
|
||
ctx->input.text_cursor_move++;
|
||
}
|
||
}
|
||
|
||
if(ctx->active == widget_id && ctx->input.text[0] != 0)
|
||
{
|
||
// @Bug: Should iterate on utf8 codepoints. If we don't, there's the possibility
|
||
// of inserting half of a multi-byte codepoint.
|
||
for(char *c = ctx->input.text; *c != 0; c++)
|
||
{
|
||
if(*c == 0x08) // Backspace
|
||
{
|
||
if(ctx->text_cursor_position > 0)
|
||
{
|
||
u32 codepoint_bytes = utf8_bytes_to_prev_valid_codepoint(text, ctx->text_cursor_position);
|
||
u64 from_index = ctx->text_cursor_position;
|
||
u64 to_index = ctx->text_cursor_position - codepoint_bytes;
|
||
memmove(text + to_index, text + from_index, ctx->text_length + 1 - from_index);
|
||
ctx->text_length -= codepoint_bytes;
|
||
ctx->text_cursor_position -= codepoint_bytes;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
if(*c == 0x7F) // Delete
|
||
{
|
||
if(ctx->text_cursor_position < ctx->text_length)
|
||
{
|
||
u32 codepoint_bytes = utf8_bytes_to_next_valid_codepoint(text, ctx->text_cursor_position);
|
||
u64 from_index = ctx->text_cursor_position + codepoint_bytes;
|
||
u64 to_index = ctx->text_cursor_position;
|
||
memmove(text + to_index, text + from_index, ctx->text_length + 1 - from_index);
|
||
ctx->text_length -= codepoint_bytes;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
if(ctx->text_length < max_size - 1) // Leave space for 0 terminator
|
||
{
|
||
memmove(text + ctx->text_cursor_position + 1, text + ctx->text_cursor_position, ctx->text_length + 1 - ctx->text_cursor_position);
|
||
text[ctx->text_cursor_position] = *c;
|
||
ctx->text_length += 1;
|
||
ctx->text_cursor_position += 1;
|
||
}
|
||
}
|
||
|
||
edited = true;
|
||
}
|
||
|
||
r_2d_immediate_rounded_rectangle(r, ctx->style.button_radius, ctx->style.button_color);
|
||
Rect text_rect;
|
||
gui_button_draw_inner_text(ctx, r, text, ctx->style.button_text_color, &text_rect);
|
||
|
||
if(ctx->active == widget_id)
|
||
{
|
||
// Draw cursor
|
||
f64 delta_t = ctx->current_frame_time - ctx->active_start_time;
|
||
f32 u = clamp(0, 1, sin(delta_t * 5) * 0.7 + 0.6);
|
||
v4 cursor_color = ctx->style.button_text_color;
|
||
cursor_color *= lerp(0, cursor_color.a, u);
|
||
|
||
char replaced = text[ctx->text_cursor_position];
|
||
text[ctx->text_cursor_position] = 0;
|
||
v2 cursor_position;
|
||
v2 text_size = gui_text_draw_size(text, ctx->style.font_size, &cursor_position);
|
||
text[ctx->text_cursor_position] = replaced;
|
||
|
||
Rect cursor_rect =
|
||
{
|
||
.position = text_rect.position + cursor_position - v2{0, ctx->style.font_size},
|
||
.size = ctx->style.font_size * v2{0.1, 0.9}
|
||
};
|
||
r_2d_immediate_rectangle(cursor_rect, cursor_color);
|
||
}
|
||
|
||
return edited;
|
||
}
|
||
|
||
bool gui_text_input(Rect r, char *text, u64 max_size)
|
||
{
|
||
return gui_text_input(&global_gui_state.default_context, r, text, max_size);
|
||
}
|
||
|
||
|
||
// Panels
|
||
void gui_panel(Gui_Context *ctx, Rect r)
|
||
{
|
||
Gui_Id widget_id = 0;
|
||
bool behaviuor = gui_button_behaviuor(ctx, widget_id, r);
|
||
|
||
bool is_inactive = true;
|
||
v4 background_color = is_inactive ? ctx->style.window_background_color_inactive :
|
||
ctx->style.window_background_color;
|
||
v4 border_color = is_inactive ? ctx->style.window_border_color_inactive :
|
||
ctx->style.window_border_color;
|
||
Rect background_rect = {r.x + 0.5, r.y + 0.5, floor(r.w)-1.0, floor(r.h)-1.0};
|
||
r_2d_immediate_rounded_rectangle(background_rect, ctx->style.window_corner_radius, background_color);
|
||
r_2d_immediate_rounded_rectangle_outline(background_rect, ctx->style.window_corner_radius, border_color, 1.0);
|
||
}
|
||
|
||
void gui_panel(Rect r)
|
||
{
|
||
gui_panel(&global_gui_state.default_context, r);
|
||
}
|
||
|
||
|
||
// Windows
|
||
bool gui_window_start(Gui_Context *ctx, Rect r, Gui_Id id)
|
||
{
|
||
gui_id_stack_push(ctx, id);
|
||
Gui_Window *window = gui_window_by_id(ctx, r, id);
|
||
window->still_open = true;
|
||
gui_window_update_rect(ctx, window, r);
|
||
u32 window_index = window - ctx->windows;
|
||
|
||
bool hovered = gui_is_hovered(ctx, id, r);
|
||
if(hovered && ctx->input.mouse_pressed_this_frame)
|
||
{
|
||
// Bring window on top
|
||
u32 move_count = ctx->window_count - 1 - window_index;
|
||
if(move_count > 0)
|
||
{
|
||
Gui_Window tmp = *window;
|
||
memmove(ctx->windows + window_index, ctx->windows + window_index + 1, sizeof(Gui_Window) * move_count);
|
||
|
||
ctx->windows[ctx->window_count - 1] = tmp;
|
||
window_index = ctx->window_count - 1;
|
||
window = &ctx->windows[window_index];
|
||
}
|
||
}
|
||
|
||
ctx->current_window = window;
|
||
ctx->input.pointer_position = ctx->input.absolute_pointer_position - window->r.position;
|
||
|
||
ctx->old_framebuffer = r_render_state.current_framebuffer;
|
||
r_framebuffer_select(&window->framebuffer);
|
||
|
||
|
||
bool is_inactive = window_index != ctx->window_count-1;
|
||
v4 background_color = is_inactive ? ctx->style.window_background_color_inactive :
|
||
ctx->style.window_background_color;
|
||
v4 border_color = is_inactive ? ctx->style.window_border_color_inactive :
|
||
ctx->style.window_border_color;
|
||
r_clear({0,0,0,0});
|
||
Rect background_rect = {0.5, 0.5, floor(r.w)-1.0, floor(r.h)-1.0};
|
||
r_2d_immediate_rounded_rectangle(background_rect, ctx->style.window_corner_radius, background_color);
|
||
r_2d_immediate_rounded_rectangle_outline(background_rect, ctx->style.window_corner_radius, border_color, 1.0);
|
||
|
||
return true;
|
||
}
|
||
|
||
bool gui_window_start(Rect r, Gui_Id id)
|
||
{
|
||
return gui_window_start(&global_gui_state.default_context, r, id);
|
||
}
|
||
|
||
void gui_window_end(Gui_Context *ctx)
|
||
{
|
||
gui_id_stack_pop(ctx);
|
||
ctx->current_window = NULL;
|
||
ctx->input.pointer_position = ctx->input.absolute_pointer_position;
|
||
|
||
r_framebuffer_select(ctx->old_framebuffer);
|
||
}
|
||
|
||
void gui_window_end()
|
||
{
|
||
return gui_window_end(&global_gui_state.default_context);
|
||
}
|
||
|
||
|
||
bool gui_window_titlebar(Gui_Context *ctx, Rect r, const char *title, bool *close, v2 *move)
|
||
{
|
||
Gui_Id widget_id = gui_id_from_pointer(ctx, title);
|
||
bool behaviour = gui_button_behaviuor(ctx, widget_id, r);
|
||
if(close)
|
||
*close = false;
|
||
if(move)
|
||
*move = {0,0};
|
||
|
||
// Background
|
||
v4 titlebar_color = ctx->style.window_titlebar_color_inactive;
|
||
if(ctx->current_window && ctx->current_window - ctx->windows == ctx->window_count - 1)
|
||
{
|
||
titlebar_color = ctx->style.window_titlebar_color;
|
||
}
|
||
r_2d_immediate_rounded_rectangle(r, ctx->style.window_corner_radius, titlebar_color);
|
||
|
||
// Title
|
||
v2 title_size = gui_text_compute_size(title);
|
||
Rect title_r = r;
|
||
title_r.size = title_size;
|
||
title_r.position = r.position + (r.size - title_r.size) / 2;
|
||
gui_text(title_r, title);
|
||
|
||
// Exit button
|
||
f32 smallest_side = minimum(r.w, r.h);
|
||
f32 exit_size = smallest_side;
|
||
Gui_Style exit_style = ctx->style;
|
||
exit_style.button_color = v4{0.8f, 0.8f, 0.8f, 1.0f}*0.0f;
|
||
exit_style.button_color_hovered = v4{1.0f, 0.0f, 0.0f, 1.0f}*1.0f;
|
||
exit_style.button_color_pressed = v4{0.8f, 0.0f, 0.0f, 1.0f};
|
||
exit_style.button_text_color = v4{1.0f, 1.0f, 1.0f, 1.0f};
|
||
exit_style.button_text_color_hovered = v4{1.0f, 1.0f, 1.0f, 1.0f};
|
||
exit_style.button_text_color_pressed = v4{1.0f, 1.0f, 1.0f, 1.0f};
|
||
exit_style.button_radius = ctx->style.window_corner_radius;
|
||
Gui_Style old_style = ctx->style;
|
||
ctx->style = exit_style;
|
||
Rect exit_button_r = {r.x + r.w - exit_size, r.y, exit_size, exit_size};
|
||
if(gui_button(ctx, exit_button_r, "⨯"))
|
||
{
|
||
if(close)
|
||
*close = true;
|
||
behaviour = true;
|
||
}
|
||
ctx->style = old_style;
|
||
|
||
// Move
|
||
if(ctx->active == widget_id && !ctx->input.mouse_pressed_this_frame)
|
||
{
|
||
if(move)
|
||
{
|
||
*move = ctx->input.absolute_pointer_position - ctx->input.absolute_pointer_position_last_frame;
|
||
}
|
||
}
|
||
|
||
return behaviour || ctx->active == widget_id;
|
||
}
|
||
|
||
bool gui_window_titlebar(Rect r, const char *title, bool *close, v2 *move)
|
||
{
|
||
return gui_window_titlebar(&global_gui_state.default_context, r, title, close, move);
|
||
}
|
||
|
||
|
||
|
||
Gui_Window *gui_window_by_id(Gui_Context *ctx, Rect r, Gui_Id id)
|
||
{
|
||
Gui_Window *window = NULL;
|
||
for(u32 i = 0; i < ctx->window_count; i++)
|
||
{
|
||
if(ctx->windows[i].id == id)
|
||
{
|
||
window = &ctx->windows[i];
|
||
break;
|
||
}
|
||
}
|
||
|
||
if(!window)
|
||
{
|
||
if(ctx->window_count >= ctx->window_capacity)
|
||
{
|
||
if(ctx->window_capacity == 0)
|
||
ctx->window_capacity = 1;
|
||
ctx->window_capacity *= 2;
|
||
ctx->windows = (Gui_Window*) p_realloc(ctx->windows, sizeof(Gui_Window) * ctx->window_capacity);
|
||
}
|
||
|
||
window = &ctx->windows[ctx->window_count];
|
||
ctx->window_count++;
|
||
|
||
window->id = id;
|
||
window->r = r;
|
||
window->framebuffer = r_framebuffer_create(V2S(r.size), 0);
|
||
}
|
||
|
||
return window;
|
||
}
|
||
|
||
void gui_window_update_rect(Gui_Context *ctx, Gui_Window *window, Rect r)
|
||
{
|
||
if(window->r.size != r.size)
|
||
{
|
||
r_framebuffer_update_size(&window->framebuffer, V2S(r.size));
|
||
}
|
||
window->r = r;
|
||
}
|
||
|
||
|
||
// Helpers
|
||
bool gui_is_hovered(Gui_Context *ctx, Gui_Id widget_id, Rect r)
|
||
{
|
||
if(is_inside(r, ctx->input.pointer_position))
|
||
{
|
||
s32 current_window_index = -1; // We use -1 to indicate we are not in a window. When we iterate over windows we do a +1 and start from 0, aka the first window. If we used 0, we would start from 1 and skip over window index 0.
|
||
|
||
// The ctx->windows array is sorted from back to front. If we are inside a window, only the following windows in the array can overlap up. The ones before are covered by the current window.
|
||
if(ctx->current_window)
|
||
current_window_index = ctx->current_window - ctx->windows;
|
||
|
||
// Am I a window? If so, we start checking from us. If ctx->current_window is set and widget_id is a window, it means we are a subwindow.
|
||
// Subwindow are not supported yet though (20 September 2023), so this should be a bug in the user code. Yeah we don't check to prevent this, but anyways.
|
||
for(s32 i = current_window_index + 1; i < ctx->window_count; i++)
|
||
{
|
||
Gui_Id window_id = ctx->windows[i].id;
|
||
if(widget_id == window_id)
|
||
{
|
||
current_window_index = i;
|
||
break;
|
||
}
|
||
}
|
||
|
||
// Iterate over windows that cover the current one
|
||
for(u32 i = current_window_index + 1; i < ctx->window_count; i++)
|
||
{
|
||
Gui_Id window_id = ctx->windows[i].id;
|
||
Rect window_rect = ctx->windows[i].r;
|
||
if(is_inside(window_rect, ctx->input.absolute_pointer_position))
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool gui_button_behaviuor(Gui_Context *ctx, Gui_Id widget_id, Rect r)
|
||
{
|
||
bool behaviour = false;
|
||
if(gui_is_hovered(ctx, widget_id, r))
|
||
{
|
||
if(!ctx->active || ctx->active == widget_id || !(ctx->active_status & GUI_WIDGET_STATUS_PREVENT_HOT))
|
||
ctx->possibly_hot = widget_id;
|
||
|
||
if(ctx->hot == widget_id && ctx->input.mouse_pressed_this_frame)
|
||
{
|
||
ctx->active = widget_id;
|
||
ctx->active_start_time = ctx->current_frame_time;
|
||
ctx->active_status = GUI_WIDGET_STATUS_PREVENT_HOT;
|
||
}
|
||
|
||
if(ctx->active == widget_id && ctx->input.mouse_released_this_frame)
|
||
{
|
||
behaviour = true;
|
||
}
|
||
}
|
||
|
||
if(ctx->active == widget_id && ctx->input.mouse_released_this_frame)
|
||
{
|
||
ctx->active = NULL;
|
||
ctx->active_status = 0;
|
||
}
|
||
|
||
return behaviour;
|
||
}
|
||
|
||
|
||
bool gui_text_input_behaviuor(Gui_Context *ctx, Gui_Id widget_id, Rect r)
|
||
{
|
||
bool behaviour = false;
|
||
if(gui_is_hovered(ctx, widget_id, r))
|
||
{
|
||
if(!ctx->active || ctx->active == widget_id || !(ctx->active_status & GUI_WIDGET_STATUS_PREVENT_HOT))
|
||
ctx->possibly_hot = widget_id;
|
||
|
||
if(ctx->hot == widget_id && ctx->input.mouse_pressed_this_frame)
|
||
{
|
||
ctx->active = widget_id;
|
||
ctx->active_start_time = ctx->current_frame_time;
|
||
ctx->active_status = 0;
|
||
}
|
||
|
||
if(ctx->active == widget_id && ctx->input.mouse_released_this_frame)
|
||
{
|
||
behaviour = true;
|
||
}
|
||
}
|
||
|
||
if(ctx->active == widget_id && ctx->input.mouse_released_this_frame)
|
||
{
|
||
// ctx->active = NULL;
|
||
// ctx->active_status = 0;
|
||
}
|
||
|
||
return behaviour;
|
||
}
|
||
|
||
Gui_Id gui_id_from_pointer(Gui_Context *ctx, const void* ptr)
|
||
{
|
||
u32 seed = 0xFFFFFFFF;
|
||
if(ctx->id_count)
|
||
seed = ctx->id_stack[ctx->id_count - 1];
|
||
return hash_crc32(&ptr, sizeof(void*), seed);
|
||
}
|
||
|
||
void gui_id_stack_push(Gui_Context *ctx, Gui_Id id)
|
||
{
|
||
if(ctx->id_capacity <= ctx->id_count)
|
||
{
|
||
u32 new_capacity = maximum(ctx->id_count + 1, ctx->id_capacity * 2);
|
||
ctx->id_stack = (Gui_Id*)p_realloc(ctx->id_stack, sizeof(Gui_Id) * new_capacity);
|
||
ctx->id_capacity = new_capacity;
|
||
}
|
||
|
||
ctx->id_stack[ctx->id_count] = id;
|
||
ctx->id_count++;
|
||
}
|
||
|
||
void gui_id_stack_pop(Gui_Context *ctx)
|
||
{
|
||
if(ctx->id_count > 0)
|
||
ctx->id_count--;
|
||
}
|