BRNSystems/minetest
1
0
Fork 0
forked from Mirrorlandia_minetest/minetest
Code Pull Requests 1 Activity

Speed up find_nodes_in_area (#12845)

Browse Source
This commit is contained in:
Jude Melton-Houghton 2022-10-13 09:35:19 -04:00 committed by GitHub
parent 6b6f886bcd
commit cb725a4555
3 changed files with 150 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
src/map.h
View File

@ -26,12 +26,14 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include <list>
#include "irrlichttypes_bloated.h"
#include "mapblock.h"
#include "mapnode.h"
#include "constants.h"
#include "voxel.h"
#include "modifiedstate.h"
#include "util/container.h"
#include "util/metricsbackend.h"
#include "util/numeric.h"
#include "nodetimer.h"
#include "map_settings_manager.h"
#include "debug.h"
@ -257,9 +259,43 @@ public:
void removeNodeTimer(v3s16 p);
/*
Variables
Utilities
*/
// Iterates through all nodes in the area in an unspecified order.
// The given callback takes the position as its first argument and the node
// as its second. If it returns false, forEachNodeInArea returns early.
template<typename F>
void forEachNodeInArea(v3s16 minp, v3s16 maxp, F func)
{
v3s16 bpmin = getNodeBlockPos(minp);
v3s16 bpmax = getNodeBlockPos(maxp);
for (s16 bz = bpmin.Z; bz <= bpmax.Z; bz++)
for (s16 bx = bpmin.X; bx <= bpmax.X; bx++)
for (s16 by = bpmin.Y; by <= bpmax.Y; by++) {
// y is iterated innermost to make use of the sector cache.
v3s16 bp(bx, by, bz);
MapBlock *block = getBlockNoCreateNoEx(bp);
v3s16 basep = bp * MAP_BLOCKSIZE;
s16 minx_block = rangelim(minp.X - basep.X, 0, MAP_BLOCKSIZE - 1);
s16 miny_block = rangelim(minp.Y - basep.Y, 0, MAP_BLOCKSIZE - 1);
s16 minz_block = rangelim(minp.Z - basep.Z, 0, MAP_BLOCKSIZE - 1);
s16 maxx_block = rangelim(maxp.X - basep.X, 0, MAP_BLOCKSIZE - 1);
s16 maxy_block = rangelim(maxp.Y - basep.Y, 0, MAP_BLOCKSIZE - 1);
s16 maxz_block = rangelim(maxp.Z - basep.Z, 0, MAP_BLOCKSIZE - 1);
for (s16 z_block = minz_block; z_block <= maxz_block; z_block++)
for (s16 y_block = miny_block; y_block <= maxy_block; y_block++)
for (s16 x_block = minx_block; x_block <= maxx_block; x_block++) {
v3s16 p = basep + v3s16(x_block, y_block, z_block);
MapNode n = block ?
block->getNodeNoCheck(x_block, y_block, z_block) :
MapNode(CONTENT_IGNORE);
if (!func(p, n))
return;
}
}
}
bool isBlockOccluded(MapBlock *block, v3s16 cam_pos_nodes);
protected:
IGameDef *m_gamedef;

22
src/script/lua_api/l_env.cpp
View File

@ -902,11 +902,8 @@ int ModApiEnvMod::l_find_nodes_in_area(lua_State *L)
for (u32 i = 0; i < filter.size(); i++)
lua_newtable(L);
v3s16 p;
for (p.X = minp.X; p.X <= maxp.X; p.X++)
for (p.Y = minp.Y; p.Y <= maxp.Y; p.Y++)
for (p.Z = minp.Z; p.Z <= maxp.Z; p.Z++) {
content_t c = map.getNode(p).getContent();
map.forEachNodeInArea(minp, maxp, [&](v3s16 p, MapNode n) -> bool {
content_t c = n.getContent();
auto it = std::find(filter.begin(), filter.end(), c);
if (it != filter.end()) {
@ -915,7 +912,9 @@ int ModApiEnvMod::l_find_nodes_in_area(lua_State *L)
push_v3s16(L, p);
lua_rawseti(L, base + 1 + filt_index, ++idx[filt_index]);
}
}
return true;
});
// last filter table is at top of stack
u32 i = filter.size() - 1;
@ -937,11 +936,8 @@ int ModApiEnvMod::l_find_nodes_in_area(lua_State *L)
lua_newtable(L);
u32 i = 0;
v3s16 p;
for (p.X = minp.X; p.X <= maxp.X; p.X++)
for (p.Y = minp.Y; p.Y <= maxp.Y; p.Y++)
for (p.Z = minp.Z; p.Z <= maxp.Z; p.Z++) {
content_t c = env->getMap().getNode(p).getContent();
map.forEachNodeInArea(minp, maxp, [&](v3s16 p, MapNode n) -> bool {
content_t c = n.getContent();
auto it = std::find(filter.begin(), filter.end(), c);
if (it != filter.end()) {
@ -951,7 +947,9 @@ int ModApiEnvMod::l_find_nodes_in_area(lua_State *L)
u32 filt_index = it - filter.begin();
individual_count[filt_index]++;
}
}
return true;
});
lua_createtable(L, 0, filter.size());
for (u32 i = 0; i < filter.size(); i++) {

103
src/unittest/test_map.cpp
View File

@ -19,7 +19,10 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "test.h"
#include <cstdio>
#include <unordered_set>
#include <unordered_map>
#include "mapblock.h"
#include "dummymap.h"
class TestMap : public TestBase
{
@ -30,6 +33,9 @@ public:
void runTests(IGameDef *gamedef);
void testMaxMapgenLimit();
void testForEachNodeInArea(IGameDef *gamedef);
void testForEachNodeInAreaBlank(IGameDef *gamedef);
void testForEachNodeInAreaEmpty(IGameDef *gamedef);
};
static TestMap g_test_instance;
@ -37,6 +43,9 @@ static TestMap g_test_instance;
void TestMap::runTests(IGameDef *gamedef)
{
TEST(testMaxMapgenLimit);
TEST(testForEachNodeInArea, gamedef);
TEST(testForEachNodeInAreaBlank, gamedef);
TEST(testForEachNodeInAreaEmpty, gamedef);
}
////////////////////////////////////////////////////////////////////////////////
@ -66,3 +75,97 @@ void TestMap::testMaxMapgenLimit()
UASSERT(blockpos_over_max_limit(v3s16(-limit_block)) == false);
UASSERT(blockpos_over_max_limit(v3s16(-limit_block-1)) == true);
}
void TestMap::testForEachNodeInArea(IGameDef *gamedef)
{
v3s16 minp_visit(-10, -10, -10);
v3s16 maxp_visit(20, 20, 10);
v3s16 dims_visit = maxp_visit - minp_visit + v3s16(1, 1, 1);
s32 volume_visit = (s32)dims_visit.X * (s32)dims_visit.Y * (s32)dims_visit.Z;
v3s16 minp = minp_visit - v3s16(1, 1, 1);
v3s16 maxp = maxp_visit + v3s16(1, 1, 1);
DummyMap map(gamedef, getNodeBlockPos(minp), getNodeBlockPos(maxp));
v3s16 p1(0, 10, 5);
MapNode n1(t_CONTENT_STONE);
map.setNode(p1, n1);
v3s16 p2(-1, 15, 5);
MapNode n2(t_CONTENT_TORCH);
map.setNode(p2, n2);
v3s16 p3 = minp_visit;
MapNode n3(CONTENT_AIR);
map.setNode(p3, n3);
v3s16 p4 = maxp_visit;
MapNode n4(t_CONTENT_LAVA);
map.setNode(p4, n4);
// These positions should not be visited.
map.setNode(minp, MapNode(t_CONTENT_WATER));
map.setNode(maxp, MapNode(t_CONTENT_WATER));
s32 n_visited = 0;
std::unordered_set<v3s16> visited;
v3s16 minp_visited(0, 0, 0);
v3s16 maxp_visited(0, 0, 0);
std::unordered_map<v3s16, MapNode> found;
map.forEachNodeInArea(minp_visit, maxp_visit, [&](v3s16 p, MapNode n) -> bool {
n_visited++;
visited.insert(p);
minp_visited.X = std::min(minp_visited.X, p.X);
minp_visited.Y = std::min(minp_visited.Y, p.Y);
minp_visited.Z = std::min(minp_visited.Z, p.Z);
maxp_visited.X = std::max(maxp_visited.X, p.X);
maxp_visited.Y = std::max(maxp_visited.Y, p.Y);
maxp_visited.Z = std::max(maxp_visited.Z, p.Z);
if (n.getContent() != CONTENT_IGNORE)
found[p] = n;
return true;
});
UASSERTEQ(s32, n_visited, volume_visit);
UASSERTEQ(s32, (s32)visited.size(), volume_visit);
UASSERT(minp_visited == minp_visit);
UASSERT(maxp_visited == maxp_visit);
UASSERTEQ(size_t, found.size(), 4);
UASSERT(found.find(p1) != found.end());
UASSERTEQ(content_t, found[p1].getContent(), n1.getContent());
UASSERT(found.find(p2) != found.end());
UASSERTEQ(content_t, found[p2].getContent(), n2.getContent());
UASSERT(found.find(p3) != found.end());
UASSERTEQ(content_t, found[p3].getContent(), n3.getContent());
UASSERT(found.find(p4) != found.end());
UASSERTEQ(content_t, found[p4].getContent(), n4.getContent());
}
void TestMap::testForEachNodeInAreaBlank(IGameDef *gamedef)
{
DummyMap map(gamedef, v3s16(0, 0, 0), v3s16(-1, -1, -1));
v3s16 invalid_p(0, 0, 0);
bool visited = false;
map.forEachNodeInArea(invalid_p, invalid_p, [&](v3s16 p, MapNode n) -> bool {
bool is_valid_position = true;
UASSERT(n == map.getNode(p, &is_valid_position));
UASSERT(!is_valid_position);
UASSERT(!visited);
visited = true;
return true;
});
UASSERT(visited);
}
void TestMap::testForEachNodeInAreaEmpty(IGameDef *gamedef)
{
DummyMap map(gamedef, v3s16(), v3s16());
map.forEachNodeInArea(v3s16(0, 0, 0), v3s16(-1, -1, -1), [&](v3s16 p, MapNode n) -> bool {
UASSERT(false); // Should be unreachable
return true;
});
}