563 lines
16 KiB
C
563 lines
16 KiB
C
/*
|
|
** [ ] Choosing a keying strategy from user code
|
|
** [ ] Using parents
|
|
** [ ] Using file and line
|
|
**
|
|
**
|
|
**
|
|
*/
|
|
|
|
typedef struct ui_id_t ui_id_t;
|
|
struct ui_id_t {
|
|
u64 value;
|
|
};
|
|
|
|
typedef struct ui_code_loc_t ui_code_loc_t;
|
|
struct ui_code_loc_t {
|
|
char *file;
|
|
int line;
|
|
int counter;
|
|
};
|
|
#define UI_CODE_LOC (ui_code_loc_t){.file = __FILE__, .line = __LINE__, .counter = __COUNTER__}
|
|
|
|
typedef enum {
|
|
ui_axis2_x,
|
|
ui_axis2_y,
|
|
ui_axis2_count,
|
|
} ui_axis2_t;
|
|
|
|
typedef enum {
|
|
ui_size_kind_null,
|
|
ui_size_kind_pixels,
|
|
ui_size_kind_text_content,
|
|
ui_size_kind_percent_of_parent,
|
|
ui_size_kind_children_sum,
|
|
} ui_size_kind_t;
|
|
|
|
typedef struct ui_size_t ui_size_t;
|
|
struct ui_size_t {
|
|
ui_size_kind_t kind;
|
|
f32 value;
|
|
f32 strictness;
|
|
};
|
|
|
|
typedef enum {
|
|
ui_box_flag_none = 0,
|
|
} ui_box_flag_t;
|
|
|
|
typedef struct ui_box_t ui_box_t;
|
|
struct ui_box_t {
|
|
// recreated every frame in building code
|
|
ui_box_t *next;
|
|
ui_box_t *prev;
|
|
ui_box_t *parent;
|
|
ui_box_t *first;
|
|
ui_box_t *last;
|
|
s8_t string;
|
|
ui_size_t semantic_size[ui_axis2_count];
|
|
b32 grow_axis[ui_axis2_count];
|
|
ui_code_loc_t loc;
|
|
|
|
// preserving state
|
|
ui_id_t id; // important position!: offset(id) used for partial zeroing
|
|
u64 last_touched_event_id;
|
|
ui_box_t *hash_next;
|
|
ui_box_t *hash_prev;
|
|
|
|
// computed by layout system every frame
|
|
f32 iter_pos[ui_axis2_count];
|
|
f32 computed_rel_pos[ui_axis2_count];
|
|
f32 computed_size[ui_axis2_count];
|
|
r2f32_t rect;
|
|
|
|
// state
|
|
b32 expanded;
|
|
};
|
|
|
|
typedef struct ui_signal_t ui_signal_t;
|
|
struct ui_signal_t {
|
|
b8 clicked;
|
|
b8 double_clicked;
|
|
b8 right_clicked;
|
|
b8 pressed;
|
|
b8 released;
|
|
b8 dragging;
|
|
b8 hovering;
|
|
};
|
|
|
|
typedef enum {
|
|
ui_id_strategy_hierarchy,
|
|
ui_id_strategy_code_loc,
|
|
} ui_id_strategy_t;
|
|
|
|
typedef struct ui_t ui_t;
|
|
struct ui_t {
|
|
ma_arena_t *box_arena; // required to be only used for boxes
|
|
app_event_t *event;
|
|
app_frame_t *frame;
|
|
|
|
i32 allocated_boxes;
|
|
ui_box_t *box_array; // first item on arena
|
|
ui_box_t *root;
|
|
ui_box_t *top;
|
|
|
|
ui_box_t *free_first;
|
|
ui_box_t *hash_first;
|
|
ui_box_t *hash_last;
|
|
|
|
ui_id_t hot;
|
|
ui_id_t active;
|
|
|
|
STACK(ui_id_t, 256) id_stack;
|
|
int indent_stack;
|
|
ui_id_strategy_t id_strategy;
|
|
};
|
|
|
|
gb ui_t *ui = NULL;
|
|
gb_read_only ui_id_t ui_id_null;
|
|
gb_read_only ui_box_t ui_box_null;
|
|
|
|
fn b32 ui_null_id(ui_id_t id) { return id.value == 0; }
|
|
fn b32 ui_null(ui_box_t *box) { return box->id.value == 0; }
|
|
fn b32 ui_hot(ui_box_t *box) { return !ui_null(box) && box->id.value == ui->hot.value; }
|
|
fn b32 ui_active(ui_box_t *box) { return !ui_null(box) && box->id.value == ui->active.value; }
|
|
|
|
#define ev_left(ev) ((ev)->mouse_button == app_mouse_button_left)
|
|
#define ev_left_up(ev) ((ev)->kind == app_event_kind_mouse_up && ev_left(ev))
|
|
#define ev_left_down(ev) ((ev)->kind == app_event_kind_mouse_down && ev_left(ev))
|
|
|
|
fn u64 ui_hash_mix(u64 x, u64 y) {
|
|
x ^= y;
|
|
x *= 0xff51afd7ed558ccd;
|
|
x ^= x >> 32;
|
|
return x;
|
|
}
|
|
|
|
s8_t ui_get_display_string(s8_t string) {
|
|
s8_t result = string;
|
|
if (s8_seek(result, s8_lit("##"), s8_seek_none, &result.len)) {
|
|
int a = 10;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
s8_t ui_get_hash_string(s8_t string) {
|
|
i64 len = 0;
|
|
if (s8_seek(string, s8_lit("##"), s8_seek_none, &len)) {
|
|
string = s8_skip(string, len + 2);
|
|
}
|
|
return string;
|
|
}
|
|
|
|
// @todo: we are not building a hierarchy, it's flat ! so this doesn't work!!
|
|
fn ui_id_t ui_id_from_string(s8_t string) {
|
|
u64 value = ht_hash_data(ui_get_hash_string(string));
|
|
ui_id_t id = {value};
|
|
return id;
|
|
}
|
|
|
|
fn ui_id_t ui_id_from_id_stack(void) {
|
|
u64 value = 134;
|
|
for (i32 i = 0; i < ui->id_stack.len; i += 1) {
|
|
value = ui_hash_mix(value, ui->id_stack.data[i].value);
|
|
}
|
|
ui_id_t id = {value};
|
|
return id;
|
|
}
|
|
|
|
fn ui_box_t *ui_find_box(ui_id_t id) {
|
|
if (id.value == 0) return NULL;
|
|
for (ui_box_t *it = ui->hash_first; it; it = it->hash_next) {
|
|
if (it->id.value == id.value) {
|
|
return it;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
fn ui_box_t *ui_alloc_box(void) {
|
|
ui_box_t *box = NULL;
|
|
if (ui->free_first) {
|
|
SLLS_POP_AND_STORE(ui->free_first, box);
|
|
} else {
|
|
box = ma_push_type(ui->box_arena, ui_box_t);
|
|
ui->allocated_boxes += 1;
|
|
}
|
|
return box;
|
|
}
|
|
|
|
fn void ui_push_box(ui_box_t *box) {
|
|
box->parent = ui->top;
|
|
DLLQ_APPEND(ui->top->first, ui->top->last, box);
|
|
}
|
|
|
|
fn ui_box_t *ui_build_box_from_id(ui_code_loc_t loc, ui_id_t id) {
|
|
ui_box_t *box = ui_find_box(id);
|
|
if (box) {
|
|
memory_zero(box, offsetof(ui_box_t, id));
|
|
} else {
|
|
box = ui_alloc_box();
|
|
// @todo: we can't really make sure ids don't repeat can't we?
|
|
DLLQ_APPEND_EX(ui->hash_first, ui->hash_last, box, hash_next, hash_prev);
|
|
}
|
|
box->loc = loc;
|
|
box->last_touched_event_id = ui->event->id;
|
|
box->id = id;
|
|
ui_push_box(box);
|
|
return box;
|
|
}
|
|
|
|
fn ui_box_t *ui_build_box_from_string(ui_code_loc_t loc, s8_t string) {
|
|
ui_id_t id = {32};
|
|
ui_id_t string_id = ui_id_from_string(string);
|
|
if (ui->id_strategy == ui_id_strategy_code_loc) {
|
|
u64 file_hash = ht_hash_data(s8_from_char(loc.file));
|
|
u64 line_hash = ht_hash_data(s8((char *)&loc.line, sizeof(loc.line)));
|
|
u64 cont_hash = ht_hash_data(s8((char *)&loc.counter, sizeof(loc.counter)));
|
|
id.value = ui_hash_mix(file_hash, line_hash);
|
|
id.value = ui_hash_mix(id.value, cont_hash);
|
|
} else if (ui->id_strategy == ui_id_strategy_hierarchy) {
|
|
ui_id_t id_from_stack = ui_id_from_id_stack();
|
|
id.value = ui_hash_mix(string_id.value, id_from_stack.value);
|
|
} else_is_invalid;
|
|
|
|
ui_box_t *box = ui_build_box_from_id(loc, id);
|
|
box->string = ui_get_display_string(string);
|
|
return box;
|
|
}
|
|
|
|
fn ui_signal_t ui_signal_from_box(ui_box_t *box) {
|
|
ui_signal_t result = {0};
|
|
app_event_t *ev = ui->event;
|
|
|
|
b32 move = ev->kind == app_event_kind_mouse_move;
|
|
b32 inside = r2f32_contains(box->rect, ev->mouse_pos);
|
|
|
|
if (ui_active(box)) {
|
|
if (ev_left_up(ev)) {
|
|
if (ui_hot(box)) {
|
|
result.clicked = true;
|
|
} else {
|
|
ui->active.value = 0;
|
|
}
|
|
}
|
|
} else if (ui_hot(box) && ev_left_down(ev)) {
|
|
ui->active = box->id;
|
|
}
|
|
|
|
if (inside) {
|
|
ui->hot.value = box->id.value;
|
|
} else if (!inside && ui_hot(box)) {
|
|
ui->hot = ui_id_null;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
fn void ui_init(ma_arena_t *arena) {
|
|
assert(arena != tcx.temp);
|
|
|
|
ui = ma_push_type(arena, ui_t);
|
|
ui->box_arena = arena;
|
|
ui->root = ma_push_type(arena, ui_box_t);
|
|
|
|
ui->box_array = ma_push_type(arena, ui_box_t);
|
|
SLLS_PUSH(ui->free_first, ui->box_array);
|
|
}
|
|
|
|
fn void ui_begin_build(ui_code_loc_t loc, app_event_t *event) {
|
|
ui->event = event;
|
|
|
|
for (ui_box_t *box = ui->hash_first, *next = NULL; box; box = next) {
|
|
next = box->hash_next;
|
|
if (box->id.value == 0) {
|
|
DLLQ_REMOVE_EX(ui->hash_first, ui->hash_last, box, hash_next, hash_prev);
|
|
zero_struct(box);
|
|
SLLS_PUSH(ui->free_first, box);
|
|
}
|
|
}
|
|
|
|
zero_struct(ui->root);
|
|
ui->top = ui->root;
|
|
ui->root->loc = UI_CODE_LOC;
|
|
}
|
|
|
|
fn void ui_end_build(void) {
|
|
assert(ui->top == ui->root);
|
|
|
|
for (ui_box_t *box = ui->hash_first, *next = NULL; box; box = next) {
|
|
next = box->hash_next;
|
|
b32 touched_box_during_update = ui->event->id <= box->last_touched_event_id;
|
|
if (!touched_box_during_update) {
|
|
DLLQ_REMOVE_EX(ui->hash_first, ui->hash_last, box, hash_next, hash_prev);
|
|
zero_struct(box);
|
|
SLLS_PUSH(ui->free_first, box);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn void ui_begin_frame(app_frame_t *frame) {
|
|
ui->frame = frame;
|
|
}
|
|
|
|
fn void ui_push_top(ui_box_t *box) {
|
|
ui->top = box;
|
|
}
|
|
|
|
fn ui_box_t *ui_pop_parent(void) {
|
|
ui_box_t *top = ui->top;
|
|
ui->top = ui->top->parent;
|
|
return top;
|
|
}
|
|
|
|
fn ui_box_t *ui_spacer(ui_code_loc_t loc, char *spacing_char) {
|
|
ui_box_t *box = ui_build_box_from_id(loc, ui_id_null);
|
|
v2f32_t spacing = rn_measure_string(&rn_state.main_font, s8_from_char(spacing_char));
|
|
box->semantic_size[0] = (ui_size_t){ui_size_kind_pixels, spacing.x, 0.5};
|
|
box->semantic_size[1] = (ui_size_t){ui_size_kind_pixels, 10, 0.5};
|
|
return box;
|
|
}
|
|
|
|
fn ui_box_t *ui_push_list_container(ui_code_loc_t loc) {
|
|
ui_box_t *box = ui_build_box_from_id(loc, ui_id_null);
|
|
ui_push_top(box);
|
|
box->semantic_size[0] = (ui_size_t){ui_size_kind_children_sum, 0, 0.5};
|
|
box->semantic_size[1] = (ui_size_t){ui_size_kind_children_sum, 0, 0.5};
|
|
box->grow_axis[1] = true;
|
|
return box;
|
|
}
|
|
|
|
fn void ui_push_indent(void) { ui->indent_stack += 1; }
|
|
fn void ui_pop_indent(void) { ui->indent_stack -= 1; }
|
|
fn void ui_set_indented_string(ui_box_t *box, s8_t string) { box->string = s8_printf(tcx.temp, "%.*s%S", ui->indent_stack, " ", string); }
|
|
|
|
fn ui_signal_t ui_push_exp(ui_code_loc_t loc, char *str, ...) {
|
|
S8_FMT(tcx.temp, str, string);
|
|
ui_box_t *box = ui_build_box_from_string(loc, string);
|
|
box->semantic_size[0] = (ui_size_t){ui_size_kind_text_content, 0, 0.5};
|
|
box->semantic_size[1] = (ui_size_t){ui_size_kind_text_content, 0, 0.5};
|
|
|
|
ui_signal_t signal = ui_signal_from_box(box);
|
|
if (signal.clicked) {
|
|
box->expanded = !box->expanded;
|
|
}
|
|
signal.clicked = box->expanded;
|
|
|
|
if (signal.clicked) {
|
|
box->string = s8_printf(tcx.temp, "* %S", box->string); // ▼
|
|
} else {
|
|
box->string = s8_printf(tcx.temp, "> %S", box->string); // ►
|
|
}
|
|
ui_set_indented_string(box, box->string);
|
|
|
|
|
|
if (signal.clicked) {
|
|
STACK_PUSH(ui->id_stack, box->id);
|
|
ui_push_indent();
|
|
}
|
|
return signal;
|
|
}
|
|
|
|
fn void ui_pop_exp(void) {
|
|
ui_pop_indent();
|
|
STACK_POP(ui->id_stack);
|
|
}
|
|
|
|
fn ui_box_t *ui_label(ui_code_loc_t loc, char *fmt, ...) {
|
|
S8_FMT(tcx.temp, fmt, string);
|
|
ui_box_t *box = ui_build_box_from_id(loc, ui_id_null);
|
|
ui_set_indented_string(box, string);
|
|
box->semantic_size[0] = (ui_size_t){ui_size_kind_text_content, 0, 0.5};
|
|
box->semantic_size[1] = (ui_size_t){ui_size_kind_text_content, 0, 0.5};
|
|
return box;
|
|
}
|
|
|
|
typedef struct ui_preorder_iter_t ui_preorder_iter_t;
|
|
struct ui_preorder_iter_t { ui_box_t *box; };
|
|
|
|
fn ui_preorder_iter_t ui_iterate_preorder(ui_box_t *box) {
|
|
ui_preorder_iter_t iter = {box};
|
|
return iter;
|
|
}
|
|
|
|
fn b32 ui_preorder_iter_is_valid(ui_preorder_iter_t iter) {
|
|
b32 result = iter.box != NULL;
|
|
return result;
|
|
}
|
|
|
|
fn void ui_iter_advance_preorder(ui_preorder_iter_t *iter) {
|
|
if (iter->box->first) {
|
|
iter->box = iter->box->first;
|
|
return;
|
|
}
|
|
while (iter->box) {
|
|
if (iter->box->next) {
|
|
iter->box = iter->box->next;
|
|
break;
|
|
} else {
|
|
iter->box = iter->box->parent;
|
|
}
|
|
}
|
|
}
|
|
|
|
typedef struct ui_postorder_iter_t ui_postorder_iter_t;
|
|
struct ui_postorder_iter_t { ui_box_t *box; };
|
|
|
|
fn ui_postorder_iter_t ui_iterate_postorder(ui_box_t *box) {
|
|
while (box->first) {
|
|
box = box->first;
|
|
}
|
|
ui_postorder_iter_t iter = {box};
|
|
return iter;
|
|
}
|
|
|
|
fn b32 ui_postorder_iter_is_valid(ui_postorder_iter_t iter) {
|
|
b32 result = iter.box != NULL;
|
|
return result;
|
|
}
|
|
|
|
fn void ui_iter_advance_postorder(ui_postorder_iter_t *iter) {
|
|
while (iter->box) {
|
|
if (iter->box->next) {
|
|
iter->box = iter->box->next;
|
|
while (iter->box->first) {
|
|
iter->box = iter->box->first;
|
|
}
|
|
break;
|
|
} else {
|
|
iter->box = iter->box->parent;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn void ui_test_stringify_preorder(sb8_t *sb, ui_box_t *box) {
|
|
sb8_printf(sb, "%S\n", box->string);
|
|
for (ui_box_t *it = box->first; it; it = it->next) {
|
|
ui_test_stringify_preorder(sb, it);
|
|
}
|
|
}
|
|
|
|
fn void ui_test_stringify_postorder(sb8_t *sb, ui_box_t *box) {
|
|
for (ui_box_t *it = box->first; it; it = it->next) {
|
|
ui_test_stringify_postorder(sb, it);
|
|
}
|
|
sb8_printf(sb, "%S\n", box->string);
|
|
}
|
|
|
|
fn void ui_end_frame(void) {
|
|
for (app_event_t *ev = ui->frame->first_event; ev; ev = ev->next) {
|
|
if (ev_left_up(ev)) {
|
|
ui->active = ui_id_null;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn void ui_draw(void) {
|
|
rn_font_t *font = &rn_state.main_font;
|
|
|
|
{
|
|
ma_temp_t scratch = ma_begin_scratch();
|
|
|
|
sb8_t *sb = sb8_serial_begin(scratch.arena);
|
|
ui_test_stringify_preorder(sb, ui->root);
|
|
s8_t recursive_string = sb8_serial_end(scratch.arena, sb);
|
|
|
|
sb = sb8_serial_begin(scratch.arena);
|
|
for (ui_preorder_iter_t it = ui_iterate_preorder(ui->root); ui_preorder_iter_is_valid(it); ui_iter_advance_preorder(&it)) {
|
|
sb8_printf(sb, "%S\n", it.box->string);
|
|
}
|
|
s8_t iter_string = sb8_serial_end(scratch.arena, sb);
|
|
|
|
assert(s8_equal(recursive_string, iter_string));
|
|
|
|
ma_end_scratch(scratch);
|
|
}
|
|
|
|
// compute standalone sizes: (pixels, text_content)
|
|
for (ui_preorder_iter_t it = ui_iterate_preorder(ui->root); ui_preorder_iter_is_valid(it); ui_iter_advance_preorder(&it)) {
|
|
ui_box_t *box = it.box;
|
|
for (i32 i = 0; i < ui_axis2_count; i += 1) {
|
|
ui_size_t sem = box->semantic_size[i];
|
|
if (sem.kind == ui_size_kind_pixels) {
|
|
box->computed_size[i] = sem.value;
|
|
} else if (sem.kind == ui_size_kind_text_content) {
|
|
box->computed_size[i] = rn_measure_string(font, box->string).e[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
// compute: (percent_of_parent)
|
|
for (ui_preorder_iter_t it = ui_iterate_preorder(ui->root); ui_preorder_iter_is_valid(it); ui_iter_advance_preorder(&it)) {
|
|
ui_box_t *box = it.box;
|
|
ui_box_t *parent = box->parent;
|
|
for (i32 i = 0; i < ui_axis2_count; i += 1) {
|
|
ui_size_t sem = box->semantic_size[i];
|
|
if (sem.kind == ui_size_kind_percent_of_parent) {
|
|
assert(sem.value >= 0 && sem.value <= 1.0);
|
|
assert(parent->semantic_size[i].kind == ui_size_kind_pixels || parent->semantic_size[i].kind == ui_size_kind_text_content);
|
|
box->computed_size[i] = sem.value * parent->computed_size[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
// compute: (children_sum)
|
|
for (ui_postorder_iter_t it = ui_iterate_postorder(ui->root); ui_postorder_iter_is_valid(it); ui_iter_advance_postorder(&it)) {
|
|
ui_box_t *box = it.box;
|
|
for (i32 i = 0; i < ui_axis2_count; i += 1) {
|
|
ui_size_t sem = box->semantic_size[i];
|
|
if (sem.kind != ui_size_kind_children_sum) continue;
|
|
|
|
b32 grow_axis = box->grow_axis[i];
|
|
for (ui_box_t *child = box->first; child; child = child->next) {
|
|
assert(child->computed_size[i] != 0.f);
|
|
if (grow_axis) {
|
|
box->computed_size[i] += child->computed_size[i];
|
|
} else {
|
|
box->computed_size[i] = MAX(box->computed_size[i], child->computed_size[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// solve violations
|
|
|
|
// compute relative positions
|
|
for (ui_preorder_iter_t it = ui_iterate_preorder(ui->root); ui_preorder_iter_is_valid(it); ui_iter_advance_preorder(&it)) {
|
|
ui_box_t *box = it.box;
|
|
ui_box_t *parent = box->parent;
|
|
if (ui->root == box) continue; // @todo: how to remove this?
|
|
|
|
for (i32 i = 0; i < ui_axis2_count; i += 1) {
|
|
f32 *pos = &box->computed_rel_pos[i];
|
|
f32 size = box->computed_size[i];
|
|
|
|
f32 parent_pos = parent->computed_rel_pos[i];
|
|
f32 *iter_pos = &parent->iter_pos[i];
|
|
|
|
*pos = parent_pos + *iter_pos;
|
|
if (parent->grow_axis[i]) *iter_pos += size;
|
|
}
|
|
|
|
v2f32_t pos = v2f32(box->computed_rel_pos[0], box->computed_rel_pos[1]);
|
|
v2f32_t size = v2f32(box->computed_size[0], box->computed_size[1]);
|
|
box->rect = r2f32_mindim(pos, size);
|
|
}
|
|
|
|
// actually draw
|
|
for (ui_preorder_iter_t it = ui_iterate_preorder(ui->root); ui_preorder_iter_is_valid(it); ui_iter_advance_preorder(&it)) {
|
|
ui_box_t *box = it.box;
|
|
|
|
v4f32_t rect_color = primary_color_global;
|
|
if (ui_hot(box)) {
|
|
rect_color = secondary_color_global;
|
|
}
|
|
if (ui_active(box)) {
|
|
rect_color = accent1_color_global;
|
|
}
|
|
|
|
rn_draw_rect(box->rect, rect_color);
|
|
rn_draw_string(font, box->rect.min, black_color_global, box->string);
|
|
}
|
|
}
|