diff options
Diffstat (limited to 'editor.c')
| -rw-r--r-- | editor.c | 1744 |
1 files changed, 1744 insertions, 0 deletions
diff --git a/editor.c b/editor.c new file mode 100644 index 0000000..6550ecf --- /dev/null +++ b/editor.c @@ -0,0 +1,1744 @@ +#include "editor.h" +#include "save.h" +#include "cam.h" +#include "physics.h" +#include "ent.h" +#include "app.h" +#include "res.h" +#include "raygui.h" + +static bool started = false; +static Vec2 start_point = {0}; +static Vec2 end_point = {0}; +static Rect sel_rec = {0}; +static f32 sel_dist = 0; +static EditorAction tr_action = {0}; + +EditorInfo ed = { + .panel = { + [ED_PNL_LEFT] = { + .type = ED_PNL_TYPE_SCENE, + // .enabled = true, + }, + [ED_PNL_RIGHT] = { + .type = ED_PNL_TYPE_PROPERTIES, + }, + [ED_PNL_CENTER] = { + .type = ED_PNL_TYPE_SPACE, + }, + }, +}; + +/* forward decl */ +static bool selection_root(Entity *ent); +static void action_apply(EditorAction*, bool); +static void action_free(EditorAction*); + +static void +history_push(EditorAction action) { + if (ed.history_save_csr > ed.history_csr) { + ed.history_save_csr = UINT32_MAX; + } + + /* discard redo branch */ + while (ed.history_cnt > ed.history_csr) { + action_free(&ed.history[--ed.history_cnt]); + } + + if (ed.history_cnt == ed.history_cap) { + u32 cap = ed.history_cap ? ed.history_cap * 2 : 64; + void *history = realloc(ed.history, cap * sizeof(action)); + if (!history) { + perror("editor history alloc failed."); + exit(1); + } + ed.history = history; + ed.history_cap = cap; + } + + ed.history[ed.history_cnt++] = action; + ed.history_csr = ed.history_cnt; +} + +static void +history_undo(void) { + if (ed.history_csr > 0) { + action_apply(&ed.history[ed.history_csr - 1], true); + ed.history_csr -= 1; + } +} + +static void +history_redo(void) { + if (ed.history_csr < ed.history_cnt) { + action_apply(&ed.history[ed.history_csr], false); + ed.history_csr += 1; + } +} + +static void +history_clear(void) { + for (u32 i = 0; i < ed.history_cnt; ++i) { + action_free(&ed.history[i]); + } + + ed.history_cnt = 0; + ed.history_csr = 0; + ed.history_save_csr = UINT32_MAX; +} + +static void +action_entity_extract(EditorAction *action) { + for (u32 i = 0; i < action->item_cnt; ++i) { + Entity *held = &action->item[i].before.stored.ent; + assert(!held->pid); + + u64 id = entity_id_from_pid(action->item[i].pid); + *held = entity_extract_now(id); + } +} + +static void +action_entity_restore(EditorAction *action) { + /* Restore all entities before resolving their relationships. */ + for (u32 i = 0; i < action->item_cnt; ++i) { + Entity *held = &action->item[i].before.stored.ent; + assert(held->pid == action->item[i].pid); + + u64 id = entity_restore(action->item[i].pid); + assert(id); + + *entity_get(id) = *held; + *held = (Entity){0}; + } + + for (u32 i = 0; i < action->item_cnt; ++i) { + const EditorActionData *data = &action->item[i].before; + u64 id = entity_id_from_pid(action->item[i].pid); + Entity *ent = entity_get(id); + + ent->tr.parent = entity_id_from_pid(data->stored.parent); + ent->tr.prev = entity_id_from_pid(data->stored.prev); + ent->tr.next = entity_id_from_pid(data->stored.next); + + if (ent->tr.prev) { + entity_get(ent->tr.prev)->tr.next = id; + } else if (ent->tr.parent) { + entity_get(ent->tr.parent)->tr.first_child = id; + } + + if (ent->tr.next) { + entity_get(ent->tr.next)->tr.prev = id; + } + } +} + +/* collects PIDs, recursive visits children first. */ +static void +action_collect(EditorAction *action, u64 id, bool recursive) { + Entity *ent = entity_get(id); + assert(ent && ent->pid); + + if (recursive) { + for (u64 child = ent->tr.first_child; child; + child = entity_get(child)->tr.next) { + action_collect(action, child, true); + } + } + + u32 i = action->item_cnt++; + + /* First pass counts, second pass fills the allocated array. */ + if (action->item) { + action->item[i].pid = ent->pid; + } +} + +static EditorAction +action_begin(EditorActionTag tag) { + EditorAction action = { .tag = tag }; + + bool roots_only = false; + bool recursive = false; + + switch (tag) { + case ED_ACTION_TRANSFORM: + roots_only = true; + break; + + case ED_ACTION_CREATE: + action.item_cnt = 1; + action.item = calloc(1, sizeof(*action.item)); + if (!action.item) { + perror("action_begin: create entity alloc failed."); + exit(1); + } + + u64 id = entity_create(false); + Entity *ent = entity_get(id); + action.item[0].pid = ent->pid; + entities_clear_selected(); + ent->ed.selected = true; + return action; + + case ED_ACTION_DELETE: + roots_only = true; + recursive = true; + break; + + case ED_ACTION_RENAME: + break; + + default: + TraceLog(LOG_FATAL, "action_begin: unsupported tag."); + } + + /* Count, allocate, then collect PIDs. */ + for (u32 pass = 0; pass < 2; ++pass) { + for (u32 i = 0; i < entity_count(); ++i) { + Entity *ent = &entity_data()[i]; + if (!ent || !ent->pid) { + continue; + } + + if (roots_only ? + !selection_root(ent) : + !ent->ed.selected) { + continue; + } + action_collect(&action, entity_id_at(i), recursive); + } + if (pass == 0) { + if (!action.item_cnt) { + return action; + } + action.item = calloc(action.item_cnt, + sizeof(*action.item)); + if (!action.item) { + perror("editor action alloc failed."); + exit(1); + } + action.item_cnt = 0; + } + } + /* Capture action-specific data for the collected entities. */ + for (u32 i = 0; i < action.item_cnt; ++i) { + Entity *ent = entity_get( + entity_id_from_pid(action.item[i].pid)); + assert(ent); + EditorActionData *before = &action.item[i].before; + switch (tag) { + case ED_ACTION_TRANSFORM: + before->transform.pos = ent->tr.pos; + before->transform.rot = ent->tr.rot; + before->transform.scale = ent->tr.scale; + break; + case ED_ACTION_DELETE: { + Entity *parent = entity_get(ent->tr.parent); + Entity *prev = entity_get(ent->tr.prev); + Entity *next = entity_get(ent->tr.next); + assert(!parent || parent->pid); + assert(!prev || prev->pid); + assert(!next || next->pid); + before->stored.parent = parent ? parent->pid : 0; + before->stored.prev = prev ? prev->pid : 0; + before->stored.next = next ? next->pid : 0; + break; + } + case ED_ACTION_RENAME: + // Name ownership will transfer when the rename is submitted. + break; + default: + TraceLog(LOG_FATAL, + "action_begin: unhandled action tag."); + break; + } + } + + return action; +} + +static void +action_apply(EditorAction *action, bool undo) { + switch (action->tag) { + case ED_ACTION_TRANSFORM: + for (u32 i = 0; i < action->item_cnt; ++i) { + u64 id = entity_id_from_pid(action->item[i].pid); + Entity *ent = entity_get(id); + assert(ent); + + const EditorActionData *data = undo ? + &action->item[i].before : + &action->item[i].after; + + ent->tr.pos = data->transform.pos; + ent->tr.rot = data->transform.rot; + ent->tr.scale = data->transform.scale; + } + break; + + case ED_ACTION_CREATE: + if (undo) { + action_entity_extract(action); + } else { + action_entity_restore(action); + } + break; + + case ED_ACTION_DELETE: + if (undo) { + action_entity_restore(action); + } else { + action_entity_extract(action); + } + break; + + case ED_ACTION_RENAME: + for (u32 i = 0; i < action->item_cnt; ++i) { + u64 id = entity_id_from_pid(action->item[i].pid); + Entity *ent = entity_get(id); + assert(ent); + + char *name = ent->name; + ent->name = action->item[i].before.rename.name; + action->item[i].before.rename.name = name; + } + break; + + default: + TraceLog(LOG_FATAL, "action with invalid tag."); + break; + } +} + +static void +action_free(EditorAction *action) { + switch (action->tag) { + case ED_ACTION_TRANSFORM: + break; + + case ED_ACTION_CREATE: + case ED_ACTION_DELETE: + for (u32 i = 0; i < action->item_cnt; ++i) { + entity_clean(&action->item[i].before.stored.ent); + } + break; + + case ED_ACTION_RENAME: + for (u32 i = 0; i < action->item_cnt; ++i) { + free(action->item[i].before.rename.name); + } + break; + + default: + TraceLog(LOG_FATAL, "action_free: unhandled action tag."); + break; + } + free(action->item); +} + +static void +action_commit(EditorAction *action) { + bool changed = false; + + switch (action->tag) { + case ED_ACTION_TRANSFORM: + for (u32 i = 0; i < action->item_cnt; ++i) { + u64 id = entity_id_from_pid(action->item[i].pid); + Entity *ent = entity_get(id); + assert(ent); + + const EditorActionData *before = + &action->item[i].before; + EditorActionData *after = &action->item[i].after; + after->transform.pos = ent->tr.pos; + after->transform.rot = ent->tr.rot; + after->transform.scale = ent->tr.scale; + + changed |= !Vector3Equals(before->transform.pos, + after->transform.pos) + || !QuaternionEquals(before->transform.rot, + after->transform.rot) + || !Vector3Equals(before->transform.scale, + after->transform.scale); + } + + if (!changed) { + action_apply(action, true); + } + break; + + case ED_ACTION_CREATE: + case ED_ACTION_DELETE: + changed = action->item_cnt != 0; + break; + + case ED_ACTION_RENAME: + for (u32 i = 0; i < action->item_cnt; ++i) { + u64 id = entity_id_from_pid(action->item[i].pid); + Entity *ent = entity_get(id); + assert(ent); + + cstr before = action->item[i].before.rename.name; + changed |= strcmp(before ? before : "", + ent->name ? ent->name : "") != 0; + } + + if (!changed) { + action_apply(action, true); + } + break; + + default: + TraceLog(LOG_FATAL, "action_commit: unhangled action tag."); + break; + } + + if (changed) { + history_push(*action); + } else { + action_free(action); + } + + *action = (EditorAction){0}; +} + +void +editor_init(void) { + // GuiLoadStyle("style_amber.rgs"); + + Asset *fnt_asset = + asset_get("res/fnt/Aileron-Regular.otf"); + if (fnt_asset) { + GuiSetFont(fnt_asset->fnt); + GuiSetStyle(DEFAULT, TEXT_SIZE, 16); + } + + /* probably will delete this later */ + ed.history_save_csr = + save_file_read("res/save/scene.fgs") ? + ed.history_csr : UINT32_MAX; +} + +void +editor_exit(void) { + action_free(&tr_action); + tr_action = (EditorAction){0}; + history_clear(); + free(ed.history); + ed.history = NULL; + ed.history_cap = 0; +} + +void +editor_update(void) { + bool ctrl = IsKeyDown(KEY_LEFT_CONTROL); + bool shift = IsKeyDown(KEY_LEFT_SHIFT); + bool alt = IsKeyDown(KEY_LEFT_ALT); + + /* sorry about the indentation */ + switch (app.mode) { +case APP_MODE_EDIT_NONE: + if (!ed.focus_captured && IsKeyPressed(KEY_SPACE)) { + ed.panel[ED_PNL_CENTER].type = ED_PNL_TYPE_SPACE; + ed.panel[ED_PNL_CENTER].enabled = true; + } + + if (ed.panel[ED_PNL_CENTER].enabled) { + ed.focus = ED_PNL_CENTER; + ed.focus_captured = true; + break; + } + + if (!ed.focus_captured) { + ed.focus = 0; + Vec2 mpos = GetMousePosition(); + + if (ed.panel[ED_PNL_LEFT].enabled && + CheckCollisionPointRec(mpos, + ed.panel[ED_PNL_LEFT].bounds)) { + ed.focus = ED_PNL_LEFT; + } + + if (ed.panel[ED_PNL_RIGHT].enabled && + CheckCollisionPointRec(mpos, + ed.panel[ED_PNL_RIGHT].bounds)) { + ed.focus = ED_PNL_RIGHT; + } + } + + if (ed.focus != 0) { + break; + } + + if (IsMouseButtonPressed(MOUSE_BUTTON_RIGHT)) { + app.mode = APP_MODE_EDIT_CTRL; + main_cam.update = true; + HideCursor(); + DisableCursor(); + break; + } + + if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT)) { + app.mode = APP_MODE_EDIT_SELECT; + editor_select(); // capture this frame + break; + } + + if (IsKeyPressed(KEY_G)) { + if (!ctrl && ed.sel_cnt) { + app.mode = APP_MODE_EDIT_MOVE; + break; + } + } + + if (IsKeyPressed(KEY_R)) { + if (!ctrl && ed.sel_cnt) { + app.mode = APP_MODE_EDIT_ROTATE; + break; + } + + if (ctrl) { + history_clear(); + entity_system_clear(); + + ed.history_save_csr = + save_file_read("res/save/scene.fgs") ? + ed.history_csr : UINT32_MAX; + } + } + + if (IsKeyPressed(KEY_S)) { + if (ctrl) { + ed.history_save_csr = + save_file_write("res/save/scene.fgs") ? + ed.history_csr : UINT32_MAX; + } + + /* scale */ + } + + if (IsKeyPressed(KEY_X)) { + if (!ctrl && ed.sel_cnt) { + EditorAction action = action_begin(ED_ACTION_DELETE); + if (action.item_cnt) { + action_apply(&action, false); + action_commit(&action); + } + } + } + + if (IsKeyPressed(KEY_A)) { + if (ctrl) { + for (u32 i = 0; i < entity_count(); ++i) { + u64 id = entity_id_at(i); + Entity *ent = entity_get(id); + if (ent && ent->pid) { + ent->ed.selected = true; + } + } + } + } + + if (ctrl && IsKeyPressed(KEY_Z)) { + if (!shift) { + history_undo(); + } else { + history_redo(); + } + } + break; + +case APP_MODE_EDIT_SELECT: + editor_select(); + break; + +case APP_MODE_EDIT_CTRL: + cam_ctrl_editor(); + if (IsMouseButtonReleased(MOUSE_RIGHT_BUTTON)) { + app.mode = APP_MODE_EDIT_NONE; + main_cam.update = false; + ShowCursor(); + } + break; + +case APP_MODE_EDIT_MOVE: + editor_move(); + break; + +case APP_MODE_EDIT_ROTATE: + editor_rotate(); + break; + +case APP_MODE_EDIT_SPACE: + break; + +// case APP_MODE_EDIT_CMD: + // break; + +default: + TraceLog(LOG_FATAL, "editor_update: unhandled app.mode value"); + break; + } + + /* reset selection data */ + ed.sel_cnt = 0; + ed.sel_point = Vector3Zero(); + ed.sel_rot = QuaternionIdentity(); + + for (u32 i = 0; i < entity_count(); ++i) { + u64 id = entity_id_at(i); + Entity *ent = entity_get(id); + + if (!ent->ed.selected) { + continue; + } + + ed.sel_cnt++; + ed.sel_point = Vector3Add(ed.sel_point, entity_world_pos(id)); + ed.sel_rot = entity_world_rot(id); + } + + if (ed.sel_cnt > 0) { + ed.sel_point = Vector3Scale( + ed.sel_point, 1.0f / ed.sel_cnt); + } + + if (ed.sel_cnt != 1) { + ed.sel_rot = QuaternionIdentity(); + } +} + +/* tools */ +static void +sel_ray(void) { + Ray ray = GetScreenToWorldRay(end_point, main_cam.cam); + + b3QueryFilter filter = { + .categoryBits = BIT(PHYS_MASK_EDITOR_RAYCAST), + .maskBits = BIT(PHYS_MASK_EDITOR_SELECTABLE), + }; + + Vec3 dir = Vector3Scale(ray.direction, 1000.0f); + b3RayResult res = + b3World_CastRayClosest(physics.world_id, + *(b3Pos*)&ray.position, + *(b3Pos*)&dir, + filter); + + if (ed.focus == ED_PNL_NULL && + !IsKeyDown(KEY_LEFT_SHIFT)) { + entities_clear_selected(); + } + + if (res.hit) { + b3BodyId bid = b3Shape_GetBody(res.shapeId); + u64 eid = *(u64*)b3Body_GetUserData(bid); + Entity *ent = entity_get(eid); + + if (ent->pid == 0) { + return; + } + + ent->ed.selected = !ent->ed.selected; + } +} + +static void +sel_area(void) { + Vec3 fwd = Vector3Subtract(main_cam.cam.target, main_cam.cam.position); + + for (u32 i = 0; i < entity_count(); ++i) { + u64 id = entity_id_at(i); + Entity *ent = entity_get(id); + + if (ent->pid == 0) { + continue; + } + + if (!IsKeyDown(KEY_LEFT_SHIFT)) { + ent->ed.selected = false; + } + + Vec3 world_pos = entity_world_pos(id); + Vec3 offset = + Vector3Subtract(world_pos, main_cam.cam.position); + + // Only the dot product’s sign matters, so neither vector + // needs normalization. + if (Vector3DotProduct(fwd, offset) <= 0) { + continue; + } + + Vec2 pos = GetWorldToScreen(world_pos, main_cam.cam); + if (CheckCollisionPointRec(pos, sel_rec)) { + ent->ed.selected = true; + } + } +} + +static void +sel_rec_draw(void) { + DrawRectangleRec(sel_rec, (Color) { 255, 255, 255, 40 }); + DrawRectangleLines(sel_rec.x, sel_rec.y, + sel_rec.width, sel_rec.height, + (Color) { 255, 255, 255, 80 }); +} + +static bool +selection_root(Entity *ent) { + if (!ent->ed.selected) { + return false; + } + + for (u64 parent = ent->tr.parent; parent;) { + Entity *ancestor = entity_get(parent); + assert(ancestor); + + if (ancestor->ed.selected) { + return false; + } + + parent = ancestor->tr.parent; + } + + return true; +} + +static Vec3 +selected_pivot(void) { + Vec3 pivot = {0}; + int count = 0; + + for (int i = 0; i < entity_count(); ++i) { + u64 id = entity_id_at(i); + Entity *ent = entity_get(id); + + if (!ent || !ent->ed.selected) { + continue; + } + + pivot = Vector3Add(pivot, entity_world_pos(id)); + count++; + } + + if (count > 0) { + pivot = Vector3Scale(pivot, 1.0f / (f32)count); + } + + return pivot; +} + +void +editor_select(void) { + if (!started) { + start_point = GetMousePosition(); + started = true; + } + + end_point = GetMousePosition(); + sel_dist = Vector2Distance(start_point, end_point); + sel_rec = (Rect) { + fminf(start_point.x, end_point.x), + fminf(start_point.y, end_point.y), + fabs(end_point.x - start_point.x), + fabs(end_point.y - start_point.y) + }; + + if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) { + if (sel_dist < 20) { + sel_ray(); + } else { + sel_area(); + } + started = false; + sel_dist = 0; + app.mode = APP_MODE_EDIT_NONE; + } +} + +static bool +ray_plane_hit(Vec3 plane_pos, Vec3 plane_dir, Vec3 *out) { + Ray ray = GetScreenToWorldRay(GetMousePosition(), main_cam.cam); + + f32 denom = Vector3DotProduct(ray.direction, plane_dir); + if (fabsf(denom) < 0.0001f) { + return false; + } + + Vec3 offset = Vector3Subtract(plane_pos, ray.position); + f32 dist = Vector3DotProduct(offset, plane_dir) / denom; + + if (dist < 0.0f) { + return false; + } + + *out = Vector3Add(ray.position, Vector3Scale(ray.direction, dist)); + + return true; +} + +void +editor_move(void) { + static Vec3 mv_start = {0}; + + if (!tr_action.item) { + tr_action = action_begin(ED_ACTION_TRANSFORM); + started = false; + } + + bool cancel = IsKeyPressed(KEY_ESCAPE) || !tr_action.item_cnt; + if (cancel || IsKeyPressed(KEY_ENTER) || + IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) { + if (cancel) { + action_apply(&tr_action, true); + action_free(&tr_action); + tr_action = (EditorAction){0}; + } else { + action_commit(&tr_action); + } + started = false; + app.mode = APP_MODE_EDIT_NONE; + return; + } + + Vec3 pivot = selected_pivot(); + Vec3 axis = { 0, 1, 0 }; // mv plane normal + Vec3 delta = {0}; + + if (IsKeyDown(KEY_LEFT_ALT)) { + started = false; + + Vec2 a = GetWorldToScreen(pivot, main_cam.cam); + Vec2 b = GetWorldToScreen( + Vector3Add(pivot, axis), main_cam.cam); + + Vec2 scr_axis = Vector2Subtract(b, a); + f32 lensqr = Vector2LengthSqr(scr_axis); + + if (lensqr <= 0.001f) { + return; + } + + f32 amount = + Vector2DotProduct(GetMouseDelta(), scr_axis) / lensqr; + + delta = Vector3Scale(axis, amount); + } else { + Vec3 hit; + if (!ray_plane_hit(pivot, axis, &hit)) { + return; + } + + if (!started) { + mv_start = hit; + started = true; + return; + } + + delta = Vector3Subtract(hit, mv_start); + mv_start = hit; + } + + for (u32 i = 0; i < tr_action.item_cnt; ++i) { + u64 id = entity_id_from_pid(tr_action.item[i].pid); + Entity *ent = entity_get(id); + assert(ent); + + Vec3 pos = Vector3Add(entity_world_pos(id), delta); + entity_set_world_pos(ent, pos); + } +} + +void +editor_rotate(void) { + if (!tr_action.item) { + tr_action = action_begin(ED_ACTION_TRANSFORM); + started = false; + } + + bool cancel = IsKeyPressed(KEY_ESCAPE) || !tr_action.item_cnt; + if (cancel || IsKeyPressed(KEY_ENTER) || + IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) { + if (cancel) { + action_apply(&tr_action, true); + action_free(&tr_action); + tr_action = (EditorAction){0}; + } else { + action_commit(&tr_action); + } + + started = false; + app.mode = APP_MODE_EDIT_NONE; + return; + } + + Vec3 pivot = selected_pivot(); + Vec3 mouse_hit = {0}; + if (!ray_plane_hit(pivot, (Vec3) {0,1,0}, &mouse_hit)) { + return; + } + + Vec3 dir = Vector3Subtract(mouse_hit, pivot); + if (Vector3LengthSqr(dir) < 0.0001f) { + return; + } + + f32 yaw = atan2f(dir.x, dir.z); + Quaternion rot = QuaternionFromAxisAngle((Vec3){0,1,0}, yaw); + + for (u32 i = 0; i < tr_action.item_cnt; ++i) { + u64 id = entity_id_from_pid(tr_action.item[i].pid); + Entity *ent = entity_get(id); + assert(ent); + entity_set_world_rot(ent, rot); + } +} + +/* draw */ +static void +panel_vec3(Rect bounds, Vec3 *val, cstr label) { + +} + +static void +statusline(void) { + char mode_str[16] = {0}; + char ctx_str[256] = {0}; + // Color bg = { 255, 255, 255, 150 }; + Color bg = GetColor(GuiGetStyle(DEFAULT, BACKGROUND_COLOR)); + + switch (app.mode) { + case APP_MODE_EDIT_NONE: + snprintf(mode_str, 16, "EDITOR"); + if (ed.sel_cnt > 0) { + snprintf(ctx_str, sizeof(ctx_str), + "%i Selected | " + "G: move, R: rotate, D: duplicate, " + "X: delete", + ed.sel_cnt); + } else { + snprintf(ctx_str, sizeof(ctx_str), "Nothing selected"); + } + break; + + case APP_MODE_EDIT_SELECT: + snprintf(mode_str, 16, "SELECT"); + break; + + case APP_MODE_EDIT_CTRL: + snprintf(mode_str, 16, "VIEW"); + snprintf(ctx_str, sizeof(ctx_str), "controls: " + "shift: boost speed, scroll: adjust speed"); + break; + + case APP_MODE_EDIT_MOVE: + snprintf(mode_str, 16, "MOVE"); + + cstr axis_str = IsKeyDown(KEY_LEFT_ALT) ? + "up axis" : + "xz plane"; + + snprintf(ctx_str, sizeof(ctx_str), + "%i Selected | " + "current axis: %s | " + "controls: shift: grid snap, " + "alt: up axis, X/Y/Z: toggle axis", + ed.sel_cnt, axis_str); + break; + + case APP_MODE_EDIT_ROTATE: + snprintf(mode_str, 16, "ROTATE"); + snprintf(ctx_str, sizeof(ctx_str), "%i Selected | " + "axis: global up, pivot: each entity | " + "controls: ctrl: change pivot, alt: local/global, " + "X/Y/Z: toggle axis", + ed.sel_cnt); + break; + + default: + return; + break; + }; + + /* statusline bg */ + Rect rec = { + // 0, 0, /* top bar */ + 0, GetScreenHeight() - 25, + GetScreenWidth(), 25 + // editor_label_w(mode_str) , 25 + }; + DrawRectangleRec(rec, bg); + + /* mode str */ + f32 mode_str_w = editor_label_w(mode_str); + rec.width = 70; + DrawRectangleRec(rec, (Color){0,0,0,25}); + GuiSetStyle(DEFAULT, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + GuiLabel(rec, mode_str); + GuiSetStyle(DEFAULT, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT); + + /* context str */ + f32 ctx_str_w = editor_label_w(ctx_str); + rec.x = 80; + rec.width = ctx_str_w; + GuiLabel(rec, ctx_str); + rec.x += ctx_str_w; + + /* scene file status str */ + char scene_str[96]; + if (ed.history_save_csr == UINT32_MAX) { + snprintf(scene_str, sizeof(scene_str), + "| scene.fgs * - unsaved changes"); + } else { + u32 changes = ed.history_csr > ed.history_save_csr + ? ed.history_csr - ed.history_save_csr + : ed.history_save_csr - ed.history_csr; + + snprintf(scene_str, sizeof(scene_str), + "| scene.fgs%s - %u change%s", + changes ? " *" : "", + changes, changes == 1 ? "" : "s"); + } + + f32 scene_str_w = editor_label_w(scene_str); + rec.x = GetScreenWidth() - scene_str_w - 5; + rec.width = scene_str_w; + + DrawRectangleRec(rec, bg); + GuiSetStyle(DEFAULT, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + GuiLabel(rec, scene_str); + GuiSetStyle(DEFAULT, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT); +} + +/* Scene panel */ +static void +scene_entity(u64 id, Rect view, f32 *y, int depth, bool input) { + Entity *ent = entity_get(id); + if (!ent) { + return; + } + + /* Transient entities are hidden, but their children are visited. */ + if (ent->pid) { + Rect row = { view.x, *y, view.width, 26 }; + bool hovered = input && + CheckCollisionPointRec(GetMousePosition(), view) && + CheckCollisionPointRec(GetMousePosition(), row); + + if (hovered && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) { + if (IsKeyDown(KEY_LEFT_SHIFT)) { + ent->ed.selected = !ent->ed.selected; + } else { + entities_clear_selected(); + ent->ed.selected = true; + } + } + + if (row.y + row.height > view.y && + row.y < view.y + view.height) { + if (ent->ed.selected || hovered) { + int colour = ent->ed.selected + ? BASE_COLOR_PRESSED + : BASE_COLOR_FOCUSED; + + DrawRectangleRec(row, + GetColor(GuiGetStyle(DEFAULT, + colour))); + } + + Rect label = { + row.x + 8 + depth * 18, + row.y, + fmaxf(0, row.width - 8 - depth * 18), + row.height + }; + + if (label.width > 0) { + GuiLabel(label, + ent->name && ent->name[0] ? + ent->name : "Entity"); + } + } + + *y += row.height; + depth++; + } + + for (u64 child = ent->tr.first_child; child;) { + Entity *next = entity_get(child); + if (!next) { + break; + } + + u64 sibling = next->tr.next; + scene_entity(child, view, y, depth, input); + child = sibling; + } +} + +static void +panel_scene(EditorPanelContainer container, bool input) { + Rect view = {0}; + Rect bounds = ed.panel[container].bounds; + Vec2 *scroll = &ed.panel[container].scroll; + + input = input && app.mode == APP_MODE_EDIT_NONE; + + int state = GuiGetState(); + if (!input) { + GuiSetState(STATE_DISABLED); + } + + if (input && state != STATE_DISABLED && + IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) { + ed.focus_captured = true; + } + + GuiPanel(bounds, "Entities"); + + f32 btn_w = editor_label_w("Create Entity") + 16; + GuiSetStyle(DEFAULT, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + if (GuiButton( + (Rect){ bounds.x + 8, bounds.y + 30, btn_w, 26 }, + "Create Entity")) { + EditorAction action = action_begin(ED_ACTION_CREATE); + action_commit(&action); + } + GuiSetStyle(DEFAULT, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT); + + bounds.x += 8; + bounds.y += 64; + bounds.width -= 16; + bounds.height -= 72; + + u32 count = 0; + for (u32 i = 0; i < entity_count(); ++i) { + if (entity_get(entity_id_at(i))->pid) { + count++; + } + } + + f32 width = bounds.width + - 2 * GuiGetStyle(DEFAULT, BORDER_WIDTH) + - GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH); + + GuiScrollPanel(bounds, NULL, + (Rect){ 0, 0, width, count * 26.0f }, + scroll, &view); + + BeginScissorMode( + (int)view.x, (int)view.y, + (int)view.width, (int)view.height); + + f32 y = view.y + scroll->y; + for (u32 i = 0; i < entity_count(); ++i) { + u64 id = entity_id_at(i); + Entity *ent = entity_get(id); + + if (!ent->tr.parent) { + scene_entity(id, view, &y, 0, + input && state != STATE_DISABLED); + } + } + + EndScissorMode(); + GuiSetState(state); + + if (input && container != ED_PNL_CENTER && + !IsMouseButtonDown(MOUSE_BUTTON_LEFT)) { + ed.focus_captured = false; + } +} + +// static void +// panel_properties(EditorPanelContainer container, bool input) { +// Rect view = {0}; +// Rect bounds = ed.panel[container].bounds; +// Vec2 *scroll = &ed.panel[container].scroll; + +// int state = GuiGetState(); + +// input = input && app.mode == +// APP_MODE_EDIT_NONE && state != STATE_DISABLED; + +// if (!input) { +// GuiSetState(STATE_DISABLED); +// } + +// if (input && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) { +// ed.focus_captured = true; +// } + +// GuiPanel(bounds, "Entity Properties"); + +// /* needed for input field focus */ +// enum { +// TEXT_FIELD_NONE, + +// TEXT_FIELD_NAME, + +// /* transform */ +// TEXT_FIELD_TR_POS_X, +// TEXT_FIELD_TR_POS_Y, +// TEXT_FIELD_TR_POS_Z, +// TEXT_FIELD_TR_ROT_X, +// TEXT_FIELD_TR_ROT_Y, +// TEXT_FIELD_TR_ROT_Z, +// TEXT_FIELD_TR_SCALE_X, +// TEXT_FIELD_TR_SCALE_Y, +// TEXT_FIELD_TR_SCALE_Z, +// }; + +// static int text_focus; +// static char text_input[64]; +// char display_text[sizeof(text_input)]; + +// Rect prec = bounds; +// f32 pad = 8; +// cstr substr = ""; + +// if (!ed.sel_cnt) { +// GuiSetStyle(DEFAULT, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); +// cstr str = "no entities selected"; +// GuiLabel(bounds, str); +// GuiSetStyle(DEFAULT, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT); +// text_focus = 0; +// goto reset; +// } + +// /* ed.sel_cnt can't be 0 because we've already checked and returned */ +// if (ed.sel_cnt > 1) { +// substr = "<multiple entities selected>"; +// } else { +// for (u32 i = 0; i < entity_count(); ++i) { +// Entity *ent = entity_get(entity_id_at(i)); +// if (ent && ent->pid && ent->ed.selected) { +// substr = ent->name ? ent->name : ""; +// break; +// } +// } +// } + +// if (text_focus != TEXT_FIELD_NAME) { +// snprintf(display_text, sizeof(display_text), "%s", substr); +// } + +// cstr name_lbl = "Name"; +// u32 name_lbl_w = editor_label_w(name_lbl); +// prec.x += pad; +// prec.y += 30; +// prec.width = name_lbl_w; +// prec.height = 20; +// GuiLabel(prec, name_lbl); + +// prec.x += name_lbl_w + pad; +// prec.width = bounds.x + bounds.width - prec.x - pad; + +// bool name_edit = text_focus == TEXT_FIELD_NAME; +// bool name_toggle = +// GuiTextBox( +// prec, +// name_edit ? text_input : display_text, +// sizeof(text_input), +// input && name_edit +// ); + +// if (input) { +// if (IsKeyPressed(KEY_ESCAPE)) { +// if (name_edit) { +// text_focus = 0; +// } +// } else if (name_toggle) { +// if (name_edit) { +// if (IsKeyPressed(KEY_ENTER)) { +// editor_rename_selected(text_input); +// } +// text_focus = 0; +// } else { +// snprintf(text_input, +// sizeof(text_input), +// "%s", +// ed.sel_cnt > 1 ? +// "" : display_text); +// text_focus = TEXT_FIELD_NAME; +// } +// } +// } + +// /* +// NOTE (tech kaczynski - 21/9/6): +// I had a choice here to either create a tagged union of components and +// iterate over them, or to write a giant function like this. I chose the +// latter because the former would require a big refactor that I don't +// really care for at this stage. The former still requires a loop and a +// switch or branches for each type, which requires extra indentation or +// abstraction into special helper functions etc. For now, the code +// duplication and verbosity I can live with and might not be much worse +// than the alternative anyway, plus I get to avoid refactoring every +// system that touches entity component data. +// */ + +// /* transform comp */ +// { +// prec.x = bounds.x + pad; +// prec.y += 30; +// prec.width = bounds.width - pad * 2; +// prec.height = 90 + pad * 2; +// GuiGroupBox(prec, "Transform"); + +// /* pos */ +// prec.height = 20; +// prec.y += 15; +// prec.x += pad; +// prec.width -= pad; +// GuiLabel(prec, "Pos"); +// // panel_vec3(prec, ent->pos, cstr label) + +// /* rot */ +// static Vec3 rot; // euler angle representation of entity rot +// prec.y += 30; +// GuiLabel(prec, "Rot"); +// { + +// } + +// /* scale */ +// prec.y += 30; +// GuiLabel(prec, "Scale"); + +// // GuiTextBox(prec, char *text, int textSize, false); +// } + +// /* reset */ +// reset: +// GuiSetState(state); +// if (input && container != ED_PNL_CENTER) { +// ed.focus_captured = text_focus; +// } +// } + +static void +panel_properties(EditorPanelContainer container, bool input) { + Rect view = {0}; + Rect bounds = ed.panel[container].bounds; + Vec2 *scroll = &ed.panel[container].scroll; + + int state = GuiGetState(); + + input = input && app.mode == + APP_MODE_EDIT_NONE && state != STATE_DISABLED; + + if (!input) { + GuiSetState(STATE_DISABLED); + } + + if (input && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) { + ed.focus_captured = true; + } + + GuiPanel(bounds, "Entity Properties"); + + /* needed for input field focus */ + enum { + TEXT_FIELD_NONE, + + TEXT_FIELD_NAME, + + /* transform */ + TEXT_FIELD_TR_POS_X, + TEXT_FIELD_TR_POS_Y, + TEXT_FIELD_TR_POS_Z, + TEXT_FIELD_TR_ROT_X, + TEXT_FIELD_TR_ROT_Y, + TEXT_FIELD_TR_ROT_Z, + TEXT_FIELD_TR_SCALE_X, + TEXT_FIELD_TR_SCALE_Y, + TEXT_FIELD_TR_SCALE_Z, + }; + + static int text_focus; + static char text_input[64]; + char display_text[sizeof(text_input)]; + + Rect prec = bounds; + f32 pad = 8; + cstr substr = ""; + + if (!ed.sel_cnt) { + GuiSetStyle(DEFAULT, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + cstr str = "no entities selected"; + GuiLabel(bounds, str); + GuiSetStyle(DEFAULT, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT); + text_focus = 0; + goto reset; + } + + /* ed.sel_cnt can't be 0 because we've already checked and returned */ + Entity *ent = NULL; // only set if sel_cnt == 1 + if (ed.sel_cnt > 1) { + substr = "<multiple entities selected>"; + } else { + for (u32 i = 0; i < entity_count(); ++i) { + ent = entity_get(entity_id_at(i)); + if (ent && ent->pid && ent->ed.selected) { + substr = ent->name ? ent->name : ""; + break; + } + } + } + + if (text_focus != TEXT_FIELD_NAME) { + snprintf(display_text, sizeof(display_text), "%s", substr); + } + + cstr name_lbl = "Name"; + u32 name_lbl_w = editor_label_w(name_lbl); + prec.x += pad; + prec.y += 30; + prec.width = name_lbl_w; + prec.height = 20; + GuiLabel(prec, name_lbl); + + prec.x += name_lbl_w + pad; + prec.width = bounds.x + bounds.width - prec.x - pad; + + bool name_edit = text_focus == TEXT_FIELD_NAME; + bool name_toggle = + GuiTextBox( + prec, + name_edit ? text_input : display_text, + sizeof(text_input), + input && name_edit + ); + + if (input) { + if (IsKeyPressed(KEY_ESCAPE)) { + if (name_edit) { + text_focus = 0; + } + } else if (name_toggle) { + if (name_edit) { + if (IsKeyPressed(KEY_ENTER)) { + editor_rename_selected(text_input); + } + text_focus = 0; + } else { + snprintf(text_input, + sizeof(text_input), + "%s", + ed.sel_cnt > 1 ? + "" : display_text); + text_focus = TEXT_FIELD_NAME; + } + } + } + + /* + NOTE (tech kaczynski - 21/9/6): + I had a choice here to either create a tagged union of components and + iterate over them, or to write a giant function like this. I chose the + latter because the former would require a big refactor that I don't + really care for at this stage. The former still requires a loop and a + switch or branches for each type, which requires extra indentation or + abstraction into special helper functions etc. For now, the code + duplication and verbosity I can live with and might not be much worse + than the alternative anyway, plus I get to avoid refactoring every + system that touches entity component data. + */ + + /* transform comp */ + { + prec.x = bounds.x + pad; + prec.y += 30; + prec.width = bounds.width - pad * 2; + prec.height = 90 + pad * 2; + GuiGroupBox(prec, "Transform"); + + static Vec3 pos, rot, scale; + // pos = panel_vec3(prec, pos, "pos"); + // rot = panel_vec3(prec, rot, "rot"); + // scale = panel_vec3(prec, scale, "scale"); + + // /* pos */ + // prec.height = 20; + // prec.y += 15; + // prec.x += pad; + // prec.width -= pad; + // GuiLabel(prec, "Pos"); + // // panel_vec3(prec, ent->pos, cstr label) + + // /* rot */ + // static Vec3 rot; // euler angle representation of entity rot + // prec.y += 30; + // GuiLabel(prec, "Rot"); + // if (ent) { + // rot = QuaternionToEuler(ent->tr.rot); + // } + // for (int i = 0; i < 3; ++i) { + + // } + + // /* scale */ + // prec.y += 30; + // GuiLabel(prec, "Scale"); + + // GuiTextBox(prec, char *text, int textSize, false); + } + + /* reset */ + reset: + GuiSetState(state); + if (input && container != ED_PNL_CENTER) { + ed.focus_captured = text_focus; + } +} + +static void +panel_space(EditorPanelContainer container) { + static cstr strs[][2] = { + { "Q", "Toggle left panel" }, + { "E", "Toggle right panel" }, + { "/", "Command Menu" }, + }; + static const int str_cnt = sizeof(strs) / sizeof(strs[0]); + + Rect bounds = { + .x = (f32)GetScreenWidth() / 2 - 125, + .y = (f32)GetScreenHeight() / 2 - 65, + .width = 250, + .height = 130, + }; + + Color bg = GetColor(GuiGetStyle(DEFAULT, BACKGROUND_COLOR)); + // GuiPanel(bounds, "Space Menu"); + DrawRectangleRec(bounds, bg); + GuiGroupBox((Rect) { + .x = bounds.x + 5, + .y = bounds.y + 10, + .width = bounds.width - 10, + .height = bounds.height - 15, + }, "Space Menu"); + + Rect lrec = bounds; + lrec.height = 20; + lrec.x += 16; + + for (int i = 0; i < str_cnt; ++i) { + lrec.y += 30; + GuiLabel(lrec, strs[i][0]); + + lrec.x += 50; + GuiLabel(lrec, strs[i][1]); + lrec.x -= 50; + } +} + +static void +panel_draw(EditorPanelContainer container) { + if (!ed.panel[container].enabled) { + return; + } + + bool input = app.mode == APP_MODE_EDIT_NONE && + ed.focus == container && + (!ed.panel[ED_PNL_CENTER].enabled || + container == ED_PNL_CENTER); + + Rect bounds = ed.panel[container].bounds; + int state = GuiGetState(); + + if (!input) { + GuiSetState(STATE_DISABLED); + } + + switch (ed.panel[container].type) { + case ED_PNL_TYPE_SCENE: + panel_scene(container, input); + break; + + case ED_PNL_TYPE_PROPERTIES: + panel_properties(container, input); + break; + + case ED_PNL_TYPE_SPACE: + bool exit = false; + + if (IsKeyPressed(KEY_ESCAPE)) { + exit = true; + } + + if (IsKeyPressed(KEY_Q)) { + ed.panel[ED_PNL_LEFT].enabled = + !ed.panel[ED_PNL_LEFT].enabled; + exit = true; + } + + if (IsKeyPressed(KEY_E)) { + ed.panel[ED_PNL_RIGHT].enabled = + !ed.panel[ED_PNL_RIGHT].enabled; + exit = true; + } + + if (exit) { + ed.panel[container].enabled = false; + ed.focus = ED_PNL_NULL; + ed.focus_captured = false; + app.mode = APP_MODE_EDIT_NONE; + } + panel_space(container); + break; + + case ED_PNL_TYPE_CMD: + GuiPanel(bounds, "Command Menu"); + break; + } + + GuiSetState(state); +} + +void +editor_draw_ui(void) { + statusline(); + + /* L/R panel info */ + f32 screen_w = GetScreenWidth(); + f32 screen_h = GetScreenHeight(); + f32 left_w = Clamp(screen_w * 0.16f, 210.0f, 280.0f); + f32 right_w = Clamp(screen_w * 0.22f, 260.0f, 360.0f); + f32 status_h = 25.0f; + f32 margin = 8.0f; + + ed.panel[ED_PNL_LEFT].bounds = (Rect) { + margin, + margin, + left_w, + screen_h - status_h - margin * 2.0f + }; + + ed.panel[ED_PNL_RIGHT].bounds = (Rect) { + screen_w - right_w - margin, + margin, + right_w, + screen_h - status_h - margin * 2.0f + }; + + panel_draw(ED_PNL_LEFT); + panel_draw(ED_PNL_RIGHT); + + if (app.mode == APP_MODE_EDIT_SELECT) { + if (started && sel_dist > 20) { + sel_rec_draw(); + } + } + + if (ed.panel[ED_PNL_CENTER].enabled) { + f32 width = fminf(640, screen_w - margin * 2); + f32 height = fminf(420, screen_h - status_h - margin * 2); + + ed.panel[ED_PNL_CENTER].bounds = (Rect){ + (screen_w - width) * 0.5f, + (screen_h - status_h - height) * 0.5f, + width, height + }; + + DrawRectangle(0, 0, GetScreenWidth(), GetScreenHeight(), + Fade(BLACK, 0.35f)); + panel_draw(ED_PNL_CENTER); + } +} + +/* 3D gizmos */ +static void +gizmo_transform(void) { + Vec3 point = ed.sel_point; + Quaternion rot = ed.sel_rot; + + Vec3 right = Vector3RotateByQuaternion((Vec3){1, 0, 0}, rot); + Vec3 up = Vector3RotateByQuaternion((Vec3){0, 1, 0}, rot); + Vec3 fwd = Vector3RotateByQuaternion((Vec3){0, 0, 1}, rot); + + f32 len = 0.75f; + + right = Vector3Scale(right, len); + up = Vector3Scale(up, len); + fwd = Vector3Scale(fwd, len); + + DrawLine3D(point, Vector3Add(point, fwd), BLUE); + DrawLine3D(point, Vector3Add(point, up), GREEN); + DrawLine3D(point, Vector3Add(point, right), RED); +} + +static void +gizmo_move(void) { + Color col = { 255, 255, 255, 150 }; + Vec3 point = ed.sel_point; + + if (IsKeyDown(KEY_LEFT_ALT)) { + DrawLine3D(point, Vector3Add(point, (Vec3){0,100,0}), col); // GREEN + DrawLine3D(point, Vector3Add(point, (Vec3){0,-100,0}), col); + } else { + DrawLine3D(point, Vector3Add(point, (Vec3){100,0,0}), col); //RED + DrawLine3D(point, Vector3Add(point, (Vec3){-100,0,0}), col); + + DrawLine3D(point, Vector3Add(point, (Vec3){0,0,100}), col); //BLUE + DrawLine3D(point, Vector3Add(point, (Vec3){0,0,-100}), col); + } +} + +static void +gizmo_rotate(void) { + Vec3 point = ed.sel_point; + Color line_col = { 255, 255, 255, 150 }; + Color circle_col = { 255, 255, 255, 100 }; + if (ray_plane_hit(point, (Vec3){0,1,0}, &point)) { + DrawLine3D(ed.sel_point, point, line_col); + DrawCircle3D(ed.sel_point, 1.5, (Vec3){1,0,0}, 90, circle_col); + } +} + +void +editor_draw_3d(void) { + if (app.mode == APP_MODE_EDIT_MOVE) { + gizmo_move(); + } + + if (app.mode == APP_MODE_EDIT_ROTATE) { + gizmo_rotate(); + } + + if (ed.sel_cnt > 0) { + gizmo_transform(); + } +} + +/* utils */ +f32 +editor_label_w(cstr text) { + return (f32)GuiGetTextWidth(text) + + 2.0f * GuiGetStyle(LABEL, BORDER_WIDTH) + + 2.0f * GuiGetStyle(LABEL, TEXT_PADDING) + + 2.0f; +} + +void +editor_rename_selected(cstr name) { + EditorAction action = action_begin(ED_ACTION_RENAME); + + for (u32 i = 0; i < action.item_cnt; ++i) { + u64 id = entity_id_from_pid(action.item[i].pid); + Entity *ent = entity_get(id); + assert(ent); + + char *new_name = strdup(name); + if (!new_name) { + perror("rename alloc failed."); + exit(1); + } + + action.item[i].before.rename.name = ent->name; + ent->name = new_name; + } + + action_commit(&action); +} |