void TileMap::draw(DrawingContext& context) { // skip draw if current opacity is 0.0 if (current_alpha == 0.0) return; context.push_transform(); if(draw_target != DrawingContext::NORMAL) { context.push_target(); context.set_target(draw_target); } if(drawing_effect != 0) context.set_drawing_effect(drawing_effect); if (editor_active) { if(current_alpha != 1.0) { context.set_alpha(current_alpha); } } else { context.set_alpha(current_alpha/2); } /* Force the translation to be an integer so that the tiles appear sharper. * For consistency (i.e., to avoid 1-pixel gaps), this needs to be done even * for solid tilemaps that are guaranteed to have speed 1. * FIXME Force integer translation for all graphics, not just tilemaps. */ float trans_x = roundf(context.get_translation().x); float trans_y = roundf(context.get_translation().y); context.set_translation(Vector(int(trans_x * speed_x), int(trans_y * speed_y))); Rectf draw_rect = Rectf(context.get_translation(), context.get_translation() + Vector(SCREEN_WIDTH, SCREEN_HEIGHT)); Rect t_draw_rect = get_tiles_overlapping(draw_rect); Vector start = get_tile_position(t_draw_rect.left, t_draw_rect.top); Vector pos; int tx, ty; for(pos.x = start.x, tx = t_draw_rect.left; tx < t_draw_rect.right; pos.x += 32, ++tx) { for(pos.y = start.y, ty = t_draw_rect.top; ty < t_draw_rect.bottom; pos.y += 32, ++ty) { int index = ty*width + tx; assert (index >= 0); assert (index < (width * height)); if (tiles[index] == 0) continue; const Tile* tile = tileset->get(tiles[index]); assert(tile != 0); tile->draw(context, pos, z_pos); } /* for (pos y) */ } /* for (pos x) */ if(draw_target != DrawingContext::NORMAL) { context.pop_target(); } context.pop_transform(); }
void TileMap::draw(DrawingContext& context) { // skip draw if current opacity is 0.0 if (m_current_alpha == 0.0f) return; context.push_transform(); if (m_flip != NO_FLIP) context.set_flip(m_flip); if (m_editor_active) { if (m_current_alpha != 1.0f) { context.set_alpha(m_current_alpha); } } else { context.set_alpha(m_current_alpha/2); } const float trans_x = context.get_translation().x; const float trans_y = context.get_translation().y; const bool normal_speed = m_editor_active && Editor::is_active(); context.set_translation(Vector(trans_x * (normal_speed ? 1.0f : m_speed_x), trans_y * (normal_speed ? 1.0f : m_speed_y))); Rectf draw_rect = context.get_cliprect(); Rect t_draw_rect = get_tiles_overlapping(draw_rect); Vector start = get_tile_position(t_draw_rect.left, t_draw_rect.top); Vector pos; int tx, ty; std::unordered_map<SurfacePtr, std::tuple<std::vector<Rectf>, std::vector<Rectf>>> batches; for (pos.x = start.x, tx = t_draw_rect.left; tx < t_draw_rect.right; pos.x += 32, ++tx) { for (pos.y = start.y, ty = t_draw_rect.top; ty < t_draw_rect.bottom; pos.y += 32, ++ty) { int index = ty*m_width + tx; assert (index >= 0); assert (index < (m_width * m_height)); if (m_tiles[index] == 0) continue; const Tile& tile = m_tileset->get(m_tiles[index]); if (g_debug.show_collision_rects) { tile.draw_debug(context.color(), pos, LAYER_FOREGROUND1); } const SurfacePtr& surface = Editor::is_active() ? tile.get_current_editor_surface() : tile.get_current_surface(); if (surface) { std::get<0>(batches[surface]).emplace_back(surface->get_region()); std::get<1>(batches[surface]).emplace_back(pos, Sizef(static_cast<float>(surface->get_width()), static_cast<float>(surface->get_height()))); } } } Canvas& canvas = context.get_canvas(m_draw_target); for (auto& it : batches) { const SurfacePtr& surface = it.first; if (surface) { canvas.draw_surface_batch(surface, std::move(std::get<0>(it.second)), std::move(std::get<1>(it.second)), m_current_tint, m_z_pos); } } context.pop_transform(); }
void TileMap::draw(DrawingContext& context) { // skip draw if current opacity is 0.0 if (current_alpha == 0.0) return; context.push_transform(); if(draw_target != DrawingContext::NORMAL) { context.push_target(); context.set_target(draw_target); } if(drawing_effect != 0) context.set_drawing_effect(drawing_effect); if(current_alpha != 1.0) context.set_alpha(current_alpha); /* Force the translation to be an integer so that the tiles appear sharper. * For consistency (i.e., to avoid 1-pixel gaps), this needs to be done even * for solid tilemaps that are guaranteed to have speed 1. * FIXME Force integer translation for all graphics, not just tilemaps. */ float trans_x = roundf(context.get_translation().x); float trans_y = roundf(context.get_translation().y); context.set_translation(Vector(int(trans_x * speed_x), int(trans_y * speed_y))); Rectf draw_rect = Rectf(context.get_translation(), context.get_translation() + Vector(SCREEN_WIDTH, SCREEN_HEIGHT)); Rect t_draw_rect = get_tiles_overlapping(draw_rect); // Make sure the tilemap is within draw view if (t_draw_rect.is_valid()) { Vector start = get_tile_position(t_draw_rect.left, t_draw_rect.top); Vector pos; int tx, ty; for(pos.x = start.x, tx = t_draw_rect.left; tx < t_draw_rect.right; pos.x += 32, ++tx) { for(pos.y = start.y, ty = t_draw_rect.top; ty < t_draw_rect.bottom; pos.y += 32, ++ty) { int index = ty*width + tx; assert (index >= 0); assert (index < (width * height)); if (tiles[index] == 0) continue; const Tile* tile = tileset->get(tiles[index]); assert(tile != 0); tile->draw(context, pos, z_pos, current_tint); } /* for (pos y) */ } /* for (pos x) */ /* Make sure that tiles with images larger than 32x32 that overlap * the draw rect will be drawn, even if their tile position does * not fall within the draw rect. */ static const int EXTENDING_TILES = 32; int ex_left = std::max(0, t_draw_rect.left-EXTENDING_TILES); int ex_top = std::max(0, t_draw_rect.top-EXTENDING_TILES); Vector ex_start = get_tile_position(ex_left, ex_top); for (pos.x = start.x, tx = t_draw_rect.left; tx < t_draw_rect.right; pos.x += 32, ++tx) { for (pos.y = ex_start.y, ty = ex_top; ty < t_draw_rect.top; pos.y += 32, ++ty) { int index = ty*width + tx; assert (index >= 0); assert (index < (width * height)); if (tiles[index] == 0) continue; const Tile* tile = tileset->get(tiles[index]); assert(tile != 0); SurfacePtr image = tile->get_current_image(); if (image) { int h = image->get_height(); if (h <= 32) continue; if (pos.y + h > start.y) tile->draw(context, pos, z_pos, current_tint); } } } for (pos.x = ex_start.x, tx = ex_left; tx < t_draw_rect.right; pos.x += 32, ++tx) { for(pos.y = ex_start.y, ty = ex_top; ty < t_draw_rect.bottom; pos.y += 32, ++ty) { int index = ty*width + tx; assert (index >= 0); assert (index < (width * height)); if (tiles[index] == 0) continue; const Tile* tile = tileset->get(tiles[index]); assert(tile != 0); SurfacePtr image = tile->get_current_image(); if (image) { int w = image->get_width(); int h = image->get_height(); if (w <= 32 && h <= 32) continue; if (pos.x + w > start.x && pos.y + h > start.y) tile->draw(context, pos, z_pos, current_tint); } } } } if(draw_target != DrawingContext::NORMAL) { context.pop_target(); } context.pop_transform(); }