/* Minetest Copyright (C) 2010-2015 celeron55, Perttu Ahola This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #include "minimap.h" #include "client.h" #include "clientmap.h" #include "settings.h" #include "shader.h" #include "mapblock.h" #include "client/renderingengine.h" //// //// MinimapUpdateThread //// MinimapUpdateThread::~MinimapUpdateThread() { for (auto &it : m_blocks_cache) { delete it.second; } for (auto &q : m_update_queue) { delete q.data; } } bool MinimapUpdateThread::pushBlockUpdate(v3s16 pos, MinimapMapblock *data) { MutexAutoLock lock(m_queue_mutex); // Find if block is already in queue. // If it is, update the data and quit. for (QueuedMinimapUpdate &q : m_update_queue) { if (q.pos == pos) { delete q.data; q.data = data; return false; } } // Add the block QueuedMinimapUpdate q; q.pos = pos; q.data = data; m_update_queue.push_back(q); return true; } bool MinimapUpdateThread::popBlockUpdate(QueuedMinimapUpdate *update) { MutexAutoLock lock(m_queue_mutex); if (m_update_queue.empty()) return false; *update = m_update_queue.front(); m_update_queue.pop_front(); return true; } void MinimapUpdateThread::enqueueBlock(v3s16 pos, MinimapMapblock *data) { pushBlockUpdate(pos, data); deferUpdate(); } void MinimapUpdateThread::doUpdate() { QueuedMinimapUpdate update; while (popBlockUpdate(&update)) { if (update.data) { // Swap two values in the map using single lookup std::pair::iterator, bool> result = m_blocks_cache.insert(std::make_pair(update.pos, update.data)); if (!result.second) { delete result.first->second; result.first->second = update.data; } } else { std::map::iterator it; it = m_blocks_cache.find(update.pos); if (it != m_blocks_cache.end()) { delete it->second; m_blocks_cache.erase(it); } } } if (data->map_invalidated && data->mode != MINIMAP_MODE_OFF) { getMap(data->pos, data->map_size, data->scan_height); data->map_invalidated = false; } } void MinimapUpdateThread::getMap(v3s16 pos, s16 size, s16 height) { v3s16 pos_min(pos.X - size / 2, pos.Y - height / 2, pos.Z - size / 2); v3s16 pos_max(pos_min.X + size - 1, pos.Y + height / 2, pos_min.Z + size - 1); v3s16 blockpos_min = getNodeBlockPos(pos_min); v3s16 blockpos_max = getNodeBlockPos(pos_max); // clear the map for (int z = 0; z < size; z++) for (int x = 0; x < size; x++) { MinimapPixel &mmpixel = data->minimap_scan[x + z * size]; mmpixel.air_count = 0; mmpixel.height = 0; mmpixel.n = MapNode(CONTENT_AIR); } // draw the map v3s16 blockpos; for (blockpos.Z = blockpos_min.Z; blockpos.Z <= blockpos_max.Z; ++blockpos.Z) for (blockpos.Y = blockpos_min.Y; blockpos.Y <= blockpos_max.Y; ++blockpos.Y) for (blockpos.X = blockpos_min.X; blockpos.X <= blockpos_max.X; ++blockpos.X) { std::map::const_iterator pblock = m_blocks_cache.find(blockpos); if (pblock == m_blocks_cache.end()) continue; const MinimapMapblock &block = *pblock->second; v3s16 block_node_min(blockpos * MAP_BLOCKSIZE); v3s16 block_node_max(block_node_min + MAP_BLOCKSIZE - 1); // clip v3s16 range_min = componentwise_max(block_node_min, pos_min); v3s16 range_max = componentwise_min(block_node_max, pos_max); v3s16 pos; pos.Y = range_min.Y; for (pos.Z = range_min.Z; pos.Z <= range_max.Z; ++pos.Z) for (pos.X = range_min.X; pos.X <= range_max.X; ++pos.X) { v3s16 inblock_pos = pos - block_node_min; const MinimapPixel &in_pixel = block.data[inblock_pos.Z * MAP_BLOCKSIZE + inblock_pos.X]; v3s16 inmap_pos = pos - pos_min; MinimapPixel &out_pixel = data->minimap_scan[inmap_pos.X + inmap_pos.Z * size]; out_pixel.air_count += in_pixel.air_count; if (in_pixel.n.param0 != CONTENT_AIR) { out_pixel.n = in_pixel.n; out_pixel.height = inmap_pos.Y + in_pixel.height; } } } } //// //// Mapper //// Minimap::Minimap(Client *client) { this->client = client; this->driver = RenderingEngine::get_video_driver(); this->m_tsrc = client->getTextureSource(); this->m_shdrsrc = client->getShaderSource(); this->m_ndef = client->getNodeDefManager(); m_angle = 0.f; // Initialize static settings m_enable_shaders = g_settings->getBool("enable_shaders"); m_surface_mode_scan_height = g_settings->getBool("minimap_double_scan_height") ? 256 : 128; // Initialize minimap data data = new MinimapData; data->mode = MINIMAP_MODE_OFF; data->is_radar = false; data->map_invalidated = true; data->texture = NULL; data->heightmap_texture = NULL; data->minimap_shape_round = g_settings->getBool("minimap_shape_round"); // Get round minimap textures data->minimap_mask_round = driver->createImage( m_tsrc->getTexture("minimap_mask_round.png"), core::position2d(0, 0), core::dimension2d(MINIMAP_MAX_SX, MINIMAP_MAX_SY)); data->minimap_overlay_round = m_tsrc->getTexture("minimap_overlay_round.png"); // Get square minimap textures data->minimap_mask_square = driver->createImage( m_tsrc->getTexture("minimap_mask_square.png"), core::position2d(0, 0), core::dimension2d(MINIMAP_MAX_SX, MINIMAP_MAX_SY)); data->minimap_overlay_square = m_tsrc->getTexture("minimap_overlay_square.png"); // Create player marker texture data->player_marker = m_tsrc->getTexture("player_marker.png"); // Create object marker texture data->object_marker_red = m_tsrc->getTexture("object_marker_red.png"); // Create mesh buffer for minimap m_meshbuffer = getMinimapMeshBuffer(); // Initialize and start thread m_minimap_update_thread = new MinimapUpdateThread(); m_minimap_update_thread->data = data; m_minimap_update_thread->start(); } Minimap::~Minimap() { m_minimap_update_thread->stop(); m_minimap_update_thread->wait(); m_meshbuffer->drop(); data->minimap_mask_round->drop(); data->minimap_mask_square->drop(); driver->removeTexture(data->texture); driver->removeTexture(data->heightmap_texture); driver->removeTexture(data->minimap_overlay_round); driver->removeTexture(data->minimap_overlay_square); driver->removeTexture(data->object_marker_red); delete data; delete m_minimap_update_thread; } void Minimap::addBlock(v3s16 pos, MinimapMapblock *data) { m_minimap_update_thread->enqueueBlock(pos, data); } void Minimap::toggleMinimapShape() { MutexAutoLock lock(m_mutex); data->minimap_shape_round = !data->minimap_shape_round; g_settings->setBool("minimap_shape_round", data->minimap_shape_round); m_minimap_update_thread->deferUpdate(); } void Minimap::setMinimapShape(MinimapShape shape) { MutexAutoLock lock(m_mutex); if (shape == MINIMAP_SHAPE_SQUARE) data->minimap_shape_round = false; else if (shape == MINIMAP_SHAPE_ROUND) data->minimap_shape_round = true; g_settings->setBool("minimap_shape_round", data->minimap_shape_round); m_minimap_update_thread->deferUpdate(); } MinimapShape Minimap::getMinimapShape() { if (data->minimap_shape_round) { return MINIMAP_SHAPE_ROUND; } return MINIMAP_SHAPE_SQUARE; } void Minimap::setMinimapMode(MinimapMode mode) { static const MinimapModeDef modedefs[MINIMAP_MODE_COUNT] = { {false, 0, 0}, {false, m_surface_mode_scan_height, 256}, {false, m_surface_mode_scan_height, 128}, {false, m_surface_mode_scan_height, 64}, {true, 32, 128}, {true, 32, 64}, {true, 32, 32} }; if (mode >= MINIMAP_MODE_COUNT) return; MutexAutoLock lock(m_mutex); data->is_radar = modedefs[mode].is_radar; data->scan_height = modedefs[mode].scan_height; data->map_size = modedefs[mode].map_size; data->mode = mode; m_minimap_update_thread->deferUpdate(); } void Minimap::setPos(v3s16 pos) { bool do_update = false; { MutexAutoLock lock(m_mutex); if (pos != data->old_pos) { data->old_pos = data->pos; data->pos = pos; do_update = true; } } if (do_update) m_minimap_update_thread->deferUpdate(); } void Minimap::setAngle(f32 angle) { m_angle = angle; } void Minimap::blitMinimapPixelsToImageRadar(video::IImage *map_image) { video::SColor c(240, 0, 0, 0); for (s16 x = 0; x < data->map_size; x++) for (s16 z = 0; z < data->map_size; z++) { MinimapPixel *mmpixel = &data->minimap_scan[x + z * data->map_size]; if (mmpixel->air_count > 0) c.setGreen(core::clamp(core::round32(32 + mmpixel->air_count * 8), 0, 255)); else c.setGreen(0); map_image->setPixel(x, data->map_size - z - 1, c); } } void Minimap::blitMinimapPixelsToImageSurface( video::IImage *map_image, video::IImage *heightmap_image) { // This variable creation/destruction has a 1% cost on rendering minimap video::SColor tilecolor; for (s16 x = 0; x < data->map_size; x++) for (s16 z = 0; z < data->map_size; z++) { MinimapPixel *mmpixel = &data->minimap_scan[x + z * data->map_size]; const ContentFeatures &f = m_ndef->get(mmpixel->n); const TileDef *tile = &f.tiledef[0]; // Color of the 0th tile (mostly this is the std::unordered_map<int, float>::const_iterator i = times.find(rating); if (i == times.end()) { *time = 0; return false; } *time = i->second; return true; } }; typedef std::unordered_map<std::string, struct ToolGroupCap> ToolGCMap; typedef std::unordered_map<std::string, s16> DamageGroup; struct ToolCapabilities { float full_punch_interval; int max_drop_level; ToolGCMap groupcaps; DamageGroup damageGroups; ToolCapabilities( float full_punch_interval_=1.4, int max_drop_level_=1, const ToolGCMap &groupcaps_ = ToolGCMap(), const DamageGroup &damageGroups_ = DamageGroup() ): full_punch_interval(full_punch_interval_), max_drop_level(max_drop_level_), groupcaps(groupcaps_), damageGroups(damageGroups_) {} void serialize(std::ostream &os, u16 version) const; void deSerialize(std::istream &is); }; struct DigParams { bool diggable; // Digging time in seconds float time; // Caused wear u16 wear; std::string main_group; DigParams(bool a_diggable = false, float a_time = 0.0f, u16 a_wear = 0, const std::string &a_main_group = ""): diggable(a_diggable), time(a_time), wear(a_wear), main_group(a_main_group) {} }; DigParams getDigParams(const ItemGroupList &groups, const ToolCapabilities *tp, float time_from_last_punch); DigParams getDigParams(const ItemGroupList &groups, const ToolCapabilities *tp); struct HitParams { s16 hp; s16 wear; HitParams(s16 hp_=0, s16 wear_=0): hp(hp_), wear(wear_) {} }; HitParams getHitParams(const ItemGroupList &armor_groups, const ToolCapabilities *tp, float time_from_last_punch); HitParams getHitParams(const ItemGroupList &armor_groups, const ToolCapabilities *tp); struct PunchDamageResult { bool did_punch = false; int damage = 0; int wear =</