Skip to content
Permalink
Browse files

Remove MapVoxelManipulator not really used by anyone

  • Loading branch information...
sapier sapier
sapier authored and sapier committed Jun 9, 2014
1 parent 8ad8376 commit b3a2ef1a911b5ee22ff6478b5a3f9a12f6e40121
Showing with 13 additions and 190 deletions.
  1. +3 −166 src/map.cpp
  2. +10 −24 src/map.h
@@ -3484,180 +3484,17 @@ void ServerMap::PrintInfo(std::ostream &out)
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):
MapVoxelManipulator(map),
m_create_area(false)
VoxelManipulator(),
m_create_area(false),
m_map(map)
{
}

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,
v3s16 blockpos_max, bool load_if_inexistent)
{
@@ -523,45 +523,25 @@ class ServerMap : public Map
Database *dbase;
};


#define VMANIP_BLOCK_DATA_INEXIST 1
#define VMANIP_BLOCK_CONTAINS_CIGNORE 2

class MapVoxelManipulator : public VoxelManipulator
class ManualMapVoxelManipulator : public VoxelManipulator
{
public:
MapVoxelManipulator(Map *map);
virtual ~MapVoxelManipulator();
ManualMapVoxelManipulator(Map *map);
virtual ~ManualMapVoxelManipulator();

virtual void clear()
{
VoxelManipulator::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)
{m_map = map;}

virtual void emerge(VoxelArea a, s32 caller_id=-1);

void initialEmerge(v3s16 blockpos_min, v3s16 blockpos_max,
bool load_if_inexistent = true);

@@ -570,6 +550,12 @@ class ManualMapVoxelManipulator : public MapVoxelManipulator

protected:
bool m_create_area;
Map *m_map;
/*
key = blockpos
value = flags describing the block
*/
std::map<v3s16, u8> m_loaded_blocks;
};

#endif

0 comments on commit b3a2ef1

Please sign in to comment.
You can’t perform that action at this time.