+#include <float.h>
+#include <errno.h>
+
#include "game/camera.h"
#include "system/lt.h"
#include "system/stacktrace.h"
#include "system/str.h"
#include "ui/edit_field.h"
#include "undo_history.h"
+#include "game/level/action.h"
+#include "action_picker.h"
+#include "game.h"
-#define RECT_LAYER_SELECTION_THICCNESS 10.0f
+#define RECT_LAYER_SELECTION_THICCNESS 15.0f
#define RECT_LAYER_ID_LABEL_SIZE vec(3.0f, 3.0f)
#define CREATE_AREA_THRESHOLD 10.0
-
-// TODO(#1075): there is no way to modify z order in Rect, Point and Label Layers
-
-
-static int clipboard = 0;
-static Rect clipboard_rect;
-static Color clipboard_color;
+#define RECT_LAYER_GRID_ROWS 3
+#define RECT_LAYER_GRID_COLUMNS 4
+
+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]
+ CURSOR_STYLE_RESIZE_VERT, // [1]
+ CURSOR_STYLE_RESIZE_HORIS, // [2]
+ CURSOR_STYLE_RESIZE_DIAG1, // [3]
+ CURSOR_STYLE_RESIZE_VERT, // [4]
+ 0, // [5]
+ CURSOR_STYLE_RESIZE_DIAG2, // [6]
+ 0, // [7]
+ CURSOR_STYLE_RESIZE_HORIS, // [8]
+ CURSOR_STYLE_RESIZE_DIAG2, // [9]
+ 0, // [10]
+ 0, // [11]
+ CURSOR_STYLE_RESIZE_DIAG1 // [12]
+};
typedef enum {
RECT_LAYER_IDLE = 0,
RECT_LAYER_CREATE,
- // TODO(#955): Rectangles in Level Editor have only one resize anchor to work with
RECT_LAYER_RESIZE,
RECT_LAYER_MOVE,
RECT_LAYER_ID_RENAME,
struct RectLayer {
Lt *lt;
RectLayerState state;
+ int resize_mask;
Dynarray *ids;
Dynarray *rects;
Dynarray *colors;
+ Dynarray *actions;
ColorPicker color_picker;
- Vec create_begin;
- Vec create_end;
+ ActionPicker action_picker;
+ Vec2f create_begin;
+ Vec2f create_end;
int selection;
- Vec move_anchor;
+ Vec2f move_anchor; // The mouse offset from the left-top
+ // corner of the rect during moving it
Edit_field *id_edit_field;
Color inter_color;
Rect inter_rect;
int id_name_counter;
const char *id_name_prefix;
+ Grid *grid;
+ Cursor *cursor;
+
+ int snapping_enabled;
};
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;
Color color;
- char id[RECT_LAYER_ID_MAX_SIZE];
+ Action action;
+ char id[ENTITY_MAX_ID_SIZE];
} UndoElementContext;
// 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);
dynarray_copy_to(layer->colors, &undo_context.element.color, index);
dynarray_copy_to(layer->ids, undo_context.element.id, index);
+ dynarray_copy_to(layer->actions, &undo_context.element.action, index);
return undo_context;
}
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;
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);
dynarray_delete_at(layer->ids, undo_context->add.index);
+ dynarray_delete_at(layer->actions, undo_context->add.index);
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);
dynarray_insert_before(layer->ids, undo_context->element.index, &undo_context->element.id);
+ dynarray_insert_before(layer->actions, undo_context->element.index, &undo_context->element.action);
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);
dynarray_replace_at(layer->ids, undo_context->element.index, &undo_context->element.id);
+ 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);
dynarray_swap(layer->ids, undo_context->swap.index1, undo_context->swap.index2);
+ dynarray_swap(layer->actions, undo_context->swap.index1, undo_context->swap.index2);
} break;
}
}
-#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, \
return -1;
}
- char id[RECT_LAYER_ID_MAX_SIZE];
- snprintf(id, RECT_LAYER_ID_MAX_SIZE, "%s_%d",
+ char id[ENTITY_MAX_ID_SIZE];
+ snprintf(id, ENTITY_MAX_ID_SIZE, "%s_%d",
layer->id_name_prefix,
layer->id_name_counter++);
if (dynarray_push(layer->ids, id)) {
return -1;
}
- UNDO_PUSH(
+ dynarray_push_empty(layer->actions);
+
+ RECT_UNDO_PUSH(
undo_history,
- create_undo_add_context(
+ create_rect_undo_add_context(
layer,
dynarray_count(layer->rects) - 1));
return 0;
}
-static int rect_layer_rect_at(RectLayer *layer, Vec position)
+static int rect_layer_rect_at(RectLayer *layer, Vec2f position)
{
trace_assert(layer);
dynarray_swap(layer->rects, a, b);
dynarray_swap(layer->colors, a, b);
dynarray_swap(layer->ids, a, b);
+ dynarray_swap(layer->actions, a, b);
- UNDO_PUSH(undo_history, create_undo_swap_context(layer, a, b));
-}
-
-static Rect rect_layer_resize_anchor(const Camera *camera, Rect boundary_rect)
-{
- const Rect overlay_rect =
- rect_scale(
- camera_rect(camera, boundary_rect),
- RECT_LAYER_SELECTION_THICCNESS * 0.5f);
-
- return rect(
- overlay_rect.x + overlay_rect.w,
- overlay_rect.y + overlay_rect.h,
- RECT_LAYER_SELECTION_THICCNESS * 2.0f,
- RECT_LAYER_SELECTION_THICCNESS * 2.0f);
+ RECT_UNDO_PUSH(undo_history, create_rect_undo_swap_context(layer, a, b));
}
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);
dynarray_delete_at(layer->ids, i);
+ dynarray_delete_at(layer->actions, i);
return 0;
}
+static int calc_resize_mask(Vec2f point, Rect rect)
+{
+ int mask = 0;
+ for (Rect_side side = 0; side < RECT_SIDE_N; ++side) {
+ if (rect_side_distance(rect, point, side) < RECT_LAYER_SELECTION_THICCNESS) {
+ mask = mask | (1 << side);
+ }
+ }
+ return mask;
+}
+
static int rect_layer_event_idle(RectLayer *layer,
const SDL_Event *event,
const Camera *camera,
return 0;
}
+ Rect *rects = dynarray_data(layer->rects);
+
switch (event->type) {
case SDL_MOUSEBUTTONDOWN: {
switch (event->button.button) {
case SDL_BUTTON_LEFT: {
- Point position = camera_map_screen(
+ Vec2f position = camera_map_screen(
camera,
event->button.x,
event->button.y);
int rect_at_position =
rect_layer_rect_at(layer, position);
- Rect *rects = dynarray_data(layer->rects);
+
Color *colors = dynarray_data(layer->colors);
- if (layer->selection >= 0 && rect_contains_point(
- rect_layer_resize_anchor(
- camera,
- rects[layer->selection]),
- vec(
- (float) event->button.x,
- (float) event->button.y))) {
+ if (layer->selection >= 0 &&
+ layer->selection == rect_at_position &&
+ (layer->resize_mask = calc_resize_mask(
+ vec((float) event->button.x, (float)event->button.y),
+ camera_rect(camera, rects[layer->selection])))) {
layer->state = RECT_LAYER_RESIZE;
dynarray_copy_to(layer->rects, &layer->inter_rect, (size_t) layer->selection);
} else if (rect_at_position >= 0) {
layer->selection = rect_at_position;
layer->state = RECT_LAYER_MOVE;
- layer->move_anchor =
- vec_sub(
- position,
- vec(
- rects[layer->selection].x,
- rects[layer->selection].y));
+ layer->move_anchor = vec_sub(
+ position,
+ vec(
+ rects[layer->selection].x,
+ rects[layer->selection].y));
layer->color_picker =
create_color_picker_from_rgba(colors[rect_at_position]);
-
dynarray_copy_to(layer->rects, &layer->inter_rect, (size_t) rect_at_position);
} else {
layer->selection = rect_at_position;
}
} break;
+ case SDL_MOUSEMOTION: {
+ int resize_mask = 0;
+ Vec2f position = camera_map_screen(
+ camera,
+ event->button.x,
+ event->button.y);
+ if (layer->selection >= 0 &&
+ layer->selection == rect_layer_rect_at(layer, position) &&
+ (resize_mask = calc_resize_mask(
+ vec((float) event->button.x, (float)event->button.y),
+ camera_rect(camera, rects[layer->selection])))) {
+ layer->cursor->style = resize_styles[resize_mask];
+ } else {
+ layer->cursor->style = CURSOR_STYLE_POINTER;
+ }
+ } break;
+
case SDL_KEYDOWN: {
switch (event->key.keysym.sym) {
case SDLK_UP: {
}
} break;
+ case SDLK_q: {
+ // TODO(#1171): there is no UI indication that we are in the snapping mode
+ layer->snapping_enabled = !layer->snapping_enabled;
+ } break;
+
case SDLK_F2: {
if (layer->selection >= 0) {
const char *ids = dynarray_data(layer->ids);
layer->state = RECT_LAYER_ID_RENAME;
edit_field_replace(
layer->id_edit_field,
- ids + layer->selection * RECT_LAYER_ID_MAX_SIZE);
+ ids + layer->selection * ENTITY_MAX_ID_SIZE);
SDL_StartTextInput();
}
} break;
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);
- Point position = camera_map_screen(camera, x, y);
+ Vec2f position = camera_map_screen(camera, x, y);
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;
return 0;
}
+static
+void snap_rect_resize_if_enabled(RectLayer *layer, Rect *a, float snapping_threshold)
+{
+ trace_assert(layer);
+ trace_assert(layer->selection >= 0);
+ trace_assert(a);
+
+ if (!layer->snapping_enabled) return;
+
+ Rect *rects = dynarray_data(layer->rects);
+ size_t rects_size = dynarray_count(layer->rects);
+
+ for (size_t i = 0; i < rects_size; ++i) {
+ if (i == (size_t) layer->selection) continue;
+
+ const Rect b = rects[i];
+
+ if (segment_overlap(vec(a->x, a->x + a->w), vec(b.x, b.x + b.w))) {
+ snap_var2seg(&a->y, b.y, 0, b.h, snapping_threshold);
+ }
+
+ if (segment_overlap(vec(a->y, a->y + a->h), vec(b.y, b.y + b.h))) {
+ snap_var2seg(&a->x, b.x, 0, b.w, snapping_threshold);
+ }
+ }
+}
+
static int rect_layer_event_resize(RectLayer *layer,
const SDL_Event *event,
const Camera *camera,
trace_assert(camera);
trace_assert(layer->selection >= 0);
+ Rect *rects = dynarray_data(layer->rects);
+
+ float scaled_snap_threshold = SNAPPING_THRESHOLD / camera->scale;
+
switch (event->type) {
case SDL_MOUSEMOTION: {
- layer->inter_rect = rect_from_points(
- vec(layer->inter_rect.x, layer->inter_rect.y),
- vec_sum(
- camera_map_screen(
- camera,
- event->button.x,
- event->button.y),
- vec(RECT_LAYER_SELECTION_THICCNESS * -0.5f,
- RECT_LAYER_SELECTION_THICCNESS * -0.5f)));
+ Vec2f position = camera_map_screen(
+ camera,
+ event->button.x,
+ event->button.y);
+
+ switch (layer->resize_mask) {
+ case 1: { // TOP
+ Rect a = rect(rects[layer->selection].x,
+ position.y,
+ rects[layer->selection].w,
+ rects[layer->selection].h);
+
+ snap_rect_resize_if_enabled(layer, &a, scaled_snap_threshold);
+
+ layer->inter_rect = rect_from_points(
+ vec(a.x, a.y),
+ rect_position2(rects[layer->selection]));
+ } break;
+
+ case 2: { // LEFT
+ Rect a = rect(position.x,
+ rects[layer->selection].y,
+ rects[layer->selection].w,
+ rects[layer->selection].h);
+
+ snap_rect_resize_if_enabled(layer, &a, scaled_snap_threshold);
+
+ layer->inter_rect = rect_from_points(
+ vec(a.x, a.y),
+ rect_position2(rects[layer->selection]));
+ } break;
+
+ case 3: { // TOP,LEFT
+ Rect a = rect(
+ position.x,
+ position.y,
+ rects[layer->selection].w,
+ rects[layer->selection].h);
+
+ snap_rect_resize_if_enabled(layer, &a, scaled_snap_threshold);
+
+ layer->inter_rect = rect_from_points(
+ vec(a.x, a.y),
+ rect_position2(rects[layer->selection]));
+ } break;
+
+ case 4: { // BOTTOM
+ Rect a = rect(rects[layer->selection].x,
+ position.y,
+ rects[layer->selection].w,
+ rects[layer->selection].h);
+
+ snap_rect_resize_if_enabled(layer, &a, scaled_snap_threshold);
+
+ layer->inter_rect = rect_from_points(
+ rect_position(rects[layer->selection]),
+ vec(rects[layer->selection].x + rects[layer->selection].w,
+ a.y));
+ } break;
+
+ case 6: { // BOTTOM,LEFT
+ Rect a = rect(
+ position.x,
+ position.y,
+ rects[layer->selection].w,
+ -rects[layer->selection].h);
+
+ snap_rect_resize_if_enabled(layer, &a, scaled_snap_threshold);
+
+ layer->inter_rect = rect_from_points(
+ vec(a.x, rects[layer->selection].y),
+ vec(rects[layer->selection].x + rects[layer->selection].w,
+ a.y));
+ } break;
+
+ case 8: { // RIGHT
+ Rect a = rect(position.x,
+ rects[layer->selection].y,
+ rects[layer->selection].w,
+ rects[layer->selection].h);
+
+ snap_rect_resize_if_enabled(layer, &a, scaled_snap_threshold);
+
+ layer->inter_rect = rect_from_points(
+ rect_position(rects[layer->selection]),
+ vec(a.x, rects[layer->selection].y + rects[layer->selection].h));
+ } break;
+
+ case 9: { // TOP,RIGHT
+ Rect a = rect(
+ position.x,
+ position.y,
+ -rects[layer->selection].w,
+ rects[layer->selection].h);
+
+ snap_rect_resize_if_enabled(layer, &a, scaled_snap_threshold);
+
+ layer->inter_rect = rect_from_points(
+ vec(rects[layer->selection].x, a.y),
+ vec(a.x,
+ rects[layer->selection].y + rects[layer->selection].h));
+ } break;
+
+ case 12: { // BOTTOM,RIGHT
+ Rect a = rect(
+ position.x,
+ position.y,
+ -rects[layer->selection].w,
+ -rects[layer->selection].h);
+
+ snap_rect_resize_if_enabled(layer, &a, scaled_snap_threshold);
+
+ layer->inter_rect = rect_from_points(
+ rect_position(rects[layer->selection]),
+ vec(a.x, a.y));
+ } break;
+ }
+
} break;
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;
}
return 0;
}
+static
+void snap_rect_move_if_enabled(RectLayer *layer, Rect *a,
+ float snapping_threshold)
+{
+ trace_assert(a);
+ trace_assert(layer);
+ trace_assert(layer->selection >= 0);
+
+ if (!layer->snapping_enabled) return;
+
+ Rect *rects = dynarray_data(layer->rects);
+ size_t rects_size = dynarray_count(layer->rects);
+
+ for (size_t i = 0; i < rects_size; ++i) {
+ if (i == (size_t) layer->selection) continue;
+
+ const Rect b = rects[i];
+
+ if (segment_overlap(vec(a->x, a->x + a->w), vec(b.x, b.x + b.w))) {
+ snap_seg2seg(&a->y, b.y, a->h, b.h, snapping_threshold);
+ }
+
+ if (segment_overlap(vec(a->y, a->y + a->h), vec(b.y, b.y + b.h))) {
+ snap_seg2seg(&a->x, b.x, a->w, b.w, snapping_threshold);
+ }
+ }
+}
+
static int rect_layer_event_move(RectLayer *layer,
const SDL_Event *event,
const Camera *camera,
trace_assert(camera);
trace_assert(layer->selection >= 0);
+ Rect *rects = dynarray_data(layer->rects);
+
switch (event->type) {
case SDL_MOUSEMOTION: {
- Point position = vec_sub(
+ const Uint8 *state = SDL_GetKeyboardState(NULL);
+ const Vec2f mouse_pos = vec_sub(
camera_map_screen(
camera,
event->button.x,
event->button.y),
layer->move_anchor);
- trace_assert(layer->selection >= 0);
+ if (!(state[SDL_SCANCODE_LCTRL] || state[SDL_SCANCODE_RCTRL])) {
+ layer->inter_rect.x = mouse_pos.x;
+ layer->inter_rect.y = mouse_pos.y;
+ } else {
+ const Vec2f rect_pos = rect_position(rects[layer->selection]);
+
+ const float dx = fabsf(rect_pos.x - mouse_pos.x);
+ const float dy = fabsf(rect_pos.y - mouse_pos.y);
- layer->inter_rect.x = position.x;
- layer->inter_rect.y = position.y;
+ if (dx > dy) {
+ layer->inter_rect.x = mouse_pos.x;
+ layer->inter_rect.y = rect_pos.y;
+ } else {
+ layer->inter_rect.x = rect_pos.x;
+ layer->inter_rect.y = mouse_pos.y;
+ }
+ }
+
+ snap_rect_move_if_enabled(layer, &layer->inter_rect,
+ SNAPPING_THRESHOLD / camera->scale);
} break;
case SDL_MOUSEBUTTONUP: {
layer->state = RECT_LAYER_IDLE;
- UNDO_PUSH(undo_history, create_undo_update_context(layer));
- dynarray_replace_at(layer->rects, (size_t) layer->selection, &layer->inter_rect);
+
+ float distance = vec_length(
+ vec_sub(rect_position(layer->inter_rect),
+ rect_position(rects[layer->selection])));
+
+ if (distance > 1e-6) {
+ RECT_UNDO_PUSH(undo_history, create_rect_undo_update_context(layer));
+ dynarray_replace_at(layer->rects, (size_t) layer->selection, &layer->inter_rect);
+ }
} break;
}
return 0;
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, RECT_LAYER_ID_MAX_SIZE);
- memcpy(id, edit_field_as_text(layer->id_edit_field), RECT_LAYER_ID_MAX_SIZE - 1);
+ memset(id, 0, ENTITY_MAX_ID_SIZE);
+ memcpy(id, edit_field_as_text(layer->id_edit_field), ENTITY_MAX_ID_SIZE - 1);
layer->state = RECT_LAYER_IDLE;
SDL_StopTextInput();
} break;
return layer;
}
-RectLayer *create_rect_layer(const char *id_name_prefix)
+RectLayer *create_rect_layer(const char *id_name_prefix, Cursor *cursor)
{
+ trace_assert(cursor);
+
Lt *lt = create_lt();
RectLayer *layer = PUSH_LT(lt, nth_calloc(1, sizeof(RectLayer)), free);
layer->ids = PUSH_LT(
lt,
- create_dynarray(sizeof(char) * RECT_LAYER_ID_MAX_SIZE),
+ create_dynarray(sizeof(char) * ENTITY_MAX_ID_SIZE),
destroy_dynarray);
if (layer->ids == NULL) {
RETURN_LT(lt, NULL);
RETURN_LT(lt, NULL);
}
+ layer->actions = PUSH_LT(
+ lt,
+ create_dynarray(sizeof(Action)),
+ destroy_dynarray);
+ if (layer->actions == NULL) {
+ RETURN_LT(lt, NULL);
+ }
+
layer->id_edit_field = PUSH_LT(
lt,
create_edit_field(
RETURN_LT(lt, NULL);
}
+ layer->grid =
+ PUSH_LT(
+ lt,
+ nth_calloc(
+ 1,
+ sizeof(Grid) + sizeof(Widget*) * RECT_LAYER_GRID_ROWS * RECT_LAYER_GRID_COLUMNS),
+ free);
+ if (layer->grid == NULL) {
+ RETURN_LT(lt, NULL);
+ }
+ layer->grid->rows = RECT_LAYER_GRID_ROWS;
+ layer->grid->columns = RECT_LAYER_GRID_COLUMNS;
+ grid_put_widget(layer->grid, &layer->action_picker.widget, 0, RECT_LAYER_GRID_COLUMNS - 1);
+
layer->color_picker = create_color_picker_from_rgba(rgba(1.0f, 0.0f, 0.0f, 1.0f));
layer->selection = -1;
layer->id_name_prefix = id_name_prefix;
+ layer->cursor = cursor;
return layer;
}
-RectLayer *create_rect_layer_from_line_stream(LineStream *line_stream, const char *id_name_prefix)
+RectLayer *create_rect_layer_from_line_stream(LineStream *line_stream,
+ const char *id_name_prefix,
+ Cursor *cursor)
{
trace_assert(line_stream);
- RectLayer *layer = create_rect_layer(id_name_prefix);
+ RectLayer *layer = create_rect_layer(id_name_prefix, cursor);
if (layer == NULL) {
return NULL;
}
char hex[7];
Rect rect;
- char id[RECT_LAYER_ID_MAX_SIZE];
+ char id[ENTITY_MAX_ID_SIZE];
+ int n = 0;
if (sscanf(line,
- "%"STRINGIFY(RECT_LAYER_ID_MAX_SIZE)"s%f%f%f%f%6s\n",
+ "%"STRINGIFY(ENTITY_MAX_ID_SIZE)"s%f%f%f%f%6s%n",
id,
&rect.x, &rect.y,
&rect.w, &rect.h,
- hex) < 0) {
+ hex, &n) <= 0) {
+ log_fail("%s\n", strerror(errno));
RETURN_LT(layer->lt, NULL);
}
+ line += n;
Color color = hexstr(hex);
-
dynarray_push(layer->rects, &rect);
dynarray_push(layer->ids, id);
dynarray_push(layer->colors, &color);
+
+ Action action = {
+ .type = ACTION_NONE,
+ .entity_id = {0}
+ };
+
+ if (sscanf(line, "%d%n", (int*)&action.type, &n) > 0) {
+ line += n;
+ switch (action.type) {
+ case ACTION_NONE: break;
+
+ case ACTION_TOGGLE_GOAL:
+ case ACTION_HIDE_LABEL: {
+ if (sscanf(line, "%"STRINGIFY(ENTITY_MAX_ID_SIZE)"s", action.entity_id) <= 0) {
+ log_fail("%s\n", strerror(errno));
+ RETURN_LT(layer->lt, NULL);
+ }
+ } break;
+
+ case ACTION_N: break;
+ }
+ }
+
+ dynarray_push(layer->actions, &action);
}
return layer;
}
}
+ // Main Rectangle
if (camera_fill_rect(
camera,
rect,
rgba(1.0f, 1.0f, 1.0f, active ? 1.0f : 0.5f))) < 0) {
return -1;
}
+ }
- // Selection Overlay
- if (active && (size_t) layer->selection == i) {
- const Rect overlay_rect =
- rect_scale(
- camera_rect(camera, rect),
- RECT_LAYER_SELECTION_THICCNESS * 0.5f);
- const Color overlay_color = color_invert(color);
+ // Selection Overlay
+ if (active && layer->selection >= 0) {
+ Rect rect = rects[layer->selection];
+ Color color = colors[layer->selection];
- // Main Rectangle
- if (camera_fill_rect(
- camera,
- rect,
- color_scale(
- color,
- rgba(1.0f, 1.0f, 1.0f, active ? 1.0f : 0.5f))) < 0) {
- return -1;
- }
+ if (layer->state == RECT_LAYER_RESIZE || layer->state == RECT_LAYER_MOVE) {
+ rect = layer->inter_rect;
+ }
+
+ if (layer->state == RECT_LAYER_RECOLOR) {
+ color = layer->inter_color;
+ }
+
+ const Rect overlay_rect =
+ rect_pad(
+ camera_rect(camera, rect),
+ -RECT_LAYER_SELECTION_THICCNESS * 0.5f);
+ const Color overlay_color = color_invert(color);
+
+ // Selection
+ if (camera_draw_thicc_rect_screen(
+ camera,
+ overlay_rect,
+ overlay_color,
+ RECT_LAYER_SELECTION_THICCNESS) < 0) {
+ return -1;
+ }
+
+ const Vec2f rect_id_pos = vec_sub(
+ rect_position(rect),
+ vec_mult(
+ RECT_LAYER_ID_LABEL_SIZE,
+ vec(0.0f, FONT_CHAR_HEIGHT)));
- if (camera_draw_thicc_rect_screen(
+ // Rectangle Id
+ if (layer->state == RECT_LAYER_ID_RENAME) {
+ // ID renaming Edit Field
+ if (edit_field_render_world(
+ layer->id_edit_field,
camera,
- overlay_rect,
- overlay_color,
- RECT_LAYER_SELECTION_THICCNESS) < 0) {
+ rect_id_pos) < 0) {
return -1;
}
-
- // Rectangle Id
- if (layer->state == RECT_LAYER_ID_RENAME) {
- // ID renaming Edit Field
- if (edit_field_render_world(
- layer->id_edit_field,
- camera,
- rect_position(rect)) < 0) {
- return -1;
- }
- } else {
- // Id text
- if (camera_render_text(
- camera,
- ids + layer->selection * RECT_LAYER_ID_MAX_SIZE,
- RECT_LAYER_ID_LABEL_SIZE,
- color_invert(color),
- rect_position(rect)) < 0) {
- return -1;
- }
- }
-
- // Resize Anchor
- if (camera_fill_rect_screen(
+ } else {
+ // Id text
+ if (camera_render_text(
camera,
- rect_layer_resize_anchor(camera, rect),
- overlay_color) < 0) {
+ ids + layer->selection * ENTITY_MAX_ID_SIZE,
+ RECT_LAYER_ID_LABEL_SIZE,
+ color_invert(color),
+ rect_id_pos) < 0) {
return -1;
}
}
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;
}
trace_assert(event);
trace_assert(undo_history);
+ switch (event->type) {
+ case SDL_WINDOWEVENT: {
+ switch (event->window.event) {
+ case SDL_WINDOWEVENT_SIZE_CHANGED: {
+ grid_relayout(layer->grid, rect(0.0f, 0.0f,
+ (float) event->window.data1,
+ (float) event->window.data2));
+ } break;
+ }
+ } break;
+ }
+
switch (layer->state) {
case RECT_LAYER_IDLE:
return rect_layer_event_idle(layer, event, camera, undo_history);
return rect_layer_event_recolor(layer, event, camera, undo_history);
}
+
return 0;
}
char *ids = dynarray_data(layer->ids);
Rect *rects = dynarray_data(layer->rects);
Color *colors = dynarray_data(layer->colors);
+ Action *actions = dynarray_data(layer->actions);
fprintf(filedump, "%zd\n", n);
for (size_t i = 0; i < n; ++i) {
fprintf(filedump, "%s %f %f %f %f ",
- ids + RECT_LAYER_ID_MAX_SIZE * i,
+ ids + ENTITY_MAX_ID_SIZE * i,
rects[i].x, rects[i].y, rects[i].w, rects[i].h);
color_hex_to_stream(colors[i], filedump);
+
+ switch (actions[i].type) {
+ case ACTION_NONE: {} break;
+
+ case ACTION_TOGGLE_GOAL:
+ case ACTION_HIDE_LABEL: {
+ fprintf(filedump, " %d %.*s",
+ (int)actions[i].type,
+ ENTITY_MAX_ID_SIZE, actions[i].entity_id);
+ } break;
+ case ACTION_N: break;
+ }
+
fprintf(filedump, "\n");
}
return 0;
}
+
+const Action *rect_layer_actions(const RectLayer *layer)
+{
+ return dynarray_data(layer->actions);
+}
projects / nothing.git / blobdiff