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_clear_background(camera_t *camera,
 176                             color_t color)
 177 {
 178     const SDL_Color sdl_color = color_for_sdl(camera->blackwhite_mode ? color_desaturate(color) : color);
 179
 180     if (SDL_SetRenderDrawColor(camera->renderer, sdl_color.r, sdl_color.g, sdl_color.b, sdl_color.a) < 0) {
 181         throw_error(ERROR_TYPE_SDL2);
 182         return -1;
 183     }
 184
 185     if (SDL_RenderClear(camera->renderer) < 0) {
 186         throw_error(ERROR_TYPE_SDL2);
 187         return -1;
 188     }
 189
 190     return 0;
 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_disable_debug_mode(camera_t *camera)
 206 {
 207     assert(camera);
 208     camera->debug_mode = 0;
 209 }
 210
 211 void camera_toggle_blackwhite_mode(camera_t *camera)
 212 {
 213     assert(camera);
 214     camera->blackwhite_mode = !camera->blackwhite_mode;
 215 }
 216
 217 int camera_is_point_visible(const camera_t *camera, point_t p)
 218 {
 219     SDL_Rect view_port;
 220     SDL_RenderGetViewport(camera->renderer, &view_port);
 221
 222     return rect_contains_point(
 223         rect_from_sdl(&view_port),
 224         camera_point(camera, &view_port, p));
 225 }
 226
 227 rect_t camera_view_port(const camera_t *camera)
 228 {
 229     assert(camera);
 230
 231     SDL_Rect view_port;
 232     SDL_RenderGetViewport(camera->renderer, &view_port);
 233
 234     const vec_t s = effective_scale(&view_port);
 235     const float w = (float) view_port.w * s.x;
 236     const float h = (float) view_port.h * s.y;
 237
 238     return rect(camera->position.x - w * 0.5f,
 239                 camera->position.y - h * 0.5f,
 240                 w, h);
 241 }
 242
 243
 244 /* ---------- Private Function ---------- */
 245
 246 static vec_t effective_ratio(const SDL_Rect *view_port)
 247 {
 248     if ((float) view_port->w / RATIO_X > (float) view_port->h / RATIO_Y) {
 249         return vec(RATIO_X, (float) view_port->h / ((float) view_port->w / RATIO_X));
 250     } else {
 251         return vec((float) view_port->w / ((float) view_port->h / RATIO_Y), RATIO_Y);
 252     }
 253 }
 254
 255 static vec_t effective_scale(const SDL_Rect *view_port)
 256 {
 257     return vec_entry_div(
 258         vec((float) view_port->w, (float) view_port->h),
 259         vec_scala_mult(effective_ratio(view_port), 50.0f));
 260 }
 261
 262 static vec_t camera_point(const camera_t *camera,
 263                           const SDL_Rect *view_port,
 264                           const vec_t p)
 265
 266 {
 267     return vec_sum(
 268         vec_entry_mult(
 269             vec_sum(p, vec_neg(camera->position)),
 270             effective_scale(view_port)),
 271         vec((float) view_port->w * 0.5f,
 272             (float) view_port->h * 0.5f));
 273 }
 274
 275 static triangle_t camera_triangle(const camera_t *camera,
 276                                   const SDL_Rect *view_port,
 277                                   const triangle_t t)
 278 {
 279     return triangle(
 280         camera_point(camera, view_port, t.p1),
 281         camera_point(camera, view_port, t.p2),
 282         camera_point(camera, view_port, t.p3));
 283 }
 284
 285 static rect_t camera_rect(const camera_t *camera,
 286                           const SDL_Rect *view_port,
 287                           const rect_t rect)
 288 {
 289     return rect_from_vecs(
 290         camera_point(
 291             camera,
 292             view_port,
 293             vec(rect.x, rect.y)),
 294         vec_entry_mult(
 295             effective_scale(view_port),
 296             vec(rect.w, rect.h)));
 297 }
 298
 299 int camera_render_text(camera_t *camera,
 300                        const char *text,
 301                        int size,
 302                        vec_t position)
 303 {
 304     SDL_Rect view_port;
 305     SDL_RenderGetViewport(camera->renderer, &view_port);
 306
 307     const vec_t screen_position = camera_point(camera, &view_port, position);
 308
 309     if (sprite_font_render_text(camera->font, camera->renderer, screen_position, size, text) < 0) {
 310         return -1;
 311     }
 312
 313     return 0;
 314 }