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