From: rexim Date: Wed, 4 Dec 2019 14:39:42 +0000 (+0700) Subject: (#164) Make layer translation units more unity build friendly X-Git-Url: https://git.lizzy.rs/?a=commitdiff_plain;h=81a40fe9db71c2f1dc89ff14e02fa8bba014d623;p=nothing.git (#164) Make layer translation units more unity build friendly --- diff --git a/src/game/level/level_editor/background_layer.c b/src/game/level/level_editor/background_layer.c index bdb77fa4..158eff00 100644 --- a/src/game/level/level_editor/background_layer.c +++ b/src/game/level/level_editor/background_layer.c @@ -8,7 +8,6 @@ #include "background_layer.h" #include "undo_history.h" - BackgroundLayer create_background_layer(Color color) { BackgroundLayer layer = { @@ -51,15 +50,15 @@ int background_layer_render(BackgroundLayer *layer, typedef struct { BackgroundLayer *layer; Color color; -} UndoContext; +} BackgroundUndoContext; static void background_undo_color(void *context, size_t context_size) { trace_assert(context); - trace_assert(sizeof(UndoContext) == context_size); + trace_assert(sizeof(BackgroundUndoContext) == context_size); - UndoContext *undo_context = context; + BackgroundUndoContext *undo_context = context; BackgroundLayer *background_layer = undo_context->layer; background_layer->color_picker = create_color_picker_from_rgba(undo_context->color); @@ -86,7 +85,7 @@ int background_layer_event(BackgroundLayer *layer, } if (selected && !color_picker_drag(&layer->color_picker)) { - UndoContext context = { + BackgroundUndoContext context = { .layer = layer, .color = layer->prev_color }; diff --git a/src/game/level/level_editor/label_layer.c b/src/game/level/level_editor/label_layer.c index 6267c885..6a5abcf5 100644 --- a/src/game/level/level_editor/label_layer.c +++ b/src/game/level/level_editor/label_layer.c @@ -30,9 +30,9 @@ typedef enum { LABEL_LAYER_RECOLOR } LabelLayerState; -static int clipboard; -static char clipboard_text[LABEL_LAYER_TEXT_MAX_SIZE]; -static Color clipboard_color; +static int label_clipboard = 0; +static char label_clipboard_text[LABEL_LAYER_TEXT_MAX_SIZE]; +static Color label_clipboard_color; struct LabelLayer { Lt *lt; @@ -52,14 +52,14 @@ struct LabelLayer { }; typedef enum { - UNDO_ADD, - UNDO_DELETE, - UNDO_UPDATE, - UNDO_SWAP -} UndoType; + LABEL_UNDO_ADD, + LABEL_UNDO_DELETE, + LABEL_UNDO_UPDATE, + LABEL_UNDO_SWAP +} LabelUndoType; typedef struct { - UndoType type; + LabelUndoType type; LabelLayer *layer; char id[LABEL_LAYER_ID_MAX_SIZE]; Vec2f position; @@ -67,18 +67,18 @@ typedef struct { char text[LABEL_LAYER_TEXT_MAX_SIZE]; size_t index; size_t index2; -} UndoContext; +} LabelUndoContext; static -UndoContext create_undo_swap_context(LabelLayer *label_layer, +LabelUndoContext create_label_undo_swap_context(LabelLayer *label_layer, size_t index, size_t index2) { trace_assert(label_layer); trace_assert(index < dynarray_count(label_layer->positions)); trace_assert(index2 < dynarray_count(label_layer->positions)); - UndoContext undo_context; - undo_context.type = UNDO_SWAP; + LabelUndoContext undo_context; + undo_context.type = LABEL_UNDO_SWAP; undo_context.layer = label_layer; undo_context.index = index; undo_context.index2 = index2; @@ -86,14 +86,14 @@ UndoContext create_undo_swap_context(LabelLayer *label_layer, } static -UndoContext create_undo_context(LabelLayer *label_layer, UndoType type) +LabelUndoContext create_label_undo_context(LabelLayer *label_layer, LabelUndoType type) { trace_assert(label_layer); - trace_assert(type != UNDO_SWAP); + trace_assert(type != LABEL_UNDO_SWAP); - UndoContext undo_context; + LabelUndoContext undo_context; - size_t index = type == UNDO_ADD + size_t index = type == LABEL_UNDO_ADD ? dynarray_count(label_layer->positions) - 1 : (size_t)label_layer->selection; @@ -112,34 +112,34 @@ static void label_layer_undo(void *context, size_t context_size) { trace_assert(context); - trace_assert(sizeof(UndoContext) == context_size); + trace_assert(sizeof(LabelUndoContext) == context_size); - UndoContext *undo_context = context; + LabelUndoContext *undo_context = context; LabelLayer *label_layer = undo_context->layer; switch (undo_context->type) { - case UNDO_ADD: { + case LABEL_UNDO_ADD: { dynarray_delete_at(label_layer->ids, undo_context->index); dynarray_delete_at(label_layer->positions, undo_context->index); dynarray_delete_at(label_layer->colors, undo_context->index); dynarray_delete_at(label_layer->texts, undo_context->index); } break; - case UNDO_DELETE: { + case LABEL_UNDO_DELETE: { dynarray_insert_before(label_layer->ids, undo_context->index, &undo_context->id); dynarray_insert_before(label_layer->positions, undo_context->index, &undo_context->position); dynarray_insert_before(label_layer->colors, undo_context->index, &undo_context->color); dynarray_insert_before(label_layer->texts, undo_context->index, &undo_context->text); } break; - case UNDO_UPDATE: { + case LABEL_UNDO_UPDATE: { dynarray_replace_at(label_layer->ids, undo_context->index, &undo_context->id); dynarray_replace_at(label_layer->positions, undo_context->index, &undo_context->position); dynarray_replace_at(label_layer->colors, undo_context->index, &undo_context->color); dynarray_replace_at(label_layer->texts, undo_context->index, &undo_context->text); } break; - case UNDO_SWAP: { + case LABEL_UNDO_SWAP: { dynarray_swap(label_layer->ids, undo_context->index, undo_context->index2); dynarray_swap(label_layer->positions, undo_context->index, undo_context->index2); dynarray_swap(label_layer->colors, undo_context->index, undo_context->index2); @@ -148,9 +148,9 @@ void label_layer_undo(void *context, size_t context_size) } } -#define UNDO_PUSH(HISTORY, CONTEXT) \ +#define LABEL_UNDO_PUSH(HISTORY, CONTEXT) \ do { \ - UndoContext context = (CONTEXT); \ + LabelUndoContext context = (CONTEXT); \ undo_history_push( \ HISTORY, \ label_layer_undo, \ @@ -448,7 +448,7 @@ void label_layer_delete_selected_label(LabelLayer *label_layer, trace_assert(label_layer); trace_assert(label_layer->selection >= 0); - UNDO_PUSH(undo_history, create_undo_context(label_layer, UNDO_DELETE)); + LABEL_UNDO_PUSH(undo_history, create_label_undo_context(label_layer, LABEL_UNDO_DELETE)); dynarray_delete_at(label_layer->ids, (size_t)label_layer->selection); dynarray_delete_at(label_layer->positions, (size_t)label_layer->selection); @@ -484,7 +484,7 @@ int label_layer_add_label(LabelLayer *label_layer, text, min_size_t(LABEL_LAYER_ID_MAX_SIZE - 1, strlen(text))); - UNDO_PUSH(undo_history, create_undo_context(label_layer, UNDO_ADD)); + LABEL_UNDO_PUSH(undo_history, create_label_undo_context(label_layer, LABEL_UNDO_ADD)); return (int) n; } @@ -504,7 +504,7 @@ void label_layer_swap_elements(LabelLayer *label_layer, dynarray_swap(label_layer->colors, a, b); dynarray_swap(label_layer->texts, a, b); - UNDO_PUSH(undo_history, create_undo_swap_context(label_layer, a, b)); + LABEL_UNDO_PUSH(undo_history, create_label_undo_swap_context(label_layer, a, b)); } static @@ -650,14 +650,14 @@ int label_layer_idle_event(LabelLayer *label_layer, case SDLK_c: { if ((event->key.keysym.mod & KMOD_LCTRL) && label_layer->selection >= 0) { - clipboard = 1; - dynarray_copy_to(label_layer->texts, clipboard_text, (size_t)label_layer->selection); - dynarray_copy_to(label_layer->colors, &clipboard_color, (size_t)label_layer->selection); + label_clipboard = 1; + dynarray_copy_to(label_layer->texts, label_clipboard_text, (size_t)label_layer->selection); + dynarray_copy_to(label_layer->colors, &label_clipboard_color, (size_t)label_layer->selection); } } break; case SDLK_v: { - if ((event->key.keysym.mod & KMOD_LCTRL) && clipboard) { + if ((event->key.keysym.mod & KMOD_LCTRL) && label_clipboard) { int x, y; SDL_GetMouseState(&x, &y); Vec2f position = camera_map_screen(camera, x, y); @@ -665,8 +665,8 @@ int label_layer_idle_event(LabelLayer *label_layer, label_layer_add_label( label_layer, position, - clipboard_color, - clipboard_text, + label_clipboard_color, + label_clipboard_text, undo_history); } } break; @@ -758,7 +758,7 @@ int label_layer_move_event(LabelLayer *label_layer, positions[label_layer->selection])); if (distance > 1e-6) { - UNDO_PUSH(undo_history, create_undo_context(label_layer, UNDO_UPDATE)); + LABEL_UNDO_PUSH(undo_history, create_label_undo_context(label_layer, LABEL_UNDO_UPDATE)); dynarray_replace_at( label_layer->positions, @@ -790,7 +790,7 @@ int label_layer_edit_text_event(LabelLayer *label_layer, case SDL_KEYDOWN: { switch (event->key.keysym.sym) { case SDLK_RETURN: { - UNDO_PUSH(undo_history, create_undo_context(label_layer, UNDO_UPDATE)); + LABEL_UNDO_PUSH(undo_history, create_label_undo_context(label_layer, LABEL_UNDO_UPDATE)); char *text = (char*)dynarray_data(label_layer->texts) + label_layer->selection * LABEL_LAYER_TEXT_MAX_SIZE; @@ -829,7 +829,7 @@ int label_layer_edit_id_event(LabelLayer *label_layer, case SDL_KEYDOWN: { switch (event->key.keysym.sym) { case SDLK_RETURN: { - UNDO_PUSH(undo_history, create_undo_context(label_layer, UNDO_UPDATE)); + LABEL_UNDO_PUSH(undo_history, create_label_undo_context(label_layer, LABEL_UNDO_UPDATE)); char *id = (char*)dynarray_data(label_layer->ids) + label_layer->selection * LABEL_LAYER_ID_MAX_SIZE; @@ -879,7 +879,7 @@ int label_layer_recolor_event(LabelLayer *label_layer, color_picker_rgba(&label_layer->color_picker); if (!color_picker_drag(&label_layer->color_picker)) { - UNDO_PUSH(undo_history, create_undo_context(label_layer, UNDO_UPDATE)); + LABEL_UNDO_PUSH(undo_history, create_label_undo_context(label_layer, LABEL_UNDO_UPDATE)); dynarray_replace_at( label_layer->colors, diff --git a/src/game/level/level_editor/player_layer.c b/src/game/level/level_editor/player_layer.c index 9e88316c..711ade5b 100644 --- a/src/game/level/level_editor/player_layer.c +++ b/src/game/level/level_editor/player_layer.c @@ -13,12 +13,12 @@ typedef struct { PlayerLayer *layer; Vec2f position; Color color; -} UndoContext; +} PlayerUndoContext; static -UndoContext player_layer_create_undo_context(PlayerLayer *player_layer) +PlayerUndoContext player_layer_create_undo_context(PlayerLayer *player_layer) { - UndoContext context = { + PlayerUndoContext context = { .layer = player_layer, .position = player_layer->position, .color = player_layer->prev_color @@ -31,9 +31,9 @@ static void player_layer_undo(void *context, size_t context_size) { trace_assert(context); - trace_assert(sizeof(UndoContext) == context_size); + trace_assert(sizeof(PlayerUndoContext) == context_size); - UndoContext *undo_context = context; + PlayerUndoContext *undo_context = context; PlayerLayer *player_layer = undo_context->layer; player_layer->position = undo_context->position; @@ -129,7 +129,7 @@ int player_layer_event(PlayerLayer *player_layer, } if (selected && !color_picker_drag(&player_layer->color_picker)) { - UndoContext context = + PlayerUndoContext context = player_layer_create_undo_context(player_layer); undo_history_push( undo_history, @@ -143,7 +143,7 @@ int player_layer_event(PlayerLayer *player_layer, event->type == SDL_MOUSEBUTTONDOWN && event->button.button == SDL_BUTTON_LEFT) { - UndoContext context = + PlayerUndoContext context = player_layer_create_undo_context(player_layer); undo_history_push( diff --git a/src/game/level/level_editor/point_layer.c b/src/game/level/level_editor/point_layer.c index 96f96d1c..50f6d775 100644 --- a/src/game/level/level_editor/point_layer.c +++ b/src/game/level/level_editor/point_layer.c @@ -21,8 +21,8 @@ #define POINT_LAYER_ID_TEXT_SIZE vec(2.0f, 2.0f) #define POINT_LAYER_ID_TEXT_COLOR COLOR_BLACK -static int clipboard = 0; -static Color clipboard_color; +static int point_clipboard = 0; +static Color point_clipboard_color; // TODO(#1140): PointLayer does not support snapping @@ -52,32 +52,32 @@ struct PointLayer }; typedef enum { - UNDO_ADD, - UNDO_DELETE, - UNDO_UPDATE, - UNDO_SWAP -} UndoType; + POINT_UNDO_ADD, + POINT_UNDO_DELETE, + POINT_UNDO_UPDATE, + POINT_UNDO_SWAP +} PointUndoType; typedef struct { - UndoType type; + PointUndoType type; PointLayer *layer; Vec2f position; Color color; char id[ID_MAX_SIZE]; size_t index; size_t index2; -} UndoContext; +} PointUndoContext; static -UndoContext create_undo_swap_context(PointLayer *point_layer, +PointUndoContext create_point_undo_swap_context(PointLayer *point_layer, size_t index, size_t index2) { trace_assert(point_layer); trace_assert(index < dynarray_count(point_layer->positions)); trace_assert(index2 < dynarray_count(point_layer->positions)); - UndoContext undo_context; - undo_context.type = UNDO_SWAP; + PointUndoContext undo_context; + undo_context.type = POINT_UNDO_SWAP; undo_context.layer = point_layer; undo_context.index = index; undo_context.index2 = index2; @@ -85,17 +85,17 @@ UndoContext create_undo_swap_context(PointLayer *point_layer, } static -UndoContext create_undo_context(PointLayer *point_layer, - UndoType type) +PointUndoContext create_point_undo_context(PointLayer *point_layer, + PointUndoType type) { - trace_assert(type != UNDO_SWAP); + trace_assert(type != POINT_UNDO_SWAP); - (void) create_undo_swap_context; + (void) create_point_undo_swap_context; - UndoContext undo_context; + PointUndoContext undo_context; size_t index = - type == UNDO_ADD + type == POINT_UNDO_ADD ? dynarray_count(point_layer->positions) - 1 : (size_t) point_layer->selection; @@ -113,33 +113,33 @@ static void point_layer_undo(void *context, size_t context_size) { trace_assert(context); - trace_assert(sizeof(UndoContext) == context_size); + trace_assert(sizeof(PointUndoContext) == context_size); - UndoContext *undo_context = context; + PointUndoContext *undo_context = context; PointLayer *point_layer = undo_context->layer; switch (undo_context->type) { - case UNDO_ADD: { + case POINT_UNDO_ADD: { dynarray_pop(point_layer->positions, NULL); dynarray_pop(point_layer->colors, NULL); dynarray_pop(point_layer->ids, NULL); point_layer->selection = -1; } break; - case UNDO_DELETE: { + case POINT_UNDO_DELETE: { dynarray_insert_before(point_layer->positions, undo_context->index, &undo_context->position); dynarray_insert_before(point_layer->colors, undo_context->index, &undo_context->color); dynarray_insert_before(point_layer->ids, undo_context->index, &undo_context->id); point_layer->selection = -1; } break; - case UNDO_UPDATE: { + case POINT_UNDO_UPDATE: { dynarray_replace_at(point_layer->positions, undo_context->index, &undo_context->position); dynarray_replace_at(point_layer->colors, undo_context->index, &undo_context->color); dynarray_replace_at(point_layer->ids, undo_context->index, &undo_context->id); } break; - case UNDO_SWAP: { + case POINT_UNDO_SWAP: { dynarray_swap(point_layer->positions, undo_context->index, undo_context->index2); dynarray_swap(point_layer->colors, undo_context->index, undo_context->index2); dynarray_swap(point_layer->ids, undo_context->index, undo_context->index2); @@ -147,9 +147,9 @@ void point_layer_undo(void *context, size_t context_size) } } -#define UNDO_PUSH(HISTORY, CONTEXT) \ +#define POINT_UNDO_PUSH(HISTORY, CONTEXT) \ do { \ - UndoContext context = (CONTEXT); \ + PointUndoContext context = (CONTEXT); \ undo_history_push( \ HISTORY, \ point_layer_undo, \ @@ -375,9 +375,9 @@ int point_layer_add_element(PointLayer *point_layer, dynarray_push(point_layer->colors, &color); dynarray_push(point_layer->ids, id); - UNDO_PUSH( + POINT_UNDO_PUSH( undo_history, - create_undo_context(point_layer, UNDO_ADD)); + create_point_undo_context(point_layer, POINT_UNDO_ADD)); return 0; } @@ -396,9 +396,9 @@ void point_layer_swap_elements(PointLayer *point_layer, dynarray_swap(point_layer->colors, a, b); dynarray_swap(point_layer->ids, a, b); - UNDO_PUSH( + POINT_UNDO_PUSH( undo_history, - create_undo_swap_context(point_layer, a, b)); + create_point_undo_swap_context(point_layer, a, b)); } static @@ -408,11 +408,11 @@ void point_layer_delete_nth_element(PointLayer *point_layer, { trace_assert(point_layer); - UNDO_PUSH( + POINT_UNDO_PUSH( undo_history, - create_undo_context( + create_point_undo_context( point_layer, - UNDO_DELETE)); + POINT_UNDO_DELETE)); dynarray_delete_at(point_layer->positions, i); dynarray_delete_at(point_layer->colors, i); @@ -525,13 +525,13 @@ int point_layer_idle_event(PointLayer *point_layer, case SDLK_c: { if ((event->key.keysym.mod & KMOD_LCTRL) && point_layer->selection >= 0) { - clipboard = 1; - dynarray_copy_to(point_layer->colors, &clipboard_color, (size_t)point_layer->selection); + point_clipboard = 1; + dynarray_copy_to(point_layer->colors, &point_clipboard_color, (size_t)point_layer->selection); } } break; case SDLK_v: { - if ((event->key.keysym.mod & KMOD_LCTRL) && clipboard) { + if ((event->key.keysym.mod & KMOD_LCTRL) && point_clipboard) { int x, y; SDL_GetMouseState(&x, &y); Vec2f position = camera_map_screen(camera, x, y); @@ -539,7 +539,7 @@ int point_layer_idle_event(PointLayer *point_layer, point_layer_add_element( point_layer, position, - clipboard_color, + point_clipboard_color, undo_history); } } break; @@ -564,11 +564,11 @@ int point_layer_edit_id_event(PointLayer *point_layer, case SDL_KEYDOWN: { switch(event->key.keysym.sym) { case SDLK_RETURN: { - UNDO_PUSH( + POINT_UNDO_PUSH( undo_history, - create_undo_context( + create_point_undo_context( point_layer, - UNDO_UPDATE)); + POINT_UNDO_UPDATE)); char *id = dynarray_pointer_at(point_layer->ids, (size_t) point_layer->selection); const char *text = edit_field_as_text(point_layer->edit_field); @@ -617,11 +617,11 @@ int point_layer_move_event(PointLayer *point_layer, positions[point_layer->selection])); if (distance > 1e-6) { - UNDO_PUSH( + POINT_UNDO_PUSH( undo_history, - create_undo_context( + create_point_undo_context( point_layer, - UNDO_UPDATE)); + POINT_UNDO_UPDATE)); dynarray_replace_at( point_layer->positions, @@ -680,11 +680,11 @@ int point_layer_recolor_event(PointLayer *point_layer, point_layer->inter_color = color_picker_rgba(&point_layer->color_picker); if (!color_picker_drag(&point_layer->color_picker)) { - UNDO_PUSH( + POINT_UNDO_PUSH( undo_history, - create_undo_context( + create_point_undo_context( point_layer, - UNDO_UPDATE)); + POINT_UNDO_UPDATE)); dynarray_replace_at( point_layer->colors, diff --git a/src/game/level/level_editor/rect_layer.c b/src/game/level/level_editor/rect_layer.c index 5b6b5e09..757db4d4 100644 --- a/src/game/level/level_editor/rect_layer.c +++ b/src/game/level/level_editor/rect_layer.c @@ -25,9 +25,9 @@ #define RECT_LAYER_GRID_ROWS 3 #define RECT_LAYER_GRID_COLUMNS 4 -static int clipboard = 0; -static Rect clipboard_rect; -static Color clipboard_color; +static int rect_clipboard = 0; +static Rect rect_clipboard_rect; +static Color rect_clipboard_color; static Cursor_Style resize_styles[1 << RECT_SIDE_N] = { 0, // [0] @@ -81,15 +81,15 @@ struct RectLayer { }; typedef enum { - UNDO_ADD, - UNDO_DELETE, - UNDO_UPDATE, - UNDO_SWAP -} UndoType; + RECT_UNDO_ADD, + RECT_UNDO_DELETE, + RECT_UNDO_UPDATE, + RECT_UNDO_SWAP +} RectUndoType; // Delete, Update typedef struct { - UndoType type; + RectUndoType type; RectLayer *layer; size_t index; Rect rect; @@ -100,47 +100,47 @@ typedef struct { // Add typedef struct { - UndoType type; + RectUndoType type; RectLayer *layer; size_t index; } UndoAddContext; // Swap typedef struct { - UndoType type; + RectUndoType type; RectLayer *layer; size_t index1; size_t index2; } UndoSwapContext; typedef union { - UndoType type; + RectUndoType type; UndoAddContext add; UndoElementContext element; UndoSwapContext swap; -} UndoContext; +} RectUndoContext; static -UndoContext create_undo_add_context(RectLayer *layer, size_t index) +RectUndoContext create_rect_undo_add_context(RectLayer *layer, size_t index) { trace_assert(layer); trace_assert(index < dynarray_count(layer->rects)); - UndoContext undo_context; - undo_context.add.type = UNDO_ADD; + RectUndoContext undo_context; + undo_context.add.type = RECT_UNDO_ADD; undo_context.add.layer = layer; undo_context.add.index = index; return undo_context; } static -UndoContext create_undo_element_context(RectLayer *layer) +RectUndoContext create_rect_undo_element_context(RectLayer *layer) { trace_assert(layer); size_t index = (size_t) layer->selection; trace_assert(index < dynarray_count(layer->rects)); - UndoContext undo_context; + RectUndoContext undo_context; undo_context.element.layer = layer; undo_context.element.index = index; dynarray_copy_to(layer->rects, &undo_context.element.rect, index); @@ -151,26 +151,26 @@ UndoContext create_undo_element_context(RectLayer *layer) } static -UndoContext create_undo_update_context(RectLayer *rect_layer) +RectUndoContext create_rect_undo_update_context(RectLayer *rect_layer) { - UndoContext undo_context = create_undo_element_context(rect_layer); - undo_context.type = UNDO_UPDATE; + RectUndoContext undo_context = create_rect_undo_element_context(rect_layer); + undo_context.type = RECT_UNDO_UPDATE; return undo_context; } static -UndoContext create_undo_delete_context(RectLayer *rect_layer) +RectUndoContext create_rect_undo_delete_context(RectLayer *rect_layer) { - UndoContext undo_context = create_undo_element_context(rect_layer); - undo_context.type = UNDO_DELETE; + RectUndoContext undo_context = create_rect_undo_element_context(rect_layer); + undo_context.type = RECT_UNDO_DELETE; return undo_context; } static -UndoContext create_undo_swap_context(RectLayer *rect_layer, size_t index1, size_t index2) +RectUndoContext create_rect_undo_swap_context(RectLayer *rect_layer, size_t index1, size_t index2) { - UndoContext undo_context; - undo_context.swap.type = UNDO_SWAP; + RectUndoContext undo_context; + undo_context.swap.type = RECT_UNDO_SWAP; undo_context.swap.layer = rect_layer; undo_context.swap.index1 = index1; undo_context.swap.index2 = index2; @@ -181,12 +181,12 @@ static void rect_layer_undo(void *context, size_t context_size) { trace_assert(context); - trace_assert(sizeof(UndoContext) == context_size); + trace_assert(sizeof(RectUndoContext) == context_size); - UndoContext *undo_context = context; + RectUndoContext *undo_context = context; switch (undo_context->type) { - case UNDO_ADD: { + case RECT_UNDO_ADD: { RectLayer *layer = undo_context->add.layer; dynarray_delete_at(layer->rects, undo_context->add.index); dynarray_delete_at(layer->colors, undo_context->add.index); @@ -195,7 +195,7 @@ void rect_layer_undo(void *context, size_t context_size) layer->selection = -1; } break; - case UNDO_DELETE: { + case RECT_UNDO_DELETE: { RectLayer *layer = undo_context->element.layer; dynarray_insert_before(layer->rects, undo_context->element.index, &undo_context->element.rect); dynarray_insert_before(layer->colors, undo_context->element.index, &undo_context->element.color); @@ -204,7 +204,7 @@ void rect_layer_undo(void *context, size_t context_size) layer->selection = -1; } break; - case UNDO_UPDATE: { + case RECT_UNDO_UPDATE: { RectLayer *layer = undo_context->element.layer; dynarray_replace_at(layer->rects, undo_context->element.index, &undo_context->element.rect); dynarray_replace_at(layer->colors, undo_context->element.index, &undo_context->element.color); @@ -212,7 +212,7 @@ void rect_layer_undo(void *context, size_t context_size) dynarray_replace_at(layer->actions, undo_context->element.index, &undo_context->element.action); } break; - case UNDO_SWAP: { + case RECT_UNDO_SWAP: { RectLayer *layer = undo_context->element.layer; dynarray_swap(layer->rects, undo_context->swap.index1, undo_context->swap.index2); dynarray_swap(layer->colors, undo_context->swap.index1, undo_context->swap.index2); @@ -222,9 +222,9 @@ void rect_layer_undo(void *context, size_t context_size) } } -#define UNDO_PUSH(HISTORY, CONTEXT) \ +#define RECT_UNDO_PUSH(HISTORY, CONTEXT) \ do { \ - UndoContext context = (CONTEXT); \ + RectUndoContext context = (CONTEXT); \ undo_history_push( \ HISTORY, \ rect_layer_undo, \ @@ -257,9 +257,9 @@ static int rect_layer_add_rect(RectLayer *layer, dynarray_push_empty(layer->actions); - UNDO_PUSH( + RECT_UNDO_PUSH( undo_history, - create_undo_add_context( + create_rect_undo_add_context( layer, dynarray_count(layer->rects) - 1)); @@ -294,7 +294,7 @@ static void rect_layer_swap_elements(RectLayer *layer, size_t a, size_t b, dynarray_swap(layer->ids, a, b); dynarray_swap(layer->actions, a, b); - UNDO_PUSH(undo_history, create_undo_swap_context(layer, a, b)); + RECT_UNDO_PUSH(undo_history, create_rect_undo_swap_context(layer, a, b)); } static int rect_layer_delete_rect_at(RectLayer *layer, @@ -303,7 +303,7 @@ static int rect_layer_delete_rect_at(RectLayer *layer, { trace_assert(layer); - UNDO_PUSH(undo_history, create_undo_delete_context(layer)); + RECT_UNDO_PUSH(undo_history, create_rect_undo_delete_context(layer)); dynarray_delete_at(layer->rects, i); dynarray_delete_at(layer->colors, i); @@ -470,14 +470,14 @@ static int rect_layer_event_idle(RectLayer *layer, case SDLK_c: { if ((event->key.keysym.mod & KMOD_LCTRL) && layer->selection >= 0) { - clipboard = 1; - dynarray_copy_to(layer->rects, &clipboard_rect, (size_t)layer->selection); - dynarray_copy_to(layer->colors, &clipboard_color, (size_t)layer->selection); + rect_clipboard = 1; + dynarray_copy_to(layer->rects, &rect_clipboard_rect, (size_t)layer->selection); + dynarray_copy_to(layer->colors, &rect_clipboard_color, (size_t)layer->selection); } } break; case SDLK_v: { - if ((event->key.keysym.mod & KMOD_LCTRL) && clipboard) { + if ((event->key.keysym.mod & KMOD_LCTRL) && rect_clipboard) { int x, y; SDL_GetMouseState(&x, &y); Vec2f position = camera_map_screen(camera, x, y); @@ -485,8 +485,8 @@ static int rect_layer_event_idle(RectLayer *layer, rect_layer_add_rect( layer, rect(position.x, position.y, - clipboard_rect.w, clipboard_rect.h), - clipboard_color, + rect_clipboard_rect.w, rect_clipboard_rect.h), + rect_clipboard_color, undo_history); } } break; @@ -705,7 +705,7 @@ static int rect_layer_event_resize(RectLayer *layer, case SDL_MOUSEBUTTONUP: { layer->state = RECT_LAYER_IDLE; - UNDO_PUSH(undo_history, create_undo_update_context(layer)); + RECT_UNDO_PUSH(undo_history, create_rect_undo_update_context(layer)); dynarray_replace_at(layer->rects, (size_t) layer->selection, &layer->inter_rect); } break; } @@ -793,7 +793,7 @@ static int rect_layer_event_move(RectLayer *layer, rect_position(rects[layer->selection]))); if (distance > 1e-6) { - UNDO_PUSH(undo_history, create_undo_update_context(layer)); + RECT_UNDO_PUSH(undo_history, create_rect_undo_update_context(layer)); dynarray_replace_at(layer->rects, (size_t) layer->selection, &layer->inter_rect); } } break; @@ -815,7 +815,7 @@ static int rect_layer_event_id_rename(RectLayer *layer, case SDL_KEYDOWN: { switch (event->key.keysym.sym) { case SDLK_RETURN: { - UNDO_PUSH(undo_history, create_undo_update_context(layer)); + RECT_UNDO_PUSH(undo_history, create_rect_undo_update_context(layer)); char *id = dynarray_pointer_at(layer->ids, (size_t)layer->selection); memset(id, 0, ENTITY_MAX_ID_SIZE); @@ -1130,7 +1130,7 @@ int rect_layer_event_recolor(RectLayer *layer, layer->inter_color = color_picker_rgba(&layer->color_picker); if (!color_picker_drag(&layer->color_picker)) { - UNDO_PUSH(undo_history, create_undo_update_context(layer)); + RECT_UNDO_PUSH(undo_history, create_rect_undo_update_context(layer)); dynarray_replace_at(layer->colors, (size_t) layer->selection, &layer->inter_color); layer->state = RECT_LAYER_IDLE; }