Buildbot changes to allow out-of-tree builds (#11180) - minetest.git

diff options

author	sfan5 <sfan5@live.de>	2021-04-11 17:10:06 +0200
committer	GitHub <noreply@github.com>	2021-04-11 17:10:06 +0200
commit	4d0fef8ae87aa7b940d43485e7f6466eaa3d111e (patch)
tree	24a270c7ff3071ab50b9a4e3e9f111695eaf0f9a /src
parent	4b8209d9a44425156ba89a4763f63ea088daccb3 (diff)
download	minetest-4d0fef8ae87aa7b940d43485e7f6466eaa3d111e.tar.gz minetest-4d0fef8ae87aa7b940d43485e7f6466eaa3d111e.tar.bz2 minetest-4d0fef8ae87aa7b940d43485e7f6466eaa3d111e.zip

Buildbot changes to allow out-of-tree builds (#11180)

* Do proper out-of-tree builds with buildbot * Don't write to bin/ for cross builds * This allows safely building multiple builds from the same source dir, e.g. with the buildbot. * Disable Gettext (by default) and Freetype (entirely) for server builds

Diffstat (limited to 'src')

-rw-r--r--

src/CMakeLists.txt

1 files changed, 8 insertions, 5 deletions

/* Minetest Copyright (C) 2010-2015 celeron55, Perttu Ahola <celeron55@gmail.com> 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 <cmath> #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<std::map<v3s16, MinimapMapblock*>::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<v3s16, MinimapMapblock *>::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<v3s16, MinimapMapblock *>::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();


context:
space:
mode: