src/game/level/level_editor/layer.c

   1 #include "game/camera.h"
   2 #include "system/lt.h"
   3 #include "system/stacktrace.h"
   4 #include "system/nth_alloc.h"
   5 #include "system/log.h"
   6 #include "math/rect.h"
   7 #include "color.h"
   8 #include "layer.h"
   9 #include "dynarray.h"
  10 #include "system/line_stream.h"
  11
  12 struct RectLayer {
  13     Lt lt;
  14     Dynarray *rects;
  15     Dynarray *colors;
  16 };
  17
  18 RectLayer *create_rect_layer(void)
  19 {
  20     Lt lt = {0};
  21     if (lt == NULL) {
  22         return NULL;
  23     }
  24
  25     RectLayer *layer = PUSH_LT(lt, nth_calloc(1, sizeof(RectLayer)), free);
  26     if (layer == NULL) {
  27         RETURN_LT(lt, NULL);
  28     }
  29     layer->lt = lt;
  30
  31     layer->rects = PUSH_LT(
  32         lt,
  33         create_dynarray(sizeof(Rect)),
  34         destroy_dynarray);
  35     if (layer->rects == NULL) {
  36         RETURN_LT(lt, NULL);
  37     }
  38
  39     layer->colors = PUSH_LT(
  40         lt,
  41         create_dynarray(sizeof(Color)),
  42         destroy_dynarray);
  43     if (layer->colors == NULL) {
  44         RETURN_LT(lt, NULL);
  45     }
  46
  47     return layer;
  48 }
  49
  50 RectLayer *create_layer_from_line_stream(LineStream *line_stream)
  51 {
  52     trace_assert(line_stream);
  53
  54     RectLayer *layer = create_rect_layer();
  55     if (layer == NULL) {
  56         return NULL;
  57     }
  58
  59     const char *line = line_stream_next(line_stream);
  60     if (line == NULL) {
  61         RETURN_LT(layer->lt, NULL);
  62     }
  63
  64     size_t count = 0;
  65     if (sscanf(line, "%lu", &count) < 0) {
  66         RETURN_LT(layer->lt, NULL);
  67     }
  68
  69     for (size_t i = 0; i < count; ++i) {
  70         line = line_stream_next(line_stream);
  71         if (line == NULL) {
  72             RETURN_LT(layer->lt, NULL);
  73         }
  74
  75         char hex[7];
  76         Rect rect;
  77
  78         if (sscanf(line, "%f%f%f%f%6s\n",
  79                    &rect.x, &rect.y,
  80                    &rect.w, &rect.h,
  81                    hex) < 0) {
  82             RETURN_LT(layer->lt, NULL);
  83         }
  84
  85         if (rect_layer_add_rect(layer, rect, hexstr(hex)) < 0) {
  86             RETURN_LT(layer->lt, NULL);
  87         }
  88     }
  89
  90     return layer;
  91 }
  92
  93 void destroy_rect_layer(RectLayer *layer)
  94 {
  95     trace_assert(layer);
  96     RETURN_LT0(layer->lt);
  97 }
  98
  99 int rect_layer_render(const RectLayer *layer, Camera *camera)
 100 {
 101     trace_assert(layer);
 102     trace_assert(camera);
 103
 104     const size_t n = dynarray_count(layer->rects);
 105     Rect *rects = dynarray_data(layer->rects);
 106     Color *colors = dynarray_data(layer->colors);
 107
 108     for (size_t i = 0; i < n; ++i) {
 109         Color color = rgba(colors[i].r, colors[i].g, colors[i].b, 0.75f);
 110         if (camera_fill_rect(camera, rects[i], color) < 0) {
 111             return -1;
 112         }
 113     }
 114
 115     return 0;
 116 }
 117
 118 int rect_layer_event(RectLayer *layer, const SDL_Event *event)
 119 {
 120     trace_assert(layer);
 121     trace_assert(event);
 122     return 0;
 123 }
 124
 125 int rect_layer_add_rect(RectLayer *layer, Rect rect, Color color)
 126 {
 127     trace_assert(layer);
 128
 129     if (dynarray_push(layer->rects, &rect) < 0) {
 130         return -1;
 131     }
 132
 133     if (dynarray_push(layer->colors, &color) < 0) {
 134         return -1;
 135     }
 136
 137     return 0;
 138 }
 139
 140 int rect_layer_delete_rect_at(RectLayer *layer, Vec position)
 141 {
 142     trace_assert(layer);
 143
 144     const size_t n = dynarray_count(layer->rects);
 145     Rect *rects = dynarray_data(layer->rects);
 146
 147     for (size_t i = 0; i < n; ++i) {
 148         if (rect_contains_point(rects[i], position)) {
 149             dynarray_delete_at(layer->rects, i);
 150             dynarray_delete_at(layer->colors, i);
 151             return 0;
 152         }
 153     }
 154
 155     return 0;
 156 }
 157
 158 size_t rect_layer_count(const RectLayer *layer)
 159 {
 160     return dynarray_count(layer->rects);
 161 }
 162
 163 const Rect *rect_layer_rects(const RectLayer *layer)
 164 {
 165     return dynarray_data(layer->rects);
 166 }
 167
 168 const Color *rect_layer_colors(const RectLayer *layer)
 169 {
 170     return dynarray_data(layer->colors);
 171 }