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

Remove MapVoxelManipulator not really used by anyone

Browse Source
This commit is contained in:
sapier 2014-06-09 14:25:35 +02:00
parent 8ad83767cf
commit b3a2ef1a91
2 changed files with 13 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

169
src/map.cpp
View File

@ -3484,167 +3484,10 @@ void ServerMap::PrintInfo(std::ostream &out)
out<<"ServerMap: "; out<<"ServerMap: ";
} }
/*
MapVoxelManipulator
*/
MapVoxelManipulator::MapVoxelManipulator(Map *map)
{
m_map = map;
}
MapVoxelManipulator::~MapVoxelManipulator()
{
/*infostream<<"MapVoxelManipulator: blocks: "<<m_loaded_blocks.size()
<<std::endl;*/
}
void MapVoxelManipulator::emerge(VoxelArea a, s32 caller_id)
{
TimeTaker timer1("emerge", &emerge_time);
// Units of these are MapBlocks
v3s16 p_min = getNodeBlockPos(a.MinEdge);
v3s16 p_max = getNodeBlockPos(a.MaxEdge);
VoxelArea block_area_nodes
(p_min*MAP_BLOCKSIZE, (p_max+1)*MAP_BLOCKSIZE-v3s16(1,1,1));
addArea(block_area_nodes);
for(s32 z=p_min.Z; z<=p_max.Z; z++)
for(s32 y=p_min.Y; y<=p_max.Y; y++)
for(s32 x=p_min.X; x<=p_max.X; x++)
{
u8 flags = 0;
MapBlock *block;
v3s16 p(x,y,z);
std::map<v3s16, u8>::iterator n;
n = m_loaded_blocks.find(p);
if(n != m_loaded_blocks.end())
continue;
bool block_data_inexistent = false;
try
{
TimeTaker timer1("emerge load", &emerge_load_time);
/*infostream<<"Loading block (caller_id="<<caller_id<<")"
<<" ("<<p.X<<","<<p.Y<<","<<p.Z<<")"
<<" wanted area: ";
a.print(infostream);
infostream<<std::endl;*/
block = m_map->getBlockNoCreate(p);
if(block->isDummy())
block_data_inexistent = true;
else
block->copyTo(*this);
}
catch(InvalidPositionException &e)
{
block_data_inexistent = true;
}
if(block_data_inexistent)
{
flags |= VMANIP_BLOCK_DATA_INEXIST;
VoxelArea a(p*MAP_BLOCKSIZE, (p+1)*MAP_BLOCKSIZE-v3s16(1,1,1));
// Fill with VOXELFLAG_NO_DATA
for(s32 z=a.MinEdge.Z; z<=a.MaxEdge.Z; z++)
for(s32 y=a.MinEdge.Y; y<=a.MaxEdge.Y; y++)
{
s32 i = m_area.index(a.MinEdge.X,y,z);
memset(&m_flags[i], VOXELFLAG_NO_DATA, MAP_BLOCKSIZE);
}
}
/*else if (block->getNode(0, 0, 0).getContent() == CONTENT_IGNORE)
{
// Mark that block was loaded as blank
flags |= VMANIP_BLOCK_CONTAINS_CIGNORE;
}*/
m_loaded_blocks[p] = flags;
}
//infostream<<"emerge done"<<std::endl;
}
/*
SUGG: Add an option to only update eg. water and air nodes.
This will make it interfere less with important stuff if
run on background.
*/
void MapVoxelManipulator::blitBack
(std::map<v3s16, MapBlock*> & modified_blocks)
{
if(m_area.getExtent() == v3s16(0,0,0))
return;
//TimeTaker timer1("blitBack");
/*infostream<<"blitBack(): m_loaded_blocks.size()="
<<m_loaded_blocks.size()<<std::endl;*/
/*
Initialize block cache
*/
v3s16 blockpos_last;
MapBlock *block = NULL;
bool block_checked_in_modified = false;
for(s32 z=m_area.MinEdge.Z; z<=m_area.MaxEdge.Z; z++)
for(s32 y=m_area.MinEdge.Y; y<=m_area.MaxEdge.Y; y++)
for(s32 x=m_area.MinEdge.X; x<=m_area.MaxEdge.X; x++)
{
v3s16 p(x,y,z);
u8 f = m_flags[m_area.index(p)];
if(f & (VOXELFLAG_NO_DATA))
continue;
MapNode &n = m_data[m_area.index(p)];
v3s16 blockpos = getNodeBlockPos(p);
try
{
// Get block
if(block == NULL || blockpos != blockpos_last){
block = m_map->getBlockNoCreate(blockpos);
blockpos_last = blockpos;
block_checked_in_modified = false;
}
// Calculate relative position in block
v3s16 relpos = p - blockpos * MAP_BLOCKSIZE;
// Don't continue if nothing has changed here
if(block->getNode(relpos) == n)
continue;
//m_map->setNode(m_area.MinEdge + p, n);
block->setNode(relpos, n);
/*
Make sure block is in modified_blocks
*/
if(block_checked_in_modified == false)
{
modified_blocks[blockpos] = block;
block_checked_in_modified = true;
}
}
catch(InvalidPositionException &e)
{
}
}
}
ManualMapVoxelManipulator::ManualMapVoxelManipulator(Map *map): ManualMapVoxelManipulator::ManualMapVoxelManipulator(Map *map):
MapVoxelManipulator(map), VoxelManipulator(),
m_create_area(false) m_create_area(false),
m_map(map)
{ {
} }
@ -3652,12 +3495,6 @@ ManualMapVoxelManipulator::~ManualMapVoxelManipulator()
{ {
} }
void ManualMapVoxelManipulator::emerge(VoxelArea a, s32 caller_id)
{
// Just create the area so that it can be pointed to
VoxelManipulator::addArea(a);
}
void ManualMapVoxelManipulator::initialEmerge(v3s16 blockpos_min, void ManualMapVoxelManipulator::initialEmerge(v3s16 blockpos_min,
v3s16 blockpos_max, bool load_if_inexistent) v3s16 blockpos_max, bool load_if_inexistent)
{ {

34
src/map.h
View File

@ -523,14 +523,15 @@ private:
Database *dbase; Database *dbase;
}; };
#define VMANIP_BLOCK_DATA_INEXIST 1 #define VMANIP_BLOCK_DATA_INEXIST 1
#define VMANIP_BLOCK_CONTAINS_CIGNORE 2 #define VMANIP_BLOCK_CONTAINS_CIGNORE 2
class MapVoxelManipulator : public VoxelManipulator class ManualMapVoxelManipulator : public VoxelManipulator
{ {
public: public:
MapVoxelManipulator(Map *map); ManualMapVoxelManipulator(Map *map);
virtual ~MapVoxelManipulator(); virtual ~ManualMapVoxelManipulator();
virtual void clear() virtual void clear()
{ {
@ -538,30 +539,9 @@ public:
m_loaded_blocks.clear(); m_loaded_blocks.clear();
} }
virtual void emerge(VoxelArea a, s32 caller_id=-1);
void blitBack(std::map<v3s16, MapBlock*> & modified_blocks);
protected:
Map *m_map;
/*
key = blockpos
value = flags describing the block
*/
std::map<v3s16, u8> m_loaded_blocks;
};
class ManualMapVoxelManipulator : public MapVoxelManipulator
{
public:
ManualMapVoxelManipulator(Map *map);
virtual ~ManualMapVoxelManipulator();
void setMap(Map *map) void setMap(Map *map)
{m_map = map;} {m_map = map;}
virtual void emerge(VoxelArea a, s32 caller_id=-1);
void initialEmerge(v3s16 blockpos_min, v3s16 blockpos_max, void initialEmerge(v3s16 blockpos_min, v3s16 blockpos_max,
bool load_if_inexistent = true); bool load_if_inexistent = true);
@ -570,6 +550,12 @@ public:
protected: protected:
bool m_create_area; bool m_create_area;
Map *m_map;
/*
key = blockpos
value = flags describing the block
*/
std::map<v3s16, u8> m_loaded_blocks;
}; };
#endif #endif