Working zoom

src/engine/rendering/renderer.hpp

@@ -62,6 +62,7 @@ public:
     virtual void draw_point(int x, int y, Color color) = 0;
     virtual void draw_text(std::optional<TextRenderDetails> details, std::string text,int x, int y)=0;
     virtual void draw_sprite(Sprite sprite, int x, int y)=0;
+    virtual void draw_sprite(Sprite sprite, int x, int y, float scale)=0;
     virtual TextRenderDetails get_default_text_render_details()=0;
 
     virtual ~Renderer() = default;

src/engine/rendering/sdl/sdlrenderer.cpp

@@ -20,7 +20,7 @@ void SdlRenderer::draw_text(std::optional<TextRenderDetails> details, std::strin
     TextRenderDetails unpacked_details = details.value_or(this->renderer_params.default_font);
     std::shared_ptr<TTF_Font> font = this->font_manager->fetch_resource(SdlFontArgs(unpacked_details.size, unpacked_details.font_path));
     std::shared_ptr<SDL_Texture> texture = this->texture_manager->load_text_as_texture(text, font, unpacked_details.color);
-    render_texture(x, y, texture, nullptr);
+    render_texture(x, y, texture, nullptr, nullptr);
 }
 
 SdlRenderer::~SdlRenderer() {
@@ -34,7 +34,7 @@ SdlRenderer::~SdlRenderer() {
     SDL_Quit();
 }
 
-void SdlRenderer::render_texture(int x, int y, const std::shared_ptr<SDL_Texture>& texture, SDL_Rect *src) {
+void SdlRenderer::render_texture(int x, int y, const std::shared_ptr<SDL_Texture>& texture, SDL_Rect *src, SDL_Rect *dest) {
     int w, h;
     if(src == nullptr) {
         SDL_QueryTexture(texture.get(), nullptr, nullptr, &w, &h);
@@ -43,11 +43,21 @@ void SdlRenderer::render_texture(int x, int y, const std::shared_ptr<SDL_Texture
         w = src->w;
         h = src->h;
     }
-    SDL_Rect rect = {x,y,w,h};
+    SDL_Rect destination_rect;
-    SDL_RenderCopy(this->renderer.get(), texture.get(), src, &rect);
+    if(dest == nullptr) {
+        destination_rect = {x,y,w,h};
+    }
+    else {
+        destination_rect = *dest;
+    }
+    SDL_RenderCopy(this->renderer.get(), texture.get(), src, &destination_rect);
 }
 
 void SdlRenderer::draw_sprite(Sprite sprite, int x, int y) {
+    this->draw_sprite(sprite, x, y, 1);
+}
+
+void SdlRenderer::draw_sprite(Sprite sprite, int x, int y, float scale) {
     SpriteSheet *sprite_sheet = sprite.sprite_sheet;
     TextureManagerFetchArgs args = TextureManagerFetchArgs {sprite_sheet->path, sprite_sheet->color_key};
     std::shared_ptr<SDL_Texture> texture = this->texture_manager->fetch_resource(args);
@@ -57,7 +67,8 @@ void SdlRenderer::draw_sprite(Sprite sprite, int x, int y) {
     int src_y = l*sprite_sheet->sprite_height;
     int src_x = (sprite_sheet->sprite_width * sprite.index) % w;
     auto source = SDL_Rect{src_x, src_y, sprite_sheet->sprite_width, sprite_sheet->sprite_height};
-    render_texture(x, y, texture, &source);
+    auto dest = SDL_Rect {x, y, (int)std::ceil(sprite_sheet->sprite_width * scale), (int)std::ceil(sprite_sheet->sprite_height * scale)};
+    render_texture(x, y, texture, &source, &dest);
 }
 
 SdlRenderer::SdlRenderer(RendererParams renderer_params) : renderer_params(std::move(renderer_params)) {

src/engine/rendering/sdl/sdlrenderer.hpp

@@ -23,6 +23,7 @@ public:
     void flush() override;
     void draw_point(int x, int y, Color color) override;
     void draw_sprite(Sprite sprite, int x, int y) override;
+    void draw_sprite(Sprite sprite, int x, int y, float scale) override;
     TextRenderDetails get_default_text_render_details() override {
         return this->renderer_params.default_font;
     }
@@ -32,7 +33,7 @@ private:
     std::shared_ptr<SDL_Renderer> renderer = nullptr;
     std::unique_ptr<SdlTextureManager> texture_manager = nullptr;
     std::unique_ptr<SdlFontManager> font_manager = nullptr;
-    void render_texture(int x, int y, const std::shared_ptr<SDL_Texture>& texture, SDL_Rect *src);
+    void render_texture(int x, int y, const std::shared_ptr<SDL_Texture>& texture, SDL_Rect *src, SDL_Rect *dest);
 };
 
 

src/engine/utility/camera.cpp

@@ -25,7 +25,9 @@ void Camera::set_bounds(int max_x, int max_y) {
     this->cached_bounds = calculate_bounds();
 }
 
-Rectangle Camera::calculate_bounds() {
+Rectangle Camera::calculate_bounds() const {
+    auto tiles_rendered_x = this->getTilesRenderedX();
+    auto tiles_rendered_y = this->getTilesRenderedY();
     int minx = std::clamp(center.x-(tiles_rendered_x/2), 0, std::max(0,max_x - tiles_rendered_x));
     int miny = std::clamp(center.y-(tiles_rendered_y/2), 0, std::max(0,max_y - tiles_rendered_y));
     int width = std::min(tiles_rendered_x, max_x-minx);
@@ -50,3 +52,20 @@ ranges::any_view<Point> Camera::get_range() {
         });
     }) | ranges::views::join;
 }
+
+float Camera::getScale() const {
+    return scale;
+}
+
+void Camera::setScale(float scale) {
+    this->scale = scale;
+    this->cached_bounds = calculate_bounds();
+}
+
+int Camera::getTilesRenderedX() const {
+    return (int)std::ceil(tiles_rendered_x / this->scale);
+}
+
+int Camera::getTilesRenderedY() const {
+    return (int)std::ceil(tiles_rendered_y / this->scale);
+}

src/engine/utility/camera.hpp

@@ -20,7 +20,15 @@ private:
     int max_x=0;
     int max_y=0;
     Rectangle cached_bounds=Rectangle();
-    Rectangle calculate_bounds();
+    Rectangle calculate_bounds() const;
+    float scale = 1;
+    [[nodiscard]] int getTilesRenderedX() const;
+    [[nodiscard]] int getTilesRenderedY() const;
+public:
+    [[nodiscard]] float getScale() const;
+
+    void setScale(float scale);
+
 public:
     Rectangle get_bounds();
     void move_camera(Point new_center);

src/game/visualizer.cpp

@@ -16,6 +16,8 @@ bool Visualizer::update(InputResult input) {
         case KEY_LEFT: x -= 1; break;
         case KEY_UP: y -= 1; break;
         case KEY_DOWN: y += 1; break;
+        case KEY_KP_PLUS: this->camera.setScale(this->camera.getScale() * 2); break;
+        case KEY_KP_MINUS: this->camera.setScale(this->camera.getScale() / 2); break;
         default: break;
     }
     if(input.keycode >= InputProcessorKeycode::KEY_1 && input.keycode <= InputProcessorKeycode::KEY_9) {
@@ -36,6 +38,9 @@ bool Visualizer::update(InputResult input) {
 void Visualizer::render(Renderer *renderer) {
     SpriteSheet tiles = SpriteSheet{"sprites/map1.bmp", tile_width, tile_height};
     SpriteSheet characters = SpriteSheet{"sprites/character.bmp", tile_width, tile_height, COLOR_BLACK};
+    float scale = this->camera.getScale();
+    int scaled_tile_width = (int)std::ceil(tile_width * scale);
+    int scaled_tile_height = (int)std::ceil(tile_height * scale);
     auto grass = Sprite{&tiles, 0};
     auto wall = Sprite{&tiles, 497};
     auto character = Sprite{&characters, this->sprite_index};
@@ -43,13 +48,13 @@ void Visualizer::render(Renderer *renderer) {
         auto wp = camera.camera_coords_to_screen_coords(p);
         int wx = wp.x, wy = wp.y;
         if(this->tile_map.get_tile(p.x, p.y) == floor_char) {
-            renderer->draw_sprite(grass, wx*tile_width, wy*tile_height);
+            renderer->draw_sprite(grass, wx*scaled_tile_width, wy*scaled_tile_height, scale);
         }
         else {
-            renderer->draw_sprite(wall, wx*tile_width, wy*tile_height);
+            renderer->draw_sprite(wall, wx*scaled_tile_width, wy*scaled_tile_height, scale);
         }
         if(p.x == x && p.y == y) {
-            renderer->draw_sprite(character, wx*tile_width, wy*tile_height);
+            renderer->draw_sprite(character, wx*scaled_tile_width, wy*scaled_tile_height, scale);
         }
     }