src/game/level/level_editor/point_layer.c

   1 #include <stdio.h>
   2
   3 #include <SDL.h>
   4
   5 #include "dynarray.h"
   6 #include "game/camera.h"
   7 #include "system/line_stream.h"
   8 #include "system/log.h"
   9 #include "system/lt.h"
  10 #include "system/nth_alloc.h"
  11 #include "system/stacktrace.h"
  12 #include "system/str.h"
  13 #include "ui/edit_field.h"
  14 #include "./point_layer.h"
  15 #include "math/extrema.h"
  16 #include "math/mat3x3.h"
  17 #include "./color_picker.h"
  18 #include "undo_history.h"
  19
  20 #define POINT_LAYER_ELEMENT_RADIUS 10.0f
  21 #define POINT_LAYER_ID_TEXT_SIZE vec(2.0f, 2.0f)
  22 #define POINT_LAYER_ID_TEXT_COLOR COLOR_BLACK
  23
  24 typedef enum {
  25     POINT_LAYER_IDLE = 0,
  26     POINT_LAYER_EDIT_ID,
  27     POINT_LAYER_MOVE,
  28     POINT_LAYER_RECOLOR
  29 } PointLayerState;
  30
  31 struct PointLayer
  32 {
  33     Lt *lt;
  34     PointLayerState state;
  35     Dynarray/*<Point>*/ *positions;
  36     Dynarray/*<Color>*/ *colors;
  37     Dynarray/*<char[ID_MAX_SIZE]>*/ *ids;
  38     int selected;
  39     ColorPicker color_picker;
  40
  41     Point inter_position;
  42     Color inter_color;
  43     Edit_field *edit_field;
  44 };
  45
  46 typedef enum {
  47     UNDO_ADD,
  48     UNDO_DELETE,
  49     UNDO_UPDATE
  50 } UndoType;
  51
  52 typedef struct {
  53     UndoType type;
  54     PointLayer *layer;
  55     Point position;
  56     Color color;
  57     char id[ID_MAX_SIZE];
  58     size_t index;
  59 } UndoContext;
  60
  61 static
  62 UndoContext point_layer_create_undo_context(PointLayer *point_layer,
  63                                             UndoType type)
  64 {
  65     UndoContext undo_context;
  66
  67     size_t index =
  68         type == UNDO_ADD
  69         ? dynarray_count(point_layer->positions) - 1
  70         : (size_t) point_layer->selected;
  71
  72     undo_context.type = type;
  73     undo_context.layer = point_layer;
  74     dynarray_copy_to(point_layer->positions, &undo_context.position, index);
  75     dynarray_copy_to(point_layer->colors, &undo_context.color, index);
  76     dynarray_copy_to(point_layer->ids, &undo_context.id, index);
  77     undo_context.index = index;
  78
  79     return undo_context;
  80 }
  81
  82 static
  83 void point_layer_undo(void *context, size_t context_size)
  84 {
  85     trace_assert(context);
  86     trace_assert(sizeof(UndoContext) == context_size);
  87
  88     UndoContext *undo_context = context;
  89     PointLayer *point_layer = undo_context->layer;
  90
  91     switch (undo_context->type) {
  92     case UNDO_ADD: {
  93         dynarray_pop(point_layer->positions, NULL);
  94         dynarray_pop(point_layer->colors, NULL);
  95         dynarray_pop(point_layer->ids, NULL);
  96         point_layer->selected = -1;
  97     } break;
  98
  99     case UNDO_DELETE: {
 100         dynarray_insert_before(point_layer->positions, undo_context->index, &undo_context->position);
 101         dynarray_insert_before(point_layer->colors, undo_context->index, &undo_context->color);
 102         dynarray_insert_before(point_layer->ids, undo_context->index, &undo_context->id);
 103         point_layer->selected = -1;
 104     } break;
 105
 106     case UNDO_UPDATE: {
 107         dynarray_replace_at(point_layer->positions, undo_context->index, &undo_context->position);
 108         dynarray_replace_at(point_layer->colors, undo_context->index, &undo_context->color);
 109         dynarray_replace_at(point_layer->ids, undo_context->index, &undo_context->id);
 110     } break;
 111     }
 112 }
 113
 114 #define UNDO_PUSH(LAYER, HISTORY, UNDO_TYPE)                            \
 115     do {                                                                \
 116         UndoContext context = point_layer_create_undo_context(LAYER, UNDO_TYPE); \
 117         undo_history_push(                                              \
 118             HISTORY,                                                    \
 119             point_layer_undo,                                           \
 120             &context,                                                   \
 121             sizeof(context));                                           \
 122     } while(0)
 123
 124 LayerPtr point_layer_as_layer(PointLayer *point_layer)
 125 {
 126     LayerPtr layer = {
 127         .type = LAYER_POINT,
 128         .ptr = point_layer
 129     };
 130     return layer;
 131 }
 132
 133 PointLayer *create_point_layer(void)
 134 {
 135     Lt *lt = create_lt();
 136
 137     PointLayer *point_layer = PUSH_LT(lt, nth_calloc(1, sizeof(PointLayer)), free);
 138     if (point_layer == NULL) {
 139         RETURN_LT(lt, NULL);
 140     }
 141     point_layer->lt = lt;
 142
 143     point_layer->state = POINT_LAYER_IDLE;
 144
 145     point_layer->positions = PUSH_LT(lt, create_dynarray(sizeof(Point)), destroy_dynarray);
 146     if (point_layer->positions == NULL) {
 147         RETURN_LT(lt, NULL);
 148     }
 149
 150     point_layer->colors = PUSH_LT(lt, create_dynarray(sizeof(Color)), destroy_dynarray);
 151     if (point_layer->colors == NULL) {
 152         RETURN_LT(lt, NULL);
 153     }
 154
 155     point_layer->ids = PUSH_LT(lt, create_dynarray(sizeof(char) * ID_MAX_SIZE), destroy_dynarray);
 156     if (point_layer->ids == NULL) {
 157         RETURN_LT(lt, NULL);
 158     }
 159
 160     point_layer->edit_field = PUSH_LT(
 161         lt,
 162         create_edit_field(
 163             POINT_LAYER_ID_TEXT_SIZE,
 164             POINT_LAYER_ID_TEXT_COLOR),
 165         destroy_edit_field);
 166     if (point_layer->edit_field == NULL) {
 167         RETURN_LT(lt, NULL);
 168     }
 169
 170     return point_layer;
 171 }
 172
 173 PointLayer *create_point_layer_from_line_stream(LineStream *line_stream)
 174 {
 175     trace_assert(line_stream);
 176
 177     PointLayer *point_layer = create_point_layer();
 178
 179     size_t count = 0;
 180     if (sscanf(
 181             line_stream_next(line_stream),
 182             "%zu",
 183             &count) == EOF) {
 184         log_fail("Could not read amount of points");
 185         RETURN_LT(point_layer->lt, NULL);
 186     }
 187
 188     char color_name[7];
 189     char id[ID_MAX_SIZE];
 190     float x, y;
 191     for (size_t i = 0; i < count; ++i) {
 192         if (sscanf(
 193                 line_stream_next(line_stream),
 194                 "%"STRINGIFY(ID_MAX_SIZE)"s%f%f%6s",
 195                 id, &x, &y, color_name) < 0) {
 196             log_fail("Could not read %dth goal\n", i);
 197             RETURN_LT(point_layer->lt, NULL);
 198         }
 199         const Color color = hexstr(color_name);
 200         const Point point = vec(x, y);
 201
 202         dynarray_push(point_layer->colors, &color);
 203         dynarray_push(point_layer->positions, &point);
 204         dynarray_push(point_layer->ids, id);
 205     }
 206
 207     point_layer->selected = -1;
 208
 209     point_layer->color_picker = create_color_picker_from_rgba(COLOR_RED);
 210
 211     return point_layer;
 212 }
 213
 214 void destroy_point_layer(PointLayer *point_layer)
 215 {
 216     trace_assert(point_layer);
 217     RETURN_LT0(point_layer->lt);
 218 }
 219
 220 static inline
 221 Triangle element_shape(Point position, float scale)
 222 {
 223     return triangle_mat3x3_product(
 224         equilateral_triangle(),
 225         mat3x3_product(
 226             trans_mat_vec(position),
 227             scale_mat(scale)));
 228 }
 229
 230 int point_layer_render(const PointLayer *point_layer,
 231                        Camera *camera,
 232                        int active)
 233 {
 234     trace_assert(point_layer);
 235     trace_assert(camera);
 236
 237     const int n = (int) dynarray_count(point_layer->positions);
 238     Point *positions = dynarray_data(point_layer->positions);
 239     Color *colors = dynarray_data(point_layer->colors);
 240     char *ids = dynarray_data(point_layer->ids);
 241
 242     for (int i = 0; i < n; ++i) {
 243         const Color color = color_scale(
 244             point_layer->state == POINT_LAYER_RECOLOR && i == point_layer->selected
 245             ? point_layer->inter_color
 246             : colors[i],
 247             rgba(1.0f, 1.0f, 1.0f, active ? 1.0f : 0.5f));
 248
 249         const Point position =
 250             point_layer->state == POINT_LAYER_MOVE && i == point_layer->selected
 251             ? point_layer->inter_position
 252             : positions[i];
 253
 254         // Selection Layer
 255         if (active && i == point_layer->selected) {
 256             if (camera_fill_triangle(
 257                     camera,
 258                     element_shape(
 259                         position,
 260                         POINT_LAYER_ELEMENT_RADIUS + 5.0f),
 261                     color_invert(color)) < 0) {
 262                 return -1;
 263             }
 264
 265             if (point_layer->state != POINT_LAYER_EDIT_ID &&
 266                 camera_render_text(
 267                     camera,
 268                     ids + ID_MAX_SIZE * i,
 269                     POINT_LAYER_ID_TEXT_SIZE,
 270                     POINT_LAYER_ID_TEXT_COLOR,
 271                     position) < 0) {
 272                 return -1;
 273             }
 274         }
 275
 276         if (camera_fill_triangle(
 277                 camera,
 278                 element_shape(
 279                     position,
 280                     POINT_LAYER_ELEMENT_RADIUS),
 281                 color) < 0) {
 282             return -1;
 283         }
 284     }
 285
 286     if (point_layer->state == POINT_LAYER_EDIT_ID) {
 287         if (edit_field_render_world(
 288                 point_layer->edit_field,
 289                 camera,
 290                 positions[point_layer->selected]) < 0) {
 291             return -1;
 292         }
 293     }
 294
 295     if (active && color_picker_render(&point_layer->color_picker, camera) < 0) {
 296         return -1;
 297     }
 298
 299
 300     return 0;
 301 }
 302
 303 static
 304 int point_layer_element_at(const PointLayer *point_layer,
 305                            Point position)
 306 {
 307     trace_assert(point_layer);
 308
 309     int n = (int) dynarray_count(point_layer->positions);
 310     Point *positions = dynarray_data(point_layer->positions);
 311
 312     for (int i = 0; i < n; ++i) {
 313         if (vec_length(vec_sub(positions[i], position)) < POINT_LAYER_ELEMENT_RADIUS) {
 314             return i;
 315         }
 316     }
 317
 318     return -1;
 319 }
 320
 321 static
 322 int point_layer_add_element(PointLayer *point_layer,
 323                             Point position,
 324                             Color color,
 325                             UndoHistory *undo_history)
 326 {
 327     trace_assert(point_layer);
 328     trace_assert(undo_history);
 329
 330     char id[ID_MAX_SIZE];
 331     for (size_t i = 0; i < ID_MAX_SIZE - 1; ++i) {
 332         id[i] = (char) ('a' + rand() % ('z' - 'a' + 1));
 333     }
 334     id[ID_MAX_SIZE - 1] = '\0';
 335
 336     dynarray_push(point_layer->positions, &position);
 337     dynarray_push(point_layer->colors, &color);
 338     dynarray_push(point_layer->ids, id);
 339
 340     UNDO_PUSH(point_layer, undo_history, UNDO_ADD);
 341
 342     return 0;
 343 }
 344
 345 static
 346 void point_layer_delete_nth_element(PointLayer *point_layer,
 347                                     size_t i,
 348                                     UndoHistory *undo_history)
 349 {
 350     trace_assert(point_layer);
 351
 352     UNDO_PUSH(point_layer, undo_history, UNDO_DELETE);
 353
 354     dynarray_delete_at(point_layer->positions, i);
 355     dynarray_delete_at(point_layer->colors, i);
 356     dynarray_delete_at(point_layer->ids, i);
 357 }
 358
 359 static
 360 int point_layer_idle_event(PointLayer *point_layer,
 361                            const SDL_Event *event,
 362                            const Camera *camera,
 363                            UndoHistory *undo_history)
 364 {
 365     trace_assert(point_layer);
 366     trace_assert(event);
 367     trace_assert(camera);
 368
 369     int selected = 0;
 370     if (color_picker_event(
 371             &point_layer->color_picker,
 372             event,
 373             camera,
 374             &selected) < 0) {
 375         return -1;
 376     }
 377
 378     if (selected) {
 379         if (point_layer->selected >= 0) {
 380             point_layer->inter_color = color_picker_rgba(&point_layer->color_picker);
 381             point_layer->state = POINT_LAYER_RECOLOR;
 382         }
 383         return 0;
 384     }
 385
 386     switch (event->type) {
 387     case SDL_MOUSEBUTTONDOWN: {
 388         switch (event->button.button) {
 389         case SDL_BUTTON_LEFT: {
 390             const Point position = camera_map_screen(camera, event->button.x, event->button.y);
 391
 392             point_layer->selected = point_layer_element_at(
 393                 point_layer, position);
 394
 395             if (point_layer->selected < 0) {
 396                 point_layer_add_element(
 397                     point_layer,
 398                     position,
 399                     color_picker_rgba(&point_layer->color_picker),
 400                     undo_history);
 401             } else {
 402                 Color *colors = dynarray_data(point_layer->colors);
 403                 Point *positions = dynarray_data(point_layer->positions);
 404
 405                 point_layer->state = POINT_LAYER_MOVE;
 406                 point_layer->color_picker =
 407                     create_color_picker_from_rgba(colors[point_layer->selected]);
 408                 point_layer->inter_position = positions[point_layer->selected];
 409             }
 410         } break;
 411         }
 412     } break;
 413
 414     case SDL_KEYDOWN: {
 415         switch (event->key.keysym.sym) {
 416         case SDLK_DELETE: {
 417             if (0 <= point_layer->selected && point_layer->selected < (int) dynarray_count(point_layer->positions)) {
 418                 point_layer_delete_nth_element(
 419                     point_layer,
 420                     (size_t)point_layer->selected,
 421                     undo_history);
 422                 point_layer->selected = -1;
 423             }
 424         } break;
 425
 426         case SDLK_F2: {
 427             if (point_layer->selected >= 0) {
 428                 char *ids = dynarray_data(point_layer->ids);
 429                 point_layer->state = POINT_LAYER_EDIT_ID;
 430                 edit_field_replace(
 431                     point_layer->edit_field,
 432                     ids + ID_MAX_SIZE * point_layer->selected);
 433                 SDL_StartTextInput();
 434             }
 435         } break;
 436         }
 437     } break;
 438     }
 439
 440     return 0;
 441 }
 442
 443 static
 444 int point_layer_edit_id_event(PointLayer *point_layer,
 445                               const SDL_Event *event,
 446                               const Camera *camera,
 447                               UndoHistory *undo_history)
 448 {
 449     trace_assert(point_layer);
 450     trace_assert(event);
 451     trace_assert(camera);
 452
 453     switch (event->type) {
 454     case SDL_KEYDOWN: {
 455         switch(event->key.keysym.sym) {
 456         case SDLK_RETURN: {
 457             UNDO_PUSH(point_layer, undo_history, UNDO_UPDATE);
 458
 459             char *id = dynarray_pointer_at(point_layer->ids, (size_t) point_layer->selected);
 460             const char *text = edit_field_as_text(point_layer->edit_field);
 461             size_t n = min_size_t(strlen(text), ID_MAX_SIZE - 1);
 462             memcpy(id, text, n);
 463             memset(id + n, 0, ID_MAX_SIZE - n);
 464
 465             point_layer->state = POINT_LAYER_IDLE;
 466             SDL_StopTextInput();
 467             return 0;
 468         } break;
 469
 470         case SDLK_ESCAPE: {
 471             point_layer->state = POINT_LAYER_IDLE;
 472             SDL_StopTextInput();
 473             return 0;
 474         } break;
 475         }
 476     } break;
 477     }
 478
 479     return edit_field_event(point_layer->edit_field, event);
 480 }
 481
 482 static
 483 int point_layer_move_event(PointLayer *point_layer,
 484                            const SDL_Event *event,
 485                            const Camera *camera,
 486                            UndoHistory *undo_history)
 487 {
 488     trace_assert(point_layer);
 489     trace_assert(event);
 490     trace_assert(camera);
 491     trace_assert(point_layer->selected >= 0);
 492
 493     switch (event->type) {
 494     case SDL_MOUSEBUTTONUP: {
 495         switch (event->button.button) {
 496         case SDL_BUTTON_LEFT: {
 497             point_layer->state = POINT_LAYER_IDLE;
 498
 499             // TODO(#1014): just click (without moving) on the point creates an undo history entry
 500             UNDO_PUSH(point_layer, undo_history, UNDO_UPDATE);
 501
 502             dynarray_replace_at(
 503                 point_layer->positions,
 504                 (size_t) point_layer->selected,
 505                 &point_layer->inter_position);
 506         } break;
 507         }
 508     } break;
 509
 510     case SDL_MOUSEMOTION: {
 511         point_layer->inter_position =
 512             camera_map_screen(camera, event->motion.x, event->motion.y);
 513     } break;
 514     }
 515
 516     return 0;
 517 }
 518
 519 static
 520 int point_layer_recolor_event(PointLayer *point_layer,
 521                               const SDL_Event *event,
 522                               const Camera *camera,
 523                               UndoHistory *undo_history)
 524 {
 525     trace_assert(point_layer);
 526     trace_assert(event);
 527     trace_assert(camera);
 528     trace_assert(undo_history);
 529     trace_assert(point_layer->selected >= 0);
 530
 531     int selected = 0;
 532     if (color_picker_event(
 533             &point_layer->color_picker,
 534             event,
 535             camera,
 536             &selected) < 0) {
 537         return -1;
 538     }
 539
 540     if (selected) {
 541         point_layer->inter_color = color_picker_rgba(&point_layer->color_picker);
 542
 543         if (!color_picker_drag(&point_layer->color_picker)) {
 544             UNDO_PUSH(point_layer, undo_history, UNDO_UPDATE);
 545
 546             dynarray_replace_at(
 547                 point_layer->colors,
 548                 (size_t) point_layer->selected,
 549                 &point_layer->inter_color);
 550
 551             point_layer->state = POINT_LAYER_IDLE;
 552         }
 553     }
 554
 555
 556     return 0;
 557 }
 558
 559 int point_layer_event(PointLayer *point_layer,
 560                       const SDL_Event *event,
 561                       const Camera *camera,
 562                       UndoHistory *undo_history)
 563 {
 564     trace_assert(point_layer);
 565     trace_assert(event);
 566     trace_assert(camera);
 567     trace_assert(undo_history);
 568
 569     switch (point_layer->state) {
 570     case POINT_LAYER_IDLE:
 571         return point_layer_idle_event(point_layer, event, camera, undo_history);
 572
 573     case POINT_LAYER_EDIT_ID:
 574         return point_layer_edit_id_event(point_layer, event, camera, undo_history);
 575
 576     case POINT_LAYER_MOVE:
 577         return point_layer_move_event(point_layer, event, camera, undo_history);
 578
 579     case POINT_LAYER_RECOLOR:
 580         return point_layer_recolor_event(point_layer, event, camera, undo_history);
 581     }
 582
 583     return 0;
 584 }
 585
 586 size_t point_layer_count(const PointLayer *point_layer)
 587 {
 588     trace_assert(point_layer);
 589     return dynarray_count(point_layer->positions);
 590 }
 591
 592 const Point *point_layer_positions(const PointLayer *point_layer)
 593 {
 594     trace_assert(point_layer);
 595     return dynarray_data(point_layer->positions);
 596 }
 597
 598 const Color *point_layer_colors(const PointLayer *point_layer)
 599 {
 600     trace_assert(point_layer);
 601     return dynarray_data(point_layer->colors);
 602 }
 603
 604 const char *point_layer_ids(const PointLayer *point_layer)
 605 {
 606     trace_assert(point_layer);
 607     return dynarray_data(point_layer->ids);
 608 }
 609
 610 int point_layer_dump_stream(const PointLayer *point_layer,
 611                             FILE *filedump)
 612 {
 613     trace_assert(point_layer);
 614     trace_assert(filedump);
 615
 616     size_t n = dynarray_count(point_layer->ids);
 617     char *ids = dynarray_data(point_layer->ids);
 618     Point *positions = dynarray_data(point_layer->positions);
 619     Color *colors = dynarray_data(point_layer->colors);
 620
 621     fprintf(filedump, "%zd\n", n);
 622     for (size_t i = 0; i < n; ++i) {
 623         fprintf(filedump, "%s %f %f ",
 624                 ids + ID_MAX_SIZE * i,
 625                 positions[i].x, positions[i].y);
 626         color_hex_to_stream(colors[i], filedump);
 627         fprintf(filedump, "\n");
 628     }
 629
 630     return 0;
 631 }