src/game/camera.c

   1 #include <SDL2/SDL.h>
   2 #include <assert.h>
   3 #include <math.h>
   4
   5 #include "camera.h"
   6 #include "sdl/renderer.h"
   7 #include "system/error.h"
   8
   9 #define RATIO_X 16.0f
  10 #define RATIO_Y 9.0f
  11
  12 struct camera_t {
  13     int debug_mode;
  14     int blackwhite_mode;
  15     point_t position;
  16     SDL_Renderer *renderer;
  17     sprite_font_t *font;
  18 };
  19
  20 static vec_t effective_ratio(const SDL_Rect *view_port);
  21 static vec_t effective_scale(const SDL_Rect *view_port);
  22 static vec_t camera_point(const camera_t *camera,
  23                           const SDL_Rect *view_port,
  24                           const vec_t p);
  25 static rect_t camera_rect(const camera_t *camera,
  26                           const SDL_Rect *view_port,
  27                           const rect_t rect);
  28 static triangle_t camera_triangle(const camera_t *camera,
  29                                   const SDL_Rect *view_port,
  30                                   const triangle_t t);
  31
  32 camera_t *create_camera(SDL_Renderer *renderer,
  33                         sprite_font_t *font)
  34 {
  35     camera_t *camera = malloc(sizeof(camera_t));
  36
  37     if (camera == NULL) {
  38         throw_error(ERROR_TYPE_LIBC);
  39         return NULL;
  40     }
  41
  42     camera->position = vec(0.0f, 0.0f);
  43     camera->debug_mode = 0;
  44     camera->blackwhite_mode = 0;
  45     camera->renderer = renderer;
  46     camera->font = font;
  47
  48     return camera;
  49 }
  50
  51 void destroy_camera(camera_t *camera)
  52 {
  53     assert(camera);
  54
  55     free(camera);
  56 }
  57
  58
  59 int camera_fill_rect(camera_t *camera,
  60                      rect_t rect,
  61                      color_t color)
  62 {
  63     assert(camera);
  64
  65     SDL_Rect view_port;
  66     SDL_RenderGetViewport(camera->renderer, &view_port);
  67
  68     const SDL_Rect sdl_rect = rect_for_sdl(
  69         camera_rect(camera, &view_port, rect));
  70
  71     const SDL_Color sdl_color = color_for_sdl(camera->blackwhite_mode ? color_desaturate(color) : color);
  72
  73     if (camera->debug_mode) {
  74         if (SDL_SetRenderDrawColor(camera->renderer, sdl_color.r, sdl_color.g, sdl_color.b, sdl_color.a / 2) < 0) {
  75             throw_error(ERROR_TYPE_SDL2);
  76             return -1;
  77         }
  78     } else {
  79         if (SDL_SetRenderDrawColor(camera->renderer, sdl_color.r, sdl_color.g, sdl_color.b, sdl_color.a) < 0) {
  80             throw_error(ERROR_TYPE_SDL2);
  81             return -1;
  82         }
  83     }
  84
  85     if (SDL_RenderFillRect(camera->renderer, &sdl_rect) < 0) {
  86         throw_error(ERROR_TYPE_SDL2);
  87         return -1;
  88     }
  89
  90     return 0;
  91 }
  92
  93 int camera_draw_rect(camera_t * camera,
  94                      rect_t rect,
  95                      color_t color)
  96 {
  97     assert(camera);
  98
  99     SDL_Rect view_port;
 100     SDL_RenderGetViewport(camera->renderer, &view_port);
 101
 102     const SDL_Rect sdl_rect = rect_for_sdl(
 103         camera_rect(camera, &view_port, rect));
 104
 105     const SDL_Color sdl_color = color_for_sdl(camera->blackwhite_mode ? color_desaturate(color) : color);
 106
 107     if (SDL_SetRenderDrawColor(camera->renderer, sdl_color.r, sdl_color.g, sdl_color.b, sdl_color.a) < 0) {
 108         throw_error(ERROR_TYPE_SDL2);
 109         return -1;
 110     }
 111
 112     if (SDL_RenderDrawRect(camera->renderer, &sdl_rect) < 0) {
 113         throw_error(ERROR_TYPE_SDL2);
 114         return -1;
 115     }
 116
 117     return 0;
 118 }
 119
 120 int camera_draw_triangle(camera_t *camera,
 121                          triangle_t t,
 122                          color_t color)
 123 {
 124     assert(camera);
 125
 126     SDL_Rect view_port;
 127     SDL_RenderGetViewport(camera->renderer, &view_port);
 128
 129     const SDL_Color sdl_color = color_for_sdl(camera->blackwhite_mode ? color_desaturate(color) : color);
 130
 131     if (SDL_SetRenderDrawColor(camera->renderer, sdl_color.r, sdl_color.g, sdl_color.b, sdl_color.a) < 0) {
 132         throw_error(ERROR_TYPE_SDL2);
 133         return -1;
 134     }
 135
 136     if (draw_triangle(camera->renderer, camera_triangle(camera, &view_port, t)) < 0) {
 137         return -1;
 138     }
 139
 140     return 0;
 141 }
 142
 143 int camera_fill_triangle(camera_t *camera,
 144                          triangle_t t,
 145                          color_t color)
 146 {
 147     assert(camera);
 148
 149     SDL_Rect view_port;
 150     SDL_RenderGetViewport(camera->renderer, &view_port);
 151
 152     const SDL_Color sdl_color = color_for_sdl(camera->blackwhite_mode ? color_desaturate(color) : color);
 153
 154
 155
 156     if (camera->debug_mode) {
 157         if (SDL_SetRenderDrawColor(camera->renderer, sdl_color.r, sdl_color.g, sdl_color.b, sdl_color.a / 2) < 0) {
 158             throw_error(ERROR_TYPE_SDL2);
 159             return -1;
 160         }
 161     } else {
 162         if (SDL_SetRenderDrawColor(camera->renderer, sdl_color.r, sdl_color.g, sdl_color.b, sdl_color.a) < 0) {
 163             throw_error(ERROR_TYPE_SDL2);
 164             return -1;
 165         }
 166     }
 167
 168     if (fill_triangle(camera->renderer, camera_triangle(camera, &view_port, t)) < 0) {
 169         return -1;
 170     }
 171
 172     return 0;
 173 }
 174
 175 int camera_render_text(camera_t *camera,
 176                        const char *text,
 177                        int size,
 178                        color_t color,
 179                        vec_t position)
 180 {
 181     SDL_Rect view_port;
 182     SDL_RenderGetViewport(camera->renderer, &view_port);
 183
 184     const vec_t screen_position = camera_point(camera, &view_port, position);
 185
 186     if (sprite_font_render_text(
 187             camera->font,
 188             camera->renderer,
 189             screen_position,
 190             size,
 191             camera->blackwhite_mode ? color_desaturate(color) : color,
 192             text) < 0) {
 193         return -1;
 194     }
 195
 196     return 0;
 197 }
 198
 199 int camera_clear_background(camera_t *camera,
 200                             color_t color)
 201 {
 202     const SDL_Color sdl_color = color_for_sdl(camera->blackwhite_mode ? color_desaturate(color) : color);
 203
 204     if (SDL_SetRenderDrawColor(camera->renderer, sdl_color.r, sdl_color.g, sdl_color.b, sdl_color.a) < 0) {
 205         throw_error(ERROR_TYPE_SDL2);
 206         return -1;
 207     }
 208
 209     if (SDL_RenderClear(camera->renderer) < 0) {
 210         throw_error(ERROR_TYPE_SDL2);
 211         return -1;
 212     }
 213
 214     return 0;
 215 }
 216
 217 void camera_center_at(camera_t *camera, point_t position)
 218 {
 219     assert(camera);
 220     camera->position = position;
 221 }
 222
 223 void camera_toggle_debug_mode(camera_t *camera)
 224 {
 225     assert(camera);
 226     camera->debug_mode = !camera->debug_mode;
 227 }
 228
 229 void camera_disable_debug_mode(camera_t *camera)
 230 {
 231     assert(camera);
 232     camera->debug_mode = 0;
 233 }
 234
 235 void camera_toggle_blackwhite_mode(camera_t *camera)
 236 {
 237     assert(camera);
 238     camera->blackwhite_mode = !camera->blackwhite_mode;
 239 }
 240
 241 int camera_is_point_visible(const camera_t *camera, point_t p)
 242 {
 243     SDL_Rect view_port;
 244     SDL_RenderGetViewport(camera->renderer, &view_port);
 245
 246     return rect_contains_point(
 247         rect_from_sdl(&view_port),
 248         camera_point(camera, &view_port, p));
 249 }
 250
 251 rect_t camera_view_port(const camera_t *camera)
 252 {
 253     assert(camera);
 254
 255     SDL_Rect view_port;
 256     SDL_RenderGetViewport(camera->renderer, &view_port);
 257
 258     const vec_t s = effective_scale(&view_port);
 259     const float w = (float) view_port.w * s.x;
 260     const float h = (float) view_port.h * s.y;
 261
 262     return rect(camera->position.x - w * 0.5f,
 263                 camera->position.y - h * 0.5f,
 264                 w, h);
 265 }
 266
 267
 268 /* ---------- Private Function ---------- */
 269
 270 static vec_t effective_ratio(const SDL_Rect *view_port)
 271 {
 272     if ((float) view_port->w / RATIO_X > (float) view_port->h / RATIO_Y) {
 273         return vec(RATIO_X, (float) view_port->h / ((float) view_port->w / RATIO_X));
 274     } else {
 275         return vec((float) view_port->w / ((float) view_port->h / RATIO_Y), RATIO_Y);
 276     }
 277 }
 278
 279 static vec_t effective_scale(const SDL_Rect *view_port)
 280 {
 281     return vec_entry_div(
 282         vec((float) view_port->w, (float) view_port->h),
 283         vec_scala_mult(effective_ratio(view_port), 50.0f));
 284 }
 285
 286 static vec_t camera_point(const camera_t *camera,
 287                           const SDL_Rect *view_port,
 288                           const vec_t p)
 289
 290 {
 291     return vec_sum(
 292         vec_entry_mult(
 293             vec_sum(p, vec_neg(camera->position)),
 294             effective_scale(view_port)),
 295         vec((float) view_port->w * 0.5f,
 296             (float) view_port->h * 0.5f));
 297 }
 298
 299 static triangle_t camera_triangle(const camera_t *camera,
 300                                   const SDL_Rect *view_port,
 301                                   const triangle_t t)
 302 {
 303     return triangle(
 304         camera_point(camera, view_port, t.p1),
 305         camera_point(camera, view_port, t.p2),
 306         camera_point(camera, view_port, t.p3));
 307 }
 308
 309 static rect_t camera_rect(const camera_t *camera,
 310                           const SDL_Rect *view_port,
 311                           const rect_t rect)
 312 {
 313     return rect_from_vecs(
 314         camera_point(
 315             camera,
 316             view_port,
 317             vec(rect.x, rect.y)),
 318         vec_entry_mult(
 319             effective_scale(view_port),
 320             vec(rect.w, rect.h)));
 321 }